evmos · fedekunze · Nov 14, 2023 · Nov 14, 2023 · Nov 14, 2023
@@ -85,6 +85,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - (erc20) [#2023](https://github.com/evmos/evmos/pull/2023) Add tests for ERC20 precompile queries.
 - (osmosis-outpost) [#2025](https://github.com/evmos/evmos/pull/2025) Use a struct to wrap parsed parameters from Solidity.
 - (erc20) [#2037](https://github.com/evmos/evmos/pull/2037) Add IsTransactions and RequiredGas tests for the ERC20 extension.
+- (bank) [#2040](https://github.com/evmos/evmos/pull/2040) Add bank extension unit tests for queries.
 
 ### Bug Fixes
 

@@ -19,7 +19,7 @@ const (
 )
 
 // Balances returns all the native token balances (address, amount) for a given
-// account. This method charges the account the corresponding value of a ERC-20
+// account. This method charges the account the corresponding value of an ERC-20
 // balanceOf call for each token returned.
 func (p Precompile) Balances(
 	ctx sdk.Context,

@@ -0,0 +1,161 @@
+package bank_test
+
+import (
+	"math/big"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/evmos/evmos/v15/precompiles/bank"
+	evmosutiltx "github.com/evmos/evmos/v15/testutil/tx"
+)
+
+func (s *PrecompileTestSuite) TestBalances() {
+	method := s.precompile.Methods[bank.BalancesMethod]
+
+	testcases := []struct {
+		name        string
+		malleate    func() []interface{}
+		expPass     bool
+		errContains string
+		expBalances []bank.Balance
+	}{
+		{
+			"fail - invalid number of arguments",
+			func() []interface{} {
+				return []interface{}{
+					"", "",
+				}
+			},
+			false,
+			"invalid number of arguments",
+			nil,
+		},
+		{
+			"fail - invalid account address",
+			func() []interface{} {
+				return []interface{}{
+					"random text",
+				}
+			},
+			false,
+			"invalid type for account",
+			nil,
+		},
+		{
+			"pass - empty balances for new account",
+			func() []interface{} {
+				return []interface{}{
+					evmosutiltx.GenerateAddress(),
+				}
+			},
+			true,
+			"",
+			[]bank.Balance{},
+		},
+		{
+			"pass - EVMOS balance present",
+			func() []interface{} {
+				return []interface{}{
+					s.keyring.GetAddr(0),
+				}
+			},
+			true,
+			"",
+			[]bank.Balance{{
+				ContractAddress: s.evmosAddr,
+				Amount:          big.NewInt(4e18),
+			}},
+		},
+		{
+			"pass - EVMOS and XMPL balances present",
+			func() []interface{} {
+				s.mintAndSendCoin("xmpl", s.keyring.GetAccAddr(0), sdk.NewInt(1e18))
+				return []interface{}{
+					s.keyring.GetAddr(0),
+				}
+			},
+			true,
+			"",
+			[]bank.Balance{{
+				ContractAddress: s.evmosAddr,
+				Amount:          big.NewInt(4e18),
+			}, {
+				ContractAddress: s.xmplAddr,
+				Amount:          big.NewInt(1e18),
+			}},
+		},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			s.SetupTest()
+
+			bz, err := s.precompile.Balances(
+				s.network.GetContext(),
+				nil,
+				&method,
+				tc.malleate(),
+			)
+
+			if tc.expPass {
+				s.Require().NoError(err)
+				var balances []bank.Balance
+				err = s.precompile.UnpackIntoInterface(&balances, method.Name, bz)
+				s.Require().NoError(err)
+				s.Require().Equal(tc.expBalances, balances)
+			} else {
+				s.Require().Contains(err.Error(), tc.errContains)
+			}
+		})
+	}
+}
+
+func (s *PrecompileTestSuite) TestTotalSupply() {
+	method := s.precompile.Methods[bank.TotalSupplyMethod]
+
+	evmosTotalSupply, ok := new(big.Int).SetString("11000000000000000000", 10)
+	s.Require().True(ok)
+
+	testcases := []struct {
+		name      string
+		malleate  func()
+		expSupply []bank.Balance
+	}{
+		{
+			"pass - EVMOS and XMPL total supply",
+			func() {
+				s.mintAndSendCoin("xmpl", s.keyring.GetAccAddr(0), sdk.NewInt(1e18))
+			},
+			[]bank.Balance{{
+				ContractAddress: s.evmosAddr,
+				Amount:          evmosTotalSupply,
+			}, {
+				ContractAddress: s.xmplAddr,
+				Amount:          big.NewInt(1e18),
+			}},
+		},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+
+		s.Run(tc.name, func() {
+			s.SetupTest()
+
+			bz, err := s.precompile.TotalSupply(
+				s.network.GetContext(),
+				nil,
+				&method,
+				nil,
+			)
+
+			s.Require().NoError(err)
+			var balances []bank.Balance
+			err = s.precompile.UnpackIntoInterface(&balances, method.Name, bz)
+			s.Require().NoError(err)
+			s.Require().Equal(tc.expSupply, balances)
+		})
+	}
+}
@@ -0,0 +1,117 @@
+package bank_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	inflationtypes "github.com/evmos/evmos/v15/x/inflation/v1/types"
+
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/evmos/evmos/v15/precompiles/bank"
+	"github.com/evmos/evmos/v15/testutil/integration/evmos/factory"
+	"github.com/evmos/evmos/v15/testutil/integration/evmos/grpc"
+	testkeyring "github.com/evmos/evmos/v15/testutil/integration/evmos/keyring"
+	"github.com/evmos/evmos/v15/testutil/integration/evmos/network"
+	"github.com/stretchr/testify/suite"
+)
+
+var s *PrecompileTestSuite
+
+// PrecompileTestSuite is the implementation of the TestSuite interface for ERC20 precompile
+// unit tests.
+type PrecompileTestSuite struct {
+	suite.Suite
+
+	bondDenom           string
+	evmosAddr, xmplAddr common.Address
+
+	// tokenDenom is the specific token denomination used in testing the ERC20 precompile.
+	// This denomination is used to instantiate the precompile.
+	network     *network.UnitTestNetwork
+	factory     factory.TxFactory
+	grpcHandler grpc.Handler
+	keyring     testkeyring.Keyring
+
+	precompile *bank.Precompile
+}
+
+func TestPrecompileTestSuite(t *testing.T) {
+	s = new(PrecompileTestSuite)
+	suite.Run(t, s)
+}
+
+func (s *PrecompileTestSuite) SetupTest() {
+	keyring := testkeyring.New(2)
+	integrationNetwork := network.NewUnitTestNetwork(
+		network.WithPreFundedAccounts(keyring.GetAllAccAddrs()...),
+	)
+	grpcHandler := grpc.NewIntegrationHandler(integrationNetwork)
+	txFactory := factory.New(integrationNetwork, grpcHandler)
+
+	ctx := integrationNetwork.GetContext()
+	sk := integrationNetwork.App.StakingKeeper
+	bondDenom := sk.BondDenom(ctx)
+	s.Require().NotEmpty(bondDenom, "bond denom cannot be empty")
+
+	s.bondDenom = bondDenom
+	s.factory = txFactory
+	s.grpcHandler = grpcHandler
+	s.keyring = keyring
+	s.network = integrationNetwork
+
+	// Register EVMOS
+	evmosMetadata := banktypes.Metadata{
+		Description: "The native token of Evmos",
+		Base:        bondDenom,
+		// NOTE: Denom units MUST be increasing
+		DenomUnits: []*banktypes.DenomUnit{
+			{
+				Denom:    bondDenom,
+				Exponent: 0,
+				Aliases:  []string{"aevmos"},
+			},
+			{
+				Denom:    "aevmos",
+				Exponent: 18,
+			},
+		},
+		Name:    "Evmos",
+		Symbol:  "EVMOS",
+		Display: "evmos",
+	}
+	tokenPair, err := s.network.App.Erc20Keeper.RegisterCoin(s.network.GetContext(), evmosMetadata)
+	s.Require().NoError(err, "failed to register coin")
+
+	s.evmosAddr = common.HexToAddress(tokenPair.Erc20Address)
+
+	// Mint and register a second coin for testing purposes
+	err = s.network.App.BankKeeper.MintCoins(s.network.GetContext(), inflationtypes.ModuleName, sdk.Coins{{Denom: "xmpl", Amount: sdk.NewInt(1e18)}})
+	s.Require().NoError(err)
+
+	xmplMetadata := banktypes.Metadata{
+		Description: "An exemplary token",
+		Base:        "xmpl",
+		// NOTE: Denom units MUST be increasing
+		DenomUnits: []*banktypes.DenomUnit{
+			{
+				Denom:    "xmpl",
+				Exponent: 0,
+				Aliases:  []string{"xmpl"},
+			},
+			{
+				Denom:    "xmpl",
+				Exponent: 18,
+			},
+		},
+		Name:    "Exemplary",
+		Symbol:  "XMPL",
+		Display: "xmpl",
+	}
+	tokenPair, err = s.network.App.Erc20Keeper.RegisterCoin(s.network.GetContext(), xmplMetadata)
+	s.Require().NoError(err, "failed to register coin")
+
+	s.xmplAddr = common.HexToAddress(tokenPair.Erc20Address)
+
+	s.precompile = s.setupBankPrecompile()
+}
@@ -4,7 +4,6 @@
 package bank
 
 import (
-	"errors"
 	"fmt"
 	"math/big"
 
@@ -27,7 +26,7 @@ func ParseBalancesArgs(args []interface{}) (sdk.AccAddress, error) {
 
 	account, ok := args[0].(common.Address)
 	if !ok {
-		return nil, errors.New("invalid account address")
+		return nil, fmt.Errorf(cmn.ErrInvalidType, "account", common.Address{}, args[0])
 	}
 
 	return account.Bytes(), nil

@@ -0,0 +1,30 @@
+package bank_test
+
+import (
+	"cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/evmos/evmos/v15/precompiles/bank"
+	inflationtypes "github.com/evmos/evmos/v15/x/inflation/v1/types"
+)
+
+// setupBankPrecompile is a helper function to set up an instance of the Bank precompile for
+// a given token denomination.
+func (s *PrecompileTestSuite) setupBankPrecompile() *bank.Precompile {
+	precompile, err := bank.NewPrecompile(
+		s.network.App.BankKeeper,
+		s.network.App.Erc20Keeper,
+	)
+
+	s.Require().NoError(err, "failed to create bank precompile")
+
+	return precompile
+}
+
+// mintAndSendCoin is a helper function to mint and send a coin to a given address.
+func (s *PrecompileTestSuite) mintAndSendCoin(denom string, addr sdk.AccAddress, amount math.Int) {
+	coins := sdk.NewCoins(sdk.NewCoin(denom, amount))
+	err := s.network.App.BankKeeper.MintCoins(s.network.GetContext(), inflationtypes.ModuleName, coins)
+	s.Require().NoError(err)
+	err = s.network.App.BankKeeper.SendCoinsFromModuleToAccount(s.network.GetContext(), inflationtypes.ModuleName, addr, coins)
+	s.Require().NoError(err)
+}