imp(ante): refactor AnteHandler (#1479)

* imp(ante): refactor AnteHandler

* fix test

* test

* Adjust deprecated sdkerrors import (#1493)

* refactor test files

* Apply suggestions from code review

Co-authored-by: 4rgon4ut <59182467+4rgon4ut@users.noreply.github.com>

* lint

* prioritization comment

* fix test

Co-authored-by: MalteHerrmann <42640438+MalteHerrmann@users.noreply.github.com>
Co-authored-by: 4rgon4ut <59182467+4rgon4ut@users.noreply.github.com>

x/evm/handler_test.go

@@ -594,9 +594,12 @@ func (suite *EvmTestSuite) TestERC20TransferReverted() {
 
 			before := k.GetBalance(suite.ctx, suite.from)
 
+			ethCfg := suite.app.EvmKeeper.GetChainConfig(suite.ctx).EthereumConfig(nil)
+			baseFee := suite.app.EvmKeeper.GetBaseFee(suite.ctx, ethCfg)
+
 			txData, err := types.UnpackTxData(tx.Data)
 			suite.Require().NoError(err)
-			_, _, err = k.DeductTxCostsFromUserBalance(suite.ctx, *tx, txData, "aphoton", true, true, true)
+			_, err = k.DeductTxCostsFromUserBalance(suite.ctx, *tx, txData, "aphoton", baseFee, true, true, true)
 			suite.Require().NoError(err)
 
 			res, err := k.EthereumTx(sdk.WrapSDKContext(suite.ctx), tx)

x/evm/keeper/utils.go

@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"math"
 	"math/big"
 
 	errorsmod "cosmossdk.io/errors"
@@ -17,22 +16,16 @@ import (
 )
 
 // DeductTxCostsFromUserBalance it calculates the tx costs and deducts the fees
-// returns (effectiveFee, priority, error)
 func (k Keeper) DeductTxCostsFromUserBalance(
 	ctx sdk.Context,
 	msgEthTx evmtypes.MsgEthereumTx,
 	txData evmtypes.TxData,
 	denom string,
+	baseFee *big.Int,
 	homestead, istanbul, london bool,
-) (fees sdk.Coins, priority int64, err error) {
+) (fees sdk.Coins, err error) {
 	isContractCreation := txData.GetTo() == nil
 
-	// fetch sender account from signature
-	signerAcc, err := authante.GetSignerAcc(ctx, k.accountKeeper, msgEthTx.GetFrom())
-	if err != nil {
-		return nil, 0, errorsmod.Wrapf(err, "account not found for sender %s", msgEthTx.From)
-	}
-
 	gasLimit := txData.GetGas()
 
 	var accessList ethtypes.AccessList
@@ -42,7 +35,7 @@ func (k Keeper) DeductTxCostsFromUserBalance(
 
 	intrinsicGas, err := core.IntrinsicGas(txData.GetData(), accessList, isContractCreation, homestead, istanbul)
 	if err != nil {
-		return nil, 0, errorsmod.Wrapf(
+		return nil, errorsmod.Wrapf(
 			err,
 			"failed to retrieve intrinsic gas, contract creation = %t; homestead = %t, istanbul = %t",
 			isContractCreation, homestead, istanbul,
@@ -51,53 +44,43 @@ func (k Keeper) DeductTxCostsFromUserBalance(
 
 	// intrinsic gas verification during CheckTx
 	if ctx.IsCheckTx() && gasLimit < intrinsicGas {
-		return nil, 0, errorsmod.Wrapf(
+		return nil, errorsmod.Wrapf(
 			errortypes.ErrOutOfGas,
 			"gas limit too low: %d (gas limit) < %d (intrinsic gas)", gasLimit, intrinsicGas,
 		)
 	}
 
-	var feeAmt *big.Int
-
-	baseFee := k.getBaseFee(ctx, london)
 	if baseFee != nil && txData.GetGasFeeCap().Cmp(baseFee) < 0 {
-		return nil, 0, errorsmod.Wrapf(errortypes.ErrInsufficientFee,
+		return nil, errorsmod.Wrapf(errortypes.ErrInsufficientFee,
 			"the tx gasfeecap is lower than the tx baseFee: %s (gasfeecap), %s (basefee) ",
 			txData.GetGasFeeCap(),
 			baseFee)
 	}
 
-	feeAmt = txData.EffectiveFee(baseFee)
+	feeAmt := txData.EffectiveFee(baseFee)
 	if feeAmt.Sign() == 0 {
 		// zero fee, no need to deduct
-		return sdk.Coins{}, 0, nil
+		return sdk.Coins{}, nil
 	}
 
-	fees = sdk.Coins{sdk.NewCoin(denom, sdkmath.NewIntFromBigInt(feeAmt))}
+	fees = sdk.Coins{{Denom: denom, Amount: sdkmath.NewIntFromBigInt(feeAmt)}}
+
+	// fetch sender account from signature
+	signerAcc, err := authante.GetSignerAcc(ctx, k.accountKeeper, msgEthTx.GetFrom())
+	if err != nil {
+		return nil, errorsmod.Wrapf(err, "account not found for sender %s", msgEthTx.From)
+	}
 
 	// deduct the full gas cost from the user balance
 	if err := authante.DeductFees(k.bankKeeper, ctx, signerAcc, fees); err != nil {
-		return nil, 0, errorsmod.Wrapf(
+		return nil, errorsmod.Wrapf(
 			err,
 			"failed to deduct full gas cost %s from the user %s balance",
 			fees, msgEthTx.From,
 		)
 	}
 
-	// calculate priority based on effective gas price
-	tipPrice := txData.EffectiveGasPrice(baseFee)
-	// if london hardfork is not enabled, tipPrice is the gasPrice
-	if baseFee != nil {
-		tipPrice = new(big.Int).Sub(tipPrice, baseFee)
-	}
-	priorityBig := new(big.Int).Quo(tipPrice, evmtypes.DefaultPriorityReduction.BigInt())
-	if !priorityBig.IsInt64() {
-		priority = math.MaxInt64
-	} else {
-		priority = priorityBig.Int64()
-	}
-
-	return fees, priority, nil
+	return fees, nil
 }
 
 // CheckSenderBalance validates that the tx cost value is positive and that the

x/evm/keeper/utils_test.go

@@ -453,11 +453,16 @@ func (suite *KeeperTestSuite) TestDeductTxCostsFromUserBalance() {
 
 			txData, _ := evmtypes.UnpackTxData(tx.Data)
 
-			fees, priority, err := suite.app.EvmKeeper.DeductTxCostsFromUserBalance(
+			ethCfg := suite.app.EvmKeeper.GetChainConfig(suite.ctx).EthereumConfig(nil)
+			baseFee := suite.app.EvmKeeper.GetBaseFee(suite.ctx, ethCfg)
+			priority := evmtypes.GetTxPriority(txData, baseFee)
+
+			fees, err := suite.app.EvmKeeper.DeductTxCostsFromUserBalance(
 				suite.ctx,
 				*tx,
 				txData,
 				evmtypes.DefaultEVMDenom,
+				baseFee,
 				false,
 				false,
 				suite.enableFeemarket, // london

x/evm/types/tx.go

@@ -1,10 +1,37 @@
 package types
 
 import (
+	"math"
+	"math/big"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/vm"
 )
 
+// GetTxPriority returns the priority of a given Ethereum tx. It relies of the
+// priority reduction global variable to calculate the tx priority given the tx
+// tip price:
+//
+//	tx_priority = tip_price / priority_reduction
+func GetTxPriority(txData TxData, baseFee *big.Int) (priority int64) {
+	// calculate priority based on effective gas price
+	tipPrice := txData.EffectiveGasPrice(baseFee)
+	// if london hardfork is not enabled, tipPrice is the gasPrice
+	if baseFee != nil {
+		tipPrice = new(big.Int).Sub(tipPrice, baseFee)
+	}
+
+	priority = math.MaxInt64
+	priorityBig := new(big.Int).Quo(tipPrice, DefaultPriorityReduction.BigInt())
+
+	// safety check
+	if priorityBig.IsInt64() {
+		priority = priorityBig.Int64()
+	}
+
+	return priority
+}
+
 // Failed returns if the contract execution failed in vm errors
 func (m *MsgEthereumTxResponse) Failed() bool {
 	return len(m.VmError) > 0