feat: replace l1 head with l1 finalized block as sequencer and deriva… (#319)

Author: joey0612

op-node/flags/flags.go

@@ -226,6 +226,13 @@ var (
 		Value:    15,
 		Category: L1RPCCategory,
 	}
+	L1FinalizedConfDepth = &cli.BoolFlag{
+		Name:     "l1-finalized-confs",
+		Usage:    "Use L1 finalized block as the latest head for opBNB sequencer and derivation. When enabled, verifier.l1-confs and sequencer.l1-confs will be ignored.",
+		EnvVars:  prefixEnvVars("L1_FINALIZED_CONFS"),
+		Value:    false,
+		Category: L1RPCCategory,
+	}
 	SequencerEnabledFlag = &cli.BoolFlag{
 		Name:     "sequencer.enabled",
 		Usage:    "Enable sequencing of new L2 blocks. A separate batch submitter has to be deployed to publish the data for verifiers.",
@@ -439,6 +446,7 @@ var optionalFlags = []cli.Flag{
 	L1BlobRpcRateLimit,
 	L1BlobRpcMaxBatchSize,
 	VerifierL1Confs,
+	L1FinalizedConfDepth,
 	SequencerEnabledFlag,
 	SequencerStoppedFlag,
 	SequencerMaxSafeLagFlag,

op-node/rollup/driver/conf_depth.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
@@ -43,3 +44,45 @@ func (c *confDepth) L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1B
 }
 
 var _ derive.L1Fetcher = (*confDepth)(nil)
+
+// confDepth is an util that wraps the L1 input fetcher used in the pipeline,
+// and hides the part of the L1 chain with insufficient confirmations.
+//
+// At 0 depth the l1 head is completely ignored.
+type confDepthByL1Finalized struct {
+	// everything fetched by hash is trusted already, so we implement those by embedding the fetcher
+	derive.L1Fetcher
+	l1Finalized func() eth.L1BlockRef
+	depth       uint64
+}
+
+func NewConfDepthByL1Finalized(depth uint64, l1Finalized func() eth.L1BlockRef, fetcher derive.L1Fetcher) *confDepthByL1Finalized {
+	return &confDepthByL1Finalized{L1Fetcher: fetcher, l1Finalized: l1Finalized, depth: depth}
+}
+
+// L1BlockRefByNumber is used for L1 traversal and for finding a safe common point between the L2 engine and L1 chain.
+// Any block numbers that are within confirmation depth of the L1 head are mocked to be "not found",
+// effectively hiding the uncertain part of the L1 chain.
+func (c *confDepthByL1Finalized) L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1BlockRef, error) {
+	// TODO: performance optimization: buffer the l1Unsafe, invalidate any reorged previous buffer content,
+	// and instantly return the origin by number from the buffer if we can.
+
+	// Don't apply the conf depth if l1Head is empty (as it is during the startup case before the l1State is initialized).
+	l1Finalized := c.l1Finalized()
+	if l1Finalized == (eth.L1BlockRef{}) {
+		// if l1Finalized is empty, wait for it to be set, temporarily return not found
+		log.Warn("Conf depth is waiting for L1 finalized block to be set")
+		return eth.L1BlockRef{}, ethereum.NotFound
+	}
+	if num == l1Finalized.Number {
+		log.Info("Conf depth get L1 block number is equal to finalized block number", "num", num, "finalized", l1Finalized)
+		return l1Finalized, nil
+	}
+	if num < l1Finalized.Number {
+		return c.L1Fetcher.L1BlockRefByNumber(ctx, num)
+	}
+	log.Error("Conf depth get L1 block number is greater than finalized block number", "num", num, "finalized", l1Finalized)
+	return eth.L1BlockRef{}, ethereum.NotFound
+}
+
+var _ derive.L1Fetcher = (*confDepthByL1Finalized)(nil)

op-node/rollup/driver/config.go

@@ -1,14 +1,20 @@
 package driver
 
 type Config struct {
+	// L1FinalizedConfDepth enables using L1 finalized block as the latest head for opBNB sequencer and derivation.
+	// When enabled, VerifierConfDepth and SequencerConfDepth will be ignored.
+	L1FinalizedConfDepth bool `json:"l1_finalized_conf_depth"`
+
 	// VerifierConfDepth is the distance to keep from the L1 head when reading L1 data for L2 derivation.
+	// Ignored when L1FinalizedConfDepth is enabled.
 	VerifierConfDepth uint64 `json:"verifier_conf_depth"`
 
 	// SequencerConfDepth is the distance to keep from the L1 head as origin when sequencing new L2 blocks.
 	// If this distance is too large, the sequencer may:
 	// - not adopt a L1 origin within the allowed time (rollup.Config.MaxSequencerDrift)
 	// - not adopt a L1 origin that can be included on L1 within the allowed range (rollup.Config.SeqWindowSize)
 	// and thus fail to produce a block with anything more than deposits.
+	// Ignored when L1FinalizedConfDepth is enabled.
 	SequencerConfDepth uint64 `json:"sequencer_conf_depth"`
 
 	// SequencerEnabled is true when the driver should sequence new blocks.

op-node/rollup/driver/driver.go

@@ -154,9 +154,18 @@ func NewDriver(
 ) *Driver {
 	l1 = NewMeteredL1Fetcher(l1, metrics)
 	l1State := NewL1State(log, metrics)
-	sequencerConfDepth := NewConfDepth(driverCfg.SequencerConfDepth, l1State.L1Head, l1)
+
+	var sequencerConfDepth derive.L1Fetcher
+	var verifConfDepth derive.L1Fetcher
+	if driverCfg.L1FinalizedConfDepth {
+		sequencerConfDepth = NewConfDepthByL1Finalized(driverCfg.SequencerConfDepth, l1State.L1Finalized, l1)
+		verifConfDepth = NewConfDepthByL1Finalized(driverCfg.VerifierConfDepth, l1State.L1Finalized, l1)
+	} else {
+		sequencerConfDepth = NewConfDepth(driverCfg.SequencerConfDepth, l1State.L1Head, l1)
+		verifConfDepth = NewConfDepth(driverCfg.VerifierConfDepth, l1State.L1Head, l1)
+	}
+
 	findL1Origin := NewL1OriginSelector(log, cfg, sequencerConfDepth)
-	verifConfDepth := NewConfDepth(driverCfg.VerifierConfDepth, l1State.L1Head, l1)
 	engine := derive.NewEngineController(l2, log, metrics, cfg, syncCfg, driverCfg.SequencerCombinedEngine)
 	clSync := clsync.NewCLSync(log, cfg, metrics, engine)
 

op-node/rollup/driver/l1_state.go

@@ -60,6 +60,11 @@ func (s *L1State) HandleNewL1SafeBlock(safe eth.L1BlockRef) {
 func (s *L1State) HandleNewL1FinalizedBlock(finalized eth.L1BlockRef) {
 	s.log.Info("New L1 finalized block", "l1_finalized", finalized)
 	s.metrics.RecordL1Ref("l1_finalized", finalized)
+
+	if s.l1Finalized.Number > finalized.Number {
+		s.log.Error("New L1 finalized block is less than the current finalized block", "l1_finalized", finalized, "current_l1_finalized", s.l1Finalized)
+	}
+
 	s.l1Finalized = finalized
 }
 

op-node/rollup/driver/state.go

@@ -307,6 +307,10 @@ func (s *Driver) eventLoop() {
 						s.l1State.HandleNewL1HeadBlock(newL1Head)
 						reqStep() // a new L1 head may mean we have the data to not get an EOF again.
 						continue
+					case newL1Finalized := <-s.l1FinalizedSig: // sequencerStep may depend on this when FindL1Origin
+						s.l1State.HandleNewL1FinalizedBlock(newL1Finalized)
+						reqStep() // a new L1 finalized may mean we have the data to not get an EOF again.
+						continue
 					default:
 						// immediately do sequencerStep if time is ready
 						if err := sequencerStep(); err != nil {
@@ -342,6 +346,10 @@ func (s *Driver) eventLoop() {
 				s.l1State.HandleNewL1HeadBlock(newL1Head)
 				reqStep() // a new L1 head may mean we have the data to not get an EOF again.
 				continue
+			case newL1Finalized := <-s.l1FinalizedSig: // sequencerStep may depend on this when FindL1Origin
+				s.l1State.HandleNewL1FinalizedBlock(newL1Finalized)
+				reqStep() // a new L1 finalized may mean we have the data to not get an EOF again.
+				continue
 			case respCh := <-s.stopSequencer:
 				if s.driverConfig.SequencerStopped {
 					respCh <- hashAndError{err: ErrSequencerAlreadyStopped}

op-node/service.go

@@ -204,6 +204,7 @@ func NewConfigPersistence(ctx *cli.Context) node.ConfigPersistence {
 
 func NewDriverConfig(ctx *cli.Context) *driver.Config {
 	return &driver.Config{
+		L1FinalizedConfDepth:    ctx.Bool(flags.L1FinalizedConfDepth.Name),
 		VerifierConfDepth:       ctx.Uint64(flags.VerifierL1Confs.Name),
 		SequencerConfDepth:      ctx.Uint64(flags.SequencerL1Confs.Name),
 		SequencerEnabled:        ctx.Bool(flags.SequencerEnabledFlag.Name),