From 694d4c667d23f694264db4254c7bce15f66af1a6 Mon Sep 17 00:00:00 2001 From: Sai Kumar Date: Tue, 26 Apr 2022 16:09:18 +0530 Subject: [PATCH] WIP: fixing the test cases --- app/app.go | 2 +- app/app_test.go | 44 ++-- app/benchmark_test.go | 12 +- app/export.go | 8 +- app/simulation_test.go | 19 +- app/test_helpers.go | 233 ++++++++++++++++++-- cmd/chibaclonkd/cmd_test.go | 2 +- crypto/hd/algorithm_test.go | 10 +- encoding/codec/codec.go | 2 + encoding/config.go | 11 +- testutil/network/network.go | 4 +- testutil/network/util.go | 1 - x/auction/keeper/grpc_query_test.go | 6 +- x/auction/keeper/keeper_test.go | 4 +- x/bond/keeper/grpc_query_test.go | 11 +- x/bond/keeper/keeper_test.go | 4 +- x/bond/module_test.go | 8 +- x/evm/handler_test.go | 54 ++--- x/evm/keeper/benchmark_test.go | 3 +- x/evm/keeper/grpc_query_test.go | 2 +- x/evm/keeper/keeper_test.go | 42 +--- x/evm/keeper/utils.go | 26 +-- x/feemarket/keeper/eip1559_test.go | 15 +- x/feemarket/keeper/keeper_test.go | 13 +- x/feemarket/migrations/v010/migrate_test.go | 7 +- x/nameservice/keeper/keeper_test.go | 7 +- 26 files changed, 351 insertions(+), 199 deletions(-) diff --git a/app/app.go b/app/app.go index 8f628640d..04b48797c 100644 --- a/app/app.go +++ b/app/app.go @@ -678,7 +678,6 @@ func NewEthermintApp( // initialize BaseApp app.SetInitChainer(app.InitChainer) app.SetBeginBlocker(app.BeginBlocker) - app.SetEndBlocker(app.EndBlocker) // app.ScopedIBCKeeper = scopedIBCKeeper // app.ScopedTransferKeeper = scopedTransferKeeper @@ -699,6 +698,7 @@ func NewEthermintApp( } app.setTxHandler(options, encodingConfig.TxConfig, cast.ToStringSlice(appOpts.Get(server.FlagIndexEvents))) + app.SetEndBlocker(app.EndBlocker) return app } diff --git a/app/app_test.go b/app/app_test.go index 6ddf51284..cefb5a9b1 100644 --- a/app/app_test.go +++ b/app/app_test.go @@ -1,41 +1,43 @@ package app import ( - "encoding/json" - "os" "testing" + memdb "github.com/cosmos/cosmos-sdk/db/memdb" "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/simapp" - - abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/libs/log" - dbm "github.com/tendermint/tm-db" "github.com/tharsis/ethermint/encoding" ) func TestEthermintAppExport(t *testing.T) { - db := dbm.NewMemDB() - app := NewEthermintApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) + encCfg := encoding.MakeConfig(ModuleBasics) + db := memdb.NewDB() + logger, _ := log.NewDefaultLogger("plain", "info", false) + app := NewTestAppWithCustomOptions(t, false, SetupOptions{ + Logger: logger, + DB: db, + InvCheckPeriod: 0, + EncConfig: encCfg, + HomePath: DefaultNodeHome, + SkipUpgradeHeights: map[int64]bool{}, + AppOpts: EmptyAppOptions{}, + }) - genesisState := NewDefaultGenesisState() - stateBytes, err := json.MarshalIndent(genesisState, "", " ") - require.NoError(t, err) + // for acc := range maccPerms { + // fmt.Println(acc) + // require.True( + // t, + // app.BankKeeper.BlockedAddr(app.AccountKeeper.GetModuleAddress(acc)), + // fmt.Sprintf("ensure that blocked addresses %s are properly set in bank keeper", acc), + // ) + // } - // Initialize the chain - app.InitChain( - abci.RequestInitChain{ - ChainId: "ethermint_9000-1", - Validators: []abci.ValidatorUpdate{}, - AppStateBytes: stateBytes, - }, - ) app.Commit() // Making a new app object with the db, so that initchain hasn't been called - app2 := NewEthermintApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) - _, err = app2.ExportAppStateAndValidators(false, []string{}) + app2 := NewEthermintApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{}) + _, err := app2.ExportAppStateAndValidators(false, []string{}) require.NoError(t, err, "ExportAppStateAndValidators should not have an error") } diff --git a/app/benchmark_test.go b/app/benchmark_test.go index a88712e7f..5b2bb159c 100644 --- a/app/benchmark_test.go +++ b/app/benchmark_test.go @@ -2,21 +2,21 @@ package app import ( "encoding/json" - "io" "testing" + "github.com/cosmos/cosmos-sdk/db/memdb" "github.com/cosmos/cosmos-sdk/simapp" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/libs/log" - dbm "github.com/tendermint/tm-db" "github.com/tharsis/ethermint/encoding" ) func BenchmarkEthermintApp_ExportAppStateAndValidators(b *testing.B) { - db := dbm.NewMemDB() - app := NewEthermintApp(log.NewTMLogger(io.Discard), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) + db := memdb.NewDB() + logger, _ := log.NewDefaultLogger("plain", "info", false) + app := NewEthermintApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) - genesisState := NewDefaultGenesisState() + genesisState := NewDefaultGenesisState(app.appCodec) stateBytes, err := json.MarshalIndent(genesisState, "", " ") if err != nil { b.Fatal(err) @@ -36,7 +36,7 @@ func BenchmarkEthermintApp_ExportAppStateAndValidators(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { // Making a new app object with the db, so that initchain hasn't been called - app2 := NewEthermintApp(log.NewTMLogger(log.NewSyncWriter(io.Discard)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) + app2 := NewEthermintApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) if _, err := app2.ExportAppStateAndValidators(false, []string{}); err != nil { b.Fatal(err) } diff --git a/app/export.go b/app/export.go index ddbdc290f..7efbe528c 100644 --- a/app/export.go +++ b/app/export.go @@ -6,20 +6,18 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + "github.com/cosmos/cosmos-sdk/codec" servertypes "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" "github.com/cosmos/cosmos-sdk/x/staking" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - - "github.com/tharsis/ethermint/encoding" ) // NewDefaultGenesisState generates the default state for the application. -func NewDefaultGenesisState() simapp.GenesisState { - encCfg := encoding.MakeConfig(ModuleBasics) - return ModuleBasics.DefaultGenesis(encCfg.Codec) +func NewDefaultGenesisState(cdc codec.JSONCodec) simapp.GenesisState { + return ModuleBasics.DefaultGenesis(cdc) } // ExportAppStateAndValidators exports the state of the application for a genesis diff --git a/app/simulation_test.go b/app/simulation_test.go index 43f97bea3..dc02f1260 100644 --- a/app/simulation_test.go +++ b/app/simulation_test.go @@ -13,7 +13,6 @@ import ( "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/simapp/params" - "github.com/cosmos/cosmos-sdk/store" sdk "github.com/cosmos/cosmos-sdk/types" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" @@ -29,11 +28,12 @@ import ( stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" // ibctransfertypes "github.com/cosmos/ibc-go/v3/modules/apps/transfer/types" + "github.com/cosmos/cosmos-sdk/db/memdb" + storetypes "github.com/cosmos/cosmos-sdk/store/types" ibchost "github.com/cosmos/ibc-go/v3/modules/core/24-host" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/libs/log" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - dbm "github.com/tendermint/tm-db" evmenc "github.com/tharsis/ethermint/encoding" ) @@ -49,21 +49,22 @@ func init() { const SimAppChainID = "simulation_777-1" type storeKeysPrefixes struct { - A sdk.StoreKey - B sdk.StoreKey + A storetypes.StoreKey + B storetypes.StoreKey Prefixes [][]byte } // fauxMerkleModeOpt returns a BaseApp option to use a dbStoreAdapter instead of // an IAVLStore for faster simulation speed. -func fauxMerkleModeOpt(bapp *baseapp.BaseApp) { +var fauxMerkleModeOpt = baseapp.AppOptionFunc(func(bapp *baseapp.BaseApp) { bapp.SetFauxMerkleMode() -} +}) // interBlockCacheOpt returns a BaseApp option function that sets the persistent // inter-block write-through cache. -func interBlockCacheOpt() func(*baseapp.BaseApp) { - return baseapp.SetInterBlockCache(store.NewCommitKVStoreCacheManager()) +// TODO: implement this cache as enhancement to v2 multistore +func interBlockCacheOpt() baseapp.AppOptionFunc { + return func(*baseapp.BaseApp) {} } func TestFullAppSimulation(t *testing.T) { @@ -311,7 +312,7 @@ func TestAppStateDeterminism(t *testing.T) { logger = log.NewNopLogger() } - db := dbm.NewMemDB() + db := memdb.NewDB() app := NewEthermintApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, simapp.FlagPeriodValue, MakeEncodingConfig(), simapp.EmptyAppOptions{}, interBlockCacheOpt()) fmt.Printf( diff --git a/app/test_helpers.go b/app/test_helpers.go index 104654ebe..31312207d 100644 --- a/app/test_helpers.go +++ b/app/test_helpers.go @@ -1,15 +1,31 @@ package app import ( + "context" "encoding/json" + "testing" "time" - sdk "github.com/cosmos/cosmos-sdk/types" - + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" + "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/testutil/mock" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + + "github.com/cosmos/cosmos-sdk/simapp/params" + "github.com/stretchr/testify/require" + tmjson "github.com/tendermint/tendermint/libs/json" + "github.com/tharsis/ethermint/crypto/ethsecp256k1" "github.com/tharsis/ethermint/encoding" + ethermint "github.com/tharsis/ethermint/types" "github.com/cosmos/cosmos-sdk/db/memdb" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/libs/log" @@ -17,6 +33,14 @@ import ( tmtypes "github.com/tendermint/tendermint/types" ) +// GenesisState of the blockchain is represented here as a map of raw json +// messages key'd by a identifier string. +// The identifier is used to determine which module genesis information belongs +// to so it may be appropriately routed during init chain. +// Within this application default genesis information is retrieved from +// the ModuleBasicManager which populates json from each BasicModule +// object provided to it during init. + // DefaultConsensusParams defines the default Tendermint consensus params used in // EthermintApp testing. var DefaultConsensusParams = &tmproto.ConsensusParams{ @@ -36,20 +60,50 @@ var DefaultConsensusParams = &tmproto.ConsensusParams{ }, } -// Setup initializes a new EthermintApp. A Nop logger is set in EthermintApp. -func Setup(isCheckTx bool, patchGenesis func(*EthermintApp, simapp.GenesisState) simapp.GenesisState) *EthermintApp { - app := NewEthermintApp(log.NewNopLogger(), memdb.NewDB(), nil, true, map[int64]bool{}, DefaultNodeHome, 5, encoding.MakeConfig(ModuleBasics), simapp.EmptyAppOptions{}) +// SetupOptions defines arguments that are passed into `Simapp` constructor. +type SetupOptions struct { + Logger log.Logger + DB *memdb.MemDB + InvCheckPeriod uint + HomePath string + SkipUpgradeHeights map[int64]bool + EncConfig params.EncodingConfig + AppOpts types.AppOptions +} + +func NewTestAppWithCustomOptions(t *testing.T, isCheckTx bool, options SetupOptions) *EthermintApp { + t.Helper() + + privVal := mock.NewPV() + pubKey, err := privVal.GetPubKey(context.TODO()) + require.NoError(t, err) + // create validator set with single validator + validator := tmtypes.NewValidator(pubKey, 1) + valSet := tmtypes.NewValidatorSet([]*tmtypes.Validator{validator}) + + // generate genesis account + priv, err := ethsecp256k1.GenerateKey() + require.NoError(t, err) + address := common.BytesToAddress(priv.PubKey().Address().Bytes()) + + acc := ðermint.EthAccount{ + BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(address.Bytes()), nil, 0, 0), + CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(), + } + + balance := banktypes.Balance{ + Address: acc.GetAddress().String(), + Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000000000000))), + } + + app := NewEthermintApp(options.Logger, options.DB, nil, true, options.SkipUpgradeHeights, options.HomePath, options.InvCheckPeriod, options.EncConfig, options.AppOpts) + genesisState := NewDefaultGenesisState(app.appCodec) + genesisState = genesisStateWithValSet(t, app, genesisState, valSet, []authtypes.GenesisAccount{acc}, balance) + if !isCheckTx { // init chain must be called to stop deliverState from being nil - genesisState := NewDefaultGenesisState() - if patchGenesis != nil { - genesisState = patchGenesis(app, genesisState) - } - - stateBytes, err := json.MarshalIndent(genesisState, "", " ") - if err != nil { - panic(err) - } + stateBytes, err := tmjson.MarshalIndent(genesisState, "", " ") + require.NoError(t, err) // Initialize the chain app.InitChain( @@ -65,6 +119,149 @@ func Setup(isCheckTx bool, patchGenesis func(*EthermintApp, simapp.GenesisState) return app } +// Setup initializes a new EthermintApp. A Nop logger is set in EthermintApp. +func Setup(t *testing.T, isCheckTx bool, patchGenesis func(*EthermintApp, simapp.GenesisState) simapp.GenesisState) *EthermintApp { + + t.Helper() + + privVal := mock.NewPV() + pubKey, err := privVal.GetPubKey(context.TODO()) + require.NoError(t, err) + + // create validator set with single validator + validator := tmtypes.NewValidator(pubKey, 1) + valSet := tmtypes.NewValidatorSet([]*tmtypes.Validator{validator}) + + priv, err := ethsecp256k1.GenerateKey() + require.NoError(t, err) + address := common.BytesToAddress(priv.PubKey().Address().Bytes()) + + acc := ðermint.EthAccount{ + BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(address.Bytes()), nil, 0, 0), + CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(), + } + + balance := banktypes.Balance{ + Address: acc.GetAddress().String(), + Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000000000000))), + } + + app := SetupWithGenesisValSet(t, valSet, patchGenesis, []authtypes.GenesisAccount{acc}, balance) + + return app +} + +func setup(withGenesis bool, invCheckPeriod uint, patchGenesis func(*EthermintApp, simapp.GenesisState) simapp.GenesisState) (*EthermintApp, simapp.GenesisState) { + encCdc := encoding.MakeConfig(ModuleBasics) + app := NewEthermintApp(log.NewNopLogger(), memdb.NewDB(), nil, true, map[int64]bool{}, DefaultNodeHome, invCheckPeriod, encCdc, EmptyAppOptions{}) + if withGenesis { + genesisState := NewDefaultGenesisState(encCdc.Codec) + if patchGenesis != nil { + genesisState = patchGenesis(app, genesisState) + } + return app, genesisState + } + + return app, simapp.GenesisState{} +} + +// SetupWithGenesisValSet initializes a new SimApp with a validator set and genesis accounts +// that also act as delegators. For simplicity, each validator is bonded with a delegation +// of one consensus engine unit in the default token of the simapp from first genesis +// account. A Nop logger is set in SimApp. +func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, patchGenesis func(*EthermintApp, simapp.GenesisState) simapp.GenesisState, genAccs []authtypes.GenesisAccount, balances ...banktypes.Balance) *EthermintApp { + t.Helper() + + app, genesisState := setup(true, 5, patchGenesis) + genesisState = genesisStateWithValSet(t, app, genesisState, valSet, genAccs, balances...) + + stateBytes, err := json.MarshalIndent(genesisState, "", " ") + require.NoError(t, err) + + // init chain will set the validator set and initialize the genesis accounts + app.InitChain( + abci.RequestInitChain{ + ChainId: "ethermint_9000-1", + Validators: []abci.ValidatorUpdate{}, + ConsensusParams: DefaultConsensusParams, + AppStateBytes: stateBytes, + }, + ) + + // commit genesis changes + // app.Commit() + // app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{ + // ChainID: "ethermint_9000-1", + // Height: app.LastBlockHeight() + 1, + // AppHash: app.LastCommitID().Hash, + // ValidatorsHash: valSet.Hash(), + // NextValidatorsHash: valSet.Hash(), + // }}) + + return app +} + +func genesisStateWithValSet(t *testing.T, app *EthermintApp, genesisState simapp.GenesisState, + valSet *tmtypes.ValidatorSet, genAccs []authtypes.GenesisAccount, balances ...banktypes.Balance) simapp.GenesisState { + // set genesis accounts + authGenesis := authtypes.NewGenesisState(authtypes.DefaultParams(), genAccs) + genesisState[authtypes.ModuleName] = app.AppCodec().MustMarshalJSON(authGenesis) + + validators := make([]stakingtypes.Validator, 0, len(valSet.Validators)) + delegations := make([]stakingtypes.Delegation, 0, len(valSet.Validators)) + + bondAmt := sdk.DefaultPowerReduction + + for _, val := range valSet.Validators { + pk, err := cryptocodec.FromTmPubKeyInterface(val.PubKey) + require.NoError(t, err) + pkAny, err := codectypes.NewAnyWithValue(pk) + require.NoError(t, err) + validator := stakingtypes.Validator{ + OperatorAddress: sdk.ValAddress(val.Address).String(), + ConsensusPubkey: pkAny, + Jailed: false, + Status: stakingtypes.Bonded, + Tokens: bondAmt, + DelegatorShares: sdk.OneDec(), + Description: stakingtypes.Description{}, + UnbondingHeight: int64(0), + UnbondingTime: time.Unix(0, 0).UTC(), + Commission: stakingtypes.NewCommission(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()), + MinSelfDelegation: sdk.ZeroInt(), + } + validators = append(validators, validator) + delegations = append(delegations, stakingtypes.NewDelegation(genAccs[0].GetAddress(), val.Address.Bytes(), sdk.OneDec())) + + } + // set validators and delegations + stakingGenesis := stakingtypes.NewGenesisState(stakingtypes.DefaultParams(), validators, delegations) + genesisState[stakingtypes.ModuleName] = app.AppCodec().MustMarshalJSON(stakingGenesis) + + totalSupply := sdk.NewCoins() + for _, b := range balances { + // add genesis acc tokens to total supply + totalSupply = totalSupply.Add(b.Coins...) + } + + for range delegations { + // add delegated tokens to total supply + totalSupply = totalSupply.Add(sdk.NewCoin(sdk.DefaultBondDenom, bondAmt)) + } + + // add bonded amount to bonded pool module account + balances = append(balances, banktypes.Balance{ + Address: authtypes.NewModuleAddress(stakingtypes.BondedPoolName).String(), + Coins: sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, bondAmt)}, + }) + + // update total supply + bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, totalSupply, []banktypes.Metadata{}) + genesisState[banktypes.ModuleName] = app.AppCodec().MustMarshalJSON(bankGenesis) + + return genesisState +} + // CreateRandomAccounts will generate random accounts func CreateRandomAccounts(accNum int) []sdk.AccAddress { // createRandomAccounts is a strategy used by addTestAddrs() in order to generated addresses in random order. @@ -76,3 +273,11 @@ func CreateRandomAccounts(accNum int) []sdk.AccAddress { return testAddrs } + +// EmptyAppOptions is a stub implementing AppOptions +type EmptyAppOptions struct{} + +// Get implements AppOptions +func (ao EmptyAppOptions) Get(o string) interface{} { + return nil +} diff --git a/cmd/chibaclonkd/cmd_test.go b/cmd/chibaclonkd/cmd_test.go index b3ddf0dcd..6a3425197 100644 --- a/cmd/chibaclonkd/cmd_test.go +++ b/cmd/chibaclonkd/cmd_test.go @@ -23,6 +23,6 @@ func TestInitCmd(t *testing.T) { fmt.Sprintf("--%s=%s", flags.FlagChainID, "ethermint_9000-1"), }) - err := svrcmd.Execute(rootCmd, app.DefaultNodeHome) + err := svrcmd.Execute(rootCmd, chibaclonkd.EnvPrefix, app.DefaultNodeHome) require.NoError(t, err) } diff --git a/crypto/hd/algorithm_test.go b/crypto/hd/algorithm_test.go index 8d2eda772..98b936975 100644 --- a/crypto/hd/algorithm_test.go +++ b/crypto/hd/algorithm_test.go @@ -4,6 +4,7 @@ import ( "strings" "testing" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/stretchr/testify/require" "github.com/ethereum/go-ethereum/common" @@ -12,12 +13,14 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keyring" - cryptocodec "github.com/tharsis/ethermint/crypto/codec" ethermint "github.com/tharsis/ethermint/types" ) +var protoCodec codec.Codec + func init() { + protoCodec = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) amino := codec.NewLegacyAmino() cryptocodec.RegisterCrypto(amino) } @@ -28,7 +31,7 @@ func TestKeyring(t *testing.T) { dir := t.TempDir() mockIn := strings.NewReader("") - kr, err := keyring.New("ethermint", keyring.BackendTest, dir, mockIn, EthSecp256k1Option()) + kr, err := keyring.New("ethermint", keyring.BackendTest, dir, mockIn, protoCodec, EthSecp256k1Option()) require.NoError(t, err) // fail in retrieving key @@ -40,9 +43,8 @@ func TestKeyring(t *testing.T) { info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, ethermint.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1) require.NoError(t, err) require.NotEmpty(t, mnemonic) - require.Equal(t, "foo", info.GetName()) + require.Equal(t, "foo", info.Name) require.Equal(t, "local", info.GetType().String()) - require.Equal(t, EthSecp256k1Type, info.GetAlgo()) hdPath := ethermint.BIP44HDPath diff --git a/encoding/codec/codec.go b/encoding/codec/codec.go index 957d00a1e..d600766fc 100644 --- a/encoding/codec/codec.go +++ b/encoding/codec/codec.go @@ -6,6 +6,7 @@ import ( "github.com/cosmos/cosmos-sdk/std" sdk "github.com/cosmos/cosmos-sdk/types" + txtypes "github.com/cosmos/cosmos-sdk/types/tx" cryptocodec "github.com/tharsis/ethermint/crypto/codec" ethermint "github.com/tharsis/ethermint/types" ) @@ -20,6 +21,7 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { // RegisterInterfaces registers Interfaces from types, crypto, and SDK std. func RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) { std.RegisterInterfaces(interfaceRegistry) + txtypes.RegisterInterfaces(interfaceRegistry) cryptocodec.RegisterInterfaces(interfaceRegistry) ethermint.RegisterInterfaces(interfaceRegistry) } diff --git a/encoding/config.go b/encoding/config.go index 893194ad0..56a128118 100644 --- a/encoding/config.go +++ b/encoding/config.go @@ -12,15 +12,16 @@ import ( // MakeConfig creates an EncodingConfig for testing func MakeConfig(mb module.BasicManager) params.EncodingConfig { - cdc := codec.NewLegacyAmino() + amino := codec.NewLegacyAmino() interfaceRegistry := types.NewInterfaceRegistry() - codec := codec.NewProtoCodec(interfaceRegistry) + marshaler := codec.NewProtoCodec(interfaceRegistry) + txCfg := tx.NewTxConfig(marshaler, tx.DefaultSignModes) encodingConfig := params.EncodingConfig{ InterfaceRegistry: interfaceRegistry, - Codec: codec, - TxConfig: tx.NewTxConfig(codec, tx.DefaultSignModes), - Amino: cdc, + Codec: marshaler, + TxConfig: txCfg, + Amino: amino, } enccodec.RegisterLegacyAminoCodec(encodingConfig.Amino) diff --git a/testutil/network/network.go b/testutil/network/network.go index 498b3f3c3..a9e03c3bf 100644 --- a/testutil/network/network.go +++ b/testutil/network/network.go @@ -65,7 +65,7 @@ type AppConstructor = func(val Validator) servertypes.Application // NewAppConstructor returns a new simapp AppConstructor func NewAppConstructor(encodingCfg params.EncodingConfig) AppConstructor { return func(val Validator) servertypes.Application { - return simapp.NewSimApp( + return app.NewEthermintApp( val.Ctx.Logger, memdb.NewDB(), nil, true, make(map[int64]bool), val.Ctx.Config.RootDir, 0, encodingCfg, simapp.EmptyAppOptions{}, @@ -117,7 +117,7 @@ func DefaultConfig() Config { InterfaceRegistry: encCfg.InterfaceRegistry, AccountRetriever: authtypes.AccountRetriever{}, AppConstructor: NewAppConstructor(encCfg), - GenesisState: simapp.ModuleBasics.DefaultGenesis(encCfg.Codec), + GenesisState: app.ModuleBasics.DefaultGenesis(encCfg.Codec), TimeoutCommit: 2 * time.Second, ChainID: fmt.Sprintf("ethermint_%d-1", rand.Int63n(9999999999999)+1), NumValidators: 4, diff --git a/testutil/network/util.go b/testutil/network/util.go index ddf541b0d..681f1e5a8 100644 --- a/testutil/network/util.go +++ b/testutil/network/util.go @@ -26,7 +26,6 @@ import ( v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" mintypes "github.com/cosmos/cosmos-sdk/x/mint/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - "github.com/tharsis/ethermint/server" evmtypes "github.com/tharsis/ethermint/x/evm/types" ) diff --git a/x/auction/keeper/grpc_query_test.go b/x/auction/keeper/grpc_query_test.go index dd3440e38..922d16f6f 100644 --- a/x/auction/keeper/grpc_query_test.go +++ b/x/auction/keeper/grpc_query_test.go @@ -4,8 +4,8 @@ import ( "context" "fmt" - "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/bank/testutil" "github.com/tharsis/ethermint/app" "github.com/tharsis/ethermint/x/auction/types" ) @@ -40,7 +40,7 @@ func (suite *KeeperTestSuite) TestGrpcGetAllAuctions() { suite.Run(fmt.Sprintf("Case %s", test.msg), func() { if test.createAuctions { account := app.CreateRandomAccounts(1)[0] - err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins( + err := testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins( sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom}, )) @@ -329,7 +329,7 @@ func (suite *KeeperTestSuite) createAuctionAndCommitBid(commitBid bool) (*types. accounts := app.CreateRandomAccounts(accCount) for _, account := range accounts { - err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins( + err := testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins( sdk.Coin{Amount: sdk.NewInt(100), Denom: sdk.DefaultBondDenom}, )) if err != nil { diff --git a/x/auction/keeper/keeper_test.go b/x/auction/keeper/keeper_test.go index 95cda6692..3040a867d 100644 --- a/x/auction/keeper/keeper_test.go +++ b/x/auction/keeper/keeper_test.go @@ -22,7 +22,7 @@ type KeeperTestSuite struct { } func (suite *KeeperTestSuite) SetupTest() { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(suite.T(), false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{}) @@ -37,7 +37,7 @@ func (suite *KeeperTestSuite) SetupTest() { } func TestParams(t *testing.T) { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(t, false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{}) diff --git a/x/bond/keeper/grpc_query_test.go b/x/bond/keeper/grpc_query_test.go index bb443b2c0..2c84c255e 100644 --- a/x/bond/keeper/grpc_query_test.go +++ b/x/bond/keeper/grpc_query_test.go @@ -3,8 +3,9 @@ package keeper_test import ( "context" "fmt" - "github.com/cosmos/cosmos-sdk/simapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/bank/testutil" "github.com/tharsis/ethermint/app" "github.com/tharsis/ethermint/x/bond/types" ) @@ -39,7 +40,7 @@ func (suite *KeeperTestSuite) TestGrpcQueryBondsList() { suite.Run(fmt.Sprintf("Case %s ", test.msg), func() { if test.createBonds { account := app.CreateRandomAccounts(1)[0] - err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ + err := testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(1000), })) @@ -102,7 +103,7 @@ func (suite *KeeperTestSuite) TestGrpcQueryBondBondId() { suite.Run(fmt.Sprintf("Case %s ", test.msg), func() { if test.createBonds { account := app.CreateRandomAccounts(1)[0] - err := simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ + err := testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(1000), })) @@ -156,7 +157,7 @@ func (suite *KeeperTestSuite) TestGrpcGetBondsByOwner() { suite.Run(fmt.Sprintf("Case %s ", test.msg), func() { if test.createBonds { account := app.CreateRandomAccounts(1)[0] - _ = simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ + _ = testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(1000), })) @@ -200,7 +201,7 @@ func (suite *KeeperTestSuite) TestGrpcGetModuleBalance() { suite.Run(fmt.Sprintf("Case %s ", test.msg), func() { if test.createBonds { account := app.CreateRandomAccounts(1)[0] - _ = simapp.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ + _ = testutil.FundAccount(suite.app.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(1000), })) diff --git a/x/bond/keeper/keeper_test.go b/x/bond/keeper/keeper_test.go index c94447044..88bf9efc2 100644 --- a/x/bond/keeper/keeper_test.go +++ b/x/bond/keeper/keeper_test.go @@ -22,7 +22,7 @@ type KeeperTestSuite struct { } func (suite *KeeperTestSuite) SetupTest() { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(suite.T(), false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{}) @@ -37,7 +37,7 @@ func (suite *KeeperTestSuite) SetupTest() { } func TestParams(t *testing.T) { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(t, false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{}) diff --git a/x/bond/module_test.go b/x/bond/module_test.go index c4cd211c3..60999049a 100644 --- a/x/bond/module_test.go +++ b/x/bond/module_test.go @@ -5,23 +5,17 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" "github.com/stretchr/testify/require" - abcitypes "github.com/tendermint/tendermint/abci/types" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" app "github.com/tharsis/ethermint/app" bondtypes "github.com/tharsis/ethermint/x/bond/types" ) func TestItCreatesModuleAccountOnInitBlock(t *testing.T) { - app := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + app := app.Setup(t, false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - app.InitChain(abcitypes.RequestInitChain{ - AppStateBytes: []byte("{}"), - ChainId: "test-chain-id", - }) - acc := app.AccountKeeper.GetModuleAccount(ctx, bondtypes.ModuleName) require.NotNil(t, acc) } diff --git a/x/evm/handler_test.go b/x/evm/handler_test.go index e80791bea..1542c678b 100644 --- a/x/evm/handler_test.go +++ b/x/evm/handler_test.go @@ -8,12 +8,9 @@ import ( "github.com/gogo/protobuf/proto" - abci "github.com/tendermint/tendermint/abci/types" - tmjson "github.com/tendermint/tendermint/libs/json" - "github.com/cosmos/cosmos-sdk/simapp" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/cosmos/cosmos-sdk/x/bank/testutil" feemarkettypes "github.com/tharsis/ethermint/x/feemarket/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -75,7 +72,7 @@ func (suite *EvmTestSuite) DoSetupTest(t require.TestingT) { require.NoError(t, err) consAddress := sdk.ConsAddress(priv.PubKey().Address()) - suite.app = app.Setup(checkTx, func(app *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + suite.app = app.Setup(suite.T(), checkTx, func(app *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { if suite.dynamicTxFee { feemarketGenesis := feemarkettypes.DefaultGenesisState() feemarketGenesis.Params.EnableHeight = 1 @@ -85,36 +82,6 @@ func (suite *EvmTestSuite) DoSetupTest(t require.TestingT) { return genesis }) - coins := sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt(100000000000000))) - genesisState := app.ModuleBasics.DefaultGenesis(suite.app.AppCodec()) - b32address := sdk.MustBech32ifyAddressBytes(sdk.GetConfig().GetBech32AccountAddrPrefix(), priv.PubKey().Address().Bytes()) - balances := []banktypes.Balance{ - { - Address: b32address, - Coins: coins, - }, - { - Address: suite.app.AccountKeeper.GetModuleAddress(authtypes.FeeCollectorName).String(), - Coins: coins, - }, - } - // update total supply - bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt(200000000000000))), []banktypes.Metadata{}) - genesisState[banktypes.ModuleName] = suite.app.AppCodec().MustMarshalJSON(bankGenesis) - - stateBytes, err := tmjson.MarshalIndent(genesisState, "", " ") - require.NoError(t, err) - - // Initialize the chain - suite.app.InitChain( - abci.RequestInitChain{ - ChainId: "ethermint_9000-1", - Validators: []abci.ValidatorUpdate{}, - ConsensusParams: simapp.DefaultConsensusParams, - AppStateBytes: stateBytes, - }, - ) - suite.ctx = suite.app.BaseApp.NewContext(checkTx, tmproto.Header{ Height: 1, ChainID: "ethermint_9000-1", @@ -139,10 +106,25 @@ func (suite *EvmTestSuite) DoSetupTest(t require.TestingT) { LastResultsHash: tmhash.Sum([]byte("last_result")), }) + coins := sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt(100000000000000))) + b32address := sdk.MustBech32ifyAddressBytes(sdk.GetConfig().GetBech32AccountAddrPrefix(), priv.PubKey().Address().Bytes()) + accAddr, err := sdk.AccAddressFromBech32(b32address) + require.NoError(t, err) + acc := ðermint.EthAccount{ + BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(accAddr.Bytes()), nil, 0, 0), + CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(), + } + + err = testutil.FundAccount(suite.app.BankKeeper, suite.ctx, accAddr, coins) + require.NoError(t, err) + + err = testutil.FundModuleAccount(suite.app.BankKeeper, suite.ctx, authtypes.FeeCollectorName, coins) + require.NoError(t, err) + queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry()) types.RegisterQueryServer(queryHelper, suite.app.EvmKeeper) - acc := ðermint.EthAccount{ + acc = ðermint.EthAccount{ BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(address.Bytes()), nil, 0, 0), CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(), } diff --git a/x/evm/keeper/benchmark_test.go b/x/evm/keeper/benchmark_test.go index 1abed30c7..1223737b6 100644 --- a/x/evm/keeper/benchmark_test.go +++ b/x/evm/keeper/benchmark_test.go @@ -14,6 +14,7 @@ import ( ethtypes "github.com/ethereum/go-ethereum/core/types" ethermint "github.com/tharsis/ethermint/types" "github.com/tharsis/ethermint/x/evm/types" + authmiddleware "github.com/cosmos/cosmos-sdk/x/auth/middleware" ) func SetupContract(b *testing.B) (*KeeperTestSuite, common.Address) { @@ -135,7 +136,7 @@ func BenchmarkMessageCall(b *testing.B) { require.NoError(b, err) fees := sdk.Coins{sdk.NewCoin(suite.EvmDenom(), sdk.NewIntFromBigInt(txData.Fee()))} - err = authante.DeductFees(suite.app.BankKeeper, suite.ctx, suite.app.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees) + err = authmiddleware.DeductFees(suite.app.BankKeeper, suite.ctx, suite.app.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees) require.NoError(b, err) rsp, err := suite.app.EvmKeeper.EthereumTx(sdk.WrapSDKContext(ctx), msg) diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go index 690e67b70..14550493e 100644 --- a/x/evm/keeper/grpc_query_test.go +++ b/x/evm/keeper/grpc_query_test.go @@ -467,7 +467,7 @@ func (suite *KeeperTestSuite) TestQueryValidatorAccount() { for _, tc := range testCases { suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { - suite.SetupTest() // reset + // suite.SetupTest() // reset tc.malleate() ctx := sdk.WrapSDKContext(suite.ctx) diff --git a/x/evm/keeper/keeper_test.go b/x/evm/keeper/keeper_test.go index 8386f6fe1..d3d7f3f3a 100644 --- a/x/evm/keeper/keeper_test.go +++ b/x/evm/keeper/keeper_test.go @@ -18,9 +18,8 @@ import ( "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/cosmos/cosmos-sdk/x/bank/testutil" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - tmjson "github.com/tendermint/tendermint/libs/json" feemarkettypes "github.com/tharsis/ethermint/x/feemarket/types" "github.com/tharsis/ethermint/app" @@ -86,7 +85,7 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) { require.NoError(t, err) suite.consAddress = sdk.ConsAddress(priv.PubKey().Address()) - suite.app = app.Setup(checkTx, func(app *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + suite.app = app.Setup(suite.T(), checkTx, func(app *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { feemarketGenesis := feemarkettypes.DefaultGenesisState() if suite.enableFeemarket { feemarketGenesis.Params.EnableHeight = 1 @@ -106,37 +105,6 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) { return genesis }) - if suite.mintFeeCollector { - // mint some coin to fee collector - coins := sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt(int64(params.TxGas)-1))) - genesisState := app.ModuleBasics.DefaultGenesis(suite.app.AppCodec()) - balances := []banktypes.Balance{ - { - Address: suite.app.AccountKeeper.GetModuleAddress(authtypes.FeeCollectorName).String(), - Coins: coins, - }, - } - // update total supply - bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt((int64(params.TxGas)-1)))), []banktypes.Metadata{}) - bz := suite.app.AppCodec().MustMarshalJSON(bankGenesis) - require.NotNil(t, bz) - genesisState[banktypes.ModuleName] = suite.app.AppCodec().MustMarshalJSON(bankGenesis) - - // we marshal the genesisState of all module to a byte array - stateBytes, err := tmjson.MarshalIndent(genesisState, "", " ") - require.NoError(t, err) - - // Initialize the chain - suite.app.InitChain( - abci.RequestInitChain{ - ChainId: "ethermint_9000-1", - Validators: []abci.ValidatorUpdate{}, - ConsensusParams: simapp.DefaultConsensusParams, - AppStateBytes: stateBytes, - }, - ) - } - suite.ctx = suite.app.BaseApp.NewContext(checkTx, tmproto.Header{ Height: 1, ChainID: "ethermint_9000-1", @@ -161,6 +129,12 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) { LastResultsHash: tmhash.Sum([]byte("last_result")), }) + if suite.mintFeeCollector { + // mint some coin to fee collector + coins := sdk.NewCoins(sdk.NewCoin(types.DefaultEVMDenom, sdk.NewInt(int64(params.TxGas)-1))) + testutil.FundModuleAccount(suite.app.BankKeeper, suite.ctx, authtypes.FeeCollectorName, coins) + } + queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry()) types.RegisterQueryServer(queryHelper, suite.app.EvmKeeper) suite.queryClient = types.NewQueryClient(queryHelper) diff --git a/x/evm/keeper/utils.go b/x/evm/keeper/utils.go index ca708ecdc..3242d0334 100644 --- a/x/evm/keeper/utils.go +++ b/x/evm/keeper/utils.go @@ -6,7 +6,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - // authante "github.com/cosmos/cosmos-sdk/x/auth/ante" + authmiddleware "github.com/cosmos/cosmos-sdk/x/auth/middleware" evmtypes "github.com/tharsis/ethermint/x/evm/types" @@ -25,10 +25,10 @@ func (k Keeper) DeductTxCostsFromUserBalance( isContractCreation := txData.GetTo() == nil // fetch sender account from signature - // signerAcc, err := authante.GetSignerAcc(ctx, k.accountKeeper, msgEthTx.GetFrom()) - // if err != nil { - // return nil, sdkerrors.Wrapf(err, "account not found for sender %s", msgEthTx.From) - // } + signerAcc, err := authmiddleware.GetSignerAcc(ctx, k.accountKeeper, msgEthTx.GetFrom()) + if err != nil { + return nil, sdkerrors.Wrapf(err, "account not found for sender %s", msgEthTx.From) + } gasLimit := txData.GetGas() @@ -74,14 +74,14 @@ func (k Keeper) DeductTxCostsFromUserBalance( fees := sdk.Coins{sdk.NewCoin(denom, sdk.NewIntFromBigInt(feeAmt))} - // // deduct the full gas cost from the user balance - // if err := authante.DeductFees(k.bankKeeper, ctx, signerAcc, fees); err != nil { - // return nil, sdkerrors.Wrapf( - // err, - // "failed to deduct full gas cost %s from the user %s balance", - // fees, msgEthTx.From, - // ) - // } + // deduct the full gas cost from the user balance + if err := authmiddleware.DeductFees(k.bankKeeper, ctx, signerAcc, fees); err != nil { + return nil, sdkerrors.Wrapf( + err, + "failed to deduct full gas cost %s from the user %s balance", + fees, msgEthTx.From, + ) + } return fees, nil } diff --git a/x/feemarket/keeper/eip1559_test.go b/x/feemarket/keeper/eip1559_test.go index b4da37e18..55072443d 100644 --- a/x/feemarket/keeper/eip1559_test.go +++ b/x/feemarket/keeper/eip1559_test.go @@ -2,8 +2,9 @@ package keeper_test import ( "fmt" - abci "github.com/tendermint/tendermint/abci/types" "math/big" + + prototypes "github.com/tendermint/tendermint/proto/tendermint/types" ) func (suite *KeeperTestSuite) TestCalculateBaseFee() { @@ -38,11 +39,11 @@ func (suite *KeeperTestSuite) TestCalculateBaseFee() { suite.app.FeeMarketKeeper.SetBlockGasUsed(suite.ctx, 100) // Set target/gasLimit through Consensus Param MaxGas - blockParams := abci.BlockParams{ + blockParams := prototypes.BlockParams{ MaxGas: 100, MaxBytes: 10, } - consParams := abci.ConsensusParams{Block: &blockParams} + consParams := prototypes.ConsensusParams{Block: &blockParams} suite.ctx = suite.ctx.WithConsensusParams(&consParams) // set ElasticityMultiplier @@ -60,11 +61,11 @@ func (suite *KeeperTestSuite) TestCalculateBaseFee() { suite.app.FeeMarketKeeper.SetBlockGasUsed(suite.ctx, 200) - blockParams := abci.BlockParams{ + blockParams := prototypes.BlockParams{ MaxGas: 100, MaxBytes: 10, } - consParams := abci.ConsensusParams{Block: &blockParams} + consParams := prototypes.ConsensusParams{Block: &blockParams} suite.ctx = suite.ctx.WithConsensusParams(&consParams) params := suite.app.FeeMarketKeeper.GetParams(suite.ctx) @@ -81,11 +82,11 @@ func (suite *KeeperTestSuite) TestCalculateBaseFee() { suite.app.FeeMarketKeeper.SetBlockGasUsed(suite.ctx, 50) - blockParams := abci.BlockParams{ + blockParams := prototypes.BlockParams{ MaxGas: 100, MaxBytes: 10, } - consParams := abci.ConsensusParams{Block: &blockParams} + consParams := prototypes.ConsensusParams{Block: &blockParams} suite.ctx = suite.ctx.WithConsensusParams(&consParams) params := suite.app.FeeMarketKeeper.GetParams(suite.ctx) diff --git a/x/feemarket/keeper/keeper_test.go b/x/feemarket/keeper/keeper_test.go index be9618648..0d502b042 100644 --- a/x/feemarket/keeper/keeper_test.go +++ b/x/feemarket/keeper/keeper_test.go @@ -15,8 +15,6 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keyring" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" - "github.com/tharsis/ethermint/app" "github.com/tharsis/ethermint/crypto/ethsecp256k1" "github.com/tharsis/ethermint/encoding" @@ -66,7 +64,7 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) { require.NoError(t, err) suite.consAddress = sdk.ConsAddress(priv.PubKey().Address()) - suite.app = app.Setup(checkTx, nil) + suite.app = app.Setup(suite.T(), checkTx, nil) suite.ctx = suite.app.BaseApp.NewContext(checkTx, tmproto.Header{ Height: 1, ChainID: "ethermint_9000-1", @@ -101,15 +99,6 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) { } suite.app.AccountKeeper.SetAccount(suite.ctx, acc) - - valAddr := sdk.ValAddress(suite.address.Bytes()) - validator, err := stakingtypes.NewValidator(valAddr, priv.PubKey(), stakingtypes.Description{}) - err = suite.app.StakingKeeper.SetValidatorByConsAddr(suite.ctx, validator) - require.NoError(t, err) - err = suite.app.StakingKeeper.SetValidatorByConsAddr(suite.ctx, validator) - require.NoError(t, err) - suite.app.StakingKeeper.SetValidator(suite.ctx, validator) - encodingConfig := encoding.MakeConfig(app.ModuleBasics) suite.clientCtx = client.Context{}.WithTxConfig(encodingConfig.TxConfig) suite.ethSigner = ethtypes.LatestSignerForChainID(suite.app.EvmKeeper.ChainID()) diff --git a/x/feemarket/migrations/v010/migrate_test.go b/x/feemarket/migrations/v010/migrate_test.go index 13ee56bca..5934d2905 100644 --- a/x/feemarket/migrations/v010/migrate_test.go +++ b/x/feemarket/migrations/v010/migrate_test.go @@ -1,7 +1,6 @@ package v010_test import ( - "fmt" "testing" "github.com/stretchr/testify/require" @@ -22,12 +21,12 @@ import ( func TestMigrateStore(t *testing.T) { encCfg := encoding.MakeConfig(app.ModuleBasics) feemarketKey := sdk.NewKVStoreKey(feemarkettypes.StoreKey) - tFeeMarketKey := sdk.NewTransientStoreKey(fmt.Sprintf("%s_test", feemarkettypes.StoreKey)) + tFeeMarketKey := sdk.NewTransientStoreKey("margetkey_test") ctx := testutil.DefaultContext(feemarketKey, tFeeMarketKey) paramstore := paramtypes.NewSubspace( - encCfg.Marshaler, encCfg.Amino, feemarketKey, tFeeMarketKey, "feemarket", + encCfg.Codec, encCfg.Amino, feemarketKey, tFeeMarketKey, "feemarket", ) - fmKeeper := feemarketkeeper.NewKeeper(encCfg.Marshaler, feemarketKey, paramstore) + fmKeeper := feemarketkeeper.NewKeeper(encCfg.Codec, feemarketKey, paramstore) fmKeeper.SetParams(ctx, types.DefaultParams()) require.True(t, paramstore.HasKeyTable()) diff --git a/x/nameservice/keeper/keeper_test.go b/x/nameservice/keeper/keeper_test.go index f30572692..af50af440 100644 --- a/x/nameservice/keeper/keeper_test.go +++ b/x/nameservice/keeper/keeper_test.go @@ -6,6 +6,7 @@ import ( "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/bank/testutil" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" @@ -25,7 +26,7 @@ type KeeperTestSuite struct { } func (suite *KeeperTestSuite) SetupTest() { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(suite.T(), false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{}) @@ -38,7 +39,7 @@ func (suite *KeeperTestSuite) SetupTest() { suite.accounts = app.CreateRandomAccounts(1) account := suite.accounts[0] - _ = simapp.FundAccount(testApp.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ + _ = testutil.FundAccount(testApp.BankKeeper, ctx, account, sdk.NewCoins(sdk.Coin{ Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(100000000000), })) @@ -52,7 +53,7 @@ func (suite *KeeperTestSuite) SetupTest() { } func TestParams(t *testing.T) { - testApp := app.Setup(false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { + testApp := app.Setup(t, false, func(ea *app.EthermintApp, genesis simapp.GenesisState) simapp.GenesisState { return genesis }) ctx := testApp.BaseApp.NewContext(false, tmproto.Header{})