Fix issues for post-london hardforks

consensus/misc/eip1559.go

@@ -22,7 +22,6 @@ import (
 
 	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon-lib/common"
-	libcommon "github.com/ledgerwatch/erigon-lib/common"
 	"github.com/ledgerwatch/erigon-lib/kv"
 	"github.com/ledgerwatch/erigon/polygon/bor/borcfg"
 
@@ -66,7 +65,7 @@ type eip1559Calculator struct{}
 func (f eip1559Calculator) CurrentFees(chainConfig *chain.Config, db kv.Getter) (baseFee, blobFee, minBlobGasPrice, blockGasLimit uint64, err error) {
 	hash := rawdb.ReadHeadHeaderHash(db)
 
-	if hash == (libcommon.Hash{}) {
+	if hash == (common.Hash{}) {
 		return 0, 0, 0, 0, fmt.Errorf("can't get head header hash")
 	}
 
@@ -80,7 +79,7 @@ func (f eip1559Calculator) CurrentFees(chainConfig *chain.Config, db kv.Getter)
 
 	if chainConfig != nil {
 		if currentHeader.BaseFee != nil {
-			baseFee = CalcBaseFee(chainConfig, currentHeader).Uint64()
+			baseFee = CalcBaseFeeZk(chainConfig, currentHeader).Uint64()
 		}
 
 		if currentHeader.ExcessBlobGas != nil {

consensus/misc/eip1559_zk.go

@@ -5,12 +5,19 @@ import (
 
 	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon/core/types"
+	"github.com/ledgerwatch/erigon/params"
 )
 
 func CalcBaseFeeZk(config *chain.Config, parent *types.Header) *big.Int {
-	if config.SupportGasless {
+	if config.SupportGasless || parent.Number.Cmp(big.NewInt(0)) == 0 {
+		// If the parent is the genesis block, the next block will include the initial batch transaction, which is a legacy transaction, so the basefee will be set to 0
 		return big.NewInt(0)
 	}
 
+	// If the parent block is injected block from L1 at block 1 (while block 0 is the genesis), it will have base fee of 0 so we will set the basefee of current block to the initial basefee
+	if parent.Number.Cmp(big.NewInt(1)) == 0 {
+		return new(big.Int).SetUint64(params.InitialBaseFee)
+	}
+
 	return CalcBaseFee(config, parent)
 }

core/genesis_write.go

@@ -191,11 +191,13 @@ func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *b
 	}
 
 	// set unwanted forks block to max number, so they are not activated
-	maxInt := new(big.Int).SetUint64(math.MaxUint64)
-	newCfg.LondonBlock = maxInt
-	newCfg.ShanghaiTime = maxInt
-	newCfg.CancunTime = maxInt
-	newCfg.PragueTime = maxInt
+	if newCfg.NormalcyBlock != nil && newCfg.NormalcyBlock.Cmp(big.NewInt(0)) != 0 {
+		maxInt := new(big.Int).SetUint64(math.MaxUint64)
+		newCfg.LondonBlock = maxInt
+		newCfg.ShanghaiTime = maxInt
+		newCfg.CancunTime = maxInt
+		newCfg.PragueTime = maxInt
+	}
 
 	return newCfg, storedBlock, nil
 }

eth/ethconfig/config_zkevm.go

@@ -72,7 +72,7 @@ type Zk struct {
 var DefaultZkConfig = &Zk{}
 
 func (c *Zk) ShouldCountersBeUnlimited(l1Recovery bool) bool {
-	return l1Recovery || (c.DisableVirtualCounters && !c.ExecutorStrictMode && len(c.ExecutorUrls) != 0)
+	return l1Recovery || (c.DisableVirtualCounters && !c.ExecutorStrictMode && !c.HasExecutors())
 }
 
 func (c *Zk) HasExecutors() bool {

eth/stagedsync/stage_execute.go

@@ -35,6 +35,7 @@ import (
 	"github.com/ledgerwatch/erigon/common/changeset"
 	"github.com/ledgerwatch/erigon/common/math"
 	"github.com/ledgerwatch/erigon/consensus"
+	"github.com/ledgerwatch/erigon/consensus/misc"
 	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/core/state"
@@ -513,6 +514,14 @@ Loop:
 			break
 		}
 
+		if cfg.chainConfig.IsLondon(blockNum) {
+			parentHeader, err := cfg.blockReader.Header(ctx, txc.Tx, header.ParentHash, blockNum-1)
+			if err != nil {
+				return err
+			}
+			header.BaseFee = misc.CalcBaseFeeZk(cfg.chainConfig, parentHeader)
+		}
+
 		lastLogTx += uint64(block.Transactions().Len())
 
 		// Incremental move of next stages depend on fully written ChangeSets, Receipts, CallTraceSet

eth/stagedsync/stage_execute_zkevm.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ledgerwatch/erigon-lib/kv/membatch"
 	"github.com/ledgerwatch/log/v3"
 
+	"github.com/ledgerwatch/erigon/consensus/misc"
 	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/zk/erigon_db"
 	"github.com/ledgerwatch/erigon/zk/hermez_db"
@@ -303,6 +304,14 @@ func getPreexecuteValues(cfg ExecuteBlockCfg, ctx context.Context, tx kv.RwTx, b
 
 	block.HeaderNoCopy().ParentHash = prevBlockHash
 
+	if cfg.chainConfig.IsLondon(blockNum) {
+		parentHeader, err := cfg.blockReader.Header(ctx, tx, prevBlockHash, blockNum-1)
+		if err != nil {
+			return common.Hash{}, nil, nil, err
+		}
+		block.HeaderNoCopy().BaseFee = misc.CalcBaseFeeZk(cfg.chainConfig, parentHeader)
+	}
+
 	return preExecuteHeaderHash, block, senders, nil
 }
 

turbo/stages/stageloop.go

@@ -308,7 +308,7 @@ func (h *Hook) sendNotifications(notifications *shards.Notifications, tx kv.Tx,
 			notifications.Accumulator.StartChange(0, currentHeader.Hash(), nil, false)
 		}
 
-		pendingBaseFee := misc.CalcBaseFee(h.chainConfig, currentHeader)
+		pendingBaseFee := misc.CalcBaseFeeZk(h.chainConfig, currentHeader)
 		pendingBlobFee := h.chainConfig.GetMinBlobGasPrice()
 		if currentHeader.ExcessBlobGas != nil {
 			excessBlobGas := misc.CalcExcessBlobGas(h.chainConfig, currentHeader)

turbo/stages/zk_stages.go

@@ -52,7 +52,7 @@ func NewDefaultZkStages(ctx context.Context,
 	return zkStages.DefaultZkStages(ctx,
 		zkStages.StageL1SyncerCfg(db, l1Syncer, cfg.Zk),
 		zkStages.StageL1InfoTreeCfg(db, cfg.Zk, l1InfoTreeSyncer),
-		zkStages.StageBatchesCfg(db, datastreamClient, cfg.Zk),
+		zkStages.StageBatchesCfg(db, datastreamClient, cfg.Zk, controlServer.ChainConfig, &cfg.Miner),
 		zkStages.StageDataStreamCatchupCfg(datastreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion, cfg.HasExecutors()),
 		stagedsync.StageBlockHashesCfg(db, dirs.Tmp, controlServer.ChainConfig, blockWriter),
 		stagedsync.StageSendersCfg(db, controlServer.ChainConfig, false, dirs.Tmp, cfg.Prune, blockReader, controlServer.Hd, nil),
@@ -140,6 +140,7 @@ func NewSequencerZkStages(ctx context.Context,
 			agg,
 			datastreamServer,
 			cfg.Zk,
+			&cfg.Miner,
 			txPool,
 			txPoolDb,
 		),

zk/erigon_db/db.go

@@ -4,9 +4,11 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon-lib/common"
 	"github.com/ledgerwatch/erigon-lib/kv"
 
+	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	ethTypes "github.com/ledgerwatch/erigon/core/types"
 )
@@ -28,19 +30,28 @@ func (db ErigonDb) WriteHeader(
 	blockHash common.Hash,
 	stateRoot, txHash, parentHash common.Hash,
 	coinbase common.Address,
-	ts, gasLimit uint64,
+	ts, gasLimit uint64, chainConfig *chain.Config,
 ) (*ethTypes.Header, error) {
-	h := &ethTypes.Header{
-		ParentHash: parentHash,
-		UncleHash:  sha3UncleHash,
-		Coinbase:   coinbase,
-		Root:       stateRoot,
-		TxHash:     txHash,
-		Difficulty: big.NewInt(0),
-		Number:     blockNo,
-		GasLimit:   gasLimit,
-		Time:       ts,
-		Extra:      make([]byte, 0),
+	parentHeader, err := db.GetHeader(blockNo.Uint64() - 1)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get parent header: %w", err)
+	}
+
+	h := core.MakeEmptyHeader(parentHeader, chainConfig, ts, &gasLimit)
+
+	h.ParentHash = parentHash
+	h.Root = stateRoot
+	h.TxHash = txHash
+	h.Coinbase = coinbase
+	h.UncleHash = sha3UncleHash
+	h.Extra = make([]byte, 0)
+
+	if chainConfig.IsShanghai(blockNo.Uint64()) {
+		h.WithdrawalsHash = &ethTypes.EmptyRootHash
+	}
+
+	if !chainConfig.IsNormalcy(blockNo.Uint64()) {
+		h.GasLimit = gasLimit
 	}
 
 	if err := rawdb.WriteHeaderWithhash(db.tx, blockHash, h); err != nil {

zk/stages/stage_batches.go

@@ -7,13 +7,15 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon-lib/common"
 
 	"github.com/ledgerwatch/erigon-lib/kv"
 
 	ethTypes "github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/eth/stagedsync"
 	"github.com/ledgerwatch/erigon/eth/stagedsync/stages"
+	"github.com/ledgerwatch/erigon/params"
 	"github.com/ledgerwatch/erigon/zk"
 	"github.com/ledgerwatch/erigon/zk/datastream/types"
 	"github.com/ledgerwatch/erigon/zk/erigon_db"
@@ -33,7 +35,7 @@ const (
 )
 
 type ErigonDb interface {
-	WriteHeader(batchNo *big.Int, blockHash common.Hash, stateRoot, txHash, parentHash common.Hash, coinbase common.Address, ts, gasLimit uint64) (*ethTypes.Header, error)
+	WriteHeader(batchNo *big.Int, blockHash common.Hash, stateRoot, txHash, parentHash common.Hash, coinbase common.Address, ts, gasLimit uint64, chainConfig *chain.Config) (*ethTypes.Header, error)
 	WriteBody(batchNo *big.Int, headerHash common.Hash, txs []ethTypes.Transaction) error
 }
 
@@ -86,14 +88,18 @@ type BatchesCfg struct {
 	blockRoutineStarted bool
 	dsClient            DatastreamClient
 	zkCfg               *ethconfig.Zk
+	chainConfig         *chain.Config
+	miningConfig        *params.MiningConfig
 }
 
-func StageBatchesCfg(db kv.RwDB, dsClient DatastreamClient, zkCfg *ethconfig.Zk) BatchesCfg {
+func StageBatchesCfg(db kv.RwDB, dsClient DatastreamClient, zkCfg *ethconfig.Zk, chainConfig *chain.Config, miningConfig *params.MiningConfig) BatchesCfg {
 	return BatchesCfg{
 		db:                  db,
 		blockRoutineStarted: false,
 		dsClient:            dsClient,
 		zkCfg:               zkCfg,
+		chainConfig:         chainConfig,
+		miningConfig:        miningConfig,
 	}
 }
 
@@ -340,7 +346,7 @@ LOOP:
 				l2Block.ParentHash = previousHash
 			}
 
-			if err := writeL2Block(eriDb, hermezDb, &l2Block, highestL1InfoTreeIndex); err != nil {
+			if err := writeL2Block(eriDb, hermezDb, &l2Block, highestL1InfoTreeIndex, cfg.chainConfig, cfg.miningConfig); err != nil {
 				return fmt.Errorf("writeL2Block error: %v", err)
 			}
 			dsClientProgress.Store(l2Block.L2BlockNumber)
@@ -756,7 +762,7 @@ func PruneBatchesStage(s *stagedsync.PruneState, tx kv.RwTx, cfg BatchesCfg, ctx
 
 // writeL2Block writes L2Block to ErigonDb and HermezDb
 // writes header, body, forkId and blockBatch
-func writeL2Block(eriDb ErigonDb, hermezDb HermezDb, l2Block *types.FullL2Block, highestL1InfoTreeIndex uint64) error {
+func writeL2Block(eriDb ErigonDb, hermezDb HermezDb, l2Block *types.FullL2Block, highestL1InfoTreeIndex uint64, chainConfig *chain.Config, miningConfig *params.MiningConfig) error {
 	bn := new(big.Int).SetUint64(l2Block.L2BlockNumber)
 	txs := make([]ethTypes.Transaction, 0, len(l2Block.L2Txs))
 	for _, transaction := range l2Block.L2Txs {
@@ -781,9 +787,15 @@ func writeL2Block(eriDb ErigonDb, hermezDb HermezDb, l2Block *types.FullL2Block,
 	txCollection := ethTypes.Transactions(txs)
 	txHash := ethTypes.DeriveSha(txCollection)
 
-	gasLimit := utils.GetBlockGasLimitForFork(l2Block.ForkId)
+	var gasLimit uint64
 
-	_, err := eriDb.WriteHeader(bn, l2Block.L2Blockhash, l2Block.StateRoot, txHash, l2Block.ParentHash, l2Block.Coinbase, uint64(l2Block.Timestamp), gasLimit)
+	if !chainConfig.IsNormalcy(l2Block.L2BlockNumber) {
+		gasLimit = utils.GetBlockGasLimitForFork(l2Block.ForkId)
+	} else {
+		gasLimit = miningConfig.GasLimit
+	}
+
+	_, err := eriDb.WriteHeader(bn, l2Block.L2Blockhash, l2Block.StateRoot, txHash, l2Block.ParentHash, l2Block.Coinbase, uint64(l2Block.Timestamp), gasLimit, chainConfig)
 	if err != nil {
 		return fmt.Errorf("write header error: %v", err)
 	}

zk/stages/stage_batches_test.go

@@ -72,7 +72,7 @@ func TestUnwindBatches(t *testing.T) {
 	require.NoError(t, err)
 
 	dsClient := NewTestDatastreamClient(fullL2Blocks, gerUpdates)
-	cfg := StageBatchesCfg(db1, dsClient, &ethconfig.Zk{})
+	cfg := StageBatchesCfg(db1, dsClient, &ethconfig.Zk{}, nil)
 
 	s := &stagedsync.StageState{ID: stages.Batches, BlockNumber: 0}
 	u := &stagedsync.Sync{}

zk/stages/stage_sequence_execute.go

@@ -80,7 +80,7 @@ func SpawnSequencingStage(
 			return err
 		}
 
-		header, parentBlock, err := prepareHeader(tx, executionAt, math.MaxUint64, math.MaxUint64, forkId, cfg.zk.AddressSequencer)
+		header, parentBlock, err := prepareHeader(tx, executionAt, math.MaxUint64, math.MaxUint64, forkId, cfg.zk.AddressSequencer, cfg.chainConfig, cfg.miningConfig)
 		if err != nil {
 			return err
 		}
@@ -247,7 +247,7 @@ func SpawnSequencingStage(
 		log.Info(fmt.Sprintf("[%s] Continuing unfinished batch %d from block %d", logPrefix, thisBatch, executionAt))
 	}
 
-	blockDataSizeChecker := NewBlockDataChecker()
+	blockDataSizeChecker := NewBlockDataChecker(cfg.zk.ShouldCountersBeUnlimited(l1Recovery))
 
 	prevHeader := rawdb.ReadHeaderByNumber(tx, executionAt)
 	batchDataOverflow := false
@@ -284,7 +284,7 @@ func SpawnSequencingStage(
 			addedReceipts = []*types.Receipt{}
 			addedExecutionResults = []*core.ExecutionResult{}
 			effectiveGases = []uint8{}
-			header, parentBlock, err = prepareHeader(tx, blockNumber, deltaTimestamp, limboHeaderTimestamp, forkId, nextBatchData.Coinbase)
+			header, parentBlock, err = prepareHeader(tx, blockNumber, deltaTimestamp, limboHeaderTimestamp, forkId, nextBatchData.Coinbase, cfg.chainConfig, cfg.miningConfig)
 			if err != nil {
 				return err
 			}
@@ -299,12 +299,15 @@ func SpawnSequencingStage(
 
 			// create a copy of the header otherwise the executor will return "state root mismatch error"
 			header = &types.Header{
-				ParentHash: header.ParentHash,
-				Coinbase:   header.Coinbase,
-				Difficulty: header.Difficulty,
-				Number:     header.Number,
-				GasLimit:   header.GasLimit,
-				Time:       header.Time,
+				ParentHash:    header.ParentHash,
+				Coinbase:      header.Coinbase,
+				Difficulty:    header.Difficulty,
+				Number:        header.Number,
+				GasLimit:      header.GasLimit,
+				Time:          header.Time,
+				BaseFee:       header.BaseFee,
+				BlobGasUsed:   header.BlobGasUsed,
+				ExcessBlobGas: header.ExcessBlobGas,
 			}
 		}
 

zk/stages/stage_sequence_execute_blocks.go

@@ -20,7 +20,6 @@ import (
 	"github.com/ledgerwatch/erigon/zk/erigon_db"
 	"github.com/ledgerwatch/erigon/zk/hermez_db"
 	zktypes "github.com/ledgerwatch/erigon/zk/types"
-	"github.com/ledgerwatch/erigon/zk/utils"
 	"github.com/ledgerwatch/secp256k1"
 )
 
@@ -129,6 +128,11 @@ func finaliseBlock(
 		}
 	}
 
+	var withdrawals []*types.Withdrawal
+	if cfg.chainConfig.IsShanghai(newHeader.Number.Uint64()) {
+		withdrawals = []*types.Withdrawal{}
+	}
+
 	finalBlock, finalTransactions, finalReceipts, err := core.FinalizeBlockExecutionWithHistoryWrite(
 		cfg.engine,
 		sdb.stateReader,
@@ -139,7 +143,7 @@ func finaliseBlock(
 		cfg.chainConfig,
 		ibs,
 		receipts,
-		nil, // no withdrawals
+		withdrawals,
 		chainReader,
 		true,
 		excessBlobGas,
@@ -156,7 +160,6 @@ func finaliseBlock(
 	finalHeader := finalBlock.HeaderNoCopy()
 	finalHeader.Root = newRoot
 	finalHeader.Coinbase = cfg.zk.AddressSequencer
-	finalHeader.GasLimit = utils.GetBlockGasLimitForFork(forkId)
 	finalHeader.ReceiptHash = types.DeriveSha(receipts)
 	finalHeader.Bloom = types.CreateBloom(receipts)
 	newNum := finalBlock.Number()