all: Adapt OP-Stack diff after merging upstream geth/v1.15.0

core/txpool: Add PoolJournaler to reimplement journalRemotes

fork.yaml: add tx-pool journalremotes sub-section

params: don't require BlobScheduleConfig for OP-Stack config

miner: fix OP-Stack payload building & test

conensus/beacon: fix VerifyHeader for transitioned OP networks

core/txpool/locals: Fix PoolJournaler to use ticker & journal on shutdown

consensus/beacon: add parenthesis for clarity

ethclient: check error in TestEthClientHistoricalBackend

consensus/beacon: check for OP config in CalcDifficulty

consensus/beacon: fix CalcDifficulty pre-Bedrock check

consensus/misc/4844: add exception for OP-Stack in CalcBlobFee

params: require nil BlobScheduleConfig for OP-Stack chains

Author: sebastianst

cmd/utils/flags.go

@@ -388,7 +388,7 @@ var (
 	}
 	TxPoolJournalRemotesFlag = &cli.BoolFlag{
 		Name:     "txpool.journalremotes",
-		Usage:    "Includes remote transactions in the journal",
+		Usage:    "Includes remote transactions in the journal. Only effective if nolocals is set too.",
 		Category: flags.TxPoolCategory,
 	}
 	TxPoolRejournalFlag = &cli.DurationFlag{

consensus/beacon/consensus.go

@@ -122,8 +122,11 @@ func (beacon *Beacon) VerifyHeader(chain consensus.ChainHeaderReader, header *ty
 	if parent.Difficulty.Sign() == 0 && header.Difficulty.Sign() > 0 {
 		return consensus.ErrInvalidTerminalBlock
 	}
+	cfg := chain.Config()
 	// Check >0 TDs with pre-merge, --0 TDs with post-merge rules
-	if header.Difficulty.Sign() > 0 {
+	if header.Difficulty.Sign() > 0 ||
+		// OP-Stack: transitioned networks must use legacy consensus pre-Bedrock
+		(cfg.IsOptimism() && !cfg.IsBedrock(header.Number)) {
 		return beacon.ethone.VerifyHeader(chain, header)
 	}
 	return beacon.verifyHeader(chain, header, parent)
@@ -132,21 +135,21 @@ func (beacon *Beacon) VerifyHeader(chain consensus.ChainHeaderReader, header *ty
 // OP-Stack Bedrock variant of splitHeaders: the total-terminal difficulty is terminated at bedrock transition, but also reset to 0.
 // So just use the bedrock fork check to split the headers, to simplify the splitting.
 // The returned slices are slices over the input. The input must be sorted.
-func (beacon *Beacon) splitBedrockHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) ([]*types.Header, []*types.Header, error) {
+func (beacon *Beacon) splitBedrockHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) ([]*types.Header, []*types.Header) {
 	for i, h := range headers {
 		if chain.Config().IsBedrock(h.Number) {
-			return headers[:i], headers[i:], nil
+			return headers[:i], headers[i:]
 		}
 	}
-	return headers, nil, nil
+	return headers, nil
 }
 
 // splitHeaders splits the provided header batch into two parts according to
 // the difficulty field.
 //
 // Note, this function will not verify the header validity but just split them.
-func (beacon *Beacon) splitHeaders(headers []*types.Header) ([]*types.Header, []*types.Header) {
-	if chain.Config().Optimism != nil {
+func (beacon *Beacon) splitHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) ([]*types.Header, []*types.Header) {
+	if chain.Config().IsOptimism() {
 		return beacon.splitBedrockHeaders(chain, headers)
 	}
 
@@ -169,7 +172,7 @@ func (beacon *Beacon) splitHeaders(headers []*types.Header) ([]*types.Header, []
 // a results channel to retrieve the async verifications.
 // VerifyHeaders expect the headers to be ordered and continuous.
 func (beacon *Beacon) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) (chan<- struct{}, <-chan error) {
-	preHeaders, postHeaders := beacon.splitHeaders(headers)
+	preHeaders, postHeaders := beacon.splitHeaders(chain, headers)
 	if len(postHeaders) == 0 {
 		return beacon.ethone.VerifyHeaders(chain, headers)
 	}
@@ -488,7 +491,10 @@ func (beacon *Beacon) CalcDifficulty(chain consensus.ChainHeaderReader, time uin
 	// We do not need to seal non-merge blocks anymore live, but we do need
 	// to be able to generate test chains, thus we're reverting to a testing-
 	// settable field to direct that.
-	if beacon.ttdblock != nil && *beacon.ttdblock > parent.Number.Uint64() {
+	cfg := chain.Config()
+	if beacon.ttdblock != nil && *beacon.ttdblock > parent.Number.Uint64() ||
+		// OP-Stack: transitioned networks must use legacy consensus pre-Bedrock
+		(cfg.IsOptimism() && !cfg.IsBedrock(new(big.Int).Add(parent.Number, common.Big1))) {
 		return beacon.ethone.CalcDifficulty(chain, time, parent)
 	}
 	return beaconDifficulty

consensus/misc/eip4844/eip4844.go

@@ -81,6 +81,16 @@ func CalcExcessBlobGas(config *params.ChainConfig, parent *types.Header, headTim
 
 // CalcBlobFee calculates the blobfee from the header's excess blob gas field.
 func CalcBlobFee(config *params.ChainConfig, header *types.Header) *big.Int {
+	// OP-Stack chains don't support blobs, but still set the excessBlobGas field (always to zero).
+	// So this function is called in many places for OP-Stack chains too. In order to not require
+	// a blob schedule in the chain config, we short circuit here.
+	if config.IsOptimism() {
+		if config.BlobScheduleConfig != nil || header.ExcessBlobGas == nil || *header.ExcessBlobGas != 0 {
+			panic("OP-Stack: CalcBlobFee: unexpected blob schedule or excess blob gas")
+		}
+		return minBlobGasPrice
+	}
+
 	var frac uint64
 	switch config.LatestFork(header.Time) {
 	case forks.Prague:

consensus/misc/eip4844/eip4844_test.go

@@ -21,6 +21,8 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
 )
@@ -90,6 +92,28 @@ func TestCalcBlobFee(t *testing.T) {
 	}
 }
 
+func TestCalcBlobFeeOPStack(t *testing.T) {
+	zero := uint64(0)
+	header := &types.Header{ExcessBlobGas: &zero}
+	// any non-nil optimism confic should do
+	config := &params.ChainConfig{Optimism: new(params.OptimismConfig)}
+	bfee := CalcBlobFee(config, header)
+	require.Equal(t, int64(1), bfee.Int64())
+
+	reqPanic := func() {
+		require.PanicsWithValue(t,
+			"OP-Stack: CalcBlobFee: unexpected blob schedule or excess blob gas",
+			func() { CalcBlobFee(config, header) })
+	}
+	(*header.ExcessBlobGas)++
+	reqPanic()
+	header.ExcessBlobGas = nil
+	reqPanic()
+	header.ExcessBlobGas = &zero
+	config.BlobScheduleConfig = params.DefaultBlobSchedule
+	reqPanic()
+}
+
 func TestFakeExponential(t *testing.T) {
 	tests := []struct {
 		factor      int64

core/genesis.go

@@ -477,11 +477,9 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, g
 	// OP-Stack note: Always apply overrides.
 	// The genesis function arg may be nil, and stored-config may be non-nil at the same time.
 	// This is important to apply superchain-upgrades to existing DBs, where the network CLI flag is not used.
-	chainCfg, err := overrides.apply(newCfg)
-	if err != nil {
+	if err := overrides.apply(newCfg); err != nil {
 		return nil, common.Hash{}, nil, err
 	}
-	newCfg = chainCfg
 
 	var genesisTimestamp *uint64
 	if genesis != nil {

core/state_transition.go

@@ -464,7 +464,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 
 		st.state.RevertToSnapshot(snap)
 		// Even though we revert the state changes, always increment the nonce for the next deposit transaction
-		st.state.SetNonce(st.msg.From, st.state.GetNonce(st.msg.From)+1)
+		st.state.SetNonce(st.msg.From, st.state.GetNonce(st.msg.From)+1, tracing.NonceChangeEoACall)
 		// Record deposits as using all their gas (matches the gas pool)
 		// System Transactions are special & are not recorded as using any gas (anywhere)
 		// Regolith changes this behaviour so the actual gas used is reported.

core/txpool/legacypool/legacypool.go

@@ -56,11 +56,9 @@ const (
 	txMaxSize = 4 * txSlotSize // 128KB
 )
 
-var (
-	// ErrTxPoolOverflow is returned if the transaction pool is full and can't accept
-	// another remote transaction.
-	ErrTxPoolOverflow = errors.New("txpool is full")
-)
+// ErrTxPoolOverflow is returned if the transaction pool is full and can't accept
+// another remote transaction.
+var ErrTxPoolOverflow = errors.New("txpool is full")
 
 var (
 	evictionInterval    = time.Minute     // Time interval to check for evictable transactions
@@ -480,6 +478,23 @@ func (pool *LegacyPool) ContentFrom(addr common.Address) ([]*types.Transaction,
 	return pending, queued
 }
 
+// ToJournal returns all transactions in the pool in a format suitable for journaling.
+//
+// OP-Stack addition.
+func (pool *LegacyPool) ToJournal() map[common.Address]types.Transactions {
+	pool.mu.Lock()
+	defer pool.mu.Unlock()
+
+	txs := make(map[common.Address]types.Transactions, len(pool.pending)+len(pool.queue))
+	for addr, pending := range pool.pending {
+		txs[addr] = pending.Flatten()
+	}
+	for addr, queued := range pool.queue {
+		txs[addr] = append(txs[addr], queued.Flatten()...)
+	}
+	return txs
+}
+
 // Pending retrieves all currently processable transactions, grouped by origin
 // account and sorted by nonce.
 //
@@ -518,7 +533,9 @@ func (pool *LegacyPool) Pending(filter txpool.PendingFilter) map[common.Address]
 				}
 			}
 		}
-		if filter.MaxDATxSize != nil && !pool.locals.contains(addr) {
+
+		// OP-Stack addition: exclude by max-da-size filter
+		if filter.MaxDATxSize != nil {
 			for i, tx := range txs {
 				estimate := tx.RollupCostData().EstimatedDASize()
 				if estimate.Cmp(filter.MaxDATxSize) > 0 {
@@ -566,9 +583,6 @@ func (pool *LegacyPool) validateTxBasics(tx *types.Transaction) error {
 		MinTip:           pool.gasTip.Load().ToBig(),
 		EffectiveGasCeil: pool.config.EffectiveGasCeil,
 	}
-	if local {
-		opts.MinTip = new(big.Int)
-	}
 	if err := txpool.ValidateTransaction(tx, pool.currentHead.Load(), pool.signer, opts); err != nil {
 		return err
 	}
@@ -920,7 +934,7 @@ func (pool *LegacyPool) Add(txs []*types.Transaction, sync bool) []error {
 	newErrs, dirtyAddrs := pool.addTxsLocked(news)
 	pool.mu.Unlock()
 
-	var nilSlot = 0
+	nilSlot := 0
 	for _, err := range newErrs {
 		for errs[nilSlot] != nil {
 			nilSlot++
@@ -1417,7 +1431,7 @@ func (pool *LegacyPool) promoteExecutables(accounts []common.Address) []*types.T
 		queuedGauge.Dec(int64(len(readies)))
 
 		// Drop all transactions over the allowed limit
-		var caps = list.Cap(int(pool.config.AccountQueue))
+		caps := list.Cap(int(pool.config.AccountQueue))
 		for _, tx := range caps {
 			hash := tx.Hash()
 			pool.all.Remove(hash)

core/txpool/legacypool/legacypool_test.go

@@ -699,8 +699,8 @@ func TestRejectedDropping(t *testing.T) {
 	// create some txs. tx0 has a conditional
 	tx0, tx1 := transaction(0, 100, key), transaction(1, 200, key)
 
-	pool.all.Add(tx0, false)
-	pool.all.Add(tx1, false)
+	pool.all.Add(tx0)
+	pool.all.Add(tx1)
 	pool.promoteTx(account, tx0.Hash(), tx0)
 	pool.promoteTx(account, tx1.Hash(), tx1)
 

core/txpool/legacypool/list.go

@@ -268,7 +268,7 @@ func (m *SortedMap) LastElement() *types.Transaction {
 
 // FirstElement returns the first element from the heap (guaranteed to be lowest), thus, the
 // transaction with the lowest nonce. Returns nil if there are no elements.
-func (m *sortedMap) FirstElement() *types.Transaction {
+func (m *SortedMap) FirstElement() *types.Transaction {
 	if m.Len() == 0 {
 		return nil
 	}

core/txpool/locals/pool_journaler.go

@@ -0,0 +1,108 @@
+// Copyright 2025 The op-geth Authors
+// This file is part of the op-geth library.
+//
+// The op-geth library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The op-geth library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the op-geth library. If not, see <http://www.gnu.org/licenses/>.
+
+package locals
+
+import (
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/core/txpool"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// A PoolJournaler periodically journales a transaction pool to disk.
+// It is meant to be used instead of the TxTracker when the noLocals and
+// journalRemotes settings are enabled.
+//
+// OP-Stack addition.
+type PoolJournaler struct {
+	journal   *journal       // Journal of local transaction to back up to disk
+	rejournal time.Duration  // How often to rotate journal
+	pool      *txpool.TxPool // The tx pool to interact with
+
+	shutdownCh chan struct{}
+	wg         sync.WaitGroup
+}
+
+func NewPoolJournaler(journalPath string, journalTime time.Duration, pool *txpool.TxPool) *PoolJournaler {
+	return &PoolJournaler{
+		journal:    newTxJournal(journalPath),
+		rejournal:  journalTime,
+		pool:       pool,
+		shutdownCh: make(chan struct{}),
+	}
+}
+
+// Start implements node.Lifecycle interface
+// Start is called after all services have been constructed and the networking
+// layer was also initialized to spawn any goroutines required by the service.
+func (pj *PoolJournaler) Start() error {
+	pj.wg.Add(1)
+	go pj.loop()
+	return nil
+}
+
+// Stop implements node.Lifecycle interface
+// Stop terminates all goroutines belonging to the service, blocking until they
+// are all terminated.
+func (pj *PoolJournaler) Stop() error {
+	close(pj.shutdownCh)
+	pj.wg.Wait()
+	return nil
+}
+
+func (pj *PoolJournaler) loop() {
+	defer log.Info("PoolJournaler: Stopped")
+	defer pj.wg.Done()
+
+	start := time.Now()
+	log.Info("PoolJournaler: Start loading transactions from journal...")
+	if err := pj.journal.load(func(transactions []*types.Transaction) []error {
+		log.Info("PoolJournaler: Start adding transactions to pool", "count", len(transactions), "loading_duration", time.Since(start))
+		errs := pj.pool.Add(transactions, true)
+		log.Info("PoolJournaler: Done adding transactions to pool", "total_duration", time.Since(start))
+		return errs
+	}); err != nil {
+		log.Error("PoolJournaler: Transaction journal loading failed. Exiting.", "err", err)
+		return
+	}
+	defer pj.journal.close()
+
+	ticker := time.NewTicker(pj.rejournal)
+	defer ticker.Stop()
+
+	journal := func() {
+		start := time.Now()
+		tojournal := pj.pool.ToJournal()
+		if err := pj.journal.rotate(tojournal); err != nil {
+			log.Error("PoolJournaler: Transaction journal rotation failed", "err", err)
+		} else {
+			log.Debug("PoolJournaler: Transaction journal rotated", "count", len(tojournal), "duration", time.Since(start))
+		}
+	}
+
+	for {
+		select {
+		case <-pj.shutdownCh:
+			journal()
+			return
+		case <-ticker.C:
+			journal()
+		}
+	}
+}