diff --git a/CHANGELOG.md b/CHANGELOG.md index 4e03ad41a..5139ee102 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -103,6 +103,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - [#1989](https://github.com/NibiruChain/nibiru/pull/1989) - refactor(evm): simplify evm module address - [#1996](https://github.com/NibiruChain/nibiru/pull/1996) - perf(evm-keeper-precompile): implement sorted map for `k.precompiles` to remove dead code - [#1997](https://github.com/NibiruChain/nibiru/pull/1997) - refactor(evm): Remove unnecessary params: "enable_call", "enable_create". +- [#2000](https://github.com/NibiruChain/nibiru/pull/2000) - refactor(evm): simplify ERC-20 keeper methods #### Dapp modules: perp, spot, oracle, etc diff --git a/app/evmante/evmante_can_transfer_test.go b/app/evmante/evmante_can_transfer_test.go index 6602b1dfd..74e697f8b 100644 --- a/app/evmante/evmante_can_transfer_test.go +++ b/app/evmante/evmante_can_transfer_test.go @@ -2,6 +2,7 @@ package evmante_test import ( sdk "github.com/cosmos/cosmos-sdk/types" + gethcore "github.com/ethereum/go-ethereum/core/types" "github.com/NibiruChain/nibiru/v2/app/evmante" "github.com/NibiruChain/nibiru/v2/eth" @@ -34,9 +35,8 @@ func (s *TestSuite) TestCanTransferDecorator() { txMsg := evmtest.HappyTransferTx(deps, 0) txBuilder := deps.EncCfg.TxConfig.NewTxBuilder() - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - err := txMsg.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + err := txMsg.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) tx, err := txMsg.BuildTx(txBuilder, eth.EthBaseDenom) @@ -52,9 +52,8 @@ func (s *TestSuite) TestCanTransferDecorator() { txMsg := evmtest.HappyTransferTx(deps, 0) txBuilder := deps.EncCfg.TxConfig.NewTxBuilder() - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - err := txMsg.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + err := txMsg.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) tx, err := txMsg.BuildTx(txBuilder, eth.EthBaseDenom) diff --git a/app/evmante/evmante_handler_test.go b/app/evmante/evmante_handler_test.go index cb09c60cd..62e7afb0d 100644 --- a/app/evmante/evmante_handler_test.go +++ b/app/evmante/evmante_handler_test.go @@ -7,6 +7,7 @@ import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" authante "github.com/cosmos/cosmos-sdk/x/auth/ante" + gethcore "github.com/ethereum/go-ethereum/core/types" "github.com/NibiruChain/nibiru/v2/app/ante" "github.com/NibiruChain/nibiru/v2/app/evmante" @@ -52,9 +53,8 @@ func (s *TestSuite) TestAnteHandlerEVM() { txMsg := evmtest.HappyTransferTx(deps, 0) txBuilder := deps.EncCfg.TxConfig.NewTxBuilder() - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - err := txMsg.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + err := txMsg.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) tx, err := txMsg.BuildTx(txBuilder, eth.EthBaseDenom) diff --git a/app/evmante/evmante_mempool_fees_test.go b/app/evmante/evmante_mempool_fees_test.go index d2d52646e..ef7b34e64 100644 --- a/app/evmante/evmante_mempool_fees_test.go +++ b/app/evmante/evmante_mempool_fees_test.go @@ -70,7 +70,7 @@ func (s *TestSuite) TestMempoolGasFeeDecorator() { fees := sdk.NewCoins(sdk.NewInt64Coin("unibi", int64(gasLimit))) msg := &banktypes.MsgSend{ FromAddress: deps.Sender.NibiruAddr.String(), - ToAddress: evmtest.NewEthAccInfo().NibiruAddr.String(), + ToAddress: evmtest.NewEthPrivAcc().NibiruAddr.String(), Amount: sdk.NewCoins(sdk.NewInt64Coin("unibi", 1)), } return buildTx(deps, true, msg, gasLimit, fees) diff --git a/app/evmante/evmante_sigverify_test.go b/app/evmante/evmante_sigverify_test.go index 0a898bea9..63b290140 100644 --- a/app/evmante/evmante_sigverify_test.go +++ b/app/evmante/evmante_sigverify_test.go @@ -5,6 +5,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" + gethcore "github.com/ethereum/go-ethereum/core/types" "github.com/NibiruChain/nibiru/v2/app/evmante" "github.com/NibiruChain/nibiru/v2/x/evm/evmtest" @@ -42,9 +43,8 @@ func (s *TestSuite) TestEthSigVerificationDecorator() { name: "sad: ethereum tx invalid chain id", txSetup: func(deps *evmtest.TestDeps) sdk.Tx { tx := evmtest.HappyCreateContractTx(deps) - gethSigner := deps.Sender.GethSigner(InvalidChainID) - keyringSigner := deps.Sender.KeyringSigner - err := tx.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(InvalidChainID) + err := tx.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) return tx }, @@ -54,9 +54,8 @@ func (s *TestSuite) TestEthSigVerificationDecorator() { name: "happy: signed ethereum tx", txSetup: func(deps *evmtest.TestDeps) sdk.Tx { tx := evmtest.HappyCreateContractTx(deps) - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - err := tx.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + err := tx.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) return tx }, diff --git a/app/evmante/evmante_validate_basic_test.go b/app/evmante/evmante_validate_basic_test.go index 94d7aa1a0..4f0e136ff 100644 --- a/app/evmante/evmante_validate_basic_test.go +++ b/app/evmante/evmante_validate_basic_test.go @@ -9,6 +9,7 @@ import ( authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/ethereum/go-ethereum/common" + gethcore "github.com/ethereum/go-ethereum/core/types" "github.com/NibiruChain/nibiru/v2/app/evmante" "github.com/NibiruChain/nibiru/v2/eth" @@ -56,9 +57,8 @@ func (s *TestSuite) TestEthValidateBasicDecorator() { name: "sad: tx not implementing protoTxProvider", txSetup: func(deps *evmtest.TestDeps) sdk.Tx { tx := evmtest.HappyCreateContractTx(deps) - gethSigner := deps.Sender.GethSigner(InvalidChainID) - keyringSigner := deps.Sender.KeyringSigner - err := tx.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(InvalidChainID) + err := tx.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) return tx }, @@ -113,9 +113,8 @@ func (s *TestSuite) TestEthValidateBasicDecorator() { s.Require().NoError(err) txMsg := evmtest.HappyCreateContractTx(deps) - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - err = txMsg.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + err = txMsg.Sign(gethSigner, deps.Sender.KeyringSigner) s.Require().NoError(err) tx, err := txMsg.BuildTx(txBuilder, eth.EthBaseDenom) @@ -142,7 +141,7 @@ func (s *TestSuite) TestEthValidateBasicDecorator() { fees := sdk.NewCoins(sdk.NewInt64Coin("unibi", int64(gasLimit))) msg := &banktypes.MsgSend{ FromAddress: deps.Sender.NibiruAddr.String(), - ToAddress: evmtest.NewEthAccInfo().NibiruAddr.String(), + ToAddress: evmtest.NewEthPrivAcc().NibiruAddr.String(), Amount: sdk.NewCoins(sdk.NewInt64Coin("unibi", 1)), } return buildTx(deps, true, msg, gasLimit, fees) diff --git a/eth/assert_test.go b/eth/assert_test.go index 39045d8a0..f6d38beb7 100644 --- a/eth/assert_test.go +++ b/eth/assert_test.go @@ -72,7 +72,7 @@ func TestValidateAddress(t *testing.T) { "zero address", common.Address{}.String(), false, }, { - "valid address", evmtest.NewEthAccInfo().EthAddr.Hex(), false, + "valid address", evmtest.NewEthPrivAcc().EthAddr.Hex(), false, }, } @@ -103,7 +103,7 @@ func TestValidateNonZeroAddress(t *testing.T) { "zero address", common.Address{}.String(), true, }, { - "valid address", evmtest.NewEthAccInfo().EthAddr.Hex(), false, + "valid address", evmtest.NewEthPrivAcc().EthAddr.Hex(), false, }, } diff --git a/eth/encoding/config_test.go b/eth/encoding/config_test.go index 37ec3b29f..5de6c822e 100644 --- a/eth/encoding/config_test.go +++ b/eth/encoding/config_test.go @@ -15,7 +15,7 @@ import ( ) func TestTxEncoding(t *testing.T) { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() addr, key := ethAcc.EthAddr, ethAcc.PrivKey signer := evmtest.NewSigner(key) diff --git a/eth/eth_account_test.go b/eth/eth_account_test.go index f42608b65..d33cf8fc4 100644 --- a/eth/eth_account_test.go +++ b/eth/eth_account_test.go @@ -6,7 +6,7 @@ import ( ) func (s *Suite) TestEthAddrToNibiruAddr() { - accInfo := evmtest.NewEthAccInfo() + accInfo := evmtest.NewEthPrivAcc() s.Equal( accInfo.EthAddr, eth.NibiruAddrToEthAddr(accInfo.NibiruAddr), @@ -18,7 +18,7 @@ func (s *Suite) TestEthAddrToNibiruAddr() { s.T().Log("unit operation - hex -> nibi -> hex") { - addr := evmtest.NewEthAccInfo().NibiruAddr + addr := evmtest.NewEthPrivAcc().NibiruAddr s.Equal( addr, eth.EthAddrToNibiruAddr( @@ -29,7 +29,7 @@ func (s *Suite) TestEthAddrToNibiruAddr() { s.T().Log("unit operation - nibi -> hex -> nibi") { - addr := evmtest.NewEthAccInfo().EthAddr + addr := evmtest.NewEthPrivAcc().EthAddr s.Equal( addr, eth.NibiruAddrToEthAddr( diff --git a/eth/rpc/backend/account_info_test.go b/eth/rpc/backend/account_info_test.go index 623fa4d54..15650c0f4 100644 --- a/eth/rpc/backend/account_info_test.go +++ b/eth/rpc/backend/account_info_test.go @@ -33,7 +33,7 @@ func (s *BackendSuite) TestGetCode() { }{ { "fail - BlockHash and BlockNumber are both nil ", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{}, func(addr common.Address) {}, false, @@ -41,7 +41,7 @@ func (s *BackendSuite) TestGetCode() { }, { "fail - query client errors on getting Code", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(addr common.Address) { queryClient := s.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) @@ -52,7 +52,7 @@ func (s *BackendSuite) TestGetCode() { }, { "pass", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(addr common.Address) { queryClient := s.backend.queryClient.QueryClient.(*mocks.EVMQueryClient) @@ -81,7 +81,7 @@ func (s *BackendSuite) TestGetCode() { func (s *BackendSuite) TestGetProof() { blockNrInvalid := rpc.NewBlockNumber(big.NewInt(1)) blockNr := rpc.NewBlockNumber(big.NewInt(4)) - address1 := evmtest.NewEthAccInfo().EthAddr + address1 := evmtest.NewEthPrivAcc().EthAddr testCases := []struct { name string @@ -199,7 +199,7 @@ func (s *BackendSuite) TestGetStorageAt() { }{ { "fail - BlockHash and BlockNumber are both nil", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, "0x0", rpc.BlockNumberOrHash{}, func(addr common.Address, key string, storage string) {}, @@ -208,7 +208,7 @@ func (s *BackendSuite) TestGetStorageAt() { }, { "fail - query client errors on getting Storage", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, "0x0", rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(addr common.Address, key string, storage string) { @@ -220,7 +220,7 @@ func (s *BackendSuite) TestGetStorageAt() { }, { "pass", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, "0x0", rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(addr common.Address, key string, storage string) { @@ -260,7 +260,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }{ { "fail - BlockHash and BlockNumber are both nil", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{}, func(bn rpc.BlockNumber, addr common.Address) { }, @@ -269,7 +269,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }, { "fail - tendermint client failed to get block", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(bn rpc.BlockNumber, addr common.Address) { client := s.backend.clientCtx.Client.(*mocks.Client) @@ -280,7 +280,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }, { "fail - query client failed to get balance", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(bn rpc.BlockNumber, addr common.Address) { client := s.backend.clientCtx.Client.(*mocks.Client) @@ -294,7 +294,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }, { "fail - invalid balance", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(bn rpc.BlockNumber, addr common.Address) { client := s.backend.clientCtx.Client.(*mocks.Client) @@ -308,7 +308,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }, { "fail - pruned node state", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(bn rpc.BlockNumber, addr common.Address) { client := s.backend.clientCtx.Client.(*mocks.Client) @@ -322,7 +322,7 @@ func (s *BackendSuite) TestGetEvmGasBalance() { }, { "pass", - evmtest.NewEthAccInfo().EthAddr, + evmtest.NewEthPrivAcc().EthAddr, rpc.BlockNumberOrHash{BlockNumber: &blockNr}, func(bn rpc.BlockNumber, addr common.Address) { client := s.backend.clientCtx.Client.(*mocks.Client) @@ -393,7 +393,7 @@ func (s *BackendSuite) TestGetTransactionCount() { s.Run(fmt.Sprintf("Case %s", tc.name), func() { s.SetupTest() - addr := evmtest.NewEthAccInfo().EthAddr + addr := evmtest.NewEthPrivAcc().EthAddr if tc.accExists { addr = common.BytesToAddress(s.acc.Bytes()) } diff --git a/eth/rpc/backend/backend_suite_test.go b/eth/rpc/backend/backend_suite_test.go index 1bf7e2efb..e019c2fcc 100644 --- a/eth/rpc/backend/backend_suite_test.go +++ b/eth/rpc/backend/backend_suite_test.go @@ -58,7 +58,7 @@ func (s *BackendSuite) SetupTest() { } // Create Account with set sequence - s.acc = sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()) + s.acc = sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()) accounts := map[string]client.TestAccount{} accounts[s.acc.String()] = client.TestAccount{ Address: s.acc, @@ -66,7 +66,7 @@ func (s *BackendSuite) SetupTest() { Seq: uint64(1), } - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() from, priv := ethAcc.EthAddr, ethAcc.PrivKey s.from = from s.signer = evmtest.NewSigner(priv) @@ -180,7 +180,7 @@ func (s *BackendSuite) generateTestKeyring(clientDir string) (keyring.Keyring, e } func (s *BackendSuite) signAndEncodeEthTx(msgEthereumTx *evm.MsgEthereumTx) []byte { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() from, priv := ethAcc.EthAddr, ethAcc.PrivKey signer := evmtest.NewSigner(priv) diff --git a/eth/rpc/backend/blocks_test.go b/eth/rpc/backend/blocks_test.go index 3d19f072f..d65dbf421 100644 --- a/eth/rpc/backend/blocks_test.go +++ b/eth/rpc/backend/blocks_test.go @@ -104,7 +104,7 @@ func (s *BackendSuite) TestGetBlockByNumber() { blockNumber: rpc.BlockNumber(1), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), ethTx: nil, ethTxBz: nil, registerMock: func(blockNum rpc.BlockNumber, _ math.Int, _ sdk.AccAddress, _ []byte) { @@ -120,7 +120,7 @@ func (s *BackendSuite) TestGetBlockByNumber() { blockNumber: rpc.BlockNumber(1), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), ethTx: nil, ethTxBz: nil, registerMock: func(blockNum rpc.BlockNumber, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -136,7 +136,7 @@ func (s *BackendSuite) TestGetBlockByNumber() { blockNumber: rpc.BlockNumber(1), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), ethTx: nil, ethTxBz: nil, registerMock: func(blockNum rpc.BlockNumber, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -153,7 +153,7 @@ func (s *BackendSuite) TestGetBlockByNumber() { blockNumber: rpc.BlockNumber(1), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), ethTx: nil, ethTxBz: nil, registerMock: func(blockNum rpc.BlockNumber, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -175,7 +175,7 @@ func (s *BackendSuite) TestGetBlockByNumber() { blockNumber: rpc.BlockNumber(1), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), ethTx: msgEthereumTx, ethTxBz: bz, registerMock: func(blockNum rpc.BlockNumber, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -249,7 +249,7 @@ func (s *BackendSuite) TestGetBlockByHash() { hash: common.BytesToHash(block.Hash()), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), tx: nil, txBz: nil, registerMock: func(hash common.Hash, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -264,7 +264,7 @@ func (s *BackendSuite) TestGetBlockByHash() { hash: common.BytesToHash(block.Hash()), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), tx: nil, txBz: nil, registerMock: func(hash common.Hash, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -279,7 +279,7 @@ func (s *BackendSuite) TestGetBlockByHash() { hash: common.BytesToHash(block.Hash()), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), tx: nil, txBz: nil, registerMock: func(hash common.Hash, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -297,7 +297,7 @@ func (s *BackendSuite) TestGetBlockByHash() { hash: common.BytesToHash(block.Hash()), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), tx: nil, txBz: nil, registerMock: func(hash common.Hash, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -320,7 +320,7 @@ func (s *BackendSuite) TestGetBlockByHash() { hash: common.BytesToHash(block.Hash()), fullTx: true, baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), tx: msgEthereumTx, txBz: bz, registerMock: func(hash common.Hash, baseFee math.Int, validator sdk.AccAddress, txBz []byte) { @@ -926,7 +926,7 @@ func (s *BackendSuite) TestGetEthBlockFromTendermint() { { name: "pass - block with tx - with BaseFee error", baseFee: nil, - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), height: int64(1), resBlock: &cmtrpc.ResultBlock{ Block: cmt.MakeBlock(1, []cmt.Tx{bz}, nil, nil), @@ -974,7 +974,7 @@ func (s *BackendSuite) TestGetEthBlockFromTendermint() { { name: "pass - block with tx - with ConsensusParams error - BlockMaxGas defaults to max uint32", baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), height: int64(1), resBlock: &cmtrpc.ResultBlock{ Block: cmt.MakeBlock(1, []cmt.Tx{bz}, nil, nil), @@ -998,7 +998,7 @@ func (s *BackendSuite) TestGetEthBlockFromTendermint() { { name: "pass - block with tx - with ShouldIgnoreGasUsed - empty txs", baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), height: int64(1), resBlock: &cmtrpc.ResultBlock{ Block: cmt.MakeBlock(1, []cmt.Tx{bz}, nil, nil), @@ -1028,7 +1028,7 @@ func (s *BackendSuite) TestGetEthBlockFromTendermint() { { name: "pass - block with tx - non fullTx", baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), height: int64(1), resBlock: &cmtrpc.ResultBlock{ Block: cmt.MakeBlock(1, []cmt.Tx{bz}, nil, nil), @@ -1052,7 +1052,7 @@ func (s *BackendSuite) TestGetEthBlockFromTendermint() { { name: "pass - block with tx", baseFee: math.NewInt(1).BigInt(), - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), height: int64(1), resBlock: &cmtrpc.ResultBlock{ Block: cmt.MakeBlock(1, []cmt.Tx{bz}, nil, nil), diff --git a/eth/rpc/backend/call_tx_test.go b/eth/rpc/backend/call_tx_test.go index e8aa98a86..c10039f8a 100644 --- a/eth/rpc/backend/call_tx_test.go +++ b/eth/rpc/backend/call_tx_test.go @@ -22,7 +22,7 @@ func (s *BackendSuite) TestResend() { txNonce := (hexutil.Uint64)(1) baseFee := math.NewInt(1) gasPrice := new(hexutil.Big) - toAddr := evmtest.NewEthAccInfo().EthAddr + toAddr := evmtest.NewEthPrivAcc().EthAddr chainID := (*hexutil.Big)(s.backend.chainID) callArgs := evm.JsonTxArgs{ From: nil, @@ -387,7 +387,7 @@ func (s *BackendSuite) TestSendRawTransaction() { func (s *BackendSuite) TestDoCall() { _, bz := s.buildEthereumTx() gasPrice := (*hexutil.Big)(big.NewInt(1)) - toAddr := evmtest.NewEthAccInfo().EthAddr + toAddr := evmtest.NewEthPrivAcc().EthAddr chainID := (*hexutil.Big)(s.backend.chainID) callArgs := evm.JsonTxArgs{ From: nil, diff --git a/eth/rpc/backend/chain_info_test.go b/eth/rpc/backend/chain_info_test.go index 74a91655f..b97783103 100644 --- a/eth/rpc/backend/chain_info_test.go +++ b/eth/rpc/backend/chain_info_test.go @@ -272,7 +272,7 @@ func (s *BackendSuite) TestFeeHistory() { GasUsedRatio: []float64{0}, Reward: [][]*hexutil.Big{{(*hexutil.Big)(big.NewInt(0)), (*hexutil.Big)(big.NewInt(0)), (*hexutil.Big)(big.NewInt(0)), (*hexutil.Big)(big.NewInt(0))}}, }, - validator: sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()), + validator: sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()), expPass: true, }, } diff --git a/eth/rpc/backend/evm_query_client_test.go b/eth/rpc/backend/evm_query_client_test.go index 9b5ab9c85..cb0d9eb9f 100644 --- a/eth/rpc/backend/evm_query_client_test.go +++ b/eth/rpc/backend/evm_query_client_test.go @@ -248,7 +248,7 @@ func RegisterValidatorAccountError(queryClient *mocks.EVMQueryClient) { func TestRegisterValidatorAccount(t *testing.T) { queryClient := mocks.NewEVMQueryClient(t) - validator := sdk.AccAddress(evmtest.NewEthAccInfo().EthAddr.Bytes()) + validator := sdk.AccAddress(evmtest.NewEthPrivAcc().EthAddr.Bytes()) RegisterValidatorAccount(queryClient, validator) res, err := queryClient.ValidatorAccount(rpc.NewContextWithHeight(1), &evm.QueryValidatorAccountRequest{}) require.Equal(t, &evm.QueryValidatorAccountResponse{AccountAddress: validator.String()}, res) diff --git a/eth/rpc/backend/sign_tx_test.go b/eth/rpc/backend/sign_tx_test.go index dceb47bce..93c13cfe2 100644 --- a/eth/rpc/backend/sign_tx_test.go +++ b/eth/rpc/backend/sign_tx_test.go @@ -24,7 +24,7 @@ func (s *BackendSuite) TestSendTransaction() { gasPrice := new(hexutil.Big) gas := hexutil.Uint64(1) zeroGas := hexutil.Uint64(0) - toAddr := evmtest.NewEthAccInfo().EthAddr + toAddr := evmtest.NewEthPrivAcc().EthAddr priv, _ := ethsecp256k1.GenerateKey() from := common.BytesToAddress(priv.PubKey().Address().Bytes()) nonce := hexutil.Uint64(1) @@ -145,7 +145,7 @@ func (s *BackendSuite) TestSendTransaction() { } func (s *BackendSuite) TestSign() { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() from, priv := ethAcc.EthAddr, ethAcc.PrivKey testCases := []struct { @@ -194,7 +194,7 @@ func (s *BackendSuite) TestSign() { } func (s *BackendSuite) TestSignTypedData() { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() from, priv := ethAcc.EthAddr, ethAcc.PrivKey testCases := []struct { name string diff --git a/x/evm/evm_test.go b/x/evm/evm_test.go index d341016ce..4d653cdd2 100644 --- a/x/evm/evm_test.go +++ b/x/evm/evm_test.go @@ -7,6 +7,7 @@ import ( "strings" "testing" + sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" gethcommon "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/suite" @@ -129,7 +130,7 @@ func (s *TestSuite) TestModuleAddressEVM() { // EVM module should have mint perms deps := evmtest.NewTestDeps() { - resp, err := deps.EvmKeeper.EthAccount(deps.GoCtx(), &evm.QueryEthAccountRequest{ + resp, err := deps.EvmKeeper.EthAccount(sdk.WrapSDKContext(deps.Ctx), &evm.QueryEthAccountRequest{ Address: evmModuleAddr.Hex(), }) s.NoError(err) diff --git a/x/evm/evmtest/erc20.go b/x/evm/evmtest/erc20.go index 056fa207a..7822cf0ec 100644 --- a/x/evm/evmtest/erc20.go +++ b/x/evm/evmtest/erc20.go @@ -4,6 +4,7 @@ import ( "math/big" "testing" + sdk "github.com/cosmos/cosmos-sdk/types" bank "github.com/cosmos/cosmos-sdk/x/bank/types" gethcommon "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/assert" @@ -13,24 +14,15 @@ import ( "github.com/NibiruChain/nibiru/v2/x/evm" ) -func DoEthTx( - deps *TestDeps, contract, from gethcommon.Address, input []byte, -) (evmResp *evm.MsgEthereumTxResponse, err error) { - commit := true - return deps.EvmKeeper.CallContractWithInput( - deps.Ctx, from, &contract, commit, input, - ) -} - func AssertERC20BalanceEqual( t *testing.T, deps TestDeps, - contract, account gethcommon.Address, - balance *big.Int, + erc20, account gethcommon.Address, + expectedBalance *big.Int, ) { - gotBalance, err := deps.EvmKeeper.ERC20().BalanceOf(contract, account, deps.Ctx) + actualBalance, err := deps.EvmKeeper.ERC20().BalanceOf(erc20, account, deps.Ctx) assert.NoError(t, err) - assert.Equal(t, balance.String(), gotBalance.String()) + assert.Zero(t, expectedBalance.Cmp(actualBalance)) } // CreateFunTokenForBankCoin: Uses the "TestDeps.Sender" account to create a @@ -38,6 +30,10 @@ func AssertERC20BalanceEqual( func CreateFunTokenForBankCoin( deps *TestDeps, bankDenom string, s *suite.Suite, ) (funtoken evm.FunToken) { + if deps.App.BankKeeper.HasDenomMetaData(deps.Ctx, bankDenom) { + s.Failf("setting bank.DenomMetadata would overwrite existing denom \"%s\"", bankDenom) + } + s.T().Log("Setup: Create a coin in the bank state") bankMetadata := bank.Metadata{ DenomUnits: []*bank.DenomUnit{ @@ -51,43 +47,41 @@ func CreateFunTokenForBankCoin( Name: bankDenom, Symbol: bankDenom, } - if deps.App.BankKeeper.HasDenomMetaData(deps.Ctx, bankDenom) { - s.Failf("setting bank.DenomMetadata would overwrite existing denom \"%s\"", bankDenom) - } + deps.App.BankKeeper.SetDenomMetaData(deps.Ctx, bankMetadata) // Give the sender funds for the fee - err := testapp.FundAccount( + s.Require().NoError(testapp.FundAccount( deps.App.BankKeeper, deps.Ctx, deps.Sender.NibiruAddr, deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), - ) - s.Require().NoError(err) + )) s.T().Log("happy: CreateFunToken for the bank coin") createFuntokenResp, err := deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), + sdk.WrapSDKContext(deps.Ctx), &evm.MsgCreateFunToken{ FromBankDenom: bankDenom, Sender: deps.Sender.NibiruAddr.String(), }, ) s.NoError(err, "bankDenom %s", bankDenom) + erc20 := createFuntokenResp.FuntokenMapping.Erc20Addr funtoken = evm.FunToken{ Erc20Addr: erc20, BankDenom: bankDenom, IsMadeFromCoin: true, } - s.Equal(createFuntokenResp.FuntokenMapping, funtoken) + s.Equal(funtoken, createFuntokenResp.FuntokenMapping) s.T().Log("Expect ERC20 to be deployed") - erc20Addr := erc20.ToAddr() - queryCodeReq := &evm.QueryCodeRequest{ - Address: erc20Addr.String(), - } - _, err = deps.EvmKeeper.Code(deps.Ctx, queryCodeReq) + _, err = deps.EvmKeeper.Code(deps.Ctx, + &evm.QueryCodeRequest{ + Address: erc20.String(), + }, + ) s.NoError(err) return funtoken diff --git a/x/evm/evmtest/eth.go b/x/evm/evmtest/eth.go index 08146dc36..05792bb7e 100644 --- a/x/evm/evmtest/eth.go +++ b/x/evm/evmtest/eth.go @@ -2,7 +2,6 @@ package evmtest import ( - "crypto/ecdsa" "math/big" "testing" @@ -24,9 +23,8 @@ import ( "github.com/NibiruChain/nibiru/v2/x/evm" ) -// NewEthAccInfo returns an Ethereum private key, its corresponding Eth address, -// public key, and Nibiru address. -func NewEthAccInfo() EthPrivKeyAcc { +// NewEthPrivAcc returns an Ethereum private key, its corresponding Eth address, Nibiru address, and keyring signer. +func NewEthPrivAcc() EthPrivKeyAcc { privkey, _ := ethsecp256k1.GenerateKey() privKeyE, _ := privkey.ToECDSA() ethAddr := crypto.PubkeyToAddress(privKeyE.PublicKey) @@ -34,7 +32,6 @@ func NewEthAccInfo() EthPrivKeyAcc { EthAddr: ethAddr, NibiruAddr: eth.EthAddrToNibiruAddr(ethAddr), PrivKey: privkey, - PrivKeyE: privKeyE, KeyringSigner: NewSigner(privkey), } } @@ -43,21 +40,11 @@ type EthPrivKeyAcc struct { EthAddr gethcommon.Address NibiruAddr sdk.AccAddress PrivKey *ethsecp256k1.PrivKey - PrivKeyE *ecdsa.PrivateKey KeyringSigner keyring.Signer } -func (acc EthPrivKeyAcc) GethSigner(ethChainID *big.Int) gethcore.Signer { - return gethcore.LatestSignerForChainID(ethChainID) -} - -// NewEthTxMsg: Helper that returns a valid instance of [*evm.MsgEthereumTx]. -func NewEthTxMsg() *evm.MsgEthereumTx { - return NewEthTxMsgs(1)[0] -} - func NewEthTxMsgs(count uint64) (ethTxMsgs []*evm.MsgEthereumTx) { - ethAddr := NewEthAccInfo().EthAddr + ethAddr := NewEthPrivAcc().EthAddr startIdx := uint64(1) for nonce := startIdx; nonce-startIdx < count; nonce++ { ethTxMsgs = append(ethTxMsgs, evm.NewTx(&evm.EvmTxArgs{ diff --git a/x/evm/evmtest/eth_test.go b/x/evm/evmtest/eth_test.go index 33b32ff4c..60e2087ee 100644 --- a/x/evm/evmtest/eth_test.go +++ b/x/evm/evmtest/eth_test.go @@ -20,7 +20,7 @@ func TestSuiteEVM(t *testing.T) { func (s *Suite) TestSampleFns() { s.T().Log("Test NewEthTxMsg") - ethTxMsg := evmtest.NewEthTxMsg() + ethTxMsg := evmtest.NewEthTxMsgs(1)[0] err := ethTxMsg.ValidateBasic() s.NoError(err) diff --git a/x/evm/evmtest/evmante.go b/x/evm/evmtest/evmante.go index dd83cec83..b25a72f37 100644 --- a/x/evm/evmtest/evmante.go +++ b/x/evm/evmtest/evmante.go @@ -19,7 +19,7 @@ var NextNoOpAnteHandler sdk.AnteHandler = func( } func HappyTransferTx(deps *TestDeps, nonce uint64) *evm.MsgEthereumTx { - to := NewEthAccInfo().EthAddr + to := NewEthPrivAcc().EthAddr ethContractCreationTxParams := &evm.EvmTxArgs{ ChainID: deps.App.EvmKeeper.EthChainID(deps.Ctx), Nonce: nonce, @@ -38,7 +38,7 @@ func NonEvmMsgTx(deps *TestDeps) sdk.Tx { fees := sdk.NewCoins(sdk.NewInt64Coin("unibi", int64(gasLimit))) msg := &banktypes.MsgSend{ FromAddress: deps.Sender.NibiruAddr.String(), - ToAddress: NewEthAccInfo().NibiruAddr.String(), + ToAddress: NewEthPrivAcc().NibiruAddr.String(), Amount: sdk.NewCoins(sdk.NewInt64Coin("unibi", 1)), } return buildTx(deps, true, msg, gasLimit, fees) diff --git a/x/evm/evmtest/smart_contract.go b/x/evm/evmtest/smart_contract.go index 77476618a..9c9d32cd2 100644 --- a/x/evm/evmtest/smart_contract.go +++ b/x/evm/evmtest/smart_contract.go @@ -4,19 +4,15 @@ import ( "math/big" gethcommon "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/params" + gethcore "github.com/ethereum/go-ethereum/core/types" gethparams "github.com/ethereum/go-ethereum/params" "github.com/NibiruChain/nibiru/v2/x/evm/embeds" - gethcore "github.com/ethereum/go-ethereum/core/types" - "github.com/NibiruChain/nibiru/v2/x/evm" ) -// ArgsCreateContract: Arguments to call with `CreateContractTxMsg` and -// `CreateContractGethCoreMsg` to make Ethereum transactions that create +// ArgsCreateContract: Arguments to call with `CreateContractTxMsg` to make Ethereum transactions that create // contracts. // // It is recommended to use a gas price of `big.NewInt(1)` for simpler op code @@ -41,71 +37,52 @@ type ArgsExecuteContract struct { GasLimit *big.Int } -func CreateContractTxMsg( +func CreateContractMsgEthereumTx( args ArgsCreateContract, -) (ethTxMsg *evm.MsgEthereumTx, err error) { +) (msgEthereumTx *evm.MsgEthereumTx, err error) { gasLimit := args.GasLimit if gasLimit == nil { gasLimit = new(big.Int).SetUint64(gethparams.TxGasContractCreation) } - testContract := embeds.SmartContract_TestERC20 - gethTxCreateCntract := &gethcore.AccessListTx{ + ethTx := gethcore.NewTx(&gethcore.AccessListTx{ GasPrice: args.GasPrice, Gas: gasLimit.Uint64(), To: nil, - Data: testContract.Bytecode, + Data: embeds.SmartContract_TestERC20.Bytecode, Nonce: args.Nonce, - } - ethTx := gethcore.NewTx(gethTxCreateCntract) - ethTxMsg = new(evm.MsgEthereumTx) - err = ethTxMsg.FromEthereumTx(ethTx) - if err != nil { - return ethTxMsg, err - } - fromAcc := args.EthAcc - ethTxMsg.From = fromAcc.EthAddr.Hex() + }) - gethSigner := fromAcc.GethSigner(args.EthChainIDInt) - keyringSigner := fromAcc.KeyringSigner - return ethTxMsg, ethTxMsg.Sign(gethSigner, keyringSigner) -} - -func CreateContractGethCoreMsg( - args ArgsCreateContract, - cfg *params.ChainConfig, - blockHeight *big.Int, -) (gethCoreMsg core.Message, err error) { - ethTxMsg, err := CreateContractTxMsg(args) + msgEthereumTx = new(evm.MsgEthereumTx) + err = msgEthereumTx.FromEthereumTx(ethTx) if err != nil { - return gethCoreMsg, err + return msgEthereumTx, err } + msgEthereumTx.From = args.EthAcc.EthAddr.Hex() - signer := gethcore.MakeSigner(cfg, blockHeight) - return ethTxMsg.AsMessage(signer, nil) + gethSigner := gethcore.LatestSignerForChainID(args.EthChainIDInt) + return msgEthereumTx, msgEthereumTx.Sign(gethSigner, args.EthAcc.KeyringSigner) } -func ExecuteContractTxMsg(args ArgsExecuteContract) (ethTxMsg *evm.MsgEthereumTx, err error) { +func ExecuteContractMsgEthereumTx(args ArgsExecuteContract) (msgEthereumTx *evm.MsgEthereumTx, err error) { gasLimit := args.GasLimit if gasLimit == nil { gasLimit = new(big.Int).SetUint64(gethparams.TxGas) } - gethTxExecuteContract := &gethcore.AccessListTx{ + + coreTx := gethcore.NewTx(&gethcore.AccessListTx{ GasPrice: args.GasPrice, Gas: gasLimit.Uint64(), To: args.ContractAddress, Data: args.Data, Nonce: args.Nonce, - } - ethTx := gethcore.NewTx(gethTxExecuteContract) - ethTxMsg = new(evm.MsgEthereumTx) - err = ethTxMsg.FromEthereumTx(ethTx) + }) + msgEthereumTx = new(evm.MsgEthereumTx) + err = msgEthereumTx.FromEthereumTx(coreTx) if err != nil { - return ethTxMsg, err + return msgEthereumTx, err } - fromAcc := args.EthAcc - ethTxMsg.From = fromAcc.EthAddr.Hex() + msgEthereumTx.From = args.EthAcc.EthAddr.Hex() - gethSigner := fromAcc.GethSigner(args.EthChainIDInt) - keyringSigner := fromAcc.KeyringSigner - return ethTxMsg, ethTxMsg.Sign(gethSigner, keyringSigner) + gethSigner := gethcore.LatestSignerForChainID(args.EthChainIDInt) + return msgEthereumTx, msgEthereumTx.Sign(gethSigner, args.EthAcc.KeyringSigner) } diff --git a/x/evm/evmtest/smart_contract_test.go b/x/evm/evmtest/smart_contract_test.go index cefefebe1..d5ca3434a 100644 --- a/x/evm/evmtest/smart_contract_test.go +++ b/x/evm/evmtest/smart_contract_test.go @@ -6,13 +6,12 @@ import ( gethcommon "github.com/ethereum/go-ethereum/common" - "github.com/NibiruChain/nibiru/v2/x/evm" "github.com/NibiruChain/nibiru/v2/x/evm/evmtest" ) func (s *Suite) TestCreateContractTxMsg() { deps := evmtest.NewTestDeps() - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() args := evmtest.ArgsCreateContract{ EthAcc: ethAcc, @@ -21,37 +20,14 @@ func (s *Suite) TestCreateContractTxMsg() { Nonce: deps.StateDB().GetNonce(ethAcc.EthAddr), } - ethTxMsg, err := evmtest.CreateContractTxMsg(args) + ethTxMsg, err := evmtest.CreateContractMsgEthereumTx(args) s.NoError(err) s.Require().NoError(ethTxMsg.ValidateBasic()) } -func (s *Suite) TestCreateContractGethCoreMsg() { - deps := evmtest.NewTestDeps() - ethAcc := evmtest.NewEthAccInfo() - - args := evmtest.ArgsCreateContract{ - EthAcc: ethAcc, - EthChainIDInt: deps.EvmKeeper.EthChainID(deps.Ctx), - GasPrice: big.NewInt(1), - Nonce: deps.StateDB().GetNonce(ethAcc.EthAddr), - } - - // chain config - cfg := evm.EthereumConfig(args.EthChainIDInt) - - // block height - blockHeight := big.NewInt(deps.Ctx.BlockHeight()) - - _, err := evmtest.CreateContractGethCoreMsg( - args, cfg, blockHeight, - ) - s.NoError(err) -} - func (s *Suite) TestExecuteContractTxMsg() { deps := evmtest.NewTestDeps() - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() contractAddress := gethcommon.HexToAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed") args := evmtest.ArgsExecuteContract{ EthAcc: ethAcc, @@ -62,7 +38,7 @@ func (s *Suite) TestExecuteContractTxMsg() { Data: nil, } - ethTxMsg, err := evmtest.ExecuteContractTxMsg(args) + ethTxMsg, err := evmtest.ExecuteContractMsgEthereumTx(args) s.NoError(err) s.Require().NoError(ethTxMsg.ValidateBasic()) } diff --git a/x/evm/evmtest/test_deps.go b/x/evm/evmtest/test_deps.go index c00405cf9..9c6015933 100644 --- a/x/evm/evmtest/test_deps.go +++ b/x/evm/evmtest/test_deps.go @@ -1,8 +1,6 @@ package evmtest import ( - "context" - sdk "github.com/cosmos/cosmos-sdk/types" gethcommon "github.com/ethereum/go-ethereum/common" @@ -27,10 +25,6 @@ type TestDeps struct { Sender EthPrivKeyAcc } -func (deps TestDeps) GoCtx() context.Context { - return sdk.WrapSDKContext(deps.Ctx) -} - func NewTestDeps() TestDeps { testapp.EnsureNibiruPrefix() encCfg := app.MakeEncodingConfig() @@ -38,7 +32,7 @@ func NewTestDeps() TestDeps { eth.RegisterInterfaces(encCfg.InterfaceRegistry) app, ctx := testapp.NewNibiruTestAppAndContext() ctx = ctx.WithChainID(eth.EIP155ChainID_Testnet) - ethAcc := NewEthAccInfo() + ethAcc := NewEthPrivAcc() return TestDeps{ App: app, Ctx: ctx, @@ -58,6 +52,5 @@ func (deps TestDeps) StateDB() *statedb.StateDB { } func (deps *TestDeps) GethSigner() gethcore.Signer { - ctx := deps.Ctx - return deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(ctx)) + return gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) } diff --git a/x/evm/evmtest/tx.go b/x/evm/evmtest/tx.go index e5d1c628c..03f8e4226 100644 --- a/x/evm/evmtest/tx.go +++ b/x/evm/evmtest/tx.go @@ -8,6 +8,7 @@ import ( "testing" "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" gethcommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" gethcore "github.com/ethereum/go-ethereum/core/types" @@ -113,7 +114,7 @@ func NewEthTxMsgFromTxData( // ExecuteNibiTransfer executes nibi transfer func ExecuteNibiTransfer(deps *TestDeps, t *testing.T) *evm.MsgEthereumTx { nonce := deps.StateDB().GetNonce(deps.Sender.EthAddr) - recipient := NewEthAccInfo().EthAddr + recipient := NewEthPrivAcc().EthAddr txArgs := evm.JsonTxArgs{ From: &deps.Sender.EthAddr, @@ -123,7 +124,7 @@ func ExecuteNibiTransfer(deps *TestDeps, t *testing.T) *evm.MsgEthereumTx { ethTxMsg, err := GenerateAndSignEthTxMsg(txArgs, deps) require.NoError(t, err) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) require.NoError(t, err) require.Empty(t, resp.VmError) return ethTxMsg @@ -160,7 +161,7 @@ func DeployContract( ethTxMsg, err := GenerateAndSignEthTxMsg(jsonTxArgs, deps) require.NoError(t, err) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) require.NoError(t, err) require.Empty(t, resp.VmError) @@ -194,7 +195,7 @@ func DeployAndExecuteERC20Transfer( // TX 2: execute ERC-20 contract transfer input, err := contractData.ABI.Pack( - "transfer", NewEthAccInfo().EthAddr, new(big.Int).SetUint64(1000), + "transfer", NewEthPrivAcc().EthAddr, new(big.Int).SetUint64(1000), ) require.NoError(t, err) nonce = deps.StateDB().GetNonce(deps.Sender.EthAddr) @@ -207,7 +208,7 @@ func DeployAndExecuteERC20Transfer( ethTxMsg, err := GenerateAndSignEthTxMsg(txArgs, deps) require.NoError(t, err) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) require.NoError(t, err) require.Empty(t, resp.VmError) @@ -222,21 +223,23 @@ func GenerateAndSignEthTxMsg( if err != nil { return nil, err } - res, err := deps.App.EvmKeeper.EstimateGas(deps.GoCtx(), &evm.EthCallRequest{ - Args: estimateArgs, - GasCap: srvconfig.DefaultEthCallGasLimit, - ProposerAddress: []byte{}, - ChainId: deps.App.EvmKeeper.EthChainID(deps.Ctx).Int64(), - }) + res, err := deps.App.EvmKeeper.EstimateGas( + sdk.WrapSDKContext(deps.Ctx), + &evm.EthCallRequest{ + Args: estimateArgs, + GasCap: srvconfig.DefaultEthCallGasLimit, + ProposerAddress: []byte{}, + ChainId: deps.App.EvmKeeper.EthChainID(deps.Ctx).Int64(), + }, + ) if err != nil { return nil, err } txArgs.Gas = (*hexutil.Uint64)(&res.Gas) - txMsg := txArgs.ToTransaction() - gethSigner := deps.Sender.GethSigner(deps.App.EvmKeeper.EthChainID(deps.Ctx)) - keyringSigner := deps.Sender.KeyringSigner - return txMsg, txMsg.Sign(gethSigner, keyringSigner) + msgEthereumTx := txArgs.ToTransaction() + gethSigner := gethcore.LatestSignerForChainID(deps.App.EvmKeeper.EthChainID(deps.Ctx)) + return msgEthereumTx, msgEthereumTx.Sign(gethSigner, deps.Sender.KeyringSigner) } func TransferWei( @@ -261,7 +264,7 @@ func TransferWei( return fmt.Errorf("error while transferring wei: %w", err) } - _, err = deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + _, err = deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) if err != nil { return fmt.Errorf("error while transferring wei: %w", err) } diff --git a/x/evm/keeper/erc20.go b/x/evm/keeper/erc20.go index dce823e4a..fc7d52128 100644 --- a/x/evm/keeper/erc20.go +++ b/x/evm/keeper/erc20.go @@ -176,7 +176,7 @@ func (k Keeper) CallContractWithInput( commit, gasLimit, &fromAcc, contract, contractInput, k, ctx, ) if err != nil { - return + return evmResp, err } unusedBigInt := big.NewInt(0) @@ -195,26 +195,25 @@ func (k Keeper) CallContractWithInput( ) // Apply EVM message - cfg, err := k.GetEVMConfig( + evmCfg, err := k.GetEVMConfig( ctx, sdk.ConsAddress(ctx.BlockHeader().ProposerAddress), k.EthChainID(ctx), ) if err != nil { - err = fmt.Errorf("failed to load evm config: %s", err) - return + return evmResp, fmt.Errorf("failed to load evm config: %s", err) } + txConfig := statedb.NewEmptyTxConfig(gethcommon.BytesToHash(ctx.HeaderHash())) evmResp, err = k.ApplyEvmMsg( - ctx, evmMsg, evm.NewNoOpTracer(), commit, cfg, txConfig, + ctx, evmMsg, evm.NewNoOpTracer(), commit, evmCfg, txConfig, ) if err != nil { - return + return evmResp, err } if evmResp.Failed() { - err = fmt.Errorf("%w: EVM error: %s", err, evmResp.VmError) - return + return evmResp, fmt.Errorf("%w: EVM error: %s", err, evmResp.VmError) } return evmResp, err diff --git a/x/evm/keeper/erc20_test.go b/x/evm/keeper/erc20_test.go index d6a60696b..20946553f 100644 --- a/x/evm/keeper/erc20_test.go +++ b/x/evm/keeper/erc20_test.go @@ -25,12 +25,11 @@ func (s *Suite) TestCreateFunTokenFromERC20() { deps := evmtest.NewTestDeps() // Compute contract address. FindERC20 should fail - nonce := deps.StateDB().GetNonce(deps.Sender.EthAddr) - contractAddress := crypto.CreateAddress(deps.Sender.EthAddr, nonce) - _, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, contractAddress) + expectedERC20Addr := crypto.CreateAddress(deps.Sender.EthAddr, deps.StateDB().GetNonce(deps.Sender.EthAddr)) + _, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, expectedERC20Addr) s.Error(err) - s.T().Log("Case 1: Deploy and invoke ERC20 for info") + s.T().Log("Case 1: Deploy and invoke ERC20 with 18 decimals") { metadata := keeper.ERC20Metadata{ Name: "erc20name", @@ -42,115 +41,120 @@ func (s *Suite) TestCreateFunTokenFromERC20() { metadata.Name, metadata.Symbol, metadata.Decimals, ) s.Require().NoError(err) - s.Equal(contractAddress, deployResp.ContractAddr) + s.Equal(expectedERC20Addr, deployResp.ContractAddr) info, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, deployResp.ContractAddr) s.NoError(err, info) s.Equal(metadata, info) } - s.T().Log("Case 2: Deploy and invoke ERC20 for info") + s.T().Log("Case 2: Deploy and invoke ERC20 with 9 decimals") { metadata := keeper.ERC20Metadata{ Name: "gwei", Symbol: "GWEI", Decimals: 9, } + expectedERC20Addr = crypto.CreateAddress(deps.Sender.EthAddr, deps.StateDB().GetNonce(deps.Sender.EthAddr)) deployResp, err := evmtest.DeployContract( &deps, embeds.SmartContract_ERC20Minter, s.T(), metadata.Name, metadata.Symbol, metadata.Decimals, ) s.Require().NoError(err) - s.NotEqual(contractAddress, deployResp.ContractAddr) + s.Require().Equal(expectedERC20Addr, deployResp.ContractAddr) info, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, deployResp.ContractAddr) s.NoError(err, info) s.Equal(metadata, info) + + queryCodeReq := &evm.QueryCodeRequest{ + Address: expectedERC20Addr.String(), + } + _, err = deps.EvmKeeper.Code(deps.Ctx, queryCodeReq) + s.Require().NoError(err) } + erc20Addr := eth.NewHexAddr(expectedERC20Addr) s.T().Log("happy: CreateFunToken for the ERC20") + { + // Give the sender funds for the fee + s.Require().NoError(testapp.FundAccount( + deps.App.BankKeeper, + deps.Ctx, + deps.Sender.NibiruAddr, + deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), + )) + + resp, err := deps.EvmKeeper.CreateFunToken( + sdk.WrapSDKContext(deps.Ctx), + &evm.MsgCreateFunToken{ + FromErc20: &erc20Addr, + Sender: deps.Sender.NibiruAddr.String(), + }, + ) + s.Require().NoError(err, "erc20 %s", erc20Addr) + + expectedBankDenom := fmt.Sprintf("erc20/%s", erc20Addr.String()) + s.Equal( + resp.FuntokenMapping, + evm.FunToken{ + Erc20Addr: erc20Addr, + BankDenom: expectedBankDenom, + IsMadeFromCoin: false, + }) - erc20Addr := eth.NewHexAddr(contractAddress) - queryCodeReq := &evm.QueryCodeRequest{ - Address: erc20Addr.String(), + // Event "EventFunTokenCreated" must present + testutil.RequireContainsTypedEvent( + s.T(), + deps.Ctx, + &evm.EventFunTokenCreated{ + BankDenom: expectedBankDenom, + Erc20ContractAddress: erc20Addr.String(), + Creator: deps.Sender.NibiruAddr.String(), + IsMadeFromCoin: false, + }, + ) } - _, err = deps.EvmKeeper.Code(deps.Ctx, queryCodeReq) - s.Require().NoError(err) - - // Give the sender funds for the fee - err = testapp.FundAccount( - deps.App.BankKeeper, - deps.Ctx, - deps.Sender.NibiruAddr, - deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), - ) - s.Require().NoError(err) - - createFuntokenResp, err := deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), - &evm.MsgCreateFunToken{ - FromErc20: &erc20Addr, - Sender: deps.Sender.NibiruAddr.String(), - }, - ) - s.NoError(err, "erc20 %s", erc20Addr) - expectedBankDenom := fmt.Sprintf("erc20/%s", erc20Addr.String()) - s.Equal( - createFuntokenResp.FuntokenMapping, - evm.FunToken{ - Erc20Addr: erc20Addr, - BankDenom: expectedBankDenom, - IsMadeFromCoin: false, - }) - - // Event "EventFunTokenCreated" must present - testutil.RequireContainsTypedEvent( - s.T(), - deps.Ctx, - &evm.EventFunTokenCreated{ - BankDenom: expectedBankDenom, - Erc20ContractAddress: erc20Addr.String(), - Creator: deps.Sender.NibiruAddr.String(), - IsMadeFromCoin: false, - }, - ) s.T().Log("sad: CreateFunToken for the ERC20: already registered") - // Give the sender funds for the fee - err = testapp.FundAccount( - deps.App.BankKeeper, - deps.Ctx, - deps.Sender.NibiruAddr, - deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), - ) - s.Require().NoError(err) - - _, err = deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), - &evm.MsgCreateFunToken{ - FromErc20: &erc20Addr, - Sender: deps.Sender.NibiruAddr.String(), - }, - ) - s.ErrorContains(err, "funtoken mapping already created") + { + // Give the sender funds for the fee + s.Require().NoError(testapp.FundAccount( + deps.App.BankKeeper, + deps.Ctx, + deps.Sender.NibiruAddr, + deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), + )) + + _, err = deps.EvmKeeper.CreateFunToken( + sdk.WrapSDKContext(deps.Ctx), + &evm.MsgCreateFunToken{ + FromErc20: &erc20Addr, + Sender: deps.Sender.NibiruAddr.String(), + }, + ) + s.ErrorContains(err, "funtoken mapping already created") + } s.T().Log("sad: CreateFunToken for the ERC20: invalid sender") - _, err = deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), - &evm.MsgCreateFunToken{ - FromErc20: &erc20Addr, - }, - ) - s.ErrorContains(err, "invalid sender") + { + _, err = deps.EvmKeeper.CreateFunToken( + sdk.WrapSDKContext(deps.Ctx), + &evm.MsgCreateFunToken{ + FromErc20: &erc20Addr, + }, + ) + s.ErrorContains(err, "invalid sender") + } } func (s *Suite) TestDeployERC20ForBankCoin() { deps := evmtest.NewTestDeps() // Compute contract address. FindERC20 should fail - nonce := deps.StateDB().GetNonce(deps.Sender.EthAddr) - contractAddress := crypto.CreateAddress(deps.Sender.EthAddr, nonce) - _, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, contractAddress) + nonce := deps.StateDB().GetNonce(evm.EVM_MODULE_ADDRESS) + expectedERC20Addr := crypto.CreateAddress(evm.EVM_MODULE_ADDRESS, nonce) + _, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, expectedERC20Addr) s.Error(err) s.T().Log("Case 1: Deploy and invoke ERC20 for info") @@ -171,18 +175,16 @@ func (s *Suite) TestDeployERC20ForBankCoin() { deps.Ctx, bankMetadata, ) s.Require().NoError(err) - s.NotEqual(contractAddress, erc20Addr, - "address derived from before call should differ since the contract deployment succeeds") + s.Equal(expectedERC20Addr, erc20Addr) s.T().Log("Expect ERC20 metadata on contract") - metadata := keeper.ERC20Metadata{ + info, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, erc20Addr) + s.NoError(err) + s.Equal(keeper.ERC20Metadata{ Name: bankDenom, Symbol: "TOKEN", Decimals: 0, - } - info, err := deps.EvmKeeper.FindERC20Metadata(deps.Ctx, erc20Addr) - s.NoError(err, info) - s.Equal(metadata, info) + }, info) } func (s *Suite) TestCreateFunTokenFromCoin() { @@ -201,16 +203,15 @@ func (s *Suite) TestCreateFunTokenFromCoin() { s.T().Log("happy: CreateFunToken for the bank coin") // Give the sender funds for the fee - err = testapp.FundAccount( + s.Require().NoError(testapp.FundAccount( deps.App.BankKeeper, deps.Ctx, deps.Sender.NibiruAddr, deps.EvmKeeper.FeeForCreateFunToken(deps.Ctx), - ) - s.Require().NoError(err) + )) createFuntokenResp, err := deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), + sdk.WrapSDKContext(deps.Ctx), &evm.MsgCreateFunToken{ FromBankDenom: bankDenom, Sender: deps.Sender.NibiruAddr.String(), @@ -229,7 +230,7 @@ func (s *Suite) TestCreateFunTokenFromCoin() { s.T().Log("Expect ERC20 to be deployed") queryCodeReq := &evm.QueryCodeRequest{ - Address: erc20Addr.String(), + Address: erc20.String(), } _, err = deps.EvmKeeper.Code(deps.Ctx, queryCodeReq) s.Require().NoError(err) @@ -251,7 +252,7 @@ func (s *Suite) TestCreateFunTokenFromCoin() { deps.Ctx, &evm.EventFunTokenCreated{ BankDenom: bankDenom, - Erc20ContractAddress: erc20Addr.String(), + Erc20ContractAddress: erc20.String(), Creator: deps.Sender.NibiruAddr.String(), IsMadeFromCoin: true, }, @@ -267,7 +268,7 @@ func (s *Suite) TestCreateFunTokenFromCoin() { ) s.Require().NoError(err) _, err = deps.EvmKeeper.CreateFunToken( - deps.GoCtx(), + sdk.WrapSDKContext(deps.Ctx), &evm.MsgCreateFunToken{ FromBankDenom: bankDenom, Sender: deps.Sender.NibiruAddr.String(), @@ -318,7 +319,7 @@ func (s *Suite) TestSendFunTokenToEvm() { spendableAmount := tc.senderBalanceBefore.Int64() spendableCoins := sdk.NewCoins(sdk.NewInt64Coin(bankDenom, spendableAmount)) - ctx := deps.GoCtx() + ctx := sdk.WrapSDKContext(deps.Ctx) setBankDenomMetadata(deps.Ctx, deps.App.BankKeeper, bankDenom) // Fund sender's wallet diff --git a/x/evm/keeper/funtoken_from_coin.go b/x/evm/keeper/funtoken_from_coin.go index 87191e52d..c58d43db9 100644 --- a/x/evm/keeper/funtoken_from_coin.go +++ b/x/evm/keeper/funtoken_from_coin.go @@ -18,9 +18,7 @@ func (k *Keeper) CreateFunTokenFromCoin( ctx sdk.Context, bankDenom string, ) (funtoken evm.FunToken, err error) { // 1 | Coin already registered with FunToken? - if funtokens := k.FunTokens.Collect( - ctx, k.FunTokens.Indexes.BankDenom.ExactMatch(ctx, bankDenom), - ); len(funtokens) > 0 { + if funtokens := k.FunTokens.Collect(ctx, k.FunTokens.Indexes.BankDenom.ExactMatch(ctx, bankDenom)); len(funtokens) > 0 { return funtoken, fmt.Errorf("funtoken mapping already created for bank denom \"%s\"", bankDenom) } @@ -33,13 +31,11 @@ func (k *Keeper) CreateFunTokenFromCoin( // 3 | deploy ERC20 for metadata erc20Addr, err := k.DeployERC20ForBankCoin(ctx, bankCoin) if err != nil { - return + return funtoken, errors.Wrap(err, "failed to deploy ERC20 for bank coin") } // 4 | ERC20 already registered with FunToken? - if funtokens := k.FunTokens.Collect( - ctx, k.FunTokens.Indexes.ERC20Addr.ExactMatch(ctx, erc20Addr), - ); len(funtokens) > 0 { + if funtokens := k.FunTokens.Collect(ctx, k.FunTokens.Indexes.ERC20Addr.ExactMatch(ctx, erc20Addr)); len(funtokens) > 0 { return funtoken, fmt.Errorf("funtoken mapping already created for ERC20 \"%s\"", erc20Addr.Hex()) } @@ -71,23 +67,19 @@ func (k *Keeper) DeployERC20ForBankCoin( } erc20Embed := embeds.SmartContract_ERC20Minter - callArgs := []any{bankCoin.Name, bankCoin.Symbol, decimals} - methodName := "" // pass empty method name to deploy the contract - packedArgs, err := erc20Embed.ABI.Pack(methodName, callArgs...) + + // pass empty method name to deploy the contract + packedArgs, err := erc20Embed.ABI.Pack("", bankCoin.Name, bankCoin.Symbol, decimals) if err != nil { err = errors.Wrap(err, "failed to pack ABI args") - return + return gethcommon.Address{}, err } - bytecodeForCall := append(erc20Embed.Bytecode, packedArgs...) - fromEvmAddr := evm.EVM_MODULE_ADDRESS - nonce := k.GetAccNonce(ctx, fromEvmAddr) - erc20Addr = crypto.CreateAddress(fromEvmAddr, nonce) - erc20Contract := (*gethcommon.Address)(nil) // nil >> doesn't exist yet - commit := true + erc20Addr = crypto.CreateAddress(evm.EVM_MODULE_ADDRESS, k.GetAccNonce(ctx, evm.EVM_MODULE_ADDRESS)) + bytecodeForCall := append(erc20Embed.Bytecode, packedArgs...) _, err = k.CallContractWithInput( - ctx, fromEvmAddr, erc20Contract, commit, bytecodeForCall, + ctx, evm.EVM_MODULE_ADDRESS, nil, true, bytecodeForCall, ) if err != nil { err = errors.Wrap(err, "deploy ERC20 failed") diff --git a/x/evm/keeper/funtoken_from_erc20.go b/x/evm/keeper/funtoken_from_erc20.go index 9fb333f3b..9e2dcda5a 100644 --- a/x/evm/keeper/funtoken_from_erc20.go +++ b/x/evm/keeper/funtoken_from_erc20.go @@ -11,7 +11,6 @@ import ( gethcommon "github.com/ethereum/go-ethereum/common" "github.com/NibiruChain/nibiru/v2/eth" - "github.com/NibiruChain/nibiru/v2/x/common" "github.com/NibiruChain/nibiru/v2/x/evm" "github.com/NibiruChain/nibiru/v2/x/evm/embeds" ) @@ -31,19 +30,19 @@ func (k Keeper) FindERC20Metadata( ) (info ERC20Metadata, err error) { var abi *gethabi.ABI = embeds.SmartContract_ERC20Minter.ABI - errs := []error{} - // Load name, symbol, decimals name, err := k.LoadERC20Name(ctx, abi, contract) - errs = append(errs, err) + if err != nil { + return info, err + } + symbol, err := k.LoadERC20Symbol(ctx, abi, contract) - errs = append(errs, err) - decimals, err := k.LoadERC20Decimals(ctx, abi, contract) - errs = append(errs, err) + if err != nil { + return info, err + } - err = common.CombineErrors(errs...) + decimals, err := k.LoadERC20Decimals(ctx, abi, contract) if err != nil { - err = fmt.Errorf("failed to \"FindERC20Metadata\": %w", err) return info, err } @@ -99,27 +98,24 @@ func (k *Keeper) CreateFunTokenFromERC20( erc20Addr := erc20.ToAddr() // 1 | ERC20 already registered with FunToken? - if funtokens := k.FunTokens.Collect( - ctx, k.FunTokens.Indexes.ERC20Addr.ExactMatch(ctx, erc20Addr), - ); len(funtokens) > 0 { + if funtokens := k.FunTokens.Collect(ctx, k.FunTokens.Indexes.ERC20Addr.ExactMatch(ctx, erc20Addr)); len(funtokens) > 0 { return funtoken, fmt.Errorf("funtoken mapping already created for ERC20 \"%s\"", erc20Addr.Hex()) } // 2 | Get existing ERC20 metadata info, err := k.FindERC20Metadata(ctx, erc20Addr) if err != nil { - return + return funtoken, err } bankDenom := fmt.Sprintf("erc20/%s", erc20.String()) // 3 | Coin already registered with FunToken? - _, isAlreadyCoin := k.bankKeeper.GetDenomMetaData(ctx, bankDenom) - if isAlreadyCoin { + _, isFound := k.bankKeeper.GetDenomMetaData(ctx, bankDenom) + if isFound { return funtoken, fmt.Errorf("bank coin denom already registered with denom \"%s\"", bankDenom) } - if funtokens := k.FunTokens.Collect( - ctx, k.FunTokens.Indexes.BankDenom.ExactMatch(ctx, bankDenom), - ); len(funtokens) > 0 { + + if funtokens := k.FunTokens.Collect(ctx, k.FunTokens.Indexes.BankDenom.ExactMatch(ctx, bankDenom)); len(funtokens) > 0 { return funtoken, fmt.Errorf("funtoken mapping already created for bank denom \"%s\"", bankDenom) } @@ -142,7 +138,7 @@ func (k *Keeper) CreateFunTokenFromERC20( err = bankMetadata.Validate() if err != nil { - return + return funtoken, fmt.Errorf("failed to validate bank metadata: %w", err) } k.bankKeeper.SetDenomMetaData(ctx, bankMetadata) diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go index f9f53784c..be0bdc8bd 100644 --- a/x/evm/keeper/grpc_query_test.go +++ b/x/evm/keeper/grpc_query_test.go @@ -140,7 +140,7 @@ func (s *Suite) TestQueryEvmAccount() { { name: "happy: not existing account", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() req = &evm.QueryEthAccountRequest{ Address: ethAcc.EthAddr.String(), } @@ -304,7 +304,7 @@ func (s *Suite) TestQueryStorage() { { name: "happy", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { - addr := evmtest.NewEthAccInfo().EthAddr + addr := evmtest.NewEthPrivAcc().EthAddr storageKey := gethcommon.BytesToHash([]byte("storagekey")) req = &evm.QueryStorageRequest{ Address: addr.Hex(), @@ -327,7 +327,7 @@ func (s *Suite) TestQueryStorage() { { name: "happy: no committed state", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { - addr := evmtest.NewEthAccInfo().EthAddr + addr := evmtest.NewEthPrivAcc().EthAddr storageKey := gethcommon.BytesToHash([]byte("storagekey")) req = &evm.QueryStorageRequest{ Address: addr.Hex(), @@ -380,7 +380,7 @@ func (s *Suite) TestQueryCode() { { name: "happy", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { - addr := evmtest.NewEthAccInfo().EthAddr + addr := evmtest.NewEthPrivAcc().EthAddr req = &evm.QueryCodeRequest{ Address: addr.Hex(), } @@ -429,7 +429,7 @@ func (s *Suite) TestQueryParams() { deps := evmtest.NewTestDeps() want := evm.DefaultParams() deps.EvmKeeper.SetParams(deps.Ctx, want) - gotResp, err := deps.EvmKeeper.Params(deps.GoCtx(), nil) + gotResp, err := deps.EvmKeeper.Params(sdk.WrapSDKContext(deps.Ctx), nil) s.NoError(err) got := gotResp.Params s.Require().NoError(err) @@ -440,7 +440,7 @@ func (s *Suite) TestQueryParams() { // Empty params to test the setter want.EvmDenom = "wei" deps.EvmKeeper.SetParams(deps.Ctx, want) - gotResp, err = deps.EvmKeeper.Params(deps.GoCtx(), nil) + gotResp, err = deps.EvmKeeper.Params(sdk.WrapSDKContext(deps.Ctx), nil) s.Require().NoError(err) got = gotResp.Params @@ -491,7 +491,7 @@ func (s *Suite) TestQueryEthCall() { tc.setup(&deps) } req, wantResp := tc.scenario(&deps) - gotResp, err := deps.App.EvmKeeper.EthCall(deps.GoCtx(), req) + gotResp, err := deps.App.EvmKeeper.EthCall(sdk.WrapSDKContext(deps.Ctx), req) if tc.wantErr != "" { s.Require().ErrorContains(err, tc.wantErr) return @@ -524,7 +524,7 @@ func (s *Suite) TestQueryBalance() { name: "happy: zero balance", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { req = &evm.QueryBalanceRequest{ - Address: evmtest.NewEthAccInfo().EthAddr.String(), + Address: evmtest.NewEthPrivAcc().EthAddr.String(), } wantResp = &evm.QueryBalanceResponse{ Balance: "0", @@ -666,14 +666,14 @@ func (s *Suite) TestEstimateGasForEvmCallType() { s.Require().NoError(err) // assert balance of 1000 * 10^12 wei - resp, _ := deps.App.EvmKeeper.Balance(deps.GoCtx(), &evm.QueryBalanceRequest{ + resp, _ := deps.App.EvmKeeper.Balance(sdk.WrapSDKContext(deps.Ctx), &evm.QueryBalanceRequest{ Address: deps.Sender.EthAddr.Hex(), }) s.Equal("1000", resp.Balance) s.Require().Equal("1000"+strings.Repeat("0", 12), resp.BalanceWei) // Send Eth call to transfer from the account - 5 * 10^12 wei - recipient := evmtest.NewEthAccInfo().EthAddr + recipient := evmtest.NewEthPrivAcc().EthAddr amountToSend := hexutil.Big(*evm.NativeToWei(big.NewInt(5))) gasLimitArg := hexutil.Uint64(100000) @@ -700,7 +700,7 @@ func (s *Suite) TestEstimateGasForEvmCallType() { { name: "sad: insufficient balance for transfer", scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) { - recipient := evmtest.NewEthAccInfo().EthAddr + recipient := evmtest.NewEthPrivAcc().EthAddr amountToSend := hexutil.Big(*evm.NativeToWei(big.NewInt(10))) jsonTxArgs, err := json.Marshal(&evm.JsonTxArgs{ diff --git a/x/evm/keeper/msg_ethereum_tx_test.go b/x/evm/keeper/msg_ethereum_tx_test.go index 883cd94b3..f1075a854 100644 --- a/x/evm/keeper/msg_ethereum_tx_test.go +++ b/x/evm/keeper/msg_ethereum_tx_test.go @@ -50,12 +50,12 @@ func (s *Suite) TestMsgEthereumTx_CreateContract() { Nonce: deps.StateDB().GetNonce(ethAcc.EthAddr), GasLimit: gasLimit, } - ethTxMsg, err := evmtest.CreateContractTxMsg(args) + ethTxMsg, err := evmtest.CreateContractMsgEthereumTx(args) s.Require().NoError(err) s.Require().NoError(ethTxMsg.ValidateBasic()) s.Equal(ethTxMsg.GetGas(), gasLimit.Uint64()) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) s.Require().NoError( err, "resp: %s\nblock header: %s", @@ -89,12 +89,12 @@ func (s *Suite) TestMsgEthereumTx_CreateContract() { GasPrice: big.NewInt(1), Nonce: deps.StateDB().GetNonce(ethAcc.EthAddr), } - ethTxMsg, err := evmtest.CreateContractTxMsg(args) + ethTxMsg, err := evmtest.CreateContractMsgEthereumTx(args) s.NoError(err) s.Require().NoError(ethTxMsg.ValidateBasic()) s.Equal(ethTxMsg.GetGas(), gasLimit) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) s.Require().ErrorContains( err, core.ErrIntrinsicGas.Error(), @@ -144,11 +144,11 @@ func (s *Suite) TestMsgEthereumTx_ExecuteContract() { ContractAddress: &contractAddr, Data: input, } - ethTxMsg, err := evmtest.ExecuteContractTxMsg(args) + ethTxMsg, err := evmtest.ExecuteContractMsgEthereumTx(args) s.NoError(err) s.Require().NoError(ethTxMsg.ValidateBasic()) s.Equal(ethTxMsg.GetGas(), gasLimit.Uint64()) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) s.Require().NoError( err, "resp: %s\nblock header: %s", @@ -213,7 +213,7 @@ func (s *Suite) TestMsgEthereumTx_SimpleTransfer() { ) s.NoError(err) - resp, err := deps.App.EvmKeeper.EthereumTx(deps.GoCtx(), ethTxMsg) + resp, err := deps.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(deps.Ctx), ethTxMsg) s.Require().NoError(err) s.Require().Empty(resp.VmError) diff --git a/x/evm/logs_test.go b/x/evm/logs_test.go index 467535de5..34cb80a12 100644 --- a/x/evm/logs_test.go +++ b/x/evm/logs_test.go @@ -12,7 +12,7 @@ import ( ) func TestTransactionLogsValidate(t *testing.T) { - addr := evmtest.NewEthAccInfo().EthAddr.String() + addr := evmtest.NewEthPrivAcc().EthAddr.String() testCases := []struct { name string @@ -96,7 +96,7 @@ func TestTransactionLogsValidate(t *testing.T) { } func TestValidateLog(t *testing.T) { - addr := evmtest.NewEthAccInfo().EthAddr.String() + addr := evmtest.NewEthPrivAcc().EthAddr.String() testCases := []struct { name string @@ -169,7 +169,7 @@ func TestValidateLog(t *testing.T) { } func TestConversionFunctions(t *testing.T) { - addr := evmtest.NewEthAccInfo().EthAddr.String() + addr := evmtest.NewEthPrivAcc().EthAddr.String() txLogs := evm.TransactionLogs{ Hash: common.BytesToHash([]byte("tx_hash")).String(), diff --git a/x/evm/msg_test.go b/x/evm/msg_test.go index c761dd59c..f6835e0d7 100644 --- a/x/evm/msg_test.go +++ b/x/evm/msg_test.go @@ -45,12 +45,12 @@ func TestMsgsSuite(t *testing.T) { } func (s *MsgsSuite) SetupTest() { - ethAcc := evmtest.NewEthAccInfo() + ethAcc := evmtest.NewEthPrivAcc() from, privFrom := ethAcc.EthAddr, ethAcc.PrivKey s.signer = evmtest.NewSigner(privFrom) s.from = from - s.to = evmtest.NewEthAccInfo().EthAddr + s.to = evmtest.NewEthPrivAcc().EthAddr s.chainID = big.NewInt(1) s.hundredBigInt = big.NewInt(100) @@ -958,7 +958,7 @@ func (s *MsgsSuite) TestUnwrapEthererumMsg() { } func (s *MsgsSuite) TestTransactionLogsEncodeDecode() { - addr := evmtest.NewEthAccInfo().EthAddr.String() + addr := evmtest.NewEthPrivAcc().EthAddr.String() txLogs := evm.TransactionLogs{ Hash: common.BytesToHash([]byte("tx_hash")).String(), diff --git a/x/evm/precompile/funtoken.go b/x/evm/precompile/funtoken.go index b8f593525..59eb53e73 100644 --- a/x/evm/precompile/funtoken.go +++ b/x/evm/precompile/funtoken.go @@ -13,25 +13,19 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/NibiruChain/nibiru/v2/app/keepers" - "github.com/NibiruChain/nibiru/v2/eth" "github.com/NibiruChain/nibiru/v2/x/evm" "github.com/NibiruChain/nibiru/v2/x/evm/embeds" ) -var ( - _ vm.PrecompiledContract = (*precompileFunToken)(nil) - _ NibiruPrecompile = (*precompileFunToken)(nil) -) +var _ vm.PrecompiledContract = (*precompileFunToken)(nil) // Precompile address for "FunToken.sol", the contract that // enables transfers of ERC20 tokens to "nibi" addresses as bank coins // using the ERC20's `FunToken` mapping. -var PrecompileAddr_FuntokenGateway = eth.MustNewHexAddrFromStr( - "0x0000000000000000000000000000000000000800", -) +var PrecompileAddr_FuntokenGateway = gethcommon.HexToAddress("0x0000000000000000000000000000000000000800") func (p precompileFunToken) Address() gethcommon.Address { - return PrecompileAddr_FuntokenGateway.ToAddr() + return PrecompileAddr_FuntokenGateway } func (p precompileFunToken) RequiredGas(input []byte) (gasPrice uint64) { @@ -62,18 +56,16 @@ func (p precompileFunToken) Run( } }() - contractInput := contract.Input - ctx, method, args, err := OnRunStart(p, evm, contractInput) + ctx, method, args, err := OnRunStart(embeds.SmartContract_FunToken.ABI, evm, contract.Input) if err != nil { return nil, err } - caller := contract.CallerAddress switch FunTokenMethod(method.Name) { case FunTokenMethod_BankSend: // TODO: UD-DEBUG: Test that calling non-method on the right address does // nothing. - bz, err = p.bankSend(ctx, caller, method, args, readonly) + bz, err = p.bankSend(ctx, contract.CallerAddress, method, args, readonly) default: // TODO: UD-DEBUG: test invalid method called err = fmt.Errorf("invalid method called with name \"%s\"", method.Name) @@ -88,13 +80,8 @@ func PrecompileFunToken(keepers keepers.PublicKeepers) vm.PrecompiledContract { } } -func (p precompileFunToken) ABI() *gethabi.ABI { - return embeds.SmartContract_FunToken.ABI -} - type precompileFunToken struct { keepers.PublicKeepers - NibiruPrecompile } var executionGuard sync.Mutex @@ -120,8 +107,7 @@ func (p precompileFunToken) bankSend( ) (bz []byte, err error) { if readOnly { // Check required for transactions but not needed for queries - err = fmt.Errorf("cannot write state from staticcall (a read-only call)") - return + return nil, fmt.Errorf("cannot write state from staticcall (a read-only call)") } if !executionGuard.TryLock() { return nil, fmt.Errorf("bankSend is already in progress") @@ -188,8 +174,7 @@ func (p precompileFunToken) bankSend( // Since we're sending them away and want accurate total supply tracking, the // tokens need to be burned. if funtoken.IsMadeFromCoin { - caller := evm.EVM_MODULE_ADDRESS - _, err = p.EvmKeeper.ERC20().Burn(erc20, caller, amount, ctx) + _, err = p.EvmKeeper.ERC20().Burn(erc20, evm.EVM_MODULE_ADDRESS, amount, ctx) if err != nil { err = fmt.Errorf("ERC20.Burn: %w", err) return @@ -202,40 +187,34 @@ func (p precompileFunToken) bankSend( return method.Outputs.Pack() // TODO: change interface } -// ArgsFunTokenBankSend: Constructor for an "args" array of arguments for the -// "IFunToken.bankSend" function. -func ArgsFunTokenBankSend( - erc20 gethcommon.Address, - amount *big.Int, - to sdk.AccAddress, -) []any { - return []any{erc20, amount, to.String()} -} - func (p precompileFunToken) AssertArgTypesBankSend(args []any) ( erc20 gethcommon.Address, amount *big.Int, to string, err error, ) { - err = AssertArgCount(args, 3) - if err != nil { + if len(args) != 3 { + err = fmt.Errorf("expected 3 arguments but got %d", len(args)) return } - erc20, ok1 := args[0].(gethcommon.Address) - amount, ok2 := args[1].(*big.Int) - to, ok3 := args[2].(string) - if !(ok1 && ok2 && ok3) { - err = fmt.Errorf("type validation for failed for \"%s\"", - "function bankSend(address erc20, uint256 amount, string memory to) external") + erc20, ok := args[0].(gethcommon.Address) + if !ok { + err = fmt.Errorf("type validation for failed for (address erc20) argument") + return } - return -} -func AssertArgCount(args []interface{}, wantNumArgs int) error { - if len(args) != wantNumArgs { - return fmt.Errorf("expected %d arguments but got %d", wantNumArgs, len(args)) + amount, ok = args[1].(*big.Int) + if !ok { + err = fmt.Errorf("type validation for failed for (uint256 amount) argument") + return } - return nil + + to, ok = args[2].(string) + if !ok { + err = fmt.Errorf("type validation for failed for (string to) argument") + return + } + + return } diff --git a/x/evm/precompile/funtoken_test.go b/x/evm/precompile/funtoken_test.go index 8353dac9c..239940e17 100644 --- a/x/evm/precompile/funtoken_test.go +++ b/x/evm/precompile/funtoken_test.go @@ -5,13 +5,14 @@ import ( "math/big" "testing" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/suite" + "github.com/NibiruChain/nibiru/v2/x/common/testutil" "github.com/NibiruChain/nibiru/v2/x/evm" "github.com/NibiruChain/nibiru/v2/x/evm/embeds" "github.com/NibiruChain/nibiru/v2/x/evm/evmtest" "github.com/NibiruChain/nibiru/v2/x/evm/precompile" - - "github.com/stretchr/testify/suite" ) type Suite struct { @@ -37,7 +38,7 @@ func (s *Suite) FunToken_PrecompileExists() { deps := evmtest.NewTestDeps() codeResp, err := deps.EvmKeeper.Code( - deps.GoCtx(), + sdk.WrapSDKContext(deps.Ctx), &evm.QueryCodeRequest{ Address: precompileAddr.String(), }, @@ -45,7 +46,7 @@ func (s *Suite) FunToken_PrecompileExists() { s.NoError(err) s.Equal(string(codeResp.Code), "") - s.True(deps.EvmKeeper.IsAvailablePrecompile(precompileAddr.ToAddr()), + s.True(deps.EvmKeeper.IsAvailablePrecompile(precompileAddr), "did not see precompile address during \"InitPrecompiles\"") callArgs := []any{"nonsense", "args here", "to see if", "precompile is", "called"} @@ -59,11 +60,10 @@ func (s *Suite) FunToken_PrecompileExists() { "callArgs: ", callArgs) fromEvmAddr := evm.EVM_MODULE_ADDRESS - contractAddr := precompileAddr.ToAddr() commit := true bytecodeForCall := packedArgs _, err = deps.EvmKeeper.CallContractWithInput( - deps.Ctx, fromEvmAddr, &contractAddr, commit, + deps.Ctx, fromEvmAddr, &precompileAddr, commit, bytecodeForCall, ) s.ErrorContains(err, "precompile error") @@ -77,7 +77,7 @@ func (s *Suite) FunToken_HappyPath() { theUser := deps.Sender.EthAddr theEvm := evm.EVM_MODULE_ADDRESS - s.True(deps.EvmKeeper.IsAvailablePrecompile(precompileAddr.ToAddr()), + s.True(deps.EvmKeeper.IsAvailablePrecompile(precompileAddr), "did not see precompile address during \"InitPrecompiles\"") s.T().Log("Create FunToken mapping and ERC20") @@ -95,7 +95,9 @@ func (s *Suite) FunToken_HappyPath() { to := theUser input, err := embeds.SmartContract_ERC20Minter.ABI.Pack("mint", to, big.NewInt(69_420)) s.NoError(err) - _, err = evmtest.DoEthTx(&deps, contract, from, input) + _, err = deps.EvmKeeper.CallContractWithInput( + deps.Ctx, from, &contract, true, input, + ) s.ErrorContains(err, "Ownable: caller is not the owner") } @@ -106,7 +108,9 @@ func (s *Suite) FunToken_HappyPath() { input, err := embeds.SmartContract_ERC20Minter.ABI.Pack("mint", to, big.NewInt(69_420)) s.NoError(err) - _, err = evmtest.DoEthTx(&deps, contract, from, input) + _, err = deps.EvmKeeper.CallContractWithInput( + deps.Ctx, from, &contract, true, input, + ) s.NoError(err) evmtest.AssertERC20BalanceEqual(s.T(), deps, contract, theUser, big.NewInt(69_420)) evmtest.AssertERC20BalanceEqual(s.T(), deps, contract, theEvm, big.NewInt(0)) @@ -128,13 +132,15 @@ func (s *Suite) FunToken_HappyPath() { s.T().Log("Send using precompile") amtToSend := int64(419) - callArgs := precompile.ArgsFunTokenBankSend(contract, big.NewInt(amtToSend), randomAcc) + callArgs := []any{contract, big.NewInt(amtToSend), randomAcc.String()} methodName := string(precompile.FunTokenMethod_BankSend) input, err := abi.Pack(methodName, callArgs...) s.NoError(err) from := theUser - _, err = evmtest.DoEthTx(&deps, precompileAddr.ToAddr(), from, input) + _, err = deps.EvmKeeper.CallContractWithInput( + deps.Ctx, from, &precompileAddr, true, input, + ) s.Require().NoError(err) evmtest.AssertERC20BalanceEqual(s.T(), deps, contract, theUser, big.NewInt(69_419-amtToSend)) diff --git a/x/evm/precompile/precompile.go b/x/evm/precompile/precompile.go index bba3c6e8d..c42b40c26 100644 --- a/x/evm/precompile/precompile.go +++ b/x/evm/precompile/precompile.go @@ -7,7 +7,6 @@ // // Key components: // - InitPrecompiles: Initializes and returns a map of precompiled contracts. -// - NibiruPrecompile: Interface for Nibiru-specific precompiles. // - PrecompileFunToken: Implements the FunToken precompile for ERC20-to-bank transfers. // // The package also provides utility functions for working with precompiles, such @@ -92,29 +91,24 @@ func addPrecompileToVM(p vm.PrecompiledContract) { // vm.PrecompiledAddressesCancun, } -// NibiruPrecompile is the interface that all Nibiru-specific precompiles -// must implement. -type NibiruPrecompile interface { - vm.PrecompiledContract - ABI() *gethabi.ABI -} - -// ABIMethodByID: Looks up an ABI method by the 4-byte id. +// methodById: Looks up an ABI method by the 4-byte id. // Copy of "ABI.MethodById" from go-ethereum version > 1.10 -func ABIMethodByID(abi *gethabi.ABI, sigdata []byte) (*gethabi.Method, error) { - if len(sigdata) < 4 { - return nil, fmt.Errorf("data too short (%d bytes) for abi method lookup", len(sigdata)) +func methodById(abi *gethabi.ABI, sigdata []byte) (*gethabi.Method, error) { + if len(sigdata) != 4 { + return nil, fmt.Errorf("data (%d bytes) insufficient for abi method lookup", len(sigdata)) } + for _, method := range abi.Methods { if bytes.Equal(method.ID, sigdata[:4]) { return &method, nil } } + return nil, fmt.Errorf("no method with id: %#x", sigdata[:4]) } func OnRunStart( - p NibiruPrecompile, evm *vm.EVM, input []byte, + abi *gethabi.ABI, evm *vm.EVM, input []byte, ) (ctx sdk.Context, method *gethabi.Method, args []interface{}, err error) { // 1 | Get context from StateDB stateDB, ok := evm.StateDB.(*statedb.StateDB) @@ -125,23 +119,19 @@ func OnRunStart( ctx = stateDB.GetContext() // 2 | Parse the ABI method - // ABI method IDs are at least 4 bytes according to "gethabi.ABI.MethodByID". - methodIdBytes := 4 - if len(input) < methodIdBytes { + // ABI method IDs are exactly 4 bytes according to "gethabi.ABI.MethodByID". + if len(input) < 4 { readableBz := collections.HumanizeBytes(input) err = fmt.Errorf("input \"%s\" too short to extract method ID (less than 4 bytes)", readableBz) return } - methodID := input[:methodIdBytes] - abi := p.ABI() - method, err = ABIMethodByID(abi, methodID) + method, err = methodById(abi, input[:4]) if err != nil { err = fmt.Errorf("unable to parse ABI method by its 4-byte ID: %w", err) return } - argsBz := input[methodIdBytes:] - args, err = method.Inputs.Unpack(argsBz) + args, err = method.Inputs.Unpack(input[4:]) if err != nil { err = fmt.Errorf("unable to unpack input args: %w", err) return diff --git a/x/evm/tx_test.go b/x/evm/tx_test.go index 638fb585a..2a8a2acd2 100644 --- a/x/evm/tx_test.go +++ b/x/evm/tx_test.go @@ -45,7 +45,7 @@ func (suite *TxDataTestSuite) SetupTest() { suite.sdkMinusOneInt = sdkmath.NewInt(-1) suite.invalidAddr = "123456" - suite.addr = evmtest.NewEthAccInfo().EthAddr + suite.addr = evmtest.NewEthPrivAcc().EthAddr suite.hexAddr = suite.addr.Hex() suite.hexDataBytes = hexutil.Bytes([]byte("data"))