EIP-1559 - Dynamic Base Fee

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

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/info.go

@@ -3,6 +3,7 @@ package evmrpc
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"slices"
 	"time"
@@ -80,16 +81,27 @@ 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.GetBaseFeePerGas(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
 func (i *InfoAPI) FeeHistory(ctx context.Context, blockCount math.HexOrDecimal64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (result *FeeHistoryResult, returnErr error) {
+	fmt.Println("rewardPercentages = ", rewardPercentiles)
 	startTime := time.Now()
 	defer recordMetrics("eth_feeHistory", i.connectionType, startTime, returnErr == nil)
 	result = &FeeHistoryResult{}
@@ -159,6 +171,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)
@@ -172,6 +186,8 @@ func (i *InfoAPI) FeeHistory(ctx context.Context, blockCount math.HexOrDecimal64
 		}
 		result.Reward = append(result.Reward, rewards)
 	}
+	fmt.Println("result.BaseFee = ", result.BaseFee)
+	fmt.Println("result.Reward = ", result.Reward)
 	return result, nil
 }
 
@@ -195,7 +211,10 @@ 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))
+	fmt.Println("safeGetBaseFee = ", baseFee)
+	res = baseFee.TruncateInt().BigInt()
+	fmt.Println("res = ", res)
 	return
 }
 

evmrpc/info_test.go

@@ -2,6 +2,7 @@ package evmrpc_test
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"testing"
 
@@ -58,11 +59,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 +81,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 +103,8 @@ func TestFeeHistory(t *testing.T) {
 				require.False(t, errorExists)
 
 				resObj = resObj["result"].(map[string]interface{})
+				fmt.Println("resObj = ", resObj)
+
 				require.Equal(t, tc.expectedOldest, resObj["oldestBlock"].(string))
 				rewards, ok := resObj["reward"].([]interface{})
 

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)).BigInt(),
 		GasLimit:      b.config.GasCap,
 		Time:          uint64(time.Now().Unix()),
 		ExcessBlobGas: &zeroExcessBlobGas,

go.mod

@@ -354,7 +354,7 @@ replace (
 	github.com/sei-protocol/sei-db => github.com/sei-protocol/sei-db v0.0.43
 	// 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-0.20240816184629-eb6d20caf603 h1:aOUWB+ABNMdAjghn/PqCKDuz5WTwfoYfre5I/rtOnKo=

x/evm/ante/fee.go

@@ -101,7 +101,7 @@ func (fc EVMFeeCheckDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b
 
 // fee per gas to be burnt
 func (fc EVMFeeCheckDecorator) getBaseFee(ctx sdk.Context) *big.Int {
-	return fc.evmKeeper.GetBaseFeePerGas(ctx).TruncateInt().BigInt()
+	return fc.evmKeeper.GetDynamicBaseFeePerGas(ctx).TruncateInt().BigInt()
 }
 
 // lowest allowed fee per gas

x/evm/keeper/fee.go

@@ -0,0 +1,44 @@
+package keeper
+
+import (
+	"encoding/binary"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/sei-protocol/sei-chain/x/evm/types"
+)
+
+// TODO: make this a param
+const MaxBaseFeeChange = 0.125
+
+// eip-1559 adjustment
+func (k *Keeper) AdjustDynamicBaseFeePerGas(ctx sdk.Context, blockGasUsed uint64) {
+	currentBaseFee := k.GetDynamicBaseFeePerGas(ctx).MustFloat64()
+	minimumFeePerGas := k.GetParams(ctx).MinimumFeePerGas.MustFloat64()
+	blockGasLimit := ctx.ConsensusParams().Block.MaxGas
+	blockFullness := float64(blockGasUsed) / float64(blockGasLimit)
+	adjustmentFactor := MaxBaseFeeChange * (blockFullness - 0.5) / 0.5 // range between -12.5% to 12.5%
+	newBaseFee := float64(currentBaseFee) * (1 + adjustmentFactor)
+	if newBaseFee < minimumFeePerGas {
+		newBaseFee = minimumFeePerGas
+	}
+	k.SetDynamicBaseFeePerGas(ctx, uint64(newBaseFee))
+}
+
+func (k *Keeper) GetDynamicBaseFeePerGas(ctx sdk.Context) sdk.Dec {
+	h := make([]byte, 8)
+	binary.BigEndian.PutUint64(h, uint64(ctx.BlockHeight()))
+	bz := k.PrefixStore(ctx, types.BaseFeePerGasPrefix).Get(h)
+	if bz == nil {
+		return k.GetMinimumFeePerGas(ctx)
+	}
+
+	return sdk.NewDecFromInt(sdk.NewInt(int64(binary.BigEndian.Uint64(bz))))
+}
+
+func (k *Keeper) SetDynamicBaseFeePerGas(ctx sdk.Context, baseFeePerGas uint64) {
+	h := make([]byte, 8)
+	binary.BigEndian.PutUint64(h, uint64(ctx.BlockHeight()))
+	fee := make([]byte, 8)
+	binary.BigEndian.PutUint64(fee, baseFeePerGas)
+	k.PrefixStore(ctx, types.BaseFeePerGasPrefix).Set(h, fee)
+}

x/evm/keeper/fee_test.go

@@ -0,0 +1,79 @@
+package keeper_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	testkeeper "github.com/sei-protocol/sei-chain/testutil/keeper"
+	"github.com/sei-protocol/sei-chain/x/evm/keeper"
+	"github.com/stretchr/testify/require"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+)
+
+func TestBaseFeePerGas(t *testing.T) {
+	k := &testkeeper.EVMTestApp.EvmKeeper
+	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{})
+	require.Equal(t, k.GetMinimumFeePerGas(ctx), k.GetDynamicBaseFeePerGas(ctx))
+	k.SetDynamicBaseFeePerGas(ctx, 1)
+	require.Equal(t, sdk.NewDecFromInt(sdk.NewInt(1)), k.GetDynamicBaseFeePerGas(ctx))
+}
+
+func TestAdjustBaseFeePerGas(t *testing.T) {
+	k, ctx := testkeeper.MockEVMKeeper()
+	testCases := []struct {
+		name            string
+		currentBaseFee  float64
+		minimumFee      float64
+		blockGasUsed    uint64
+		blockGasLimit   uint64
+		expectedBaseFee uint64
+	}{
+		{
+			name:            "Block gas usage exactly half of limit, no fee change",
+			currentBaseFee:  100,
+			minimumFee:      10,
+			blockGasUsed:    500000,
+			blockGasLimit:   1000000,
+			expectedBaseFee: 100,
+		},
+		{
+			name:            "Block gas usage 75%, base fee increases",
+			currentBaseFee:  10000,
+			minimumFee:      10,
+			blockGasUsed:    750000,
+			blockGasLimit:   1000000,
+			expectedBaseFee: 10000 + 10000*(keeper.MaxBaseFeeChange/2), // 6.25% increase
+		},
+		{
+			name:            "Block gas usage 25%, base fee decreases",
+			currentBaseFee:  10000,
+			minimumFee:      10,
+			blockGasUsed:    250000,
+			blockGasLimit:   1000000,
+			expectedBaseFee: 10000 - 10000*(keeper.MaxBaseFeeChange/2), // 6.25% decrease
+		},
+		{
+			name:            "Block gas usage low, new base fee below minimum, set to minimum",
+			currentBaseFee:  100,
+			minimumFee:      90,
+			blockGasUsed:    100000,
+			blockGasLimit:   1000000,
+			expectedBaseFee: 90, // Should not go below the minimum fee
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx = ctx.WithConsensusParams(&tmproto.ConsensusParams{
+				Block: &tmproto.BlockParams{MaxGas: int64(tc.blockGasLimit)},
+			})
+			k.SetDynamicBaseFeePerGas(ctx, uint64(tc.currentBaseFee))
+			p := k.GetParams(ctx)
+			p.MinimumFeePerGas = sdk.NewDec(int64(tc.minimumFee))
+			k.SetParams(ctx, p)
+			k.AdjustDynamicBaseFeePerGas(ctx, tc.blockGasUsed)
+			expected := sdk.NewDecFromInt(sdk.NewInt(int64(tc.expectedBaseFee)))
+			require.Equal(t, expected, k.GetDynamicBaseFeePerGas(ctx), "base fee did not match expected value")
+		})
+	}
+}

x/evm/keeper/keeper.go

@@ -209,9 +209,9 @@ func (k *Keeper) GetVMBlockContext(ctx sdk.Context, gp core.GasPool) (*vm.BlockC
 		GasLimit:    gp.Gas(),
 		BlockNumber: big.NewInt(ctx.BlockHeight()),
 		Time:        uint64(ctx.BlockHeader().Time.Unix()),
-		Difficulty:  utils.Big0,                                     // only needed for PoW
-		BaseFee:     k.GetBaseFeePerGas(ctx).TruncateInt().BigInt(), // feemarket not enabled
-		BlobBaseFee: utils.Big1,                                     // Cancun not enabled
+		Difficulty:  utils.Big0,                                            // only needed for PoW
+		BaseFee:     k.GetDynamicBaseFeePerGas(ctx).TruncateInt().BigInt(), // feemarket not enabled
+		BlobBaseFee: utils.Big1,                                            // Cancun not enabled
 		Random:      &rh,
 	}, nil
 }

x/evm/keeper/params_test.go

@@ -15,7 +15,7 @@ func TestParams(t *testing.T) {
 	ctx := testkeeper.EVMTestApp.GetContextForDeliverTx([]byte{}).WithBlockTime(time.Now())
 	require.Equal(t, "usei", k.GetBaseDenom(ctx))
 	require.Equal(t, types.DefaultPriorityNormalizer, k.GetPriorityNormalizer(ctx))
-	require.Equal(t, types.DefaultBaseFeePerGas, k.GetBaseFeePerGas(ctx))
+	require.Equal(t, types.DefaultBaseFeePerGas, k.GetDynamicBaseFeePerGas(ctx))
 	require.Equal(t, types.DefaultMinFeePerGas, k.GetMinimumFeePerGas(ctx))
 	require.Equal(t, types.DefaultDeliverTxHookWasmGasLimit, k.GetDeliverTxHookWasmGasLimit(ctx))
 

x/evm/module.go

@@ -276,7 +276,13 @@
 
 // EndBlock executes all ABCI EndBlock logic respective to the evm module. It
 // returns no validator updates.
-func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {
+	fmt.Println("JEREMYDEBUG: EndBlock, block gas limit = ", ctx.ConsensusParams().Block.MaxGas)
+	fmt.Println("JEREMYDEBUG: EndBlock, block gas used = ", req.BlockGasUsed)
+	// Adjust base fee for dynamic base fee
+	fmt.Println("JEREMYDEBUG: Pre-adjustment Dynamic Base Fee Per Gas = ", am.keeper.GetDynamicBaseFeePerGas(ctx))
+	am.keeper.AdjustDynamicBaseFeePerGas(ctx, uint64(req.BlockGasUsed))
+	fmt.Println("JEREMYDEBUG: Post-adjustment Dynamic Base Fee Per Gas = ", am.keeper.GetDynamicBaseFeePerGas(ctx))
 	var coinbase sdk.AccAddress
 	if am.keeper.EthBlockTestConfig.Enabled {
 		blocks := am.keeper.BlockTest.Json.Blocks

x/evm/types/keys.go

@@ -54,6 +54,8 @@ var (
 
 	AnteSurplusPrefix  = []byte{0x18} // transient
 	DeferredInfoPrefix = []byte{0x19} // transient
+
+	BaseFeePerGasPrefix = []byte{0x20}
 )
 
 var (