EIP-1559 - Dynamic Base Fee

aclmapping/evm/mappings_test.go

@@ -126,6 +126,7 @@ func (suite *KeeperTestSuite) TestMsgEVMTransaction() {
 			ctx, err := suite.preprocessor.AnteHandle(handlerCtx, tx.GetTx(), false, func(ctx sdk.Context, _ sdk.Tx, _ bool) (sdk.Context, error) { return ctx, nil })
 			suite.Require().Nil(err)
 			cms.ResetEvents()
+			suite.App.EvmKeeper.SetDynamicBaseFeePerGas(ctx, sdk.ZeroDec())
 			_, err = suite.msgServer.EVMTransaction(sdk.WrapSDKContext(ctx), tc.msg)
 			suite.Require().Nil(err)
 

app/app.go

@@ -1593,8 +1593,15 @@ func (app *App) ProcessBlock(ctx sdk.Context, txs [][]byte, req BlockProcessRequ
 	lazyWriteEvents := app.BankKeeper.WriteDeferredBalances(ctx)
 	events = append(events, lazyWriteEvents...)
 
+	// Sum up total used per block
+	blockTotalGasUsed := int64(0)
+	for _, txResult := range txResults {
+		blockTotalGasUsed += txResult.GasUsed
+	}
+
 	endBlockResp := app.EndBlock(ctx, abci.RequestEndBlock{
-		Height: req.GetHeight(),
+		Height:       req.GetHeight(),
+		BlockGasUsed: blockTotalGasUsed,
 	})
 
 	events = append(events, endBlockResp.Events...)

app/eth_replay.go

@@ -141,6 +141,7 @@
 		}
 		params := a.EvmKeeper.GetParams(a.GetContextForDeliverTx([]byte{}))
 		params.MinimumFeePerGas = sdk.NewDecFromInt(sdk.NewInt(0))
+		// params.BaseFeePerGas = sdk.NewDecFromInt(sdk.NewInt(0))
 		a.EvmKeeper.SetParams(a.GetContextForDeliverTx([]byte{}), params)
 	}
 
@@ -177,6 +178,7 @@
 
 	// Check post-state after all blocks are run
 	ctx := a.GetCheckCtx()
+	coinbases := getCoinbases(ethblocks)
 	for addr, accountData := range bt.Json.Post {
 		if IsWithdrawalAddress(addr, ethblocks) {
 			fmt.Println("Skipping withdrawal address: ", addr)
@@ -187,11 +189,19 @@
 			fmt.Println("Skipping beacon roots storage address: ", addr)
 			continue
 		}
-		a.EvmKeeper.VerifyAccount(ctx, addr, accountData)
+		a.EvmKeeper.VerifyAccount(ctx, addr, accountData, coinbases)
 		fmt.Println("Successfully verified account: ", addr)
 	}
 }
 
+func getCoinbases(ethBlocks []*ethtypes.Block) []common.Address {
+	var coinbases []common.Address
+	for _, b := range ethBlocks {
+		coinbases = append(coinbases, b.Coinbase())
+	}
+	return coinbases
+}
+
 func encodeTx(tx *ethtypes.Transaction, txConfig client.TxConfig) []byte {
 	var txData ethtx.TxData
 	var err error

evmrpc/block.go

@@ -72,7 +72,7 @@ func (a *BlockAPI) GetBlockByHash(ctx context.Context, blockHash common.Hash, fu
 		return nil, err
 	}
 	blockBloom := a.keeper.GetBlockBloom(a.ctxProvider(block.Block.Height))
-	return EncodeTmBlock(a.ctxProvider(LatestCtxHeight), block, blockRes, blockBloom, a.keeper, a.txConfig.TxDecoder(), fullTx)
+	return EncodeTmBlock(a.ctxProvider(block.Block.Height), block, blockRes, blockBloom, a.keeper, a.txConfig.TxDecoder(), fullTx)
 }
 
 func (a *BlockAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (result map[string]interface{}, returnErr error) {
@@ -91,7 +91,7 @@ func (a *BlockAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber,
 		return nil, err
 	}
 	blockBloom := a.keeper.GetBlockBloom(a.ctxProvider(block.Block.Height))
-	return EncodeTmBlock(a.ctxProvider(LatestCtxHeight), block, blockRes, blockBloom, a.keeper, a.txConfig.TxDecoder(), fullTx)
+	return EncodeTmBlock(a.ctxProvider(block.Block.Height), block, blockRes, blockBloom, a.keeper, a.txConfig.TxDecoder(), fullTx)
 }
 
 func (a *BlockAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (result []map[string]interface{}, returnErr error) {
@@ -169,7 +169,7 @@ func EncodeTmBlock(
 	txHash := common.HexToHash(block.Block.DataHash.String())
 	resultHash := common.HexToHash(block.Block.LastResultsHash.String())
 	miner := common.HexToAddress(block.Block.ProposerAddress.String())
-	baseFeePerGas := k.GetBaseFeePerGas(ctx).TruncateInt().BigInt()
+	baseFeePerGas := k.GetDynamicBaseFeePerGas(ctx).TruncateInt().BigInt()
 	var blockGasUsed int64
 	chainConfig := types.DefaultChainConfig().EthereumConfig(k.ChainID(ctx))
 	transactions := []interface{}{}

evmrpc/block_test.go

@@ -124,7 +124,7 @@ func verifyBlockResult(t *testing.T, resObj map[string]interface{}) {
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000001", tx["blockHash"])
 	require.Equal(t, "0x5b4eba929f3811980f5ae0c5d04fa200f837df4e", tx["from"])
 	require.Equal(t, "0x3e8", tx["gas"])
-	require.Equal(t, "0x0", tx["gasPrice"])
+	require.Equal(t, "0xa", tx["gasPrice"])
 	require.Equal(t, "0xa", tx["maxFeePerGas"])
 	require.Equal(t, "0x0", tx["maxPriorityFeePerGas"])
 	require.Equal(t, "0xf02362077ac075a397344172496b28e913ce5294879d811bb0269b3be20a872e", tx["hash"])
@@ -142,7 +142,7 @@ func verifyBlockResult(t *testing.T, resObj map[string]interface{}) {
 	require.Equal(t, "0x0", tx["yParity"])
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000002", resObj["transactionsRoot"])
 	require.Equal(t, []interface{}{}, resObj["uncles"])
-	require.Equal(t, "0x0", resObj["baseFeePerGas"])
+	require.Equal(t, "0x174876e800", resObj["baseFeePerGas"])
 	require.Equal(t, "0x0", resObj["totalDifficulty"])
 }
 

evmrpc/info.go

@@ -80,12 +80,15 @@
 	}
 	if len(feeHist.Reward) == 0 || len(feeHist.Reward[0]) == 0 {
 		// if there is no EVM tx in the most recent block, return the minimum fee param
-		return (*hexutil.Big)(i.keeper.GetMinimumFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt()), nil
+		baseFee := i.keeper.GetMinimumFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt()
+		return (*hexutil.Big)(baseFee), nil
 	}
-	return (*hexutil.Big)(new(big.Int).Add(
+	baseFee := i.keeper.GetDynamicBaseFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt()
+	sum := new(big.Int).Add(
 		feeHist.Reward[0][0].ToInt(),
-		i.keeper.GetBaseFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt(),
-	)), nil
+		baseFee,
+	)
+	return (*hexutil.Big)(sum), nil
 }
 
 // lastBlock is inclusive
@@ -195,7 +198,8 @@
 			res = nil
 		}
 	}()
-	res = i.keeper.GetBaseFeePerGas(i.ctxProvider(targetHeight)).BigInt()
+	baseFee := i.keeper.GetDynamicBaseFeePerGas(i.ctxProvider(targetHeight))
+	res = baseFee.TruncateInt().BigInt()
 	return
 }
 

evmrpc/info_test.go

@@ -58,11 +58,10 @@ func TestCoinbase(t *testing.T) {
 }
 
 func TestGasPrice(t *testing.T) {
-	Ctx = Ctx.WithBlockHeight(1)
 	resObj := sendRequestGood(t, "gasPrice")
 	Ctx = Ctx.WithBlockHeight(8)
 	result := resObj["result"].(string)
-	require.Equal(t, "0xa", result)
+	require.Equal(t, "0x174876e800", result)
 }
 
 func TestFeeHistory(t *testing.T) {
@@ -81,12 +80,12 @@ func TestFeeHistory(t *testing.T) {
 	Ctx = Ctx.WithBlockHeight(1) // Simulate context with a specific block height
 
 	testCases := []feeHistoryTestCase{
-		{name: "Valid request by number", blockCount: 1, lastBlock: "0x8", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
-		{name: "Valid request by latest", blockCount: 1, lastBlock: "latest", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
-		{name: "Valid request by earliest", blockCount: 1, lastBlock: "earliest", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
-		{name: "Request on the same block", blockCount: 1, lastBlock: "0x1", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
-		{name: "Request on future block", blockCount: 1, lastBlock: "0x9", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
-		{name: "Block count truncates", blockCount: 1025, lastBlock: "latest", rewardPercentiles: []interface{}{25}, expectedOldest: "0x1", expectedReward: "0xa", expectedBaseFee: "0x0", expectedGasUsed: 0.5},
+		{name: "Valid request by number", blockCount: 1, lastBlock: "0x8", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
+		{name: "Valid request by latest", blockCount: 1, lastBlock: "latest", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
+		{name: "Valid request by earliest", blockCount: 1, lastBlock: "earliest", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
+		{name: "Request on the same block", blockCount: 1, lastBlock: "0x1", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
+		{name: "Request on future block", blockCount: 1, lastBlock: "0x9", rewardPercentiles: []interface{}{0.5}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
+		{name: "Block count truncates", blockCount: 1025, lastBlock: "latest", rewardPercentiles: []interface{}{25}, expectedOldest: "0x1", expectedReward: "0x0", expectedBaseFee: "0x174876e800", expectedGasUsed: 0.5},
 		{name: "Too many percentiles", blockCount: 10, lastBlock: "latest", rewardPercentiles: make([]interface{}, 101), expectedError: errors.New("rewardPercentiles length must be less than or equal to 100")},
 		{name: "Invalid percentiles order", blockCount: 10, lastBlock: "latest", rewardPercentiles: []interface{}{99, 1}, expectedError: errors.New("invalid reward percentiles: must be ascending and between 0 and 100")},
 	}
@@ -103,6 +102,7 @@ func TestFeeHistory(t *testing.T) {
 				require.False(t, errorExists)
 
 				resObj = resObj["result"].(map[string]interface{})
+
 				require.Equal(t, tc.expectedOldest, resObj["oldestBlock"].(string))
 				rewards, ok := resObj["reward"].([]interface{})
 
@@ -164,5 +164,5 @@ func TestMaxPriorityFeePerGas(t *testing.T) {
 	Ctx = Ctx.WithBlockHeight(1)
 	// Mimic request sending and handle the response
 	resObj := sendRequestGood(t, "maxPriorityFeePerGas")
-	assert.Equal(t, "0xa", resObj["result"])
+	assert.Equal(t, "0x0", resObj["result"])
 }

evmrpc/setup_test.go

@@ -559,7 +559,7 @@ func generateTxData() {
 		TxHashHex:         tx1.Hash().Hex(),
 		GasUsed:           55,
 		Status:            0,
-		EffectiveGasPrice: 10,
+		EffectiveGasPrice: 100000000000,
 		Logs: []*types.Log{{
 			Address: "0x1111111111111111111111111111111111111111",
 			Topics:  []string{"0x1111111111111111111111111111111111111111111111111111111111111111", "0x1111111111111111111111111111111111111111111111111111111111111112"},

evmrpc/simulate.go

@@ -424,7 +424,7 @@ func (b *Backend) getHeader(blockNumber *big.Int) *ethtypes.Header {
 	header := &ethtypes.Header{
 		Difficulty:    common.Big0,
 		Number:        blockNumber,
-		BaseFee:       b.keeper.GetBaseFeePerGas(b.ctxProvider(LatestCtxHeight)).BigInt(),
+		BaseFee:       b.keeper.GetDynamicBaseFeePerGas(b.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt(),
 		GasLimit:      b.config.GasCap,
 		Time:          uint64(time.Now().Unix()),
 		ExcessBlobGas: &zeroExcessBlobGas,

evmrpc/simulate_test.go

@@ -89,7 +89,7 @@ func TestCreateAccessList(t *testing.T) {
 		"chainId": fmt.Sprintf("%#x", EVMKeeper.ChainID(Ctx)),
 		"input":   fmt.Sprintf("%#x", input),
 	}
-	amts := sdk.NewCoins(sdk.NewCoin(EVMKeeper.GetBaseDenom(Ctx), sdk.NewInt(20)))
+	amts := sdk.NewCoins(sdk.NewCoin(EVMKeeper.GetBaseDenom(Ctx), sdk.NewInt(2000000)))
 	EVMKeeper.BankKeeper().MintCoins(Ctx, types.ModuleName, amts)
 	EVMKeeper.BankKeeper().SendCoinsFromModuleToAccount(Ctx, types.ModuleName, sdk.AccAddress(from[:]), amts)
 	resObj := sendRequestGood(t, "createAccessList", txArgs, "latest")
@@ -148,10 +148,8 @@ func TestEthCallHighAmount(t *testing.T) {
 		from.Hex(): {"balance": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
 	}
 	resObj := sendRequestGood(t, "call", txArgs, "latest", overrides)
-	fmt.Println("resObj = ", resObj)
 	errMap := resObj["error"].(map[string]interface{})
 	result := errMap["message"]
-	fmt.Println("res = ", result)
 	require.Equal(t, result, "error: balance override overflow")
 
 	Ctx = Ctx.WithBlockHeight(8)

evmrpc/tx_test.go

@@ -40,7 +40,7 @@ func TestGetTxReceipt(t *testing.T) {
 	require.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000001", resObj["blockHash"].(string))
 	require.Equal(t, "0x8", resObj["blockNumber"].(string))
 	require.Equal(t, "0x7b", resObj["cumulativeGasUsed"].(string))
-	require.Equal(t, "0xa", resObj["effectiveGasPrice"].(string))
+	require.Equal(t, "0x174876e800", resObj["effectiveGasPrice"].(string))
 	require.Equal(t, "0x1234567890123456789012345678901234567890", resObj["from"].(string))
 	require.Equal(t, "0x37", resObj["gasUsed"].(string))
 	logs := resObj["logs"].([]interface{})

go.mod

@@ -347,14 +347,16 @@ replace (
 	github.com/CosmWasm/wasmd => github.com/sei-protocol/sei-wasmd v0.2.4
 	github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0
 	github.com/cosmos/cosmos-sdk => github.com/sei-protocol/sei-cosmos v0.3.35
+	// github.com/cosmos/cosmos-sdk => ../sei-cosmos
 	github.com/cosmos/iavl => github.com/sei-protocol/sei-iavl v0.1.9
 	github.com/cosmos/ibc-go/v3 => github.com/sei-protocol/sei-ibc-go/v3 v3.3.2
-	github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.13.5-sei-22
+	// github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.13.5-sei-22
+	github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240909131410-424e099743bb
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	github.com/sei-protocol/sei-db => github.com/sei-protocol/sei-db v0.0.44
 	// Latest goleveldb is broken, we have to stick to this version
 	github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
-	github.com/tendermint/tendermint => github.com/sei-protocol/sei-tendermint v0.3.8
+	github.com/tendermint/tendermint => github.com/sei-protocol/sei-tendermint v0.3.7-0.20240904023453-8f9a2036b3e9
 	github.com/tendermint/tm-db => github.com/sei-protocol/tm-db v0.0.4
 	google.golang.org/grpc => google.golang.org/grpc v1.33.2
 )

go.sum

@@ -1343,8 +1343,8 @@ github.com/seccomp/libseccomp-golang v0.9.2-0.20220502022130-f33da4d89646/go.mod
 github.com/securego/gosec/v2 v2.11.0 h1:+PDkpzR41OI2jrw1q6AdXZCbsNGNGT7pQjal0H0cArI=
 github.com/securego/gosec/v2 v2.11.0/go.mod h1:SX8bptShuG8reGC0XS09+a4H2BoWSJi+fscA+Pulbpo=
 github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
-github.com/sei-protocol/go-ethereum v1.13.5-sei-22 h1:t/m1qXER+DEMrcpqgoYmUxifkAdmz5T8xpL9KRVgLtw=
-github.com/sei-protocol/go-ethereum v1.13.5-sei-22/go.mod h1:kcRZmuzRn1lVejiFNTz4l4W7imnpq1bDAnuKS/RyhbQ=
+github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240909131410-424e099743bb h1:3gwC9PVNDdozAj2jeF+GqS8vFkbrmgcpFa4Cmc8rCjU=
+github.com/sei-protocol/go-ethereum v1.13.5-sei-9.0.20240909131410-424e099743bb/go.mod h1:kcRZmuzRn1lVejiFNTz4l4W7imnpq1bDAnuKS/RyhbQ=
 github.com/sei-protocol/goutils v0.0.2 h1:Bfa7Sv+4CVLNM20QcpvGb81B8C5HkQC/kW1CQpIbXDA=
 github.com/sei-protocol/goutils v0.0.2/go.mod h1:iYE2DuJfEnM+APPehr2gOUXfuLuPsVxorcDO+Tzq9q8=
 github.com/sei-protocol/sei-cosmos v0.3.35 h1:mPj5AE21DE5Zpe4UzMv2YwsaPm8mCFLbb0WQoDL4AnQ=
@@ -1355,8 +1355,8 @@ github.com/sei-protocol/sei-iavl v0.1.9 h1:y4mVYftxLNRs6533zl7N0/Ch+CzRQc04JDfHo
 github.com/sei-protocol/sei-iavl v0.1.9/go.mod h1:7PfkEVT5dcoQE+s/9KWdoXJ8VVVP1QpYYPLdxlkSXFk=
 github.com/sei-protocol/sei-ibc-go/v3 v3.3.2 h1:BaMZ6gjwqe3R/5dLmcJ1TkSZ3omcWy2TjaAZAeOJH44=
 github.com/sei-protocol/sei-ibc-go/v3 v3.3.2/go.mod h1:VwB/vWu4ysT5DN2aF78d17LYmx3omSAdq6gpKvM7XRA=
-github.com/sei-protocol/sei-tendermint v0.3.8 h1:9o+A3tL6q1ki++dLng/J8MHHiT6y3l7D4Ir2UIQSkAQ=
-github.com/sei-protocol/sei-tendermint v0.3.8/go.mod h1:4LSlJdhl3nf3OmohliwRNUFLOB1XWlrmSodrIP7fLh4=
+github.com/sei-protocol/sei-tendermint v0.3.7-0.20240904023453-8f9a2036b3e9 h1:Q4xhlpnA9qcURKgvyP2hVYcSRI+rzZVZwUY1/39Tk/E=
+github.com/sei-protocol/sei-tendermint v0.3.7-0.20240904023453-8f9a2036b3e9/go.mod h1:4LSlJdhl3nf3OmohliwRNUFLOB1XWlrmSodrIP7fLh4=
 github.com/sei-protocol/sei-tm-db v0.0.5 h1:3WONKdSXEqdZZeLuWYfK5hP37TJpfaUa13vAyAlvaQY=
 github.com/sei-protocol/sei-tm-db v0.0.5/go.mod h1:Cpa6rGyczgthq7/0pI31jys2Fw0Nfrc+/jKdP1prVqY=
 github.com/sei-protocol/sei-wasmd v0.2.4 h1:W++xiJ1P57BhBW8TGk8vfPRJlWXr1vp2kQCvSc8Qpaw=

loadtest/evm.go

@@ -25,8 +25,8 @@ import (
 )
 
 var (
-	DefaultPriorityFee = big.NewInt(1000000000) // 1gwei
-	DefaultMaxFee      = big.NewInt(1000000000) // 1gwei
+	DefaultPriorityFee = big.NewInt(1000000000)    // 1gwei
+	DefaultMaxFee      = big.NewInt(1000000000000) // 1000gwei
 )
 
 type EvmTxClient struct {
@@ -112,7 +112,7 @@ func (txClient *EvmTxClient) GenerateSendFundsTx() *ethtypes.Transaction {
 	if !txClient.useEip1559 {
 		tx = ethtypes.NewTx(&ethtypes.LegacyTx{
 			Nonce:    txClient.nextNonce(),
-			GasPrice: txClient.gasPrice,
+			GasPrice: DefaultMaxFee,
 			Gas:      uint64(21000),
 			To:       &txClient.accountAddress,
 			Value:    randomValue(),
@@ -186,7 +186,7 @@ func (txClient *EvmTxClient) getTransactOpts() *bind.TransactOpts {
 		panic(fmt.Sprintf("Failed to create transactor: %v \n", err))
 	}
 	if !txClient.useEip1559 {
-		auth.GasPrice = txClient.gasPrice
+		auth.GasPrice = DefaultMaxFee
 	} else {
 		auth.GasFeeCap = DefaultMaxFee
 		auth.GasTipCap = DefaultPriorityFee
@@ -221,7 +221,6 @@ func (txClient *EvmTxClient) SendEvmTx(signedTx *ethtypes.Transaction, onSuccess
 	if err != nil {
 		fmt.Printf("Failed to send evm transaction: %v \n", err)
 	} else {
-		// We choose not to GetTxReceipt because we assume the EVM RPC would be running with broadcast mode = block
 		onSuccess()
 	}
 }

occ_tests/messages/test_msgs.go

@@ -82,8 +82,8 @@ func EVMTransferConflicting(tCtx *utils.TestContext, count int) []*utils.TestMes
 // each message will have a brand new address
 func evmTransfer(testAcct utils.TestAcct, to common.Address, scenario string) *utils.TestMessage {
 	signedTx, err := ethtypes.SignTx(ethtypes.NewTx(&ethtypes.DynamicFeeTx{
-		GasFeeCap: new(big.Int).SetUint64(1000000000000),
-		GasTipCap: new(big.Int).SetUint64(1000000000000),
+		GasFeeCap: new(big.Int).SetUint64(100000000000),
+		GasTipCap: new(big.Int).SetUint64(100000000000),
 		Gas:       21000,
 		ChainID:   big.NewInt(config.DefaultChainID),
 		To:        &to,

precompiles/pointer/pointer_test.go

@@ -57,7 +57,7 @@ func TestAddNative(t *testing.T) {
 	evm = vm.NewEVM(*blockCtx, vm.TxContext{}, statedb, cfg, vm.Config{})
 	ret, g, err := p.RunAndCalculateGas(evm, caller, caller, append(p.GetExecutor().(*pointer.PrecompileExecutor).AddNativePointerID, args...), suppliedGas, nil, nil, false)
 	require.Nil(t, err)
-	require.Equal(t, uint64(8888494), g)
+	require.Equal(t, uint64(8883738), g)
 	outputs, err := m.Outputs.Unpack(ret)
 	require.Nil(t, err)
 	addr := outputs[0].(common.Address)