MsgInstantiateContractCompat

app/app.go

@@ -619,6 +619,7 @@ func New(
 		app.GetSubspace(wasmxtypes.ModuleName),
 		app.AccountKeeper,
 		app.BankKeeper,
+		app.WasmKeeper,
 	)
 
 	badgesIBCModule := badgesmodule.NewIBCModule(app.BadgesKeeper)

proto/wasmx/tx.proto

@@ -9,6 +9,7 @@ option go_package = "github.com/bitbadges/bitbadgeschain/x/wasmx/types";
 service Msg {
   rpc ExecuteContractCompat(MsgExecuteContractCompat) returns (MsgExecuteContractCompatResponse);
   rpc StoreCodeCompat(MsgStoreCodeCompat) returns (MsgStoreCodeCompatResponse);
+  rpc InstantiateContractCompat(MsgInstantiateContractCompat) returns (MsgInstantiateContractCompatResponse);
 }
 
 // MsgExecuteContractCompat submits the given message data to a smart contract, compatible with EIP712
@@ -43,4 +44,21 @@ message MsgStoreCodeCompatResponse {
   string codeId = 1 [(gogoproto.customtype) = "Uint", (gogoproto.nullable) = false];
   // Checksum is the sha256 hash of the stored code
   bytes checksum = 2;
+}
+
+message MsgInstantiateContractCompat {
+  // Sender is the that actor that signed the messages
+  string sender = 1;
+  // Code ID obtained from store wasm code
+  string codeId = 2 [(gogoproto.customtype) = "Uint", (gogoproto.nullable) = false];
+  // Label is a human-readable string for labelling the contract
+  string label = 3;
+  // Funds coins that are transferred to the contract on instantiation
+  string funds = 4;
+}
+
+// MsgInstantiateContractCompatResponse returns store result data.
+message MsgInstantiateContractCompatResponse {
+  string address = 1;
+  bytes data = 2;
 }

x/wasmx/handler.go

@@ -30,6 +30,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgStoreCodeCompat:
 			res, err := msgServer.StoreCodeCompat(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgInstantiateContractCompat:
+			res, err := msgServer.InstantiateContractCompat(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 		default:
 			return nil, sdkerrors.Wrap(badgestypes.ErrUnknownRequest,
 				fmt.Sprintf("Unrecognized wasmx Msg type: %T", msg))

x/wasmx/keeper/keeper.go

@@ -31,6 +31,7 @@ func NewKeeper(
 	paramSpace paramtypes.Subspace,
 	ak authkeeper.AccountKeeper,
 	bk types.BankKeeper,
+	wk wasmkeeper.Keeper,
 ) Keeper {
 
 	// set KeyTable if it has not already been set
@@ -45,6 +46,7 @@ func NewKeeper(
 		cdc:           cdc,
 		accountKeeper: ak,
 		bankKeeper:    bk,
+		wasmKeeper: 	 wk,
 	}
 }
 

x/wasmx/keeper/msg_server.go

@@ -58,6 +58,10 @@ func (m msgServer) StoreCodeCompat(goCtx context.Context, msg *types.MsgStoreCod
 	oMsg := &wasmtypes.MsgStoreCode{
 		Sender:   msg.Sender,
 		WASMByteCode: hexutil.MustDecode(msg.HexWasmByteCode),
+		InstantiatePermission: &wasmtypes.AccessConfig{
+			Permission: wasmtypes.AccessTypeEverybody,
+			Addresses: []string{},
+		},
 	}
 
 	res, err := wasmMsgServer.StoreCode(goCtx, oMsg)
@@ -70,3 +74,28 @@ func (m msgServer) StoreCodeCompat(goCtx context.Context, msg *types.MsgStoreCod
 		Checksum: res.Checksum,
 	}, nil
 }
+
+func (m msgServer) InstantiateContractCompat(goCtx context.Context, msg *types.MsgInstantiateContractCompat) (*types.MsgInstantiateContractCompatResponse, error) {
+	wasmMsgServer := wasmkeeper.NewMsgServerImpl(&m.wasmKeeper)
+	funds := sdk.Coins{}
+	if msg.Funds != "0" {
+		funds, _ = sdk.ParseCoinsNormalized(msg.Funds)
+	}
+	oMsg := &wasmtypes.MsgInstantiateContract{
+		Sender: msg.Sender,
+		CodeID: msg.CodeId.Uint64(),
+		Label: 	msg.Label,
+		Funds: 	funds,
+	}
+
+	res, err := wasmMsgServer.InstantiateContract(goCtx, oMsg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.MsgInstantiateContractCompatResponse{
+		Address: res.Address,
+		Data: res.Data,
+	}, nil
+}
+

x/wasmx/types/codec.go

@@ -13,13 +13,15 @@ import (
 func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgExecuteContractCompat{}, "wasmx/MsgExecuteContractCompat", nil)
 	cdc.RegisterConcrete(&MsgStoreCodeCompat{}, "wasmx/MsgStoreCodeCompat", nil)
+	cdc.RegisterConcrete(&MsgInstantiateContractCompat{}, "wasmx/MsgInstantiateContractCompat", nil)
 }
 
 func RegisterInterfaces(registry types.InterfaceRegistry) {
 
 	registry.RegisterImplementations((*sdk.Msg)(nil),
 		&MsgExecuteContractCompat{},
 		&MsgStoreCodeCompat{},
+		&MsgInstantiateContractCompat{},
 	)
 
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)

x/wasmx/types/msg_instantiate_contract_compat.go

@@ -0,0 +1,50 @@
+package types
+
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+	TypeMsgInstantiateContractCompat = "instantiateContractCompat"
+)
+
+func (msg MsgInstantiateContractCompat) Route() string {
+	return RouterKey
+}
+
+func (msg MsgInstantiateContractCompat) Type() string {
+	return TypeMsgInstantiateContractCompat
+}
+
+func (msg MsgInstantiateContractCompat) ValidateBasic() error {
+	funds := sdk.Coins{}
+	if msg.Funds != "0" {
+		funds, _ = sdk.ParseCoinsNormalized(msg.Funds)
+	}
+
+	oMsg := &wasmtypes.MsgInstantiateContract{
+		Sender: msg.Sender,
+		CodeID: msg.CodeId.Uint64(),
+		Label: 	msg.Label,
+		Funds: 	funds,
+	}
+
+	if err := oMsg.ValidateBasic(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Note ModuleCdc is Amino (see codec.go)
+func (msg MsgInstantiateContractCompat) GetSignBytes() []byte {
+	return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
+}
+
+func (msg MsgInstantiateContractCompat) GetSigners() []sdk.AccAddress {
+	senderAddr, err := sdk.AccAddressFromBech32(msg.Sender)
+	if err != nil { // should never happen as valid basic rejects invalid addresses
+		panic(err.Error())
+	}
+	return []sdk.AccAddress{senderAddr}
+}

x/wasmx/types/msg_store_code_compat.go

@@ -22,6 +22,10 @@ func (msg MsgStoreCodeCompat) ValidateBasic() error {
 	oMsg := &wasmtypes.MsgStoreCode{
 		Sender:   msg.Sender,
 		WASMByteCode: hexutil.MustDecode(msg.HexWasmByteCode),
+		InstantiatePermission: &wasmtypes.AccessConfig{
+			Permission: wasmtypes.AccessTypeEverybody,
+			Addresses: []string{},
+		},
 	}
 
 	if err := oMsg.ValidateBasic(); err != nil {