github.com/InjectiveLabs/sdk-go@v1.53.0/chain/wasmx/types/msgs.go (about)

     1  package types
     2  
     3  import (
     4  	"cosmossdk.io/errors"
     5  	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
     6  	sdk "github.com/cosmos/cosmos-sdk/types"
     7  	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
     8  )
     9  
    10  const RouterKey = ModuleName
    11  
    12  const (
    13  	TypeMsgUpdate                = "msgUpdate"
    14  	TypeMsgActivate              = "msgActivate"
    15  	TypeMsgDeactivate            = "msgDeactivate"
    16  	TypeMsgExecuteContractCompat = "executeContractCompat"
    17  	TypeMsgUpdateParams          = "updateParams"
    18  	TypeMsgRegisterContract      = "registerContract"
    19  )
    20  
    21  // Route implements the sdk.Msg interface. It should return the name of the module
    22  func (msg MsgUpdateParams) Route() string { return RouterKey }
    23  
    24  // Type implements the sdk.Msg interface. It should return the action.
    25  func (msg MsgUpdateParams) Type() string { return TypeMsgUpdateParams }
    26  
    27  // ValidateBasic implements the sdk.Msg interface. It runs stateless checks on the message
    28  func (msg MsgUpdateParams) ValidateBasic() error {
    29  	if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
    30  		return errors.Wrap(err, "invalid authority address")
    31  	}
    32  
    33  	if err := msg.Params.Validate(); err != nil {
    34  		return err
    35  	}
    36  
    37  	return nil
    38  }
    39  
    40  // GetSignBytes implements the sdk.Msg interface. It encodes the message for signing
    41  func (msg *MsgUpdateParams) GetSignBytes() []byte {
    42  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
    43  }
    44  
    45  // GetSigners implements the sdk.Msg interface. It defines whose signature is required
    46  func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress {
    47  	addr, _ := sdk.AccAddressFromBech32(msg.Authority)
    48  	return []sdk.AccAddress{addr}
    49  }
    50  
    51  // Route implements the sdk.Msg interface. It should return the name of the module
    52  func (msg MsgUpdateContract) Route() string { return RouterKey }
    53  
    54  // Type implements the sdk.Msg interface. It should return the action.
    55  func (msg MsgUpdateContract) Type() string { return TypeMsgUpdate }
    56  
    57  // ValidateBasic implements the sdk.Msg interface. It runs stateless checks on the message
    58  func (msg MsgUpdateContract) ValidateBasic() error {
    59  	if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
    60  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Sender)
    61  	}
    62  
    63  	if _, err := sdk.AccAddressFromBech32(msg.ContractAddress); err != nil {
    64  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.ContractAddress)
    65  	}
    66  
    67  	if msg.AdminAddress != "" {
    68  		if _, err := sdk.AccAddressFromBech32(msg.AdminAddress); err != nil {
    69  			return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.AdminAddress)
    70  		}
    71  	}
    72  
    73  	if msg.GasLimit == 0 {
    74  		return errors.Wrap(sdkerrors.ErrInvalidRequest, "GasLimit must be > 0")
    75  	}
    76  
    77  	if msg.GasPrice == 0 {
    78  		return errors.Wrap(sdkerrors.ErrInvalidRequest, "GasPrice must be > 0")
    79  	}
    80  
    81  	return nil
    82  }
    83  
    84  // GetSignBytes implements the sdk.Msg interface. It encodes the message for signing
    85  func (msg *MsgUpdateContract) GetSignBytes() []byte {
    86  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
    87  }
    88  
    89  // GetSigners implements the sdk.Msg interface. It defines whose signature is required
    90  func (msg MsgUpdateContract) GetSigners() []sdk.AccAddress {
    91  	sender, err := sdk.AccAddressFromBech32(msg.Sender)
    92  	if err != nil {
    93  		panic(err)
    94  	}
    95  	return []sdk.AccAddress{sender}
    96  }
    97  
    98  // Route implements the sdk.Msg interface. It should return the name of the module
    99  func (msg MsgActivateContract) Route() string { return RouterKey }
   100  
   101  // Type implements the sdk.Msg interface. It should return the action.
   102  func (msg MsgActivateContract) Type() string { return TypeMsgActivate }
   103  
   104  // ValidateBasic implements the sdk.Msg interface. It runs stateless checks on the message
   105  func (msg MsgActivateContract) ValidateBasic() error {
   106  	if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
   107  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Sender)
   108  	}
   109  	if _, err := sdk.AccAddressFromBech32(msg.ContractAddress); err != nil {
   110  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.ContractAddress)
   111  	}
   112  	return nil
   113  }
   114  
   115  // GetSignBytes implements the sdk.Msg interface. It encodes the message for signing
   116  func (msg *MsgActivateContract) GetSignBytes() []byte {
   117  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
   118  }
   119  
   120  // GetSigners implements the sdk.Msg interface. It defines whose signature is required
   121  func (msg MsgActivateContract) GetSigners() []sdk.AccAddress {
   122  	sender, err := sdk.AccAddressFromBech32(msg.Sender)
   123  	if err != nil {
   124  		panic(err)
   125  	}
   126  	return []sdk.AccAddress{sender}
   127  }
   128  
   129  // Route implements the sdk.Msg interface. It should return the name of the module
   130  func (msg MsgDeactivateContract) Route() string { return RouterKey }
   131  
   132  // Type implements the sdk.Msg interface. It should return the action.
   133  func (msg MsgDeactivateContract) Type() string { return TypeMsgDeactivate }
   134  
   135  // ValidateBasic implements the sdk.Msg interface. It runs stateless checks on the message
   136  func (msg MsgDeactivateContract) ValidateBasic() error {
   137  	if _, err := sdk.AccAddressFromBech32(msg.Sender); err != nil {
   138  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Sender)
   139  	}
   140  	if _, err := sdk.AccAddressFromBech32(msg.ContractAddress); err != nil {
   141  		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.ContractAddress)
   142  	}
   143  	return nil
   144  }
   145  
   146  // GetSignBytes implements the sdk.Msg interface. It encodes the message for signing
   147  func (msg *MsgDeactivateContract) GetSignBytes() []byte {
   148  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
   149  }
   150  
   151  // GetSigners implements the sdk.Msg interface. It defines whose signature is required
   152  func (msg MsgDeactivateContract) GetSigners() []sdk.AccAddress {
   153  	sender, err := sdk.AccAddressFromBech32(msg.Sender)
   154  	if err != nil {
   155  		panic(err)
   156  	}
   157  	return []sdk.AccAddress{sender}
   158  }
   159  
   160  func (msg MsgExecuteContractCompat) Route() string {
   161  	return RouterKey
   162  }
   163  
   164  func (msg MsgExecuteContractCompat) Type() string {
   165  	return TypeMsgExecuteContractCompat
   166  }
   167  
   168  func (msg MsgExecuteContractCompat) ValidateBasic() error {
   169  	funds := sdk.Coins{}
   170  	if msg.Funds != "0" {
   171  		var err error
   172  		funds, err = sdk.ParseCoinsNormalized(msg.Funds)
   173  		if err != nil {
   174  			return err
   175  		}
   176  	}
   177  
   178  	oMsg := &wasmtypes.MsgExecuteContract{
   179  		Sender:   msg.Sender,
   180  		Contract: msg.Contract,
   181  		Msg:      []byte(msg.Msg),
   182  		Funds:    funds,
   183  	}
   184  
   185  	if err := oMsg.ValidateBasic(); err != nil {
   186  		return err
   187  	}
   188  	return nil
   189  }
   190  
   191  func (msg MsgExecuteContractCompat) GetSignBytes() []byte {
   192  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg))
   193  }
   194  
   195  func (msg MsgExecuteContractCompat) GetSigners() []sdk.AccAddress {
   196  	senderAddr, err := sdk.AccAddressFromBech32(msg.Sender)
   197  	if err != nil { // should never happen as valid basic rejects invalid addresses
   198  		panic(err.Error())
   199  	}
   200  	return []sdk.AccAddress{senderAddr}
   201  }
   202  
   203  // Route implements the sdk.Msg interface. It should return the name of the module
   204  func (msg MsgRegisterContract) Route() string { return RouterKey }
   205  
   206  // Type implements the sdk.Msg interface. It should return the action.
   207  func (msg MsgRegisterContract) Type() string { return TypeMsgRegisterContract }
   208  
   209  // ValidateBasic implements the sdk.Msg interface. It runs stateless checks on the message
   210  func (msg MsgRegisterContract) ValidateBasic() error {
   211  	if err := msg.ContractRegistrationRequest.Validate(); err != nil {
   212  		return err
   213  	}
   214  	return nil
   215  }
   216  
   217  // GetSignBytes implements the sdk.Msg interface. It encodes the message for signing
   218  func (msg *MsgRegisterContract) GetSignBytes() []byte {
   219  	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg))
   220  }
   221  
   222  // GetSigners implements the sdk.Msg interface. It defines whose signature is required
   223  func (msg MsgRegisterContract) GetSigners() []sdk.AccAddress {
   224  	addr, _ := sdk.AccAddressFromBech32(msg.Sender)
   225  	return []sdk.AccAddress{addr}
   226  }