improve performance

- don't duplicate params loading
- passing EVMConfig around as pointer

app/ante/eth.go

@@ -28,7 +28,7 @@ type EVMKeeper interface {
 	GetParams(ctx sdk.Context) evmtypes.Params
 	WithContext(ctx sdk.Context)
 	ResetRefundTransient(ctx sdk.Context)
-	NewEVM(msg core.Message, cfg evmtypes.EVMConfig, tracer vm.Tracer) *vm.EVM
+	NewEVM(msg core.Message, cfg *evmtypes.EVMConfig, tracer vm.Tracer) *vm.EVM
 	GetCodeHash(addr common.Address) common.Hash
 	DeductTxCostsFromUserBalance(
 		ctx sdk.Context, msgEthTx evmtypes.MsgEthereumTx, txData evmtypes.TxData, denom string, homestead, istanbul, london bool,
@@ -371,7 +371,7 @@ func (ctd CanTransferDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 		}
 
 		// NOTE: pass in an empty coinbase address and nil tracer as we don't need them for the check below
-		cfg := evmtypes.EVMConfig{
+		cfg := &evmtypes.EVMConfig{
 			ChainConfig: ethCfg,
 			Params:      params,
 			CoinBase:    common.Address{},

x/evm/keeper/grpc_query.go

@@ -289,11 +289,12 @@ func (k Keeper) EstimateGas(c context.Context, req *types.EthCallRequest) (*type
 	}
 	cap = hi
 
-	params := k.GetParams(ctx)
-	ethCfg := params.ChainConfig.EthereumConfig(k.eip155ChainID)
-
+	cfg, err := k.EVMConfig(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "failed to load evm config")
+	}
 	var baseFee *big.Int
-	if types.IsLondon(ethCfg, ctx.BlockHeight()) {
+	if types.IsLondon(cfg.ChainConfig, ctx.BlockHeight()) {
 		baseFee = k.feeMarketKeeper.GetBaseFee(ctx)
 	}
 
@@ -309,7 +310,7 @@ func (k Keeper) EstimateGas(c context.Context, req *types.EthCallRequest) (*type
 			return false, nil, err
 		}
 
-		rsp, err = k.ApplyMessage(msg, nil, false)
+		rsp, err = k.ApplyMessageWithConfig(msg, nil, false, cfg)
 
 		if err != nil {
 			if errors.Is(stacktrace.RootCause(err), core.ErrIntrinsicGas) {

x/evm/keeper/state_transition.go

@@ -22,22 +22,22 @@ import (
 )
 
 // EVMConfig creates the EVMConfig based on current state
-func (k *Keeper) EVMConfig(ctx sdk.Context) (types.EVMConfig, error) {
+func (k *Keeper) EVMConfig(ctx sdk.Context) (*types.EVMConfig, error) {
 	params := k.GetParams(ctx)
 	ethCfg := params.ChainConfig.EthereumConfig(k.eip155ChainID)
 
 	// get the coinbase address from the block proposer
 	coinbase, err := k.GetCoinbaseAddress(ctx)
 	if err != nil {
-		return types.EVMConfig{}, stacktrace.Propagate(err, "failed to obtain coinbase address")
+		return nil, stacktrace.Propagate(err, "failed to obtain coinbase address")
 	}
 
 	var baseFee *big.Int
 	if types.IsLondon(ethCfg, ctx.BlockHeight()) {
 		baseFee = k.feeMarketKeeper.GetBaseFee(ctx)
 	}
 
-	return types.EVMConfig{
+	return &types.EVMConfig{
 		Params:      params,
 		ChainConfig: ethCfg,
 		CoinBase:    coinbase,
@@ -51,7 +51,7 @@ func (k *Keeper) EVMConfig(ctx sdk.Context) (types.EVMConfig, error) {
 // beneficiary of the coinbase transaction (since we're not mining).
 func (k *Keeper) NewEVM(
 	msg core.Message,
-	cfg types.EVMConfig,
+	cfg *types.EVMConfig,
 	tracer vm.Tracer,
 ) *vm.EVM {
 	blockCtx := vm.BlockContext{
@@ -165,18 +165,20 @@ func (k Keeper) GetHashFn() vm.GetHashFunc {
 // For relevant discussion see: https://github.com/cosmos/cosmos-sdk/discussions/9072
 func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumTxResponse, error) {
 	ctx := k.Ctx()
-	params := k.GetParams(ctx)
 
 	// ensure keeper state error is cleared
 	defer k.ClearStateError()
 
-	ethCfg := params.ChainConfig.EthereumConfig(k.eip155ChainID)
+	cfg, err := k.EVMConfig(ctx)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to load evm config")
+	}
 
 	// get the latest signer according to the chain rules from the config
-	signer := ethtypes.MakeSigner(ethCfg, big.NewInt(ctx.BlockHeight()))
+	signer := ethtypes.MakeSigner(cfg.ChainConfig, big.NewInt(ctx.BlockHeight()))
 
 	var baseFee *big.Int
-	if types.IsLondon(ethCfg, ctx.BlockHeight()) {
+	if types.IsLondon(cfg.ChainConfig, ctx.BlockHeight()) {
 		baseFee = k.feeMarketKeeper.GetBaseFee(ctx)
 	}
 
@@ -206,13 +208,13 @@ func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumT
 		})()
 	}
 
-	res, err := k.ApplyMessage(msg, nil, true)
+	res, err := k.ApplyMessageWithConfig(msg, nil, true, cfg)
 	if err != nil {
 		return nil, stacktrace.Propagate(err, "failed to apply ethereum core message")
 	}
 
 	// refund gas prior to handling the vm error in order to match the Ethereum gas consumption instead of the default SDK one.
-	err = k.RefundGas(msg, msg.Gas()-res.GasUsed, params.EvmDenom)
+	err = k.RefundGas(msg, msg.Gas()-res.GasUsed, cfg.Params.EvmDenom)
 	if err != nil {
 		return nil, stacktrace.Propagate(err, "failed to refund gas leftover gas to sender %s", msg.From())
 	}
@@ -249,7 +251,7 @@ func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumT
 	return res, nil
 }
 
-// ApplyMessage computes the new state by applying the given message against the existing state.
+// ApplyMessageWithConfig computes the new state by applying the given message against the existing state.
 // If the message fails, the VM execution error with the reason will be returned to the client
 // and the transaction won't be committed to the store.
 //
@@ -288,7 +290,7 @@ func (k *Keeper) ApplyTransaction(tx *ethtypes.Transaction) (*types.MsgEthereumT
 // Commit parameter
 //
 // If commit is true, the cache context stack will be committed, otherwise discarded.
-func (k *Keeper) ApplyMessage(msg core.Message, tracer vm.Tracer, commit bool) (*types.MsgEthereumTxResponse, error) {
+func (k *Keeper) ApplyMessageWithConfig(msg core.Message, tracer vm.Tracer, commit bool, cfg *types.EVMConfig) (*types.MsgEthereumTxResponse, error) {
 	var (
 		ret   []byte // return bytes from evm execution
 		vmErr error  // vm errors do not effect consensus and are therefore not assigned to err
@@ -298,10 +300,6 @@ func (k *Keeper) ApplyMessage(msg core.Message, tracer vm.Tracer, commit bool) (
 		panic("context stack shouldn't be dirty before apply message")
 	}
 
-	cfg, err := k.EVMConfig(k.Ctx())
-	if err != nil {
-		return nil, stacktrace.Propagate(err, "failed to load evm config")
-	}
 	evm := k.NewEVM(msg, cfg, tracer)
 
 	// ensure keeper state error is cleared
@@ -381,6 +379,15 @@ func (k *Keeper) ApplyMessage(msg core.Message, tracer vm.Tracer, commit bool) (
 	}, nil
 }
 
+// ApplyMessage calls ApplyMessageWithConfig with default EVMConfig
+func (k *Keeper) ApplyMessage(msg core.Message, tracer vm.Tracer, commit bool) (*types.MsgEthereumTxResponse, error) {
+	cfg, err := k.EVMConfig(k.Ctx())
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to load evm config")
+	}
+	return k.ApplyMessageWithConfig(msg, tracer, commit, cfg)
+}
+
 // GetEthIntrinsicGas returns the intrinsic gas cost for the transaction
 func (k *Keeper) GetEthIntrinsicGas(msg core.Message, cfg *params.ChainConfig, isContractCreation bool) (uint64, error) {
 	height := big.NewInt(k.Ctx().BlockHeight())