Add sanity test for all genesis message types

app/app.go

@@ -433,7 +433,8 @@ func NewWasmApp(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest b
 	// NOTE: Capability module must occur first so that it can initialize any capabilities
 	// so that other modules that want to create or claim capabilities afterwards in InitChain
 	// can do so safely.
-	// wasm module must occur after bank for an account sanity check
+	// wasm module should be a the end as it can call other modules functionality direct or via message dispatching during
+	// genesis phase. For example bank transfer, auth account check, staking, ...
 	app.mm.SetOrderInitGenesis(
 		capabilitytypes.ModuleName, authtypes.ModuleName, banktypes.ModuleName, distrtypes.ModuleName, stakingtypes.ModuleName,
 		slashingtypes.ModuleName, govtypes.ModuleName, minttypes.ModuleName, crisistypes.ModuleName,

x/wasm/internal/keeper/genesis.go

@@ -5,8 +5,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	abci "github.com/tendermint/tendermint/abci/types"
-	// authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
-	// "github.com/CosmWasm/wasmd/x/wasm/internal/types"
 )
 
 // ValidatorSetSource is a subset of the staking keeper

x/wasm/internal/keeper/genesis_test.go

@@ -519,40 +519,74 @@ func TestImportContractWithCodeHistoryReset(t *testing.T) {
 	assert.Equal(t, expHistory, keeper.GetContractHistory(ctx, contractAddr))
 }
 
-func TestImportWithGenMsg(t *testing.T) {
+func TestSupportedGenMsgTypes(t *testing.T) {
 	wasmCode, err := ioutil.ReadFile("./testdata/hackatom.wasm")
 	require.NoError(t, err)
-
-	myAddress := RandomBech32AccountAddress(t)
+	var (
+		myAddress          sdk.AccAddress = bytes.Repeat([]byte{1}, sdk.AddrLen)
+		verifierAddress    sdk.AccAddress = bytes.Repeat([]byte{2}, sdk.AddrLen)
+		beneficiaryAddress sdk.AccAddress = bytes.Repeat([]byte{3}, sdk.AddrLen)
+	)
+	const denom = "stake"
 	importState := types.GenesisState{
 		Params: types.DefaultParams(),
 		GenMsgs: []types.GenesisState_GenMsgs{
 			{
 				Sum: &types.GenesisState_GenMsgs_StoreCode{
 					StoreCode: &types.MsgStoreCode{
-						Sender:       myAddress,
+						Sender:       myAddress.String(),
 						WASMByteCode: wasmCode,
 					},
 				},
 			},
-			// todo: test other messages
+			{
+				Sum: &types.GenesisState_GenMsgs_InstantiateContract{
+					InstantiateContract: &types.MsgInstantiateContract{
+						Sender: myAddress.String(),
+						CodeID: 1,
+						Label:  "testing",
+						InitMsg: HackatomExampleInitMsg{
+							Verifier:    verifierAddress,
+							Beneficiary: beneficiaryAddress,
+						}.GetBytes(t),
+						InitFunds: sdk.NewCoins(sdk.NewCoin(denom, sdk.NewInt(10))),
+					},
+				},
+			},
+			{
+				Sum: &types.GenesisState_GenMsgs_ExecuteContract{
+					ExecuteContract: &types.MsgExecuteContract{
+						Sender:   verifierAddress.String(),
+						Contract: contractAddress(1, 1).String(),
+						Msg:      []byte(`{"release":{}}`),
+					},
+				},
+			},
 		},
 	}
 	require.NoError(t, importState.ValidateBasic())
-	keeper, ctx, _ := setupKeeper(t)
-
+	ctx, keepers := CreateDefaultTestInput(t)
+	keeper := keepers.WasmKeeper
 	ctx = ctx.WithBlockHeight(0).WithGasMeter(sdk.NewInfiniteGasMeter())
-
+	fundAccounts(t, ctx, keepers.AccountKeeper, keepers.BankKeeper, myAddress, sdk.NewCoins(sdk.NewCoin(denom, sdk.NewInt(100))))
 	// when
 	_, err = InitGenesis(ctx, keeper, importState, &StakingKeeperMock{}, TestHandler(keeper))
 	require.NoError(t, err)
 
-	// verify wasm code
+	// verify code stored
 	gotWasmCode, err := keeper.GetByteCode(ctx, 1)
 	require.NoError(t, err)
 	assert.Equal(t, wasmCode, gotWasmCode)
 	codeInfo := keeper.GetCodeInfo(ctx, 1)
 	require.NotNil(t, codeInfo)
+
+	// verify contract instantiated
+	cInfo := keeper.GetContractInfo(ctx, contractAddress(1, 1))
+	require.NotNil(t, cInfo)
+
+	// verify contract executed
+	gotBalance := keepers.BankKeeper.GetBalance(ctx, beneficiaryAddress, denom)
+	assert.Equal(t, sdk.NewCoin(denom, sdk.NewInt(10)), gotBalance)
 }
 
 func setupKeeper(t *testing.T) (*Keeper, sdk.Context, []sdk.StoreKey) {
@@ -607,8 +641,8 @@ type MockMsgHandler struct {
 	err      error
 	expCalls int
 	gotCalls int
-	expMsg sdk.Msg
-	gotMsg sdk.Msg
+	expMsg   sdk.Msg
+	gotMsg   sdk.Msg
 }
 
 func (m *MockMsgHandler) Handle(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {

x/wasm/internal/keeper/test_common.go

@@ -123,6 +123,11 @@ type TestKeepers struct {
 	WasmKeeper    *Keeper
 }
 
+// CreateDefaultTestInput common settings for CreateTestInput
+func CreateDefaultTestInput(t *testing.T) (sdk.Context, TestKeepers) {
+	return CreateTestInput(t, false, "staking", nil, nil)
+}
+
 // encoders can be nil to accept the defaults, or set it to override some of the message handlers (like default)
 func CreateTestInput(t *testing.T, isCheckTx bool, supportedFeatures string, encoders *MessageEncoders, queriers *QueryPlugins) (sdk.Context, TestKeepers) {
 	tempDir := t.TempDir()
@@ -315,10 +320,13 @@ func handleInstantiate(ctx sdk.Context, k *Keeper, msg *types.MsgInstantiateCont
 	if err != nil {
 		return nil, sdkerrors.Wrap(err, "sender")
 	}
-	adminAddr, err := sdk.AccAddressFromBech32(msg.Admin)
-	if err != nil {
-		return nil, sdkerrors.Wrap(err, "admin")
+	var adminAddr sdk.AccAddress
+	if msg.Admin != "" {
+		if adminAddr, err = sdk.AccAddressFromBech32(msg.Admin); err != nil {
+			return nil, sdkerrors.Wrap(err, "admin")
+		}
 	}
+
 	contractAddr, err := k.Instantiate(ctx, msg.CodeID, senderAddr, adminAddr, msg.InitMsg, msg.Label, msg.InitFunds)
 	if err != nil {
 		return nil, err