fix sim

Author: mmsqe

app/app.go

@@ -26,6 +26,7 @@ import (
 	"slices"
 	"sort"
 
+	authmodulev1 "cosmossdk.io/api/cosmos/auth/module/v1"
 	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
 	reflectionv1 "cosmossdk.io/api/cosmos/reflection/v1"
 	"cosmossdk.io/client/v2/autocli"
@@ -163,22 +164,31 @@ var (
 	DefaultNodeHome string
 
 	// module account permissions
-	maccPerms = map[string][]string{
-		authtypes.FeeCollectorName:         nil,
-		distrtypes.ModuleName:              nil,
-		pooltypes.ModuleName:               nil,
-		pooltypes.StreamAccount:            nil,
-		pooltypes.ProtocolPoolDistrAccount: nil,
-		minttypes.ModuleName:               {authtypes.Minter},
-		stakingtypes.BondedPoolName:        {authtypes.Burner, authtypes.Staking},
-		stakingtypes.NotBondedPoolName:     {authtypes.Burner, authtypes.Staking},
-		govtypes.ModuleName:                {authtypes.Burner},
+	moduleAccPerms = []*authmodulev1.ModuleAccountPermission{
+		{Account: authtypes.FeeCollectorName},
+		{Account: distrtypes.ModuleName},
+		{Account: pooltypes.ModuleName},
+		{Account: pooltypes.StreamAccount},
+		{Account: pooltypes.ProtocolPoolDistrAccount},
+		{Account: minttypes.ModuleName, Permissions: []string{authtypes.Minter}},
+		{Account: stakingtypes.BondedPoolName, Permissions: []string{authtypes.Burner, stakingtypes.ModuleName}},
+		{Account: stakingtypes.NotBondedPoolName, Permissions: []string{authtypes.Burner, stakingtypes.ModuleName}},
+		{Account: govtypes.ModuleName, Permissions: []string{authtypes.Burner}},
 		// used for secure addition and subtraction of balance using module account
-		evmtypes.ModuleName: {authtypes.Minter, authtypes.Burner},
+		{Account: evmtypes.ModuleName, Permissions: []string{authtypes.Minter, authtypes.Burner}},
 	}
 
-	// module accounts that are allowed to receive tokens
-	allowedReceivingModAcc = map[string]bool{}
+	// blocked account addresses
+	blockAccAddrs = []string{
+		authtypes.FeeCollectorName,
+		distrtypes.ModuleName,
+		minttypes.ModuleName,
+		stakingtypes.BondedPoolName,
+		stakingtypes.NotBondedPoolName,
+		// We allow the following module accounts to receive funds:
+		// govtypes.ModuleName
+		// pooltypes.ModuleName
+	}
 )
 
 var (
@@ -386,7 +396,7 @@ func NewEthermintApp(
 		appCodec,
 		ethermint.ProtoAccount,
 		accountsKeeper,
-		maccPerms,
+		GetMaccPerms(),
 		signingCtx.AddressCodec(),
 		sdk.Bech32MainPrefix,
 		authAddr,
@@ -397,7 +407,7 @@ func NewEthermintApp(
 		appCodec,
 		okeys[banktypes.ObjectStoreKey],
 		app.AuthKeeper,
-		app.BlockedAddrs(),
+		app.BlockedAddresses(),
 		authAddr,
 	)
 
@@ -952,25 +962,23 @@ func (app *EthermintApp) LoadHeight(height int64) error {
 	return app.LoadVersion(height)
 }
 
-// ModuleAccountAddrs returns all the app's module account addresses.
-func (app *EthermintApp) ModuleAccountAddrs() map[string]bool {
-	modAccAddrs := make(map[string]bool)
-	for acc := range maccPerms {
-		modAccAddrs[authtypes.NewModuleAddress(acc).String()] = true
-	}
-
-	return modAccAddrs
-}
+// BlockedAddresses returns all the app's blocked account addresses.
+// This function takes an address.Codec parameter to maintain compatibility
+// with the signature of the same function in appV1.
+func (app *EthermintApp) BlockedAddresses() map[string]bool {
+	result := make(map[string]bool)
 
-// BlockedAddrs returns all the app's module account addresses that are not
-// allowed to receive external tokens.
-func (app *EthermintApp) BlockedAddrs() map[string]bool {
-	blockedAddrs := make(map[string]bool)
-	for acc := range maccPerms {
-		blockedAddrs[authtypes.NewModuleAddress(acc).String()] = !allowedReceivingModAcc[acc]
+	if len(blockAccAddrs) > 0 {
+		for _, addr := range blockAccAddrs {
+			result[addr] = true
+		}
+	} else {
+		for addr := range GetMaccPerms() {
+			result[addr] = true
+		}
 	}
 
-	return blockedAddrs
+	return result
 }
 
 // LegacyAmino returns EthermintApp's amino codec.
@@ -1168,12 +1176,15 @@ func RegisterSwaggerAPI(_ client.Context, rtr *mux.Router) {
 }
 
 // GetMaccPerms returns a copy of the module account permissions
+//
+// NOTE: This is solely to be used for testing purposes.
 func GetMaccPerms() map[string][]string {
-	dupMaccPerms := make(map[string][]string)
-	for k, v := range maccPerms {
-		dupMaccPerms[k] = v
+	dup := make(map[string][]string)
+	for _, perms := range moduleAccPerms {
+		dup[perms.Account] = perms.Permissions
 	}
-	return dupMaccPerms
+
+	return dup
 }
 
 // initParamsKeeper init params keeper and its subspaces

app/simulation_test.go

@@ -4,6 +4,7 @@ package app_test
 import (
 	"encoding/json"
 	"flag"
+	"fmt"
 	"io"
 	"math/rand"
 	"sync"
@@ -21,12 +22,17 @@ import (
 	abci "github.com/cometbft/cometbft/abci/types"
 	cmtproto "github.com/cometbft/cometbft/api/cometbft/types/v1"
 	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/runtime"
+	"github.com/cosmos/cosmos-sdk/server"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 	"github.com/cosmos/cosmos-sdk/simsx"
+	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 	"github.com/cosmos/cosmos-sdk/x/simulation"
 	simcli "github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
 	"github.com/evmos/ethermint/app"
+	"github.com/evmos/ethermint/app/ante"
 	"github.com/evmos/ethermint/testutil"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -55,25 +61,24 @@ func setupStateFactory(app *app.EthermintApp) simsx.SimStateFactory {
 	return simsx.SimStateFactory{
 		Codec:         app.AppCodec(),
 		AppStateFn:    testutil.StateFn(app),
-		BlockedAddr:   app.BlockedAddrs(),
+		BlockedAddr:   app.BlockedAddresses(),
 		AccountSource: app.AuthKeeper,
 		BalanceSource: app.BankKeeper,
 	}
 }
 
 func TestFullAppSimulation(t *testing.T) {
-	return
 	config := simcli.NewConfigFromFlags()
 	config.ChainID = SimAppChainID
 	config.BlockMaxGas = SimBlockMaxGas
-	simsx.RunWithSeed(
+	simsx.RunWithSeedAndRandAcc(
 		t,
 		config,
-		app.NewEthermintApp,
+		NewSimApp,
 		setupStateFactory,
 		config.Seed,
 		config.FuzzSeed,
-		simtypes.RandomAccounts,
+		testutil.RandomAccounts,
 	)
 }
 
@@ -82,15 +87,54 @@ var (
 	exportWithValidatorSet []string
 )
 
+func NewSimApp(
+	logger log.Logger,
+	db corestore.KVStoreWithBatch,
+	traceStore io.Writer,
+	loadLatest bool,
+	appOpts servertypes.AppOptions,
+	baseAppOptions ...func(*baseapp.BaseApp),
+) *app.EthermintApp {
+	appOptions := make(simtestutil.AppOptionsMap, 0)
+	appOptions[flags.FlagHome] = app.DefaultNodeHome
+	appOptions[server.FlagInvCheckPeriod] = simcli.FlagPeriodValue
+	app := app.NewEthermintApp(logger, db, nil, false, appOptions, baseAppOptions...)
+	// disable feemarket on native tx
+	anteHandler, err := ante.NewAnteHandler(ante.HandlerOptions{
+		Environment: runtime.NewEnvironment(
+			nil,
+			logger,
+		), // nil is set as the kvstoreservice to avoid module access
+		ConsensusKeeper:          app.ConsensusParamsKeeper,
+		AccountKeeper:            app.AuthKeeper,
+		AccountAbstractionKeeper: app.AccountsKeeper,
+		BankKeeper:               app.BankKeeper,
+		SignModeHandler:          app.TxConfig().SignModeHandler(),
+		FeegrantKeeper:           app.FeeGrantKeeper,
+		SigGasConsumer:           ante.DefaultSigVerificationGasConsumer,
+		EvmKeeper:                app.EvmKeeper,
+		FeeMarketKeeper:          app.FeeMarketKeeper,
+		MaxTxGasWanted:           0,
+	})
+	if err != nil {
+		panic(err)
+	}
+	app.SetAnteHandler(anteHandler)
+	if err := app.LoadLatestVersion(); err != nil {
+		panic(err)
+	}
+	return app
+}
+
 func TestAppImportExport(t *testing.T) {
 	return
 	config := simcli.NewConfigFromFlags()
 	config.ChainID = SimAppChainID
 	config.BlockMaxGas = SimBlockMaxGas
-	simsx.RunWithSeed(
+	simsx.RunWithSeedAndRandAcc(
 		t,
 		config,
-		app.NewEthermintApp,
+		NewSimApp,
 		setupStateFactory,
 		config.Seed,
 		config.FuzzSeed,
@@ -102,11 +146,14 @@ func TestAppImportExport(t *testing.T) {
 			require.NoError(t, err)
 
 			t.Log("importing genesis...\n")
-			newTestInstance := simsx.NewSimulationAppInstance(t, ti.Cfg, app.NewEthermintApp)
+			newTestInstance := simsx.NewSimulationAppInstance(t, ti.Cfg, NewSimApp)
 			newApp := newTestInstance.App
 			var genesisState map[string]json.RawMessage
 			require.NoError(t, json.Unmarshal(exported.AppState, &genesisState))
-			ctxB := newApp.NewContextLegacy(true, cmtproto.Header{Height: a.LastBlockHeight()})
+			ctxB := newApp.NewContextLegacy(true, cmtproto.Header{
+				Height:  a.LastBlockHeight(),
+				ChainID: config.ChainID,
+			})
 			_, err = newApp.ModuleManager.InitGenesis(ctxB, genesisState)
 			if simapp.IsEmptyValidatorSetErr(err) {
 				t.Skip("Skipping simulation as all validators have been unbonded")
@@ -135,10 +182,10 @@ func TestAppSimulationAfterImport(t *testing.T) {
 	config := simcli.NewConfigFromFlags()
 	config.ChainID = SimAppChainID
 	config.BlockMaxGas = SimBlockMaxGas
-	simsx.RunWithSeed(
+	simsx.RunWithSeedAndRandAcc(
 		t,
 		config,
-		app.NewEthermintApp,
+		NewSimApp,
 		setupStateFactory,
 		config.Seed,
 		config.FuzzSeed,
@@ -158,7 +205,7 @@ func TestAppSimulationAfterImport(t *testing.T) {
 
 						_, err = a.InitChain(&abci.InitChainRequest{
 							AppStateBytes: exported.AppState,
-							ChainId:       simsx.SimAppChainID,
+							ChainId:       config.ChainID,
 							InitialHeight: exported.Height,
 							Time:          genesisTimestamp,
 						})
@@ -170,18 +217,17 @@ func TestAppSimulationAfterImport(t *testing.T) {
 						// use accounts from initial run
 						return exported.AppState, accs, config.ChainID, genesisTimestamp
 					},
-					BlockedAddr:   a.BlockedAddrs(),
+					BlockedAddr:   a.BlockedAddresses(),
 					AccountSource: a.AuthKeeper,
 					BalanceSource: a.BankKeeper,
 				}
 			}
 			ti.Cfg.InitialBlockHeight = int(exported.Height)
-			simsx.RunWithSeed(t, ti.Cfg, app.NewEthermintApp, importGenesisStateFactory, ti.Cfg.Seed, ti.Cfg.FuzzSeed, testutil.RandomAccounts)
+			simsx.RunWithSeedAndRandAcc(t, ti.Cfg, NewSimApp, importGenesisStateFactory, ti.Cfg.Seed, ti.Cfg.FuzzSeed, testutil.RandomAccounts)
 		})
 }
 
 func TestAppStateDeterminism(t *testing.T) {
-	return
 	const numTimesToRunPerSeed = 3
 	var seeds []int64
 	if s := simcli.NewConfigFromFlags().Seed; s != simcli.DefaultSeedValue {
@@ -214,7 +260,7 @@ func TestAppStateDeterminism(t *testing.T) {
 				return others.Get(k)
 			})
 		}
-		return app.NewEthermintApp(logger, db, nil, true, appOpts, append(baseAppOptions, interBlockCacheOpt())...)
+		return NewSimApp(logger, db, nil, true, appOpts, append(baseAppOptions, interBlockCacheOpt())...)
 	}
 	var mx sync.Mutex
 	appHashResults := make(map[int64][][]byte)
@@ -245,13 +291,23 @@ func TestAppStateDeterminism(t *testing.T) {
 		}
 	}
 	// run simulations
-	simsx.RunWithSeeds(
-		t,
-		interBlockCachingAppFactory,
-		setupStateFactory,
-		seeds,
-		[]byte{},
-		testutil.RandomAccounts,
-		captureAndCheckHash,
-	)
+	cfg := simcli.NewConfigFromFlags()
+	cfg.ChainID = SimAppChainID
+	for i := range seeds {
+		seed := seeds[i]
+		t.Run(fmt.Sprintf("seed: %d", seed), func(t *testing.T) {
+			t.Parallel()
+			simsx.RunWithSeedAndRandAcc(
+				t,
+				cfg,
+				interBlockCachingAppFactory,
+				setupStateFactory,
+				seed,
+				[]byte{},
+				testutil.RandomAccounts,
+				captureAndCheckHash,
+			)
+		})
+	}
+
 }