From 7156f44a0c43163a88ff8db0ba396e3dc180ad36 Mon Sep 17 00:00:00 2001 From: stepit Date: Tue, 17 Dec 2024 12:22:56 +0100 Subject: [PATCH 01/12] add bank mock --- x/evm/wrappers/testutil/mock.go | 102 ++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 x/evm/wrappers/testutil/mock.go diff --git a/x/evm/wrappers/testutil/mock.go b/x/evm/wrappers/testutil/mock.go new file mode 100644 index 0000000..7418042 --- /dev/null +++ b/x/evm/wrappers/testutil/mock.go @@ -0,0 +1,102 @@ +package testutil + +import ( + "context" + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/evmos/os/x/evm/types" +) + +var _ types.BankKeeper = &MockBank{} + +type MockBank struct { + Balances map[string]sdk.Coin + HasPermission bool +} + +func NewMockBank() *MockBank { + return &MockBank{ + HasPermission: true, + } +} + +// SendCoinsFromModuleToAccount implements types.BankKeeper. +func (m *MockBank) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error { + evmCoin := amt[0] + + senderBalance := m.Balances[senderModule] + if senderBalance.Amount.LT(evmCoin.Amount) { + return fmt.Errorf("insufficient balance: %s < %s", senderBalance.Amount, evmCoin.Amount) + } + + m.Balances[recipientAddr.String()] = m.Balances[recipientAddr.String()].Add(evmCoin) + m.Balances[senderModule] = m.Balances[senderModule].Sub(evmCoin) + + return nil +} + +// SendCoinsFromAccountToModule implements types.BankKeeper. +func (m *MockBank) SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error { + evmCoin := amt[0] + + senderBalance := m.Balances[senderAddr.String()] + if senderBalance.Amount.LT(evmCoin.Amount) { + return fmt.Errorf("insufficient balance: %s < %s", senderBalance.Amount, evmCoin.Amount) + } + + m.Balances[recipientModule] = m.Balances[recipientModule].Add(evmCoin) + m.Balances[senderAddr.String()] = m.Balances[senderAddr.String()].Sub(evmCoin) + + return nil +} + +// BurnCoins implements types.BankKeeper. +func (m *MockBank) BurnCoins(ctx context.Context, moduleName string, amt sdk.Coins) error { + evmCoin := amt[0] + + moduleBalance := m.Balances[moduleName] + if moduleBalance.Amount.LT(evmCoin.Amount) { + return fmt.Errorf("insufficient balance: %s < %s", moduleBalance.Amount, evmCoin.Amount) + } + + m.Balances[moduleName] = m.Balances[moduleName].Sub(evmCoin) + + return nil +} + +// MintCoins implements types.BankKeeper. +func (m *MockBank) MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error { + if !m.HasPermission { + return fmt.Errorf("permission denied") + } + + evmCoin := amt[0] + + m.Balances[moduleName] = m.Balances[moduleName].Add(evmCoin) + + return nil +} + +// GetBalance implements types.BankKeeper. +func (m *MockBank) GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin { + return m.Balances[addr.String()] +} + +// NOTE: Below methods are not implemented because are not used from the wrapper but are required to +// implement the interface. + +// GetAllBalances implements types.BankKeeper. +func (m *MockBank) GetAllBalances(ctx context.Context, addr sdk.AccAddress) sdk.Coins { + panic("unimplemented") +} + +// IsSendEnabledCoins implements types.BankKeeper. +func (m *MockBank) IsSendEnabledCoins(ctx context.Context, coins ...sdk.Coin) error { + panic("unimplemented") +} + +// SendCoins implements types.BankKeeper. +func (m *MockBank) SendCoins(ctx context.Context, from sdk.AccAddress, to sdk.AccAddress, amt sdk.Coins) error { + panic("unimplemented") +} From bdbcb819d9c0eefdc00d59bfc0c7b516fb3e30ca Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 18 Dec 2024 09:33:22 +0100 Subject: [PATCH 02/12] replace deprecated golang mock with uber mock --- go.mod | 3 ++- go.sum | 2 ++ x/erc20/keeper/msg_server_test.go | 2 +- x/erc20/types/mocks/BankKeeper.go | 2 +- 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index bda0086..d562107 100644 --- a/go.mod +++ b/go.mod @@ -28,7 +28,6 @@ require ( github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf github.com/ethereum/go-ethereum v1.11.5 github.com/evmos/os/example_chain v0.0.0-20240924163020-b2a4187dad50 - github.com/golang/mock v1.6.0 github.com/golang/protobuf v1.5.4 github.com/gorilla/mux v1.8.1 github.com/gorilla/websocket v1.5.3 @@ -48,6 +47,7 @@ require ( github.com/tidwall/sjson v1.2.5 github.com/tyler-smith/go-bip39 v1.1.0 github.com/zondax/hid v0.9.2 + go.uber.org/mock v0.5.0 golang.org/x/crypto v0.29.0 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 golang.org/x/net v0.31.0 @@ -135,6 +135,7 @@ require ( github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/glog v1.2.2 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/mock v1.6.0 // indirect github.com/golang/snappy v0.0.4 // indirect github.com/google/btree v1.1.3 // indirect github.com/google/flatbuffers v23.5.26+incompatible // indirect diff --git a/go.sum b/go.sum index 69756fe..525f4a7 100644 --- a/go.sum +++ b/go.sum @@ -1194,6 +1194,8 @@ go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= diff --git a/x/erc20/keeper/msg_server_test.go b/x/erc20/keeper/msg_server_test.go index 563fff6..238928d 100644 --- a/x/erc20/keeper/msg_server_test.go +++ b/x/erc20/keeper/msg_server_test.go @@ -15,8 +15,8 @@ import ( erc20mocks "github.com/evmos/os/x/erc20/types/mocks" "github.com/evmos/os/x/evm/statedb" evmtypes "github.com/evmos/os/x/evm/types" - "github.com/golang/mock/gomock" "github.com/stretchr/testify/mock" + gomock "go.uber.org/mock/gomock" ) func (suite *KeeperTestSuite) TestConvertERC20NativeERC20() { diff --git a/x/erc20/types/mocks/BankKeeper.go b/x/erc20/types/mocks/BankKeeper.go index a4582cd..664ff49 100644 --- a/x/erc20/types/mocks/BankKeeper.go +++ b/x/erc20/types/mocks/BankKeeper.go @@ -12,7 +12,7 @@ import ( query "github.com/cosmos/cosmos-sdk/types/query" keeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" types0 "github.com/cosmos/cosmos-sdk/x/bank/types" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // BankKeeper is a mock of BankKeeper interface. From 362dbbe786d60522bd4e9cd598b659b2a793d799 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 18 Dec 2024 11:11:23 +0100 Subject: [PATCH 03/12] refactor bank mock to use uber mock --- x/evm/wrappers/testutil/mock.go | 700 +++++++++++++++++++++++++++++--- 1 file changed, 639 insertions(+), 61 deletions(-) diff --git a/x/evm/wrappers/testutil/mock.go b/x/evm/wrappers/testutil/mock.go index 7418042..719b2f3 100644 --- a/x/evm/wrappers/testutil/mock.go +++ b/x/evm/wrappers/testutil/mock.go @@ -1,102 +1,680 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./x/evm/types/interfaces.go +// +// Generated by this command: +// +// mockgen -source=./x/evm/types/interfaces.go -package testutil -destination=./x/evm/wrappers/testutil/mock.go +// + +// Package testutil is a generated GoMock package. package testutil import ( - "context" - "fmt" + context "context" + big "math/big" + reflect "reflect" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/evmos/os/x/evm/types" + address "cosmossdk.io/core/address" + math "cosmossdk.io/math" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/cosmos-sdk/x/auth/types" + types1 "github.com/cosmos/cosmos-sdk/x/staking/types" + common "github.com/ethereum/go-ethereum/common" + vm "github.com/evmos/os/x/evm/core/vm" + types2 "github.com/evmos/os/x/evm/types" + types3 "github.com/evmos/os/x/feemarket/types" + gomock "go.uber.org/mock/gomock" ) -var _ types.BankKeeper = &MockBank{} +// MockAccountKeeper is a mock of AccountKeeper interface. +type MockAccountKeeper struct { + ctrl *gomock.Controller + recorder *MockAccountKeeperMockRecorder + isgomock struct{} +} -type MockBank struct { - Balances map[string]sdk.Coin - HasPermission bool +// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper. +type MockAccountKeeperMockRecorder struct { + mock *MockAccountKeeper } -func NewMockBank() *MockBank { - return &MockBank{ - HasPermission: true, - } +// NewMockAccountKeeper creates a new mock instance. +func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper { + mock := &MockAccountKeeper{ctrl: ctrl} + mock.recorder = &MockAccountKeeperMockRecorder{mock} + return mock } -// SendCoinsFromModuleToAccount implements types.BankKeeper. -func (m *MockBank) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error { - evmCoin := amt[0] +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder { + return m.recorder +} - senderBalance := m.Balances[senderModule] - if senderBalance.Amount.LT(evmCoin.Amount) { - return fmt.Errorf("insufficient balance: %s < %s", senderBalance.Amount, evmCoin.Amount) - } +// AddressCodec mocks base method. +func (m *MockAccountKeeper) AddressCodec() address.Codec { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddressCodec") + ret0, _ := ret[0].(address.Codec) + return ret0 +} - m.Balances[recipientAddr.String()] = m.Balances[recipientAddr.String()].Add(evmCoin) - m.Balances[senderModule] = m.Balances[senderModule].Sub(evmCoin) +// AddressCodec indicates an expected call of AddressCodec. +func (mr *MockAccountKeeperMockRecorder) AddressCodec() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressCodec", reflect.TypeOf((*MockAccountKeeper)(nil).AddressCodec)) +} - return nil +// GetAccount mocks base method. +func (m *MockAccountKeeper) GetAccount(ctx context.Context, addr types.AccAddress) types.AccountI { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccount", ctx, addr) + ret0, _ := ret[0].(types.AccountI) + return ret0 } -// SendCoinsFromAccountToModule implements types.BankKeeper. -func (m *MockBank) SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error { - evmCoin := amt[0] +// GetAccount indicates an expected call of GetAccount. +func (mr *MockAccountKeeperMockRecorder) GetAccount(ctx, addr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), ctx, addr) +} - senderBalance := m.Balances[senderAddr.String()] - if senderBalance.Amount.LT(evmCoin.Amount) { - return fmt.Errorf("insufficient balance: %s < %s", senderBalance.Amount, evmCoin.Amount) - } +// GetModuleAddress mocks base method. +func (m *MockAccountKeeper) GetModuleAddress(moduleName string) types.AccAddress { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetModuleAddress", moduleName) + ret0, _ := ret[0].(types.AccAddress) + return ret0 +} - m.Balances[recipientModule] = m.Balances[recipientModule].Add(evmCoin) - m.Balances[senderAddr.String()] = m.Balances[senderAddr.String()].Sub(evmCoin) +// GetModuleAddress indicates an expected call of GetModuleAddress. +func (mr *MockAccountKeeperMockRecorder) GetModuleAddress(moduleName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAddress", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAddress), moduleName) +} - return nil +// GetParams mocks base method. +func (m *MockAccountKeeper) GetParams(ctx context.Context) types0.Params { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetParams", ctx) + ret0, _ := ret[0].(types0.Params) + return ret0 } -// BurnCoins implements types.BankKeeper. -func (m *MockBank) BurnCoins(ctx context.Context, moduleName string, amt sdk.Coins) error { - evmCoin := amt[0] +// GetParams indicates an expected call of GetParams. +func (mr *MockAccountKeeperMockRecorder) GetParams(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParams", reflect.TypeOf((*MockAccountKeeper)(nil).GetParams), ctx) +} + +// GetSequence mocks base method. +func (m *MockAccountKeeper) GetSequence(ctx context.Context, account types.AccAddress) (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSequence", ctx, account) + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSequence indicates an expected call of GetSequence. +func (mr *MockAccountKeeperMockRecorder) GetSequence(ctx, account any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSequence", reflect.TypeOf((*MockAccountKeeper)(nil).GetSequence), ctx, account) +} - moduleBalance := m.Balances[moduleName] - if moduleBalance.Amount.LT(evmCoin.Amount) { - return fmt.Errorf("insufficient balance: %s < %s", moduleBalance.Amount, evmCoin.Amount) +// NewAccountWithAddress mocks base method. +func (m *MockAccountKeeper) NewAccountWithAddress(ctx context.Context, addr types.AccAddress) types.AccountI { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NewAccountWithAddress", ctx, addr) + ret0, _ := ret[0].(types.AccountI) + return ret0 +} + +// NewAccountWithAddress indicates an expected call of NewAccountWithAddress. +func (mr *MockAccountKeeperMockRecorder) NewAccountWithAddress(ctx, addr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAccountWithAddress", reflect.TypeOf((*MockAccountKeeper)(nil).NewAccountWithAddress), ctx, addr) +} + +// RemoveAccount mocks base method. +func (m *MockAccountKeeper) RemoveAccount(ctx context.Context, account types.AccountI) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RemoveAccount", ctx, account) +} + +// RemoveAccount indicates an expected call of RemoveAccount. +func (mr *MockAccountKeeperMockRecorder) RemoveAccount(ctx, account any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccount", reflect.TypeOf((*MockAccountKeeper)(nil).RemoveAccount), ctx, account) +} + +// SetAccount mocks base method. +func (m *MockAccountKeeper) SetAccount(ctx context.Context, account types.AccountI) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetAccount", ctx, account) +} + +// SetAccount indicates an expected call of SetAccount. +func (mr *MockAccountKeeperMockRecorder) SetAccount(ctx, account any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetAccount), ctx, account) +} + +// MockBankKeeper is a mock of BankKeeper interface. +type MockBankKeeper struct { + ctrl *gomock.Controller + recorder *MockBankKeeperMockRecorder + isgomock struct{} +} + +// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper. +type MockBankKeeperMockRecorder struct { + mock *MockBankKeeper +} + +// NewMockBankKeeper creates a new mock instance. +func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper { + mock := &MockBankKeeper{ctrl: ctrl} + mock.recorder = &MockBankKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder { + return m.recorder +} + +// BurnCoins mocks base method. +func (m *MockBankKeeper) BurnCoins(ctx context.Context, moduleName string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BurnCoins", ctx, moduleName, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// BurnCoins indicates an expected call of BurnCoins. +func (mr *MockBankKeeperMockRecorder) BurnCoins(ctx, moduleName, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BurnCoins", reflect.TypeOf((*MockBankKeeper)(nil).BurnCoins), ctx, moduleName, amt) +} + +// GetAllBalances mocks base method. +func (m *MockBankKeeper) GetAllBalances(ctx context.Context, addr types.AccAddress) types.Coins { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr) + ret0, _ := ret[0].(types.Coins) + return ret0 +} + +// GetAllBalances indicates an expected call of GetAllBalances. +func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr) +} + +// GetBalance mocks base method. +func (m *MockBankKeeper) GetBalance(ctx context.Context, addr types.AccAddress, denom string) types.Coin { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBalance", ctx, addr, denom) + ret0, _ := ret[0].(types.Coin) + return ret0 +} + +// GetBalance indicates an expected call of GetBalance. +func (mr *MockBankKeeperMockRecorder) GetBalance(ctx, addr, denom any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockBankKeeper)(nil).GetBalance), ctx, addr, denom) +} + +// IsSendEnabledCoins mocks base method. +func (m *MockBankKeeper) IsSendEnabledCoins(ctx context.Context, coins ...types.Coin) error { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range coins { + varargs = append(varargs, a) } + ret := m.ctrl.Call(m, "IsSendEnabledCoins", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// IsSendEnabledCoins indicates an expected call of IsSendEnabledCoins. +func (mr *MockBankKeeperMockRecorder) IsSendEnabledCoins(ctx any, coins ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, coins...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledCoins", reflect.TypeOf((*MockBankKeeper)(nil).IsSendEnabledCoins), varargs...) +} + +// MintCoins mocks base method. +func (m *MockBankKeeper) MintCoins(ctx context.Context, moduleName string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// MintCoins indicates an expected call of MintCoins. +func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt) +} + +// SendCoins mocks base method. +func (m *MockBankKeeper) SendCoins(ctx context.Context, from, to types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoins", ctx, from, to, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoins indicates an expected call of SendCoins. +func (mr *MockBankKeeperMockRecorder) SendCoins(ctx, from, to, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoins", reflect.TypeOf((*MockBankKeeper)(nil).SendCoins), ctx, from, to, amt) +} + +// SendCoinsFromAccountToModule mocks base method. +func (m *MockBankKeeper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule. +func (mr *MockBankKeeperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt) +} + +// SendCoinsFromModuleToAccount mocks base method. +func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount. +func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt) +} + +// MockStakingKeeper is a mock of StakingKeeper interface. +type MockStakingKeeper struct { + ctrl *gomock.Controller + recorder *MockStakingKeeperMockRecorder + isgomock struct{} +} + +// MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper. +type MockStakingKeeperMockRecorder struct { + mock *MockStakingKeeper +} + +// NewMockStakingKeeper creates a new mock instance. +func NewMockStakingKeeper(ctrl *gomock.Controller) *MockStakingKeeper { + mock := &MockStakingKeeper{ctrl: ctrl} + mock.recorder = &MockStakingKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStakingKeeper) EXPECT() *MockStakingKeeperMockRecorder { + return m.recorder +} + +// GetHistoricalInfo mocks base method. +func (m *MockStakingKeeper) GetHistoricalInfo(ctx context.Context, height int64) (types1.HistoricalInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHistoricalInfo", ctx, height) + ret0, _ := ret[0].(types1.HistoricalInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHistoricalInfo indicates an expected call of GetHistoricalInfo. +func (mr *MockStakingKeeperMockRecorder) GetHistoricalInfo(ctx, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoricalInfo", reflect.TypeOf((*MockStakingKeeper)(nil).GetHistoricalInfo), ctx, height) +} + +// GetValidatorByConsAddr mocks base method. +func (m *MockStakingKeeper) GetValidatorByConsAddr(ctx context.Context, consAddr types.ConsAddress) (types1.Validator, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetValidatorByConsAddr", ctx, consAddr) + ret0, _ := ret[0].(types1.Validator) + ret1, _ := ret[1].(error) + return ret0, ret1 +} - m.Balances[moduleName] = m.Balances[moduleName].Sub(evmCoin) +// GetValidatorByConsAddr indicates an expected call of GetValidatorByConsAddr. +func (mr *MockStakingKeeperMockRecorder) GetValidatorByConsAddr(ctx, consAddr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorByConsAddr", reflect.TypeOf((*MockStakingKeeper)(nil).GetValidatorByConsAddr), ctx, consAddr) +} + +// ValidatorAddressCodec mocks base method. +func (m *MockStakingKeeper) ValidatorAddressCodec() address.Codec { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidatorAddressCodec") + ret0, _ := ret[0].(address.Codec) + return ret0 +} + +// ValidatorAddressCodec indicates an expected call of ValidatorAddressCodec. +func (mr *MockStakingKeeperMockRecorder) ValidatorAddressCodec() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorAddressCodec", reflect.TypeOf((*MockStakingKeeper)(nil).ValidatorAddressCodec)) +} + +// MockFeeMarketKeeper is a mock of FeeMarketKeeper interface. +type MockFeeMarketKeeper struct { + ctrl *gomock.Controller + recorder *MockFeeMarketKeeperMockRecorder + isgomock struct{} +} + +// MockFeeMarketKeeperMockRecorder is the mock recorder for MockFeeMarketKeeper. +type MockFeeMarketKeeperMockRecorder struct { + mock *MockFeeMarketKeeper +} + +// NewMockFeeMarketKeeper creates a new mock instance. +func NewMockFeeMarketKeeper(ctrl *gomock.Controller) *MockFeeMarketKeeper { + mock := &MockFeeMarketKeeper{ctrl: ctrl} + mock.recorder = &MockFeeMarketKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockFeeMarketKeeper) EXPECT() *MockFeeMarketKeeperMockRecorder { + return m.recorder +} + +// CalculateBaseFee mocks base method. +func (m *MockFeeMarketKeeper) CalculateBaseFee(ctx types.Context) math.LegacyDec { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CalculateBaseFee", ctx) + ret0, _ := ret[0].(math.LegacyDec) + return ret0 +} + +// CalculateBaseFee indicates an expected call of CalculateBaseFee. +func (mr *MockFeeMarketKeeperMockRecorder) CalculateBaseFee(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateBaseFee", reflect.TypeOf((*MockFeeMarketKeeper)(nil).CalculateBaseFee), ctx) +} + +// GetBaseFee mocks base method. +func (m *MockFeeMarketKeeper) GetBaseFee(ctx types.Context) math.LegacyDec { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBaseFee", ctx) + ret0, _ := ret[0].(math.LegacyDec) + return ret0 +} + +// GetBaseFee indicates an expected call of GetBaseFee. +func (mr *MockFeeMarketKeeperMockRecorder) GetBaseFee(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFee", reflect.TypeOf((*MockFeeMarketKeeper)(nil).GetBaseFee), ctx) +} + +// GetParams mocks base method. +func (m *MockFeeMarketKeeper) GetParams(ctx types.Context) types3.Params { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetParams", ctx) + ret0, _ := ret[0].(types3.Params) + return ret0 +} + +// GetParams indicates an expected call of GetParams. +func (mr *MockFeeMarketKeeperMockRecorder) GetParams(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParams", reflect.TypeOf((*MockFeeMarketKeeper)(nil).GetParams), ctx) +} + +// MockErc20Keeper is a mock of Erc20Keeper interface. +type MockErc20Keeper struct { + ctrl *gomock.Controller + recorder *MockErc20KeeperMockRecorder + isgomock struct{} +} + +// MockErc20KeeperMockRecorder is the mock recorder for MockErc20Keeper. +type MockErc20KeeperMockRecorder struct { + mock *MockErc20Keeper +} + +// NewMockErc20Keeper creates a new mock instance. +func NewMockErc20Keeper(ctrl *gomock.Controller) *MockErc20Keeper { + mock := &MockErc20Keeper{ctrl: ctrl} + mock.recorder = &MockErc20KeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockErc20Keeper) EXPECT() *MockErc20KeeperMockRecorder { + return m.recorder +} + +// GetERC20PrecompileInstance mocks base method. +func (m *MockErc20Keeper) GetERC20PrecompileInstance(ctx types.Context, address common.Address) (vm.PrecompiledContract, bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetERC20PrecompileInstance", ctx, address) + ret0, _ := ret[0].(vm.PrecompiledContract) + ret1, _ := ret[1].(bool) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetERC20PrecompileInstance indicates an expected call of GetERC20PrecompileInstance. +func (mr *MockErc20KeeperMockRecorder) GetERC20PrecompileInstance(ctx, address any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetERC20PrecompileInstance", reflect.TypeOf((*MockErc20Keeper)(nil).GetERC20PrecompileInstance), ctx, address) +} + +// MockSubspace is a mock of Subspace interface. +type MockSubspace struct { + ctrl *gomock.Controller + recorder *MockSubspaceMockRecorder + isgomock struct{} +} + +// MockSubspaceMockRecorder is the mock recorder for MockSubspace. +type MockSubspaceMockRecorder struct { + mock *MockSubspace +} - return nil +// NewMockSubspace creates a new mock instance. +func NewMockSubspace(ctrl *gomock.Controller) *MockSubspace { + mock := &MockSubspace{ctrl: ctrl} + mock.recorder = &MockSubspaceMockRecorder{mock} + return mock } -// MintCoins implements types.BankKeeper. -func (m *MockBank) MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error { - if !m.HasPermission { - return fmt.Errorf("permission denied") +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSubspace) EXPECT() *MockSubspaceMockRecorder { + return m.recorder +} + +// GetParamSetIfExists mocks base method. +func (m *MockSubspace) GetParamSetIfExists(ctx types.Context, ps types2.LegacyParams) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "GetParamSetIfExists", ctx, ps) +} + +// GetParamSetIfExists indicates an expected call of GetParamSetIfExists. +func (mr *MockSubspaceMockRecorder) GetParamSetIfExists(ctx, ps any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParamSetIfExists", reflect.TypeOf((*MockSubspace)(nil).GetParamSetIfExists), ctx, ps) +} + +// MockBankWrapper is a mock of BankWrapper interface. +type MockBankWrapper struct { + ctrl *gomock.Controller + recorder *MockBankWrapperMockRecorder + isgomock struct{} +} + +// MockBankWrapperMockRecorder is the mock recorder for MockBankWrapper. +type MockBankWrapperMockRecorder struct { + mock *MockBankWrapper +} + +// NewMockBankWrapper creates a new mock instance. +func NewMockBankWrapper(ctrl *gomock.Controller) *MockBankWrapper { + mock := &MockBankWrapper{ctrl: ctrl} + mock.recorder = &MockBankWrapperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBankWrapper) EXPECT() *MockBankWrapperMockRecorder { + return m.recorder +} + +// BurnAmountFromAccount mocks base method. +func (m *MockBankWrapper) BurnAmountFromAccount(ctx context.Context, account types.AccAddress, amt *big.Int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BurnAmountFromAccount", ctx, account, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// BurnAmountFromAccount indicates an expected call of BurnAmountFromAccount. +func (mr *MockBankWrapperMockRecorder) BurnAmountFromAccount(ctx, account, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BurnAmountFromAccount", reflect.TypeOf((*MockBankWrapper)(nil).BurnAmountFromAccount), ctx, account, amt) +} + +// BurnCoins mocks base method. +func (m *MockBankWrapper) BurnCoins(ctx context.Context, moduleName string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BurnCoins", ctx, moduleName, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// BurnCoins indicates an expected call of BurnCoins. +func (mr *MockBankWrapperMockRecorder) BurnCoins(ctx, moduleName, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BurnCoins", reflect.TypeOf((*MockBankWrapper)(nil).BurnCoins), ctx, moduleName, amt) +} + +// GetAllBalances mocks base method. +func (m *MockBankWrapper) GetAllBalances(ctx context.Context, addr types.AccAddress) types.Coins { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr) + ret0, _ := ret[0].(types.Coins) + return ret0 +} + +// GetAllBalances indicates an expected call of GetAllBalances. +func (mr *MockBankWrapperMockRecorder) GetAllBalances(ctx, addr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankWrapper)(nil).GetAllBalances), ctx, addr) +} + +// GetBalance mocks base method. +func (m *MockBankWrapper) GetBalance(ctx context.Context, addr types.AccAddress, denom string) types.Coin { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBalance", ctx, addr, denom) + ret0, _ := ret[0].(types.Coin) + return ret0 +} + +// GetBalance indicates an expected call of GetBalance. +func (mr *MockBankWrapperMockRecorder) GetBalance(ctx, addr, denom any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockBankWrapper)(nil).GetBalance), ctx, addr, denom) +} + +// IsSendEnabledCoins mocks base method. +func (m *MockBankWrapper) IsSendEnabledCoins(ctx context.Context, coins ...types.Coin) error { + m.ctrl.T.Helper() + varargs := []any{ctx} + for _, a := range coins { + varargs = append(varargs, a) } + ret := m.ctrl.Call(m, "IsSendEnabledCoins", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// IsSendEnabledCoins indicates an expected call of IsSendEnabledCoins. +func (mr *MockBankWrapperMockRecorder) IsSendEnabledCoins(ctx any, coins ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx}, coins...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledCoins", reflect.TypeOf((*MockBankWrapper)(nil).IsSendEnabledCoins), varargs...) +} + +// MintAmountToAccount mocks base method. +func (m *MockBankWrapper) MintAmountToAccount(ctx context.Context, recipientAddr types.AccAddress, amt *big.Int) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MintAmountToAccount", ctx, recipientAddr, amt) + ret0, _ := ret[0].(error) + return ret0 +} - evmCoin := amt[0] +// MintAmountToAccount indicates an expected call of MintAmountToAccount. +func (mr *MockBankWrapperMockRecorder) MintAmountToAccount(ctx, recipientAddr, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintAmountToAccount", reflect.TypeOf((*MockBankWrapper)(nil).MintAmountToAccount), ctx, recipientAddr, amt) +} - m.Balances[moduleName] = m.Balances[moduleName].Add(evmCoin) +// MintCoins mocks base method. +func (m *MockBankWrapper) MintCoins(ctx context.Context, moduleName string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt) + ret0, _ := ret[0].(error) + return ret0 +} - return nil +// MintCoins indicates an expected call of MintCoins. +func (mr *MockBankWrapperMockRecorder) MintCoins(ctx, moduleName, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankWrapper)(nil).MintCoins), ctx, moduleName, amt) } -// GetBalance implements types.BankKeeper. -func (m *MockBank) GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin { - return m.Balances[addr.String()] +// SendCoins mocks base method. +func (m *MockBankWrapper) SendCoins(ctx context.Context, from, to types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoins", ctx, from, to, amt) + ret0, _ := ret[0].(error) + return ret0 } -// NOTE: Below methods are not implemented because are not used from the wrapper but are required to -// implement the interface. +// SendCoins indicates an expected call of SendCoins. +func (mr *MockBankWrapperMockRecorder) SendCoins(ctx, from, to, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoins", reflect.TypeOf((*MockBankWrapper)(nil).SendCoins), ctx, from, to, amt) +} + +// SendCoinsFromAccountToModule mocks base method. +func (m *MockBankWrapper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt) + ret0, _ := ret[0].(error) + return ret0 +} -// GetAllBalances implements types.BankKeeper. -func (m *MockBank) GetAllBalances(ctx context.Context, addr sdk.AccAddress) sdk.Coins { - panic("unimplemented") +// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule. +func (mr *MockBankWrapperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankWrapper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt) } -// IsSendEnabledCoins implements types.BankKeeper. -func (m *MockBank) IsSendEnabledCoins(ctx context.Context, coins ...sdk.Coin) error { - panic("unimplemented") +// SendCoinsFromModuleToAccount mocks base method. +func (m *MockBankWrapper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt) + ret0, _ := ret[0].(error) + return ret0 } -// SendCoins implements types.BankKeeper. -func (m *MockBank) SendCoins(ctx context.Context, from sdk.AccAddress, to sdk.AccAddress, amt sdk.Coins) error { - panic("unimplemented") +// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount. +func (mr *MockBankWrapperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankWrapper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt) } From a214b0ec91e51565370bb10a3fe696682f9f62b5 Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 18 Dec 2024 11:11:35 +0100 Subject: [PATCH 04/12] add mint tests --- x/evm/wrappers/bank_test.go | 144 ++++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 x/evm/wrappers/bank_test.go diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go new file mode 100644 index 0000000..5729137 --- /dev/null +++ b/x/evm/wrappers/bank_test.go @@ -0,0 +1,144 @@ +package wrappers_test + +import ( + "context" + "errors" + "math/big" + "testing" + + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + evmtypes "github.com/evmos/os/x/evm/types" + "github.com/evmos/os/x/evm/wrappers" + "github.com/evmos/os/x/evm/wrappers/testutil" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" +) + +func TestMintAmountToAccount(t *testing.T) { + tokenDenom := "token" + + testCases := []struct { + name string + evmDenom string + evmDecimals uint8 + amount *big.Int + recipient sdk.AccAddress + expectErr string + mockSetup func(*testutil.MockBankKeeper) + }{ + { + name: "success - convert 18 decimals amount to 6 decimals", + evmDenom: tokenDenom, + evmDecimals: 6, + amount: big.NewInt(1e18), // 1 token in 18 decimals + recipient: sdk.AccAddress([]byte("test_address")), + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) // 1 token in 6 decimals + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + MintCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(nil) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + sdk.AccAddress([]byte("test_address")), + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - 18 decimals amount not modified", + evmDenom: tokenDenom, + evmDecimals: 18, + amount: big.NewInt(1e18), // 1 token in 18 decimals + recipient: sdk.AccAddress([]byte("test_address")), + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + MintCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(nil) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + sdk.AccAddress([]byte("test_address")), + expectedCoins, + ).Return(nil) + }, + }, + { + name: "fail - mint coins error", + evmDenom: tokenDenom, + evmDecimals: 6, + amount: big.NewInt(1e18), + recipient: sdk.AccAddress([]byte("test_address")), + expectErr: "failed to mint coins to account in bank wrapper", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + MintCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(errors.New("mint error")) + }, + }, + { + name: "fail - send coins error", + evmDenom: "evm", + evmDecimals: 6, + amount: big.NewInt(1e18), + recipient: sdk.AccAddress([]byte("test_address")), + expectErr: "send error", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin("evm", sdkmath.NewInt(1e6)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + MintCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(nil) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + sdk.AccAddress([]byte("test_address")), + expectedCoins, + ).Return(errors.New("send error")) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup EVM configurator to have access to the EVM coin info. + configurator := evmtypes.NewEVMConfigurator() + configurator.ResetTestConfig() + err := configurator.WithEVMCoinInfo(tc.evmDenom, tc.evmDecimals).Configure() + require.NoError(t, err, "failed to configure EVMConfigurator") + + // Setup mock controller + ctrl := gomock.NewController(t) + + mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + tc.mockSetup(mockBankKeeper) + + bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) + err = bankWrapper.MintAmountToAccount(context.Background(), tc.recipient, tc.amount) + + if tc.expectErr != "" { + require.ErrorContains(t, err, tc.expectErr) + } else { + require.NoError(t, err) + } + }) + } +} From ef7f695625684c8dd4d98f04472a3ccbe4b8d1df Mon Sep 17 00:00:00 2001 From: stepit Date: Wed, 18 Dec 2024 12:57:39 +0100 Subject: [PATCH 05/12] add tests for burn coins --- x/evm/wrappers/bank_test.go | 124 ++++++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index 5729137..7754b58 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -142,3 +142,127 @@ func TestMintAmountToAccount(t *testing.T) { }) } } + +func TestBurnAmountFromAccount(t *testing.T) { + tokenDenom := "token" + account := sdk.AccAddress([]byte("test_address")) + + testCases := []struct { + name string + evmDenom string + evmDecimals uint8 + amount *big.Int + expectErr string + mockSetup func(*testutil.MockBankKeeper) + }{ + { + name: "success - convert 18 decimals amount to 6 decimals", + evmDenom: tokenDenom, + evmDecimals: 6, + amount: big.NewInt(1e18), + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + + mbk.EXPECT(). + BurnCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(nil) + }, + }, + { + name: "success - 18 decimals amount not modified", + evmDenom: tokenDenom, + evmDecimals: 18, + amount: big.NewInt(1e18), + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + + mbk.EXPECT(). + BurnCoins(gomock.Any(), evmtypes.ModuleName, expectedCoins). + Return(nil) + }, + }, + { + name: "fail - send coins error", + evmDenom: tokenDenom, + evmDecimals: 6, + amount: big.NewInt(1e18), + expectErr: "failed to burn coins from account in bank wrapper", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(errors.New("send error")) + }, + }, + { + name: "fail - send burn error", + evmDenom: tokenDenom, + evmDecimals: 6, + amount: big.NewInt(1e18), + expectErr: "burn error", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoins := sdk.NewCoins(expectedCoin) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(errors.New("burn error")) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup EVM configurator to have access to the EVM coin info. + configurator := evmtypes.NewEVMConfigurator() + configurator.ResetTestConfig() + err := configurator.WithEVMCoinInfo(tc.evmDenom, tc.evmDecimals).Configure() + require.NoError(t, err, "failed to configure EVMConfigurator") + + // Setup mock controller + ctrl := gomock.NewController(t) + + mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + tc.mockSetup(mockBankKeeper) + + bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) + err = bankWrapper.BurnAmountFromAccount(context.Background(), account, tc.amount) + + if tc.expectErr != "" { + require.ErrorContains(t, err, tc.expectErr) + } else { + require.NoError(t, err) + } + }) + } +} From 1aa44e9f981e6a811f0fcaa82d050e24e3f193da Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 11:43:23 +0100 Subject: [PATCH 06/12] add get balance tests --- x/evm/wrappers/bank_test.go | 153 ++++++++++++++++++++++++++++++++++++ 1 file changed, 153 insertions(+) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index 7754b58..7e4d7df 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -3,6 +3,7 @@ package wrappers_test import ( "context" "errors" + "fmt" "math/big" "testing" @@ -266,3 +267,155 @@ func TestBurnAmountFromAccount(t *testing.T) { }) } } + +func TestGetBalance(t *testing.T) { + maxInt64 := int64(9223372036854775807) + evmDenom := "token" + account := sdk.AccAddress([]byte("test_address")) + + testCases := []struct { + name string + evmDecimals uint8 + denom string + expCoin sdk.Coin + expErr string + expPanic string + mockSetup func(*testutil.MockBankKeeper) + }{ + { + name: "success - convert 6 decimals amount to 18 decimals", + denom: evmDenom, + evmDecimals: 6, + expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)), + expErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(1e6)) + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + evmDenom, + ).Return(returnedCoin) + }, + }, + { + name: "success - convert max int 6 decimals amount to 18 decimals", + denom: evmDenom, + evmDecimals: 6, + expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e12).MulRaw(maxInt64)), + expErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(maxInt64)) + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + evmDenom, + ).Return(returnedCoin) + }, + }, + { + name: "success - does not convert 18 decimals amount", + denom: evmDenom, + evmDecimals: 18, + expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)), + expErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)) + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + evmDenom, + ).Return(returnedCoin) + }, + }, + { + name: "success - zero balance", + denom: evmDenom, + evmDecimals: 6, + expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(0)), + expErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(0)) + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + evmDenom, + ).Return(returnedCoin) + }, + }, + { + name: "success - small amount (less than 1 full token)", + denom: evmDenom, + evmDecimals: 6, + expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e14)), // 0.0001 token in 18 decimals + expErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(100)) // 0.0001 token in 6 decimals + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + evmDenom, + ).Return(returnedCoin) + }, + }, + { + name: "panic - wrong evm denom", + denom: "wrong_denom", + evmDecimals: 18, + expPanic: "expected evm denom token", + mockSetup: func(mbk *testutil.MockBankKeeper) { + returnedCoin := sdk.NewCoin("wrong_denom", sdkmath.NewInt(1e18)) + + mbk.EXPECT(). + GetBalance( + gomock.Any(), + account, + "wrong_denom", + ).Return(returnedCoin) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup EVM configurator to have access to the EVM coin info. + configurator := evmtypes.NewEVMConfigurator() + configurator.ResetTestConfig() + err := configurator.WithEVMCoinInfo(evmDenom, tc.evmDecimals).Configure() + require.NoError(t, err, "failed to configure EVMConfigurator") + + // Setup mock controller + ctrl := gomock.NewController(t) + + mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + tc.mockSetup(mockBankKeeper) + + bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) + + // When calling the function with a denom different than the evm one, it should panic + defer func() { + if r := recover(); r != nil { + require.Contains(t, fmt.Sprint(r), tc.expPanic) + } + }() + + balance := bankWrapper.GetBalance(context.Background(), account, tc.denom) + + if tc.expErr != "" { + require.ErrorContains(t, err, tc.expErr) + } else { + require.NoError(t, err) + require.Equal(t, tc.expCoin, balance, "expected a different balance") + } + }) + } +} From 069c5e608995817e09bfcc9be9008b9e68a5b9d0 Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:20:57 +0100 Subject: [PATCH 07/12] add tests for send coins --- x/evm/wrappers/bank_test.go | 334 ++++++++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index 7e4d7df..c75c9c9 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -16,6 +16,8 @@ import ( "go.uber.org/mock/gomock" ) +// --------------------------------------TRANSACTIONS----------------------------------------------- + func TestMintAmountToAccount(t *testing.T) { tokenDenom := "token" @@ -268,6 +270,338 @@ func TestBurnAmountFromAccount(t *testing.T) { } } +func TestSendCoinsFromModuleToAccount(t *testing.T) { + tokenDenom := "token" + account := sdk.AccAddress([]byte("test_address")) + + testCases := []struct { + name string + evmDenom string + evmDecimals uint8 + coins func() sdk.Coins + expectErr string + mockSetup func(*testutil.MockBankKeeper) + }{ + { + name: "success - does not convert 18 decimals amount with single token", + evmDenom: tokenDenom, + evmDecimals: 18, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + account, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - convert 18 decimals amount to 6 decimals with single token", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + }...) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + account, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - does not convert 18 decimals amount with multiple tokens", + evmDenom: tokenDenom, + evmDecimals: 18, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + account, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - convert 18 decimals amount to 6 decimals with multiple tokens", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + evmtypes.ModuleName, + account, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - no op if converted coin is zero", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e11)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + mbk.EXPECT(). + SendCoinsFromModuleToAccount( + gomock.Any(), + gomock.Any(), + gomock.Any(), + gomock.Any(), + ).Times(0) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup EVM configurator to have access to the EVM coin info. + configurator := evmtypes.NewEVMConfigurator() + configurator.ResetTestConfig() + err := configurator.WithEVMCoinInfo(tc.evmDenom, tc.evmDecimals).Configure() + require.NoError(t, err, "failed to configure EVMConfigurator") + + // Setup mock controller + ctrl := gomock.NewController(t) + + mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + tc.mockSetup(mockBankKeeper) + + bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) + err = bankWrapper.SendCoinsFromModuleToAccount(context.Background(), evmtypes.ModuleName, account, tc.coins()) + + if tc.expectErr != "" { + require.ErrorContains(t, err, tc.expectErr) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestSendCoinsFromAccountToModule(t *testing.T) { + tokenDenom := "token" + account := sdk.AccAddress([]byte("test_address")) + + testCases := []struct { + name string + evmDenom string + evmDecimals uint8 + coins func() sdk.Coins + expectErr string + mockSetup func(*testutil.MockBankKeeper) + }{ + { + name: "success - does not convert 18 decimals amount with single token", + evmDenom: tokenDenom, + evmDecimals: 18, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - convert 18 decimals amount to 6 decimals with single token", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + }...) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - does not convert 18 decimals amount with multiple tokens", + evmDenom: tokenDenom, + evmDecimals: 18, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - convert 18 decimals amount to 6 decimals with multiple tokens", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + expectedCoins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin("something", sdkmath.NewInt(3e18)), + }...) + + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + account, + evmtypes.ModuleName, + expectedCoins, + ).Return(nil) + }, + }, + { + name: "success - no op if converted coin is zero", + evmDenom: tokenDenom, + evmDecimals: 6, + coins: func() sdk.Coins { + coins := sdk.NewCoins([]sdk.Coin{ + sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e11)), + }...) + return coins + }, + expectErr: "", + mockSetup: func(mbk *testutil.MockBankKeeper) { + mbk.EXPECT(). + SendCoinsFromAccountToModule( + gomock.Any(), + gomock.Any(), + gomock.Any(), + gomock.Any(), + ).Times(0) + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup EVM configurator to have access to the EVM coin info. + configurator := evmtypes.NewEVMConfigurator() + configurator.ResetTestConfig() + err := configurator.WithEVMCoinInfo(tc.evmDenom, tc.evmDecimals).Configure() + require.NoError(t, err, "failed to configure EVMConfigurator") + + // Setup mock controller + ctrl := gomock.NewController(t) + + mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + tc.mockSetup(mockBankKeeper) + + bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) + err = bankWrapper.SendCoinsFromAccountToModule(context.Background(), account, evmtypes.ModuleName, tc.coins()) + + if tc.expectErr != "" { + require.ErrorContains(t, err, tc.expectErr) + } else { + require.NoError(t, err) + } + }) + } +} + +// ----------------------------------------QUERIES------------------------------------------------- + func TestGetBalance(t *testing.T) { maxInt64 := int64(9223372036854775807) evmDenom := "token" From 08051bb6de774788a6ba36efff5018609f6adfad Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:21:09 +0100 Subject: [PATCH 08/12] add contract doc to scaling --- x/evm/types/scaling.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/x/evm/types/scaling.go b/x/evm/types/scaling.go index b9bc3bd..7750457 100644 --- a/x/evm/types/scaling.go +++ b/x/evm/types/scaling.go @@ -14,6 +14,9 @@ import ( // MustConvertEvmCoinTo18Decimals converts the coin's Amount from its original // representation into a 18 decimals. The function panics if coin denom is // not the evm denom or in case of overflow. +// +// CONTRACT: The function should only be called when the coin denom is the EVM. This means that +// should be called only when the code forces the denom to be the expected one. func MustConvertEvmCoinTo18Decimals(coin sdk.Coin) sdk.Coin { if coin.Denom != GetEVMCoinDenom() { panic(fmt.Sprintf("expected evm denom %s, received %s", GetEVMCoinDenom(), coin.Denom)) From 00caa02fac41d8030880f168d9fc99fc289ca647 Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:28:00 +0100 Subject: [PATCH 09/12] add changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 03eac41..0bb0c41 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ This changelog was created using the `clu` binary (https://github.com/MalteHerrmann/changelog-utils). --> + # Changelog ## Unreleased @@ -30,3 +31,4 @@ This changelog was created using the `clu` binary - (proto) [#14](https://github.com/evmos/os/pull/14) Add Protobufs and adjust scripts. - (eip-712) [#13](https://github.com/evmos/os/pull/13) Add EIP-712 package. - (ci) [#12](https://github.com/evmos/os/pull/12) Add CI workflows, configurations, Makefile, License, etc. +- (tests) [#65](https://github.com/evmos/os/pull/65) Add tests for bank wrapper in EVM module with mock. From c60628d262635c0a83203127ba8f60b6b9750eb0 Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:28:08 +0100 Subject: [PATCH 10/12] use correct mock --- x/evm/wrappers/bank_test.go | 68 ++--- x/evm/wrappers/testutil/mock.go | 424 -------------------------------- 2 files changed, 34 insertions(+), 458 deletions(-) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index c75c9c9..5c200d8 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -28,7 +28,7 @@ func TestMintAmountToAccount(t *testing.T) { amount *big.Int recipient sdk.AccAddress expectErr string - mockSetup func(*testutil.MockBankKeeper) + mockSetup func(*testutil.MockBankWrapper) }{ { name: "success - convert 18 decimals amount to 6 decimals", @@ -37,7 +37,7 @@ func TestMintAmountToAccount(t *testing.T) { amount: big.NewInt(1e18), // 1 token in 18 decimals recipient: sdk.AccAddress([]byte("test_address")), expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) // 1 token in 6 decimals expectedCoins := sdk.NewCoins(expectedCoin) @@ -61,7 +61,7 @@ func TestMintAmountToAccount(t *testing.T) { amount: big.NewInt(1e18), // 1 token in 18 decimals recipient: sdk.AccAddress([]byte("test_address")), expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -85,7 +85,7 @@ func TestMintAmountToAccount(t *testing.T) { amount: big.NewInt(1e18), recipient: sdk.AccAddress([]byte("test_address")), expectErr: "failed to mint coins to account in bank wrapper", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -101,7 +101,7 @@ func TestMintAmountToAccount(t *testing.T) { amount: big.NewInt(1e18), recipient: sdk.AccAddress([]byte("test_address")), expectErr: "send error", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin("evm", sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -131,7 +131,7 @@ func TestMintAmountToAccount(t *testing.T) { // Setup mock controller ctrl := gomock.NewController(t) - mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + mockBankKeeper := testutil.NewMockBankWrapper(ctrl) tc.mockSetup(mockBankKeeper) bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) @@ -156,7 +156,7 @@ func TestBurnAmountFromAccount(t *testing.T) { evmDecimals uint8 amount *big.Int expectErr string - mockSetup func(*testutil.MockBankKeeper) + mockSetup func(*testutil.MockBankWrapper) }{ { name: "success - convert 18 decimals amount to 6 decimals", @@ -164,7 +164,7 @@ func TestBurnAmountFromAccount(t *testing.T) { evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -187,7 +187,7 @@ func TestBurnAmountFromAccount(t *testing.T) { evmDecimals: 18, amount: big.NewInt(1e18), expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -210,7 +210,7 @@ func TestBurnAmountFromAccount(t *testing.T) { evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "failed to burn coins from account in bank wrapper", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -229,7 +229,7 @@ func TestBurnAmountFromAccount(t *testing.T) { evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "burn error", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) @@ -255,7 +255,7 @@ func TestBurnAmountFromAccount(t *testing.T) { // Setup mock controller ctrl := gomock.NewController(t) - mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + mockBankKeeper := testutil.NewMockBankWrapper(ctrl) tc.mockSetup(mockBankKeeper) bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) @@ -280,7 +280,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { evmDecimals uint8 coins func() sdk.Coins expectErr string - mockSetup func(*testutil.MockBankKeeper) + mockSetup func(*testutil.MockBankWrapper) }{ { name: "success - does not convert 18 decimals amount with single token", @@ -293,7 +293,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), }...) @@ -318,7 +318,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), }...) @@ -344,7 +344,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), @@ -371,7 +371,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), @@ -397,7 +397,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { mbk.EXPECT(). SendCoinsFromModuleToAccount( gomock.Any(), @@ -420,7 +420,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { // Setup mock controller ctrl := gomock.NewController(t) - mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + mockBankKeeper := testutil.NewMockBankWrapper(ctrl) tc.mockSetup(mockBankKeeper) bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) @@ -445,7 +445,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { evmDecimals uint8 coins func() sdk.Coins expectErr string - mockSetup func(*testutil.MockBankKeeper) + mockSetup func(*testutil.MockBankWrapper) }{ { name: "success - does not convert 18 decimals amount with single token", @@ -458,7 +458,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), }...) @@ -483,7 +483,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), }...) @@ -509,7 +509,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), @@ -536,7 +536,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), @@ -562,7 +562,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { return coins }, expectErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { mbk.EXPECT(). SendCoinsFromAccountToModule( gomock.Any(), @@ -585,7 +585,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { // Setup mock controller ctrl := gomock.NewController(t) - mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + mockBankKeeper := testutil.NewMockBankWrapper(ctrl) tc.mockSetup(mockBankKeeper) bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) @@ -614,7 +614,7 @@ func TestGetBalance(t *testing.T) { expCoin sdk.Coin expErr string expPanic string - mockSetup func(*testutil.MockBankKeeper) + mockSetup func(*testutil.MockBankWrapper) }{ { name: "success - convert 6 decimals amount to 18 decimals", @@ -622,7 +622,7 @@ func TestGetBalance(t *testing.T) { evmDecimals: 6, expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)), expErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(1e6)) mbk.EXPECT(). @@ -639,7 +639,7 @@ func TestGetBalance(t *testing.T) { evmDecimals: 6, expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e12).MulRaw(maxInt64)), expErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(maxInt64)) mbk.EXPECT(). @@ -656,7 +656,7 @@ func TestGetBalance(t *testing.T) { evmDecimals: 18, expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)), expErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(1e18)) mbk.EXPECT(). @@ -673,7 +673,7 @@ func TestGetBalance(t *testing.T) { evmDecimals: 6, expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(0)), expErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(0)) mbk.EXPECT(). @@ -690,7 +690,7 @@ func TestGetBalance(t *testing.T) { evmDecimals: 6, expCoin: sdk.NewCoin(evmDenom, sdkmath.NewInt(1e14)), // 0.0001 token in 18 decimals expErr: "", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin(evmDenom, sdkmath.NewInt(100)) // 0.0001 token in 6 decimals mbk.EXPECT(). @@ -706,7 +706,7 @@ func TestGetBalance(t *testing.T) { denom: "wrong_denom", evmDecimals: 18, expPanic: "expected evm denom token", - mockSetup: func(mbk *testutil.MockBankKeeper) { + mockSetup: func(mbk *testutil.MockBankWrapper) { returnedCoin := sdk.NewCoin("wrong_denom", sdkmath.NewInt(1e18)) mbk.EXPECT(). @@ -730,7 +730,7 @@ func TestGetBalance(t *testing.T) { // Setup mock controller ctrl := gomock.NewController(t) - mockBankKeeper := testutil.NewMockBankKeeper(ctrl) + mockBankKeeper := testutil.NewMockBankWrapper(ctrl) tc.mockSetup(mockBankKeeper) bankWrapper := wrappers.NewBankWrapper(mockBankKeeper) diff --git a/x/evm/wrappers/testutil/mock.go b/x/evm/wrappers/testutil/mock.go index 719b2f3..fa0d6cd 100644 --- a/x/evm/wrappers/testutil/mock.go +++ b/x/evm/wrappers/testutil/mock.go @@ -14,360 +14,12 @@ import ( big "math/big" reflect "reflect" - address "cosmossdk.io/core/address" math "cosmossdk.io/math" types "github.com/cosmos/cosmos-sdk/types" - types0 "github.com/cosmos/cosmos-sdk/x/auth/types" - types1 "github.com/cosmos/cosmos-sdk/x/staking/types" - common "github.com/ethereum/go-ethereum/common" - vm "github.com/evmos/os/x/evm/core/vm" - types2 "github.com/evmos/os/x/evm/types" types3 "github.com/evmos/os/x/feemarket/types" gomock "go.uber.org/mock/gomock" ) -// MockAccountKeeper is a mock of AccountKeeper interface. -type MockAccountKeeper struct { - ctrl *gomock.Controller - recorder *MockAccountKeeperMockRecorder - isgomock struct{} -} - -// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper. -type MockAccountKeeperMockRecorder struct { - mock *MockAccountKeeper -} - -// NewMockAccountKeeper creates a new mock instance. -func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper { - mock := &MockAccountKeeper{ctrl: ctrl} - mock.recorder = &MockAccountKeeperMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder { - return m.recorder -} - -// AddressCodec mocks base method. -func (m *MockAccountKeeper) AddressCodec() address.Codec { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddressCodec") - ret0, _ := ret[0].(address.Codec) - return ret0 -} - -// AddressCodec indicates an expected call of AddressCodec. -func (mr *MockAccountKeeperMockRecorder) AddressCodec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressCodec", reflect.TypeOf((*MockAccountKeeper)(nil).AddressCodec)) -} - -// GetAccount mocks base method. -func (m *MockAccountKeeper) GetAccount(ctx context.Context, addr types.AccAddress) types.AccountI { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccount", ctx, addr) - ret0, _ := ret[0].(types.AccountI) - return ret0 -} - -// GetAccount indicates an expected call of GetAccount. -func (mr *MockAccountKeeperMockRecorder) GetAccount(ctx, addr any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), ctx, addr) -} - -// GetModuleAddress mocks base method. -func (m *MockAccountKeeper) GetModuleAddress(moduleName string) types.AccAddress { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetModuleAddress", moduleName) - ret0, _ := ret[0].(types.AccAddress) - return ret0 -} - -// GetModuleAddress indicates an expected call of GetModuleAddress. -func (mr *MockAccountKeeperMockRecorder) GetModuleAddress(moduleName any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAddress", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAddress), moduleName) -} - -// GetParams mocks base method. -func (m *MockAccountKeeper) GetParams(ctx context.Context) types0.Params { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetParams", ctx) - ret0, _ := ret[0].(types0.Params) - return ret0 -} - -// GetParams indicates an expected call of GetParams. -func (mr *MockAccountKeeperMockRecorder) GetParams(ctx any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParams", reflect.TypeOf((*MockAccountKeeper)(nil).GetParams), ctx) -} - -// GetSequence mocks base method. -func (m *MockAccountKeeper) GetSequence(ctx context.Context, account types.AccAddress) (uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSequence", ctx, account) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSequence indicates an expected call of GetSequence. -func (mr *MockAccountKeeperMockRecorder) GetSequence(ctx, account any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSequence", reflect.TypeOf((*MockAccountKeeper)(nil).GetSequence), ctx, account) -} - -// NewAccountWithAddress mocks base method. -func (m *MockAccountKeeper) NewAccountWithAddress(ctx context.Context, addr types.AccAddress) types.AccountI { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewAccountWithAddress", ctx, addr) - ret0, _ := ret[0].(types.AccountI) - return ret0 -} - -// NewAccountWithAddress indicates an expected call of NewAccountWithAddress. -func (mr *MockAccountKeeperMockRecorder) NewAccountWithAddress(ctx, addr any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAccountWithAddress", reflect.TypeOf((*MockAccountKeeper)(nil).NewAccountWithAddress), ctx, addr) -} - -// RemoveAccount mocks base method. -func (m *MockAccountKeeper) RemoveAccount(ctx context.Context, account types.AccountI) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RemoveAccount", ctx, account) -} - -// RemoveAccount indicates an expected call of RemoveAccount. -func (mr *MockAccountKeeperMockRecorder) RemoveAccount(ctx, account any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccount", reflect.TypeOf((*MockAccountKeeper)(nil).RemoveAccount), ctx, account) -} - -// SetAccount mocks base method. -func (m *MockAccountKeeper) SetAccount(ctx context.Context, account types.AccountI) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "SetAccount", ctx, account) -} - -// SetAccount indicates an expected call of SetAccount. -func (mr *MockAccountKeeperMockRecorder) SetAccount(ctx, account any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetAccount), ctx, account) -} - -// MockBankKeeper is a mock of BankKeeper interface. -type MockBankKeeper struct { - ctrl *gomock.Controller - recorder *MockBankKeeperMockRecorder - isgomock struct{} -} - -// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper. -type MockBankKeeperMockRecorder struct { - mock *MockBankKeeper -} - -// NewMockBankKeeper creates a new mock instance. -func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper { - mock := &MockBankKeeper{ctrl: ctrl} - mock.recorder = &MockBankKeeperMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder { - return m.recorder -} - -// BurnCoins mocks base method. -func (m *MockBankKeeper) BurnCoins(ctx context.Context, moduleName string, amt types.Coins) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BurnCoins", ctx, moduleName, amt) - ret0, _ := ret[0].(error) - return ret0 -} - -// BurnCoins indicates an expected call of BurnCoins. -func (mr *MockBankKeeperMockRecorder) BurnCoins(ctx, moduleName, amt any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BurnCoins", reflect.TypeOf((*MockBankKeeper)(nil).BurnCoins), ctx, moduleName, amt) -} - -// GetAllBalances mocks base method. -func (m *MockBankKeeper) GetAllBalances(ctx context.Context, addr types.AccAddress) types.Coins { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr) - ret0, _ := ret[0].(types.Coins) - return ret0 -} - -// GetAllBalances indicates an expected call of GetAllBalances. -func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr) -} - -// GetBalance mocks base method. -func (m *MockBankKeeper) GetBalance(ctx context.Context, addr types.AccAddress, denom string) types.Coin { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBalance", ctx, addr, denom) - ret0, _ := ret[0].(types.Coin) - return ret0 -} - -// GetBalance indicates an expected call of GetBalance. -func (mr *MockBankKeeperMockRecorder) GetBalance(ctx, addr, denom any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockBankKeeper)(nil).GetBalance), ctx, addr, denom) -} - -// IsSendEnabledCoins mocks base method. -func (m *MockBankKeeper) IsSendEnabledCoins(ctx context.Context, coins ...types.Coin) error { - m.ctrl.T.Helper() - varargs := []any{ctx} - for _, a := range coins { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "IsSendEnabledCoins", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// IsSendEnabledCoins indicates an expected call of IsSendEnabledCoins. -func (mr *MockBankKeeperMockRecorder) IsSendEnabledCoins(ctx any, coins ...any) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]any{ctx}, coins...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSendEnabledCoins", reflect.TypeOf((*MockBankKeeper)(nil).IsSendEnabledCoins), varargs...) -} - -// MintCoins mocks base method. -func (m *MockBankKeeper) MintCoins(ctx context.Context, moduleName string, amt types.Coins) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt) - ret0, _ := ret[0].(error) - return ret0 -} - -// MintCoins indicates an expected call of MintCoins. -func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt) -} - -// SendCoins mocks base method. -func (m *MockBankKeeper) SendCoins(ctx context.Context, from, to types.AccAddress, amt types.Coins) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendCoins", ctx, from, to, amt) - ret0, _ := ret[0].(error) - return ret0 -} - -// SendCoins indicates an expected call of SendCoins. -func (mr *MockBankKeeperMockRecorder) SendCoins(ctx, from, to, amt any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoins", reflect.TypeOf((*MockBankKeeper)(nil).SendCoins), ctx, from, to, amt) -} - -// SendCoinsFromAccountToModule mocks base method. -func (m *MockBankKeeper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt) - ret0, _ := ret[0].(error) - return ret0 -} - -// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule. -func (mr *MockBankKeeperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt) -} - -// SendCoinsFromModuleToAccount mocks base method. -func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt) - ret0, _ := ret[0].(error) - return ret0 -} - -// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount. -func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt) -} - -// MockStakingKeeper is a mock of StakingKeeper interface. -type MockStakingKeeper struct { - ctrl *gomock.Controller - recorder *MockStakingKeeperMockRecorder - isgomock struct{} -} - -// MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper. -type MockStakingKeeperMockRecorder struct { - mock *MockStakingKeeper -} - -// NewMockStakingKeeper creates a new mock instance. -func NewMockStakingKeeper(ctrl *gomock.Controller) *MockStakingKeeper { - mock := &MockStakingKeeper{ctrl: ctrl} - mock.recorder = &MockStakingKeeperMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStakingKeeper) EXPECT() *MockStakingKeeperMockRecorder { - return m.recorder -} - -// GetHistoricalInfo mocks base method. -func (m *MockStakingKeeper) GetHistoricalInfo(ctx context.Context, height int64) (types1.HistoricalInfo, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetHistoricalInfo", ctx, height) - ret0, _ := ret[0].(types1.HistoricalInfo) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetHistoricalInfo indicates an expected call of GetHistoricalInfo. -func (mr *MockStakingKeeperMockRecorder) GetHistoricalInfo(ctx, height any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoricalInfo", reflect.TypeOf((*MockStakingKeeper)(nil).GetHistoricalInfo), ctx, height) -} - -// GetValidatorByConsAddr mocks base method. -func (m *MockStakingKeeper) GetValidatorByConsAddr(ctx context.Context, consAddr types.ConsAddress) (types1.Validator, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetValidatorByConsAddr", ctx, consAddr) - ret0, _ := ret[0].(types1.Validator) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetValidatorByConsAddr indicates an expected call of GetValidatorByConsAddr. -func (mr *MockStakingKeeperMockRecorder) GetValidatorByConsAddr(ctx, consAddr any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorByConsAddr", reflect.TypeOf((*MockStakingKeeper)(nil).GetValidatorByConsAddr), ctx, consAddr) -} - -// ValidatorAddressCodec mocks base method. -func (m *MockStakingKeeper) ValidatorAddressCodec() address.Codec { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidatorAddressCodec") - ret0, _ := ret[0].(address.Codec) - return ret0 -} - -// ValidatorAddressCodec indicates an expected call of ValidatorAddressCodec. -func (mr *MockStakingKeeperMockRecorder) ValidatorAddressCodec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorAddressCodec", reflect.TypeOf((*MockStakingKeeper)(nil).ValidatorAddressCodec)) -} - // MockFeeMarketKeeper is a mock of FeeMarketKeeper interface. type MockFeeMarketKeeper struct { ctrl *gomock.Controller @@ -434,82 +86,6 @@ func (mr *MockFeeMarketKeeperMockRecorder) GetParams(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParams", reflect.TypeOf((*MockFeeMarketKeeper)(nil).GetParams), ctx) } -// MockErc20Keeper is a mock of Erc20Keeper interface. -type MockErc20Keeper struct { - ctrl *gomock.Controller - recorder *MockErc20KeeperMockRecorder - isgomock struct{} -} - -// MockErc20KeeperMockRecorder is the mock recorder for MockErc20Keeper. -type MockErc20KeeperMockRecorder struct { - mock *MockErc20Keeper -} - -// NewMockErc20Keeper creates a new mock instance. -func NewMockErc20Keeper(ctrl *gomock.Controller) *MockErc20Keeper { - mock := &MockErc20Keeper{ctrl: ctrl} - mock.recorder = &MockErc20KeeperMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockErc20Keeper) EXPECT() *MockErc20KeeperMockRecorder { - return m.recorder -} - -// GetERC20PrecompileInstance mocks base method. -func (m *MockErc20Keeper) GetERC20PrecompileInstance(ctx types.Context, address common.Address) (vm.PrecompiledContract, bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetERC20PrecompileInstance", ctx, address) - ret0, _ := ret[0].(vm.PrecompiledContract) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// GetERC20PrecompileInstance indicates an expected call of GetERC20PrecompileInstance. -func (mr *MockErc20KeeperMockRecorder) GetERC20PrecompileInstance(ctx, address any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetERC20PrecompileInstance", reflect.TypeOf((*MockErc20Keeper)(nil).GetERC20PrecompileInstance), ctx, address) -} - -// MockSubspace is a mock of Subspace interface. -type MockSubspace struct { - ctrl *gomock.Controller - recorder *MockSubspaceMockRecorder - isgomock struct{} -} - -// MockSubspaceMockRecorder is the mock recorder for MockSubspace. -type MockSubspaceMockRecorder struct { - mock *MockSubspace -} - -// NewMockSubspace creates a new mock instance. -func NewMockSubspace(ctrl *gomock.Controller) *MockSubspace { - mock := &MockSubspace{ctrl: ctrl} - mock.recorder = &MockSubspaceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSubspace) EXPECT() *MockSubspaceMockRecorder { - return m.recorder -} - -// GetParamSetIfExists mocks base method. -func (m *MockSubspace) GetParamSetIfExists(ctx types.Context, ps types2.LegacyParams) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "GetParamSetIfExists", ctx, ps) -} - -// GetParamSetIfExists indicates an expected call of GetParamSetIfExists. -func (mr *MockSubspaceMockRecorder) GetParamSetIfExists(ctx, ps any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParamSetIfExists", reflect.TypeOf((*MockSubspace)(nil).GetParamSetIfExists), ctx, ps) -} - // MockBankWrapper is a mock of BankWrapper interface. type MockBankWrapper struct { ctrl *gomock.Controller From 6acee28aa64a7375722ac7b9ba81874034c801cd Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:33:48 +0100 Subject: [PATCH 11/12] fix linter --- x/evm/wrappers/bank_test.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index 5c200d8..7a307cb 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -18,9 +18,9 @@ import ( // --------------------------------------TRANSACTIONS----------------------------------------------- -func TestMintAmountToAccount(t *testing.T) { - tokenDenom := "token" +const TokenDenom = "token" +func TestMintAmountToAccount(t *testing.T) { testCases := []struct { name string evmDenom string @@ -32,13 +32,13 @@ func TestMintAmountToAccount(t *testing.T) { }{ { name: "success - convert 18 decimals amount to 6 decimals", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, amount: big.NewInt(1e18), // 1 token in 18 decimals recipient: sdk.AccAddress([]byte("test_address")), expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) // 1 token in 6 decimals + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)) // 1 token in 6 decimals expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -56,13 +56,13 @@ func TestMintAmountToAccount(t *testing.T) { }, { name: "success - 18 decimals amount not modified", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, amount: big.NewInt(1e18), // 1 token in 18 decimals recipient: sdk.AccAddress([]byte("test_address")), expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -80,13 +80,13 @@ func TestMintAmountToAccount(t *testing.T) { }, { name: "fail - mint coins error", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, amount: big.NewInt(1e18), recipient: sdk.AccAddress([]byte("test_address")), expectErr: "failed to mint coins to account in bank wrapper", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). From 797631958df6d73651a710952caf4283e1cc2219 Mon Sep 17 00:00:00 2001 From: stepit Date: Thu, 19 Dec 2024 16:44:46 +0100 Subject: [PATCH 12/12] linter --- x/evm/wrappers/bank_test.go | 75 ++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 39 deletions(-) diff --git a/x/evm/wrappers/bank_test.go b/x/evm/wrappers/bank_test.go index 7a307cb..b11bfea 100644 --- a/x/evm/wrappers/bank_test.go +++ b/x/evm/wrappers/bank_test.go @@ -147,7 +147,6 @@ func TestMintAmountToAccount(t *testing.T) { } func TestBurnAmountFromAccount(t *testing.T) { - tokenDenom := "token" account := sdk.AccAddress([]byte("test_address")) testCases := []struct { @@ -160,12 +159,12 @@ func TestBurnAmountFromAccount(t *testing.T) { }{ { name: "success - convert 18 decimals amount to 6 decimals", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -183,12 +182,12 @@ func TestBurnAmountFromAccount(t *testing.T) { }, { name: "success - 18 decimals amount not modified", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, amount: big.NewInt(1e18), expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -206,12 +205,12 @@ func TestBurnAmountFromAccount(t *testing.T) { }, { name: "fail - send coins error", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "failed to burn coins from account in bank wrapper", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -225,12 +224,12 @@ func TestBurnAmountFromAccount(t *testing.T) { }, { name: "fail - send burn error", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, amount: big.NewInt(1e18), expectErr: "burn error", mockSetup: func(mbk *testutil.MockBankWrapper) { - expectedCoin := sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)) + expectedCoin := sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)) expectedCoins := sdk.NewCoins(expectedCoin) mbk.EXPECT(). @@ -271,7 +270,6 @@ func TestBurnAmountFromAccount(t *testing.T) { } func TestSendCoinsFromModuleToAccount(t *testing.T) { - tokenDenom := "token" account := sdk.AccAddress([]byte("test_address")) testCases := []struct { @@ -284,18 +282,18 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { }{ { name: "success - does not convert 18 decimals amount with single token", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) return coins }, expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) mbk.EXPECT(). @@ -309,18 +307,18 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { }, { name: "success - convert 18 decimals amount to 6 decimals with single token", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) return coins }, expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)), }...) mbk.EXPECT(). @@ -334,11 +332,11 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { }, { name: "success - does not convert 18 decimals amount with multiple tokens", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) return coins @@ -346,7 +344,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) @@ -361,11 +359,11 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { }, { name: "success - convert 18 decimals amount to 6 decimals with multiple tokens", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) return coins @@ -373,7 +371,7 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) @@ -388,11 +386,11 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { }, { name: "success - no op if converted coin is zero", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e11)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e11)), }...) return coins }, @@ -436,7 +434,6 @@ func TestSendCoinsFromModuleToAccount(t *testing.T) { } func TestSendCoinsFromAccountToModule(t *testing.T) { - tokenDenom := "token" account := sdk.AccAddress([]byte("test_address")) testCases := []struct { @@ -449,18 +446,18 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { }{ { name: "success - does not convert 18 decimals amount with single token", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) return coins }, expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) mbk.EXPECT(). @@ -474,18 +471,18 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { }, { name: "success - convert 18 decimals amount to 6 decimals with single token", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), }...) return coins }, expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)), }...) mbk.EXPECT(). @@ -499,11 +496,11 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { }, { name: "success - does not convert 18 decimals amount with multiple tokens", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 18, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) return coins @@ -511,7 +508,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) @@ -526,11 +523,11 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { }, { name: "success - convert 18 decimals amount to 6 decimals with multiple tokens", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e18)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e18)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) return coins @@ -538,7 +535,7 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { expectErr: "", mockSetup: func(mbk *testutil.MockBankWrapper) { expectedCoins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e6)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e6)), sdk.NewCoin("something", sdkmath.NewInt(3e18)), }...) @@ -553,11 +550,11 @@ func TestSendCoinsFromAccountToModule(t *testing.T) { }, { name: "success - no op if converted coin is zero", - evmDenom: tokenDenom, + evmDenom: TokenDenom, evmDecimals: 6, coins: func() sdk.Coins { coins := sdk.NewCoins([]sdk.Coin{ - sdk.NewCoin(tokenDenom, sdkmath.NewInt(1e11)), + sdk.NewCoin(TokenDenom, sdkmath.NewInt(1e11)), }...) return coins },