Introducing base fee + hard fork logic

api/accounts/accounts.go

@@ -256,6 +256,7 @@ func (a *Accounts) batchCall(
 			Time:        header.Timestamp(),
 			GasLimit:    header.GasLimit(),
 			TotalScore:  header.TotalScore(),
+			BaseFee:     header.BaseFee(),
 		},
 		a.forkConfig)
 	results = make(BatchCallResults, 0)

api/blocks/types.go

@@ -33,6 +33,7 @@ type JSONBlockSummary struct {
 	Signer       thor.Address `json:"signer"`
 	IsTrunk      bool         `json:"isTrunk"`
 	IsFinalized  bool         `json:"isFinalized"`
+	BaseFee      *big.Int     `json:"baseFee,omitempty"`
 }
 
 type JSONRawBlockSummary struct {
@@ -120,6 +121,7 @@ func buildJSONBlockSummary(summary *chain.BlockSummary, isTrunk bool, isFinalize
 		COM:          header.COM(),
 		IsTrunk:      isTrunk,
 		IsFinalized:  isFinalized,
+		BaseFee:      summary.Header.BaseFee(),
 	}
 }
 

api/debug/debug.go

@@ -268,6 +268,7 @@ func (d *Debug) traceCall(ctx context.Context, tracer tracers.Tracer, header *bl
 			Time:        header.Timestamp(),
 			GasLimit:    header.GasLimit(),
 			TotalScore:  header.TotalScore(),
+			BaseFee:     header.BaseFee(),
 		},
 		d.forkConfig)
 

api/transactions/transactions_benchmark_test.go

@@ -38,9 +38,13 @@ import (
 )
 
 var (
-	cachedAccounts []genesis.DevAccount
-	once           sync.Once
-	blockCount     = 1_000
+	cachedAccounts    []genesis.DevAccount
+	once              sync.Once
+	blockCount        = 1_000
+	createManyTxFuncs = []func(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain) (tx.Transactions, error){
+		createManyClausesPerTxLegacy,
+		createManyClausesPerTxDynFee,
+	}
 )
 
 func getCachedAccounts(b *testing.B) []genesis.DevAccount {
@@ -56,28 +60,29 @@ func BenchmarkFetchTx_RealDB_RandomSigners_ManyClausesPerTx(b *testing.B) {
 	// create state accounts
 	accounts := getCachedAccounts(b)
 
-	// randomly pick a signer for signing the transactions
-	randomSignerFunc := randomPickSignerFunc(accounts, createManyClausesPerTx)
+	for _, createManyClausesPerTx := range createManyTxFuncs { // randomly pick a signer for signing the transactions
+		randomSignerFunc := randomPickSignerFunc(accounts, createManyClausesPerTx)
 
-	// create test db - will be automagically removed when the benchmark ends
-	db, err := openTempMainDB(b.TempDir())
-	require.NoError(b, err)
+		// create test db - will be automagically removed when the benchmark ends
+		db, err := openTempMainDB(b.TempDir())
+		require.NoError(b, err)
 
-	// create blocks
-	newChain, transactions := createPackedChain(b, db, blockCount, accounts, randomSignerFunc)
+		// create blocks
+		newChain, transactions := createPackedChain(b, db, blockCount, accounts, randomSignerFunc)
 
-	// shuffle the transaction into a randomized order
-	randomizedTransactions := shuffleSlice(transactions)
-	b.Logf("About to process %d txs", len(randomizedTransactions))
+		// shuffle the transaction into a randomized order
+		randomizedTransactions := shuffleSlice(transactions)
+		b.Logf("About to process %d txs", len(randomizedTransactions))
 
-	// run the benchmarks
-	b.Run("getTransaction", func(b *testing.B) {
-		benchmarkGetTransaction(b, newChain, randomizedTransactions)
-	})
+		// run the benchmarks
+		b.Run("getTransaction", func(b *testing.B) {
+			benchmarkGetTransaction(b, newChain, randomizedTransactions)
+		})
 
-	b.Run("getReceipt", func(b *testing.B) {
-		benchmarkGetReceipt(b, newChain, randomizedTransactions)
-	})
+		b.Run("getReceipt", func(b *testing.B) {
+			benchmarkGetReceipt(b, newChain, randomizedTransactions)
+		})
+	}
 }
 
 func BenchmarkFetchTx_RealDB_RandomSigners_OneClausePerTx(b *testing.B) {
@@ -109,27 +114,27 @@ func BenchmarkFetchTx_RealDB_RandomSigners_OneClausePerTx(b *testing.B) {
 }
 
 func BenchmarkFetchTx_RandomSigners_ManyClausesPerTx(b *testing.B) {
-	// create state accounts
-	accounts := getCachedAccounts(b)
+	for _, createManyClausesPerTx := range createManyTxFuncs { // create state accounts
+		accounts := getCachedAccounts(b)
+		// randomly pick a signer for signing the transactions
+		randomSignerFunc := randomPickSignerFunc(accounts, createManyClausesPerTx)
 
-	// randomly pick a signer for signing the transactions
-	randomSignerFunc := randomPickSignerFunc(accounts, createManyClausesPerTx)
+		// create blocks
+		newChain, transactions := createPackedChain(b, muxdb.NewMem(), blockCount, accounts, randomSignerFunc)
 
-	// create blocks
-	newChain, transactions := createPackedChain(b, muxdb.NewMem(), blockCount, accounts, randomSignerFunc)
+		// shuffle the transaction into a randomized order
+		randomizedTransactions := shuffleSlice(transactions)
+		b.Logf("About to process %d txs", len(randomizedTransactions))
 
-	// shuffle the transaction into a randomized order
-	randomizedTransactions := shuffleSlice(transactions)
-	b.Logf("About to process %d txs", len(randomizedTransactions))
-
-	// run the benchmarks
-	b.Run("getTransaction", func(b *testing.B) {
-		benchmarkGetTransaction(b, newChain, randomizedTransactions)
-	})
+		// run the benchmarks
+		b.Run("getTransaction", func(b *testing.B) {
+			benchmarkGetTransaction(b, newChain, randomizedTransactions)
+		})
 
-	b.Run("getReceipt", func(b *testing.B) {
-		benchmarkGetReceipt(b, newChain, randomizedTransactions)
-	})
+		b.Run("getReceipt", func(b *testing.B) {
+			benchmarkGetReceipt(b, newChain, randomizedTransactions)
+		})
+	}
 }
 
 func BenchmarkFetchTx_RandomSigners_OneClausePerTx(b *testing.B) {
@@ -233,9 +238,15 @@ func createOneClausePerTx(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain
 	for gasUsed < 9_500_000 {
 		toAddr := datagen.RandAddress()
 		cla := tx.NewClause(&toAddr).WithValue(big.NewInt(10000))
-		transaction := tx.NewTxBuilder(tx.LegacyTxType).
+		b := tx.NewTxBuilder(tx.LegacyTxType)
+		if gasUsed%2 == 0 {
+			b = tx.NewTxBuilder(tx.DynamicFeeTxType)
+		}
+		transaction := b.
 			ChainTag(thorChain.Repo().ChainTag()).
 			GasPriceCoef(1).
+			MaxFeePerGas(big.NewInt(1000000)).
+			MaxPriorityFeePerGas(big.NewInt(100)).
 			Expiration(math.MaxUint32 - 1).
 			Gas(21_000).
 			Nonce(uint64(datagen.RandInt())).
@@ -255,7 +266,7 @@ func createOneClausePerTx(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain
 	return transactions, nil
 }
 
-func createManyClausesPerTx(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain) (tx.Transactions, error) {
+func createManyClausesPerTxLegacy(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain) (tx.Transactions, error) {
 	var transactions tx.Transactions
 	gasUsed := uint64(0)
 	txGas := uint64(42_000)
@@ -285,6 +296,37 @@ func createManyClausesPerTx(signerPK *ecdsa.PrivateKey, thorChain *testchain.Cha
 	return transactions, nil
 }
 
+func createManyClausesPerTxDynFee(signerPK *ecdsa.PrivateKey, thorChain *testchain.Chain) (tx.Transactions, error) {
+	var transactions tx.Transactions
+	gasUsed := uint64(0)
+	txGas := uint64(42_000)
+
+	transactionBuilder := tx.NewTxBuilder(tx.DynamicFeeTxType).
+		ChainTag(thorChain.Repo().ChainTag()).
+		MaxFeePerGas(big.NewInt(1000000)).
+		MaxPriorityFeePerGas(big.NewInt(100)).
+		Expiration(math.MaxUint32 - 1).
+		Nonce(uint64(datagen.RandInt())).
+		BlockRef(tx.NewBlockRef(0))
+
+	for ; gasUsed < 9_500_000; gasUsed += txGas {
+		toAddr := datagen.RandAddress()
+		transactionBuilder.Clause(tx.NewClause(&toAddr).WithValue(big.NewInt(10000)))
+	}
+
+	transaction := transactionBuilder.Gas(gasUsed).MustBuild()
+
+	sig, err := crypto.Sign(transaction.SigningHash().Bytes(), signerPK)
+	if err != nil {
+		return nil, err
+	}
+	transaction = transaction.WithSignature(sig)
+
+	transactions = append(transactions, transaction)
+
+	return transactions, nil
+}
+
 func packTxsIntoBlock(thorChain *testchain.Chain, proposerAccount *genesis.DevAccount, parentBlk *block.Block, transactions tx.Transactions) (*block.Block, error) {
 	p := packer.New(thorChain.Repo(), thorChain.Stater(), proposerAccount.Address, &proposerAccount.Address, thorChain.GetForkConfig())
 

block/builder.go

@@ -6,6 +6,8 @@
 package block
 
 import (
+	"math/big"
+
 	"github.com/vechain/thor/v2/thor"
 	"github.com/vechain/thor/v2/tx"
 )
@@ -88,6 +90,12 @@ func (b *Builder) COM() *Builder {
 	return b
 }
 
+// BaseFee sets base fee.
+func (b *Builder) BaseFee(baseFee *big.Int) *Builder {
+	b.headerBody.Extension.BaseFee = baseFee
+	return b
+}
+
 // Build build a block object.
 func (b *Builder) Build() *Block {
 	header := Header{body: b.headerBody}

block/builder_test.go

@@ -0,0 +1,71 @@
+// Copyright (c) 2024 The VeChainThor developers
+
+// Distributed under the GNU Lesser General Public License v3.0 software license, see the accompanying
+// file LICENSE or <https://www.gnu.org/licenses/lgpl-3.0.html>
+
+package block
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/vechain/thor/v2/thor"
+	"github.com/vechain/thor/v2/tx"
+)
+
+func TestBuilder_Build(t *testing.T) {
+	builder := &Builder{}
+
+	id := thor.Bytes32{1, 2, 3}
+	builder.ParentID(id)
+
+	ts := uint64(1234567890)
+	builder.Timestamp(ts)
+
+	score := uint64(100)
+	builder.TotalScore(score)
+
+	limit := uint64(5000)
+	builder.GasLimit(limit)
+
+	used := uint64(3000)
+	builder.GasUsed(used)
+
+	addr := thor.Address{1, 2, 3}
+	builder.Beneficiary(addr)
+
+	hash := thor.Bytes32{1, 2, 3}
+	builder.StateRoot(hash)
+
+	builder.ReceiptsRoot(hash)
+	tr := tx.NewTxBuilder(tx.LegacyTxType).MustBuild()
+
+	builder.Transaction(tr)
+	features := tx.Features(0x01)
+
+	builder.TransactionFeatures(features)
+	alpha := []byte{1, 2, 3}
+
+	builder.Alpha(alpha)
+	builder.COM()
+
+	baseFee := big.NewInt(1000)
+	builder.BaseFee(baseFee)
+
+	b := builder.Build()
+
+	assert.Equal(t, id, b.header.ParentID())
+	assert.Equal(t, ts, b.header.Timestamp())
+	assert.Equal(t, score, b.header.TotalScore())
+	assert.Equal(t, limit, b.header.GasLimit())
+	assert.Equal(t, used, b.header.GasUsed())
+	assert.Equal(t, addr, b.header.Beneficiary())
+	assert.Equal(t, hash, b.header.StateRoot())
+	assert.Equal(t, hash, b.header.ReceiptsRoot())
+	assert.Contains(t, b.Transactions(), tr)
+	assert.Equal(t, features, b.header.TxsFeatures())
+	assert.Equal(t, alpha, b.header.Alpha())
+	assert.True(t, b.header.COM())
+	assert.Equal(t, baseFee, b.header.BaseFee())
+}