fix(mempool): align cosmos tx priority with priority setup of anteHandler

CHANGELOG.md

@@ -82,6 +82,7 @@
 - [\#442](https://github.com/cosmos/evm/pull/442) Prevent nil pointer by checking error in gov precompile FromResponse.
 - [\#387](https://github.com/cosmos/evm/pull/387) (Experimental) EVM-compatible appside mempool
 - [\#476](https://github.com/cosmos/evm/pull/476) Add revert error e2e tests for contract and precompile calls
+- [\#534](https://github.com/cosmos/evm/pull/534) Align cosmos tx priority with priority setup of anteHandler
 
 ### FEATURES
 

ante/cosmos/min_gas_price.go

@@ -42,11 +42,8 @@ func (mpd MinGasPriceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 	feeCoins := feeTx.GetFee()
 	evmDenom := evmtypes.GetEVMCoinDenom()
 
-	// only allow user to pass in aatom and stake native token as transaction fees
-	// allow use stake native tokens for fees is just for unit tests to pass
-	//
-	// TODO: is the handling of stake necessary here? Why not adjust the tests to contain the correct denom?
-	validFees := len(feeCoins) == 0 || (len(feeCoins) == 1 && slices.Contains([]string{evmDenom, sdk.DefaultBondDenom}, feeCoins.GetDenomByIndex(0)))
+	// only allow user to pass in evm coin as transaction fee
+	validFees := IsValidFeeCoins(feeCoins, []string{evmDenom})
 	if !validFees && !simulate {
 		return ctx, fmt.Errorf("expected only native token %s for fee, but got %s", evmDenom, feeCoins.String())
 	}
@@ -94,3 +91,7 @@ func (mpd MinGasPriceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 
 	return next(ctx, tx, simulate)
 }
+
+func IsValidFeeCoins(feeCoins sdk.Coins, allowedDenoms []string) bool {
+	return len(feeCoins) == 0 || (len(feeCoins) == 1 && slices.Contains(allowedDenoms, feeCoins.GetDenomByIndex(0)))
+}

ante/cosmos/min_gas_price_test.go

@@ -0,0 +1,96 @@
+package cosmos_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/evm/ante/cosmos"
+
+	sdkmath "cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestIsValidFeeCoins(t *testing.T) {
+	tests := []struct {
+		name           string
+		feeCoins       sdk.Coins
+		allowedDenoms  []string
+		expectedResult bool
+	}{
+		{
+			name:           "empty fee coins should be valid",
+			feeCoins:       sdk.Coins{},
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: true,
+		},
+		{
+			name:           "nil fee coins should be valid",
+			feeCoins:       nil,
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: true,
+		},
+		{
+			name:           "single allowed denom should be valid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(1000))),
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: true,
+		},
+		{
+			name:           "single allowed denom from multiple allowed should be valid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(1000))),
+			allowedDenoms:  []string{"uatom", "stake", "wei"},
+			expectedResult: true,
+		},
+		{
+			name:           "single disallowed denom should be invalid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("forbidden", sdkmath.NewInt(1000))),
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: false,
+		},
+		{
+			name:           "single disallowed denom with empty allowed list should be invalid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(1000))),
+			allowedDenoms:  []string{},
+			expectedResult: false,
+		},
+		{
+			name:           "multiple fee coins should be invalid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(1000)), sdk.NewCoin("stake", sdkmath.NewInt(500))),
+			allowedDenoms:  []string{"uatom", "stake"},
+			expectedResult: false,
+		},
+		{
+			name:           "multiple fee coins with one allowed should be invalid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(1000)), sdk.NewCoin("forbidden", sdkmath.NewInt(500))),
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: false,
+		},
+		{
+			name:           "empty allowed denoms with empty fee coins should be valid",
+			feeCoins:       sdk.Coins{},
+			allowedDenoms:  []string{},
+			expectedResult: true,
+		},
+		{
+			name:           "case sensitive denom matching",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("UATOM", sdkmath.NewInt(1000))),
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: false,
+		},
+		{
+			name:           "zero amount allowed denom should be valid",
+			feeCoins:       sdk.NewCoins(sdk.NewCoin("uatom", sdkmath.NewInt(0))),
+			allowedDenoms:  []string{"uatom"},
+			expectedResult: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := cosmos.IsValidFeeCoins(tt.feeCoins, tt.allowedDenoms)
+			require.Equal(t, tt.expectedResult, result, "IsValidFeeCoins returned unexpected result")
+		})
+	}
+}

mempool/iterator.go

@@ -1,21 +1,24 @@
 package mempool
 
 import (
+	"math"
 	"math/big"
 
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/holiman/uint256"
 
 	"github.com/cosmos/evm/mempool/miner"
 	"github.com/cosmos/evm/mempool/txpool"
+	cosmosevmtypes "github.com/cosmos/evm/types"
 	msgtypes "github.com/cosmos/evm/x/vm/types"
 
 	"cosmossdk.io/log"
-	"cosmossdk.io/math"
+	sdkmath "cosmossdk.io/math"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/mempool"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
 )
 
 var _ mempool.Iterator = &EVMMempoolIterator{}
@@ -255,7 +258,29 @@ func (i *EVMMempoolIterator) extractCosmosEffectiveTip(tx sdk.Tx) *uint256.Int {
 		return nil // Transaction doesn't implement FeeTx interface
 	}
 
-	bondDenomFeeAmount := math.ZeroInt()
+	// default to `MaxInt64` when there's no extension option.
+	maxPriorityPrice := sdkmath.LegacyNewDec(math.MaxInt64)
+
+	if hasExtOptsTx, ok := feeTx.(authante.HasExtensionOptionsTx); ok {
+		for _, opt := range hasExtOptsTx.GetExtensionOptions() {
+			if extOpt, ok := opt.GetCachedValue().(*cosmosevmtypes.ExtensionOptionDynamicFeeTx); ok {
+				maxPriorityPrice = extOpt.MaxPriorityPrice
+				if maxPriorityPrice.IsNil() {
+					maxPriorityPrice = sdkmath.LegacyZeroDec()
+				}
+				break
+			}
+		}
+	}
+
+	// Convert gasTipCap (LegacyDec) to *uint256.Int for comparison
+	gasTipCap, overflow := uint256.FromBig(maxPriorityPrice.BigInt())
+	if overflow {
+		i.logger.Debug("overflowed on gas tip cap calculation")
+		return nil
+	}
+
+	bondDenomFeeAmount := sdkmath.ZeroInt()
 	fees := feeTx.GetFee()
 	for _, coin := range fees {
 		if coin.Denom == i.bondDenom {
@@ -264,8 +289,14 @@ func (i *EVMMempoolIterator) extractCosmosEffectiveTip(tx sdk.Tx) *uint256.Int {
 		}
 	}
 
+	gas := sdkmath.NewIntFromUint64(feeTx.GetGas())
+	if gas.IsZero() {
+		i.logger.Debug("Cosmos transaction has zero gas")
+		return nil
+	}
+
 	// Calculate gas price: fee_amount / gas_limit
-	gasPrice, overflow := uint256.FromBig(bondDenomFeeAmount.Quo(math.NewIntFromUint64(feeTx.GetGas())).BigInt())
+	gasPrice, overflow := uint256.FromBig(bondDenomFeeAmount.Quo(gas).BigInt())
 	if overflow {
 		i.logger.Debug("overflowed on gas price calculation")
 		return nil
@@ -287,6 +318,10 @@ func (i *EVMMempoolIterator) extractCosmosEffectiveTip(tx sdk.Tx) *uint256.Int {
 	}
 
 	effectiveTip := new(uint256.Int).Sub(gasPrice, baseFee)
+	if effectiveTip.Cmp(gasTipCap) > 0 {
+		effectiveTip = gasTipCap
+	}
+
 	i.logger.Debug("calculated effective tip", "gas_price", gasPrice.String(), "base_fee", baseFee.String(), "effective_tip", effectiveTip.String())
 	return effectiveTip
 }

mempool/mempool.go

@@ -150,18 +150,12 @@ func NewExperimentalEVMMempool(getCtxCallback func(height int64, prove bool) (sd
 		defaultConfig := sdkmempool.PriorityNonceMempoolConfig[math.Int]{}
 		defaultConfig.TxPriority = sdkmempool.TxPriority[math.Int]{
 			GetTxPriority: func(goCtx context.Context, tx sdk.Tx) math.Int {
-				cosmosTxFee, ok := tx.(sdk.FeeTx)
-				if !ok {
+				ctx := sdk.UnwrapSDKContext(goCtx)
+				priority := ctx.Priority()
+				if priority < 0 {
 					return math.ZeroInt()
 				}
-				found, coin := cosmosTxFee.GetFee().Find(bondDenom)
-				if !found {
-					return math.ZeroInt()
-				}
-
-				gasPrice := coin.Amount.Quo(math.NewIntFromUint64(cosmosTxFee.GetGas()))
-
-				return gasPrice
+				return math.NewIntFromUint64(uint64(priority))
 			},
 			Compare: func(a, b math.Int) int {
 				return a.BigInt().Cmp(b.BigInt())

tests/integration/mempool/test_helpers.go

@@ -3,6 +3,7 @@ package mempool
 import (
 	"encoding/hex"
 	"fmt"
+	"math"
 	"math/big"
 
 	abci "github.com/cometbft/cometbft/abci/types"
@@ -23,7 +24,9 @@ const (
 	TxGas = 100_000
 )
 
-// createCosmosSendTransactionWithKey creates a simple bank send transaction with the specified key
+var MaxGasTipCap = big.NewInt(math.MaxInt64)
+
+// createCosmosSendTx creates a simple bank send transaction with the provided key and gasPrice
 func (s *IntegrationTestSuite) createCosmosSendTx(key keyring.Key, gasPrice *big.Int) sdk.Tx {
 	feeDenom := "aatom"
 
@@ -42,10 +45,11 @@ func (s *IntegrationTestSuite) createCosmosSendTx(key keyring.Key, gasPrice *big
 	tx, err := s.factory.BuildCosmosTx(key.Priv, txArgs)
 	s.Require().NoError(err)
 
+	fmt.Printf("DEBUG: Created cosmos transaction successfully\n")
 	return tx
 }
 
-// createEVMTransaction creates an EVM transaction using the provided key
+// createEVMValueTransferTx creates an EVM value transfer transaction using the provided key and gasPrice
 func (s *IntegrationTestSuite) createEVMValueTransferTx(key keyring.Key, nonce int, gasPrice *big.Int) sdk.Tx {
 	to := s.keyring.GetKey(1).Addr
 
@@ -67,7 +71,7 @@ func (s *IntegrationTestSuite) createEVMValueTransferTx(key keyring.Key, nonce i
 	return tx
 }
 
-// createEVMContractDeployTx creates an EVM transaction for contract deployment
+// createEVMContractDeployTx creates an EVM contract deploy transaction using the provided key and gasPrice
 func (s *IntegrationTestSuite) createEVMContractDeployTx(key keyring.Key, gasPrice *big.Int, data []byte) sdk.Tx {
 	ethTxArgs := evmtypes.EvmTxArgs{
 		Nonce:    0,
@@ -93,7 +97,7 @@ func (s *IntegrationTestSuite) checkTxs(txs []sdk.Tx) error {
 	return nil
 }
 
-// checkTxs call abci CheckTx for a transaction
+// checkTx calls abci CheckTx for a transaction
 func (s *IntegrationTestSuite) checkTx(tx sdk.Tx) error {
 	txBytes, err := s.network.App.GetTxConfig().TxEncoder()(tx)
 	if err != nil {
@@ -138,7 +142,7 @@ func (s *IntegrationTestSuite) calculateCosmosGasPrice(feeAmount int64, gasLimit
 
 // calculateCosmosEffectiveTip calculates the effective tip for a Cosmos transaction
 // This aligns with EVM transaction prioritization: effective_tip = gas_price - base_fee
-func (s *IntegrationTestSuite) calculateCosmosEffectiveTip(feeAmount int64, gasLimit uint64, baseFee *big.Int) *big.Int {
+func (s *IntegrationTestSuite) calculateCosmosEffectiveTip(feeAmount int64, gasLimit uint64, gasTipCap, baseFee *big.Int) *big.Int {
 	gasPrice := s.calculateCosmosGasPrice(feeAmount, gasLimit)
 	if baseFee == nil || baseFee.Sign() == 0 {
 		return gasPrice // No base fee, effective tip equals gas price
@@ -148,5 +152,10 @@ func (s *IntegrationTestSuite) calculateCosmosEffectiveTip(feeAmount int64, gasL
 		return big.NewInt(0) // Gas price lower than base fee, effective tip is zero
 	}
 
-	return new(big.Int).Sub(gasPrice, baseFee)
+	effectiveTip := new(big.Int).Sub(gasPrice, baseFee)
+	if effectiveTip.Cmp(gasTipCap) > 0 {
+		effectiveTip = gasTipCap
+	}
+
+	return effectiveTip
 }