feat: Hybrid StateDB for precompile support

.github/workflows/build.yml

@@ -3,6 +3,7 @@ on:
   pull_request:
     branches:
       - main
+      - kava/release/**
 
 jobs:
   cleanup-runs:

.github/workflows/labeler.yml

@@ -9,6 +9,6 @@ jobs:
   triage:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/labeler@v4
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
+      - uses: actions/labeler@v4
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/lint.yml

@@ -7,6 +7,7 @@ on:
   push:
     branches:
       - main
+      - kava/release/**
 jobs:
   golangci:
     name: Run golangci-lint
@@ -25,7 +26,7 @@ jobs:
             **/**.go
             go.mod
             go.sum
-      - uses: golangci/golangci-lint-action@v3.3.1
+      - uses: golangci/golangci-lint-action@v3.7.0
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
           version: latest

.github/workflows/security.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - main
+      - kava/release/**
 
 jobs:
   Gosec:

.github/workflows/test.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - main
       - release/**
+      - kava/release/**
 
 jobs:
   cleanup-runs:

.golangci.yml

@@ -63,17 +63,16 @@ linters-settings:
     locale: US
   nolintlint:
     allow-unused: false
-    allow-leading-space: true
     require-explanation: false
     require-specific: false
   gofumpt:
     lang-version: "1.19"
   gomodguard:
     blocked:
-      versions: # List of blocked module version constraints
-      - https://github.com/etcd-io/etcd:                            # Blocked module with version constraint
-          version: ">= 3.4.10 || ~3.3.23"                           # Version constraint, see https://github.com/Masterminds/semver#basic-comparisons
-          reason: "CVE-2020-15114; CVE-2020-15136; CVE-2020-15115"  # Reason why the version constraint exists. (Optional)
-      - https://github.com/dgrijalva/jwt-go:                      # Blocked module with version constraint
-          version: ">= 4.0.0-preview1"                           # Version constraint, see https://github.com/Masterminds/semver#basic-comparisons
-          reason: "CVE-2020-26160"  # Reason why the version constraint exists. (Optional)
+      versions:  # List of blocked module version constraints
+        - https://github.com/etcd-io/etcd:                            # Blocked module with version constraint
+            version: ">= 3.4.10 || ~3.3.23"                           # Version constraint, see https://github.com/Masterminds/semver#basic-comparisons
+            reason: "CVE-2020-15114; CVE-2020-15136; CVE-2020-15115"  # Reason why the version constraint exists. (Optional)
+        - https://github.com/dgrijalva/jwt-go:                      # Blocked module with version constraint
+            version: ">= 4.0.0-preview1"                           # Version constraint, see https://github.com/Masterminds/semver#basic-comparisons
+            reason: "CVE-2020-26160"  # Reason why the version constraint exists. (Optional)

Makefile

@@ -235,7 +235,7 @@ endif
 
 ifeq (, $(shell which go-bindata))
 	@echo "Installing go-bindata..."
-	@go get github.com/kevinburke/go-bindata/v4/go-bindata
+	@go get github.com/kevinburke/go-bindata/v4
 else
 	@echo "go-bindata already installed; skipping..."
 endif

app/ante/eth.go

@@ -88,13 +88,14 @@ func (avd EthAccountVerificationDecorator) AnteHandle(
 		if acct == nil {
 			acc := avd.ak.NewAccountWithAddress(ctx, from)
 			avd.ak.SetAccount(ctx, acc)
-			acct = statedb.NewEmptyAccount()
 		} else if acct.IsContract() {
 			return ctx, errorsmod.Wrapf(errortypes.ErrInvalidType,
 				"the sender is not EOA: address %s, codeHash <%s>", fromAddr, acct.CodeHash)
 		}
 
-		if err := keeper.CheckSenderBalance(sdkmath.NewIntFromBigInt(acct.Balance), txData); err != nil {
+		bal := avd.evmKeeper.GetBalance(ctx, fromAddr)
+
+		if err := keeper.CheckSenderBalance(sdkmath.NewIntFromBigInt(bal), txData); err != nil {
 			return ctx, errorsmod.Wrap(err, "failed to check sender balance")
 		}
 	}

app/ante/sigs_test.go

@@ -17,9 +17,10 @@ func (suite AnteTestSuite) TestSignatures() {
 
 	acc := statedb.NewEmptyAccount()
 	acc.Nonce = 1
-	acc.Balance = big.NewInt(10000000000)
 
 	suite.app.EvmKeeper.SetAccount(suite.ctx, addr, *acc)
+	suite.app.EvmKeeper.SetBalance(suite.ctx, addr, big.NewInt(10000000000))
+
 	msgEthereumTx := evmtypes.NewTx(suite.app.EvmKeeper.ChainID(), 1, &to, big.NewInt(10), 100000, big.NewInt(1), nil, nil, nil, nil)
 	msgEthereumTx.From = addr.Hex()
 

app/app.go

@@ -423,7 +423,8 @@ func NewEthermintApp(
 	// Set authority to x/gov module account to only expect the module account to update params
 	evmSs := app.GetSubspace(evmtypes.ModuleName)
 	app.EvmKeeper = evmkeeper.NewKeeper(
-		appCodec, keys[evmtypes.StoreKey], tkeys[evmtypes.TransientKey],
+		appCodec,
+		keys[evmtypes.StoreKey], tkeys[evmtypes.TransientKey],
 		authtypes.NewModuleAddress(govtypes.ModuleName),
 		app.AccountKeeper, app.BankKeeper, stakingKeeper, app.FeeMarketKeeper,
 		vm.NewEVM, tracer, evmSs,
@@ -766,6 +767,13 @@ func (app *EthermintApp) InterfaceRegistry() types.InterfaceRegistry {
 	return app.interfaceRegistry
 }
 
+// GetKeys returns all KVStoreKeys
+//
+// NOTE: This is solely to be used for testing purposes.
+func (app *EthermintApp) GetKeys() map[string]*storetypes.KVStoreKey {
+	return app.keys
+}
+
 // GetKey returns the KVStoreKey for the provided store key.
 //
 // NOTE: This is solely to be used for testing purposes.

app/utils.go

@@ -24,12 +24,14 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	"github.com/cosmos/cosmos-sdk/testutil/mock"
 	simutils "github.com/cosmos/cosmos-sdk/testutil/sims"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/ethereum/go-ethereum/common"
 
 	dbm "github.com/cometbft/cometbft-db"
 	abci "github.com/cometbft/cometbft/abci/types"
@@ -105,7 +107,9 @@ func SetupWithDB(isCheckTx bool, patchGenesis func(*EthermintApp, simapp.Genesis
 
 // NewTestGenesisState generate genesis state with single validator
 func NewTestGenesisState(codec codec.Codec) simapp.GenesisState {
-	privVal := mock.NewPV()
+	key := ed25519.GenPrivKeyFromSecret([]byte("constant seed"))
+	privVal := mock.PV{PrivKey: key}
+
 	pubKey, err := privVal.GetPubKey()
 	if err != nil {
 		panic(err)
@@ -115,7 +119,9 @@ func NewTestGenesisState(codec codec.Codec) simapp.GenesisState {
 	valSet := tmtypes.NewValidatorSet([]*tmtypes.Validator{validator})
 
 	// generate genesis account
-	senderPrivKey := secp256k1.GenPrivKey()
+	senderPrivKey := secp256k1.PrivKey{
+		Key: common.Hex2Bytes("6b65793a225c745c3337355c33363627365c333735476c5c3331375f5c323530305c3031375c303237375c3337365c3234315c3336355c323136247d475c3237316a3c5c3336365f785c3337353b5c3336305c3031362220"), //nolint:lll
+	}
 	acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
 	balance := banktypes.Balance{
 		Address: acc.GetAddress().String(),

x/evm/genesis.go

@@ -79,7 +79,7 @@ func InitGenesis(
 		k.SetCode(ctx, codeHash.Bytes(), code)
 
 		for _, storage := range account.Storage {
-			k.SetState(ctx, address, common.HexToHash(storage.Key), common.HexToHash(storage.Value).Bytes())
+			k.SetState(ctx, address, common.HexToHash(storage.Key), common.HexToHash(storage.Value))
 		}
 	}
 

x/evm/keeper/abci_test.go

@@ -6,10 +6,10 @@ import (
 )
 
 func (suite *KeeperTestSuite) TestEndBlock() {
-	em := suite.ctx.EventManager()
+	em := suite.Ctx.EventManager()
 	suite.Require().Equal(0, len(em.Events()))
 
-	res := suite.app.EvmKeeper.EndBlock(suite.ctx, types.RequestEndBlock{})
+	res := suite.App.EvmKeeper.EndBlock(suite.Ctx, types.RequestEndBlock{})
 	suite.Require().Equal([]types.ValidatorUpdate{}, res)
 
 	// should emit 1 EventTypeBlockBloom event on EndBlock

x/evm/keeper/benchmark_test.go

@@ -21,12 +21,12 @@ func SetupContract(b *testing.B) (*KeeperTestSuite, common.Address) {
 	suite.SetupTestWithT(b)
 
 	amt := sdk.Coins{ethermint.NewPhotonCoinInt64(1000000000000000000)}
-	err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
+	err := suite.App.BankKeeper.MintCoins(suite.Ctx, types.ModuleName, amt)
 	require.NoError(b, err)
-	err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
+	err = suite.App.BankKeeper.SendCoinsFromModuleToAccount(suite.Ctx, types.ModuleName, suite.Address.Bytes(), amt)
 	require.NoError(b, err)
 
-	contractAddr := suite.DeployTestContract(b, suite.address, sdkmath.NewIntWithDecimal(1000, 18).BigInt())
+	contractAddr := suite.DeployTestContract(b, suite.Address, sdkmath.NewIntWithDecimal(1000, 18).BigInt())
 	suite.Commit()
 
 	return &suite, contractAddr
@@ -37,9 +37,9 @@ func SetupTestMessageCall(b *testing.B) (*KeeperTestSuite, common.Address) {
 	suite.SetupTestWithT(b)
 
 	amt := sdk.Coins{ethermint.NewPhotonCoinInt64(1000000000000000000)}
-	err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
+	err := suite.App.BankKeeper.MintCoins(suite.Ctx, types.ModuleName, amt)
 	require.NoError(b, err)
-	err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
+	err = suite.App.BankKeeper.SendCoinsFromModuleToAccount(suite.Ctx, types.ModuleName, suite.Address.Bytes(), amt)
 	require.NoError(b, err)
 
 	contractAddr := suite.DeployTestMessageCall(b)
@@ -54,24 +54,24 @@ func DoBenchmark(b *testing.B, txBuilder TxBuilder) {
 	suite, contractAddr := SetupContract(b)
 
 	msg := txBuilder(suite, contractAddr)
-	msg.From = suite.address.Hex()
-	err := msg.Sign(ethtypes.LatestSignerForChainID(suite.app.EvmKeeper.ChainID()), suite.signer)
+	msg.From = suite.Address.Hex()
+	err := msg.Sign(ethtypes.LatestSignerForChainID(suite.App.EvmKeeper.ChainID()), suite.Signer)
 	require.NoError(b, err)
 
 	b.ResetTimer()
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		ctx, _ := suite.ctx.CacheContext()
+		ctx, _ := suite.Ctx.CacheContext()
 
 		// deduct fee first
 		txData, err := types.UnpackTxData(msg.Data)
 		require.NoError(b, err)
 
 		fees := sdk.Coins{sdk.NewCoin(suite.EvmDenom(), sdkmath.NewIntFromBigInt(txData.Fee()))}
-		err = authante.DeductFees(suite.app.BankKeeper, suite.ctx, suite.app.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees)
+		err = authante.DeductFees(suite.App.BankKeeper, suite.Ctx, suite.App.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees)
 		require.NoError(b, err)
 
-		rsp, err := suite.app.EvmKeeper.EthereumTx(sdk.WrapSDKContext(ctx), msg)
+		rsp, err := suite.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(ctx), msg)
 		require.NoError(b, err)
 		require.False(b, rsp.Failed())
 	}
@@ -81,35 +81,35 @@ func BenchmarkTokenTransfer(b *testing.B) {
 	DoBenchmark(b, func(suite *KeeperTestSuite, contract common.Address) *types.MsgEthereumTx {
 		input, err := types.ERC20Contract.ABI.Pack("transfer", common.HexToAddress("0x378c50D9264C63F3F92B806d4ee56E9D86FfB3Ec"), big.NewInt(1000))
 		require.NoError(b, err)
-		nonce := suite.app.EvmKeeper.GetNonce(suite.ctx, suite.address)
-		return types.NewTx(suite.app.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
+		nonce := suite.App.EvmKeeper.GetNonce(suite.Ctx, suite.Address)
+		return types.NewTx(suite.App.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
 	})
 }
 
 func BenchmarkEmitLogs(b *testing.B) {
 	DoBenchmark(b, func(suite *KeeperTestSuite, contract common.Address) *types.MsgEthereumTx {
 		input, err := types.ERC20Contract.ABI.Pack("benchmarkLogs", big.NewInt(1000))
 		require.NoError(b, err)
-		nonce := suite.app.EvmKeeper.GetNonce(suite.ctx, suite.address)
-		return types.NewTx(suite.app.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 4100000, big.NewInt(1), nil, nil, input, nil)
+		nonce := suite.App.EvmKeeper.GetNonce(suite.Ctx, suite.Address)
+		return types.NewTx(suite.App.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 4100000, big.NewInt(1), nil, nil, input, nil)
 	})
 }
 
 func BenchmarkTokenTransferFrom(b *testing.B) {
 	DoBenchmark(b, func(suite *KeeperTestSuite, contract common.Address) *types.MsgEthereumTx {
-		input, err := types.ERC20Contract.ABI.Pack("transferFrom", suite.address, common.HexToAddress("0x378c50D9264C63F3F92B806d4ee56E9D86FfB3Ec"), big.NewInt(0))
+		input, err := types.ERC20Contract.ABI.Pack("transferFrom", suite.Address, common.HexToAddress("0x378c50D9264C63F3F92B806d4ee56E9D86FfB3Ec"), big.NewInt(0))
 		require.NoError(b, err)
-		nonce := suite.app.EvmKeeper.GetNonce(suite.ctx, suite.address)
-		return types.NewTx(suite.app.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
+		nonce := suite.App.EvmKeeper.GetNonce(suite.Ctx, suite.Address)
+		return types.NewTx(suite.App.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
 	})
 }
 
 func BenchmarkTokenMint(b *testing.B) {
 	DoBenchmark(b, func(suite *KeeperTestSuite, contract common.Address) *types.MsgEthereumTx {
 		input, err := types.ERC20Contract.ABI.Pack("mint", common.HexToAddress("0x378c50D9264C63F3F92B806d4ee56E9D86FfB3Ec"), big.NewInt(1000))
 		require.NoError(b, err)
-		nonce := suite.app.EvmKeeper.GetNonce(suite.ctx, suite.address)
-		return types.NewTx(suite.app.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
+		nonce := suite.App.EvmKeeper.GetNonce(suite.Ctx, suite.Address)
+		return types.NewTx(suite.App.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 410000, big.NewInt(1), nil, nil, input, nil)
 	})
 }
 
@@ -118,27 +118,27 @@ func BenchmarkMessageCall(b *testing.B) {
 
 	input, err := types.TestMessageCall.ABI.Pack("benchmarkMessageCall", big.NewInt(10000))
 	require.NoError(b, err)
-	nonce := suite.app.EvmKeeper.GetNonce(suite.ctx, suite.address)
-	msg := types.NewTx(suite.app.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 25000000, big.NewInt(1), nil, nil, input, nil)
+	nonce := suite.App.EvmKeeper.GetNonce(suite.Ctx, suite.Address)
+	msg := types.NewTx(suite.App.EvmKeeper.ChainID(), nonce, &contract, big.NewInt(0), 25000000, big.NewInt(1), nil, nil, input, nil)
 
-	msg.From = suite.address.Hex()
-	err = msg.Sign(ethtypes.LatestSignerForChainID(suite.app.EvmKeeper.ChainID()), suite.signer)
+	msg.From = suite.Address.Hex()
+	err = msg.Sign(ethtypes.LatestSignerForChainID(suite.App.EvmKeeper.ChainID()), suite.Signer)
 	require.NoError(b, err)
 
 	b.ResetTimer()
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		ctx, _ := suite.ctx.CacheContext()
+		ctx, _ := suite.Ctx.CacheContext()
 
 		// deduct fee first
 		txData, err := types.UnpackTxData(msg.Data)
 		require.NoError(b, err)
 
 		fees := sdk.Coins{sdk.NewCoin(suite.EvmDenom(), sdkmath.NewIntFromBigInt(txData.Fee()))}
-		err = authante.DeductFees(suite.app.BankKeeper, suite.ctx, suite.app.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees)
+		err = authante.DeductFees(suite.App.BankKeeper, suite.Ctx, suite.App.AccountKeeper.GetAccount(ctx, msg.GetFrom()), fees)
 		require.NoError(b, err)
 
-		rsp, err := suite.app.EvmKeeper.EthereumTx(sdk.WrapSDKContext(ctx), msg)
+		rsp, err := suite.App.EvmKeeper.EthereumTx(sdk.WrapSDKContext(ctx), msg)
 		require.NoError(b, err)
 		require.False(b, rsp.Failed())
 	}

x/evm/keeper/grpc_query.go

@@ -67,8 +67,10 @@ func (k Keeper) Account(c context.Context, req *types.QueryAccountRequest) (*typ
 	ctx := sdk.UnwrapSDKContext(c)
 	acct := k.GetAccountOrEmpty(ctx, addr)
 
+	bal := k.GetBalance(ctx, addr)
+
 	return &types.QueryAccountResponse{
-		Balance:  acct.Balance.String(),
+		Balance:  bal.String(),
 		CodeHash: common.BytesToHash(acct.CodeHash).Hex(),
 		Nonce:    acct.Nonce,
 	}, nil