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...)

contracts/test/CaviesTest.js

@@ -0,0 +1,67 @@
+const { expect } = require("chai");
+const {isBigNumber} = require("hardhat/common");
+const {uniq, shuffle} = require("lodash");
+const { ethers, upgrades } = require('hardhat');
+const { getImplementationAddress } = require('@openzeppelin/upgrades-core');
+const { deployEvmContract, setupSigners, fundAddress, getCosmosTx} = require("./lib")
+const axios = require("axios");
+const { parseEther } = require("ethers");
+
+describe("My test", function() {
+    let accounts;
+    // send money from account 0 to account 2
+    it.only("should send money from account 0 to account 2", async function() {
+        accounts = await ethers.getSigners();
+        // accounts = await hre.ethers.getSigners()
+        console.log("accounts", accounts)
+        const account0 = accounts[0];
+        console.log("account0", account0.address);
+        const account2 = accounts[2];
+        console.log("account2", account2.address);
+        const balanceBefore = await ethers.provider.getBalance(account2.address);
+        if (balanceBefore < 2100000000000000) {
+            const tx = await account0.sendTransaction({
+                to: account2.address,
+                value: 2100000000000000,
+            });
+            await tx.wait();
+        }
+        const balanceAfter = await ethers.provider.getBalance(account2.address);
+        console.log("balanceBefore", balanceBefore.toString());
+        console.log("balanceAfter", balanceAfter.toString());
+
+        const privateKey = "0xc53c11e1e8f58038548d0f6f0a5d87791a1b9e5fb4fc847b263cee9d34f40b2e";
+        const wallet = new ethers.Wallet(privateKey, ethers.provider);
+        const nonce_ = await ethers.provider.getTransactionCount(account2.address)
+        console.log("nonce", nonce_)
+        const tx = {
+            to: account0.address,
+            value: parseEther("0.1"),
+            gasLimit: 21000,
+            gasPrice: 10000000000,
+            nonce: nonce_,
+            chainId: 713715,
+        };
+
+        console.log("account2 = ", account2)
+
+        const signedTx = await wallet.signTransaction(tx);
+
+        // get block number
+        const blockNumber = await ethers.provider.getBlockNumber();
+        console.log("blockNumber = ", blockNumber);
+
+        // try to send a tx out from account2
+        const nodeUrl = 'https://evm-rpc.arctic-1.seinetwork.io/';
+        const response = await axios.post(nodeUrl, {
+            method: 'eth_sendRawTransaction',
+            params: [signedTx],
+            id: 1,
+            jsonrpc: "2.0"
+        })
+
+        console.log("receipt", response);
+
+        console.log("tx hash = ", ethers.keccak256(signedTx))
+    });
+});

evmrpc/block.go

@@ -166,7 +166,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

@@ -128,7 +128,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"])
@@ -146,7 +146,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

@@ -3,6 +3,7 @@ package evmrpc
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"slices"
 	"time"
@@ -80,12 +81,22 @@ func (i *InfoAPI) GasPrice(ctx context.Context) (result *hexutil.Big, returnErr
 	}
 	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()
+		fmt.Println("JEREMYDEBUG: eth_gasPrice, min base fee = ", baseFee)
+		return (*hexutil.Big)(baseFee), nil
 	}
-	return (*hexutil.Big)(new(big.Int).Add(
+	baseFee := i.keeper.GetDynamicBaseFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt()
+	fmt.Println("JEREMYDEBUG: eth_gasPrice, baseFee = ", baseFee)
+	reward := feeHist.Reward[0][0].ToInt()
+	fmt.Println("JEREMYDEBUG: eth_gasPrice, reward = ", reward)
+	sum := new(big.Int).Add(
 		feeHist.Reward[0][0].ToInt(),
-		i.keeper.GetBaseFeePerGas(i.ctxProvider(LatestCtxHeight)).TruncateInt().BigInt(),
-	)), nil
+		baseFee,
+	)
+	fmt.Println("JEREMYDEBUG: eth_gasPrice, sum = ", sum)
+	res := (*hexutil.Big)(sum)
+	fmt.Println("JEREMYDEBUG: eth_gasPrice, res = ", res)
+	return res, nil
 }
 
 // lastBlock is inclusive
@@ -159,6 +170,8 @@ func (i *InfoAPI) FeeHistory(ctx context.Context, blockCount math.HexOrDecimal64
 			// the block has been pruned
 			continue
 		}
+		// baseFee = big.NewInt(100000000000)
+		fmt.Println("in feeHistory, got baseFee = ", baseFee)
 		result.BaseFee = append(result.BaseFee, (*hexutil.Big)(baseFee))
 		height := blockNum
 		block, err := blockByNumber(ctx, i.tmClient, &height)
@@ -195,7 +208,8 @@ func (i *InfoAPI) safeGetBaseFee(targetHeight int64) (res *big.Int) {
 			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

@@ -2,6 +2,7 @@
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"testing"
 
@@ -58,11 +59,10 @@
 }
 
 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 +81,12 @@
 	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 +103,7 @@
 				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 +165,5 @@
 	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

@@ -551,7 +551,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)

go.mod

@@ -354,7 +354,7 @@ replace (
 	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

@@ -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=

occ_tests/messages/test_msgs.go

@@ -63,6 +63,7 @@ func EVMTransferNonConflicting(tCtx *utils.TestContext, count int) []*utils.Test
 	var msgs []*utils.TestMessage
 	for i := 0; i < count; i++ {
 		testAcct := utils.NewSigner()
+		fmt.Println("testAcct = ", testAcct)
 		msgs = append(msgs, evmTransfer(testAcct, testAcct.EvmAddress, "EVMTransferNonConflicting"))
 	}
 	return msgs