op-supervisor,op-node: Handle non-interop genesis activation

Author: sebastianst

op-node/rollup/interop/managed/system.go

@@ -54,6 +54,7 @@ type ManagedMode struct {
 }
 
 func NewManagedMode(log log.Logger, cfg *rollup.Config, addr string, port int, jwtSecret eth.Bytes32, l1 L1Source, l2 L2Source, m opmetrics.RPCMetricer) *ManagedMode {
+	log = log.With("mode", "managed", "chainId", cfg.L2ChainID)
 	out := &ManagedMode{
 		log:       log,
 		cfg:       cfg,
@@ -113,21 +114,34 @@ func (m *ManagedMode) AttachEmitter(em event.Emitter) {
 	m.emitter = em
 }
 
+// Outgoing events to supervisor
 func (m *ManagedMode) OnEvent(ev event.Event) bool {
 	switch x := ev.(type) {
 	case rollup.ResetEvent:
 		msg := x.Err.Error()
 		m.events.Send(&supervisortypes.ManagedEvent{Reset: &msg})
 	case engine.UnsafeUpdateEvent:
+		if !m.cfg.IsInterop(x.Ref.Time) {
+			m.log.Debug("Ignoring non-Interop local unsafe update", "unsafe", x.Ref)
+			return false
+		}
 		ref := x.Ref.BlockRef()
 		m.events.Send(&supervisortypes.ManagedEvent{UnsafeBlock: &ref})
 	case engine.LocalSafeUpdateEvent:
+		if !m.cfg.IsInterop(x.Ref.Time) {
+			m.log.Debug("Ignoring non-Interop local safe update", "derivedFrom", x.Source, "derived", x.Ref)
+			return false
+		}
 		m.log.Info("Emitting local safe update because of L2 block", "derivedFrom", x.Source, "derived", x.Ref)
 		m.events.Send(&supervisortypes.ManagedEvent{DerivationUpdate: &supervisortypes.DerivedBlockRefPair{
 			Source:  x.Source,
 			Derived: x.Ref.BlockRef(),
 		}})
 	case derive.DeriverL1StatusEvent:
+		if !m.cfg.IsInterop(x.LastL2.Time) {
+			m.log.Debug("Ignoring non-Interop L1 traversal", "origin", x.Origin, "lastL2", x.LastL2)
+			return false
+		}
 		m.log.Info("Emitting local safe update because of L1 traversal", "derivedFrom", x.Origin, "derived", x.LastL2)
 		m.events.Send(&supervisortypes.ManagedEvent{
 			DerivationUpdate: &supervisortypes.DerivedBlockRefPair{
@@ -240,6 +254,15 @@ func (m *ManagedMode) InvalidateBlock(ctx context.Context, seal supervisortypes.
 }
 
 func (m *ManagedMode) AnchorPoint(ctx context.Context) (supervisortypes.DerivedBlockRefPair, error) {
+	// TODO: maybe cache non-genesis anchor point when seeing safe Interop activation block?
+	//  Only needed if we don't test for activation block in the supervisor.
+	if !m.cfg.IsInterop(m.cfg.Genesis.L2Time) {
+		return supervisortypes.DerivedBlockRefPair{}, &gethrpc.JsonError{
+			Code:    InteropInactiveRPCErrCode,
+			Message: "Interop inactive at genesis",
+		}
+	}
+
 	l1Ref, err := m.l1.L1BlockRefByHash(ctx, m.cfg.Genesis.L1.Hash)
 	if err != nil {
 		return supervisortypes.DerivedBlockRefPair{}, fmt.Errorf("failed to fetch L1 block ref: %w", err)
@@ -258,8 +281,16 @@ const (
 	InternalErrorRPCErrcode    = -32603
 	BlockNotFoundRPCErrCode    = -39001
 	ConflictingBlockRPCErrCode = -39002
+	InteropInactiveRPCErrCode  = -39003
 )
 
+// TODO: add ResetPreInterop, called by supervisor if bisection went pre-Interop. Emit ResetEngineRequestEvent.
+func (m *ManagedMode) ResetPreInterop(ctx context.Context) error {
+	m.log.Info("Received pre-interop reset request")
+	m.emitter.Emit(engine.ResetEngineRequestEvent{})
+	return nil
+}
+
 func (m *ManagedMode) Reset(ctx context.Context, lUnsafe, xUnsafe, lSafe, xSafe, finalized eth.BlockID) error {
 	logger := m.log.New(
 		"localUnsafe", lUnsafe,

op-node/rollup/sync/start.go

@@ -48,9 +48,11 @@ type L2Chain interface {
 	L2BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)
 }
 
-var ReorgFinalizedErr = errors.New("cannot reorg finalized block")
-var WrongChainErr = errors.New("wrong chain")
-var TooDeepReorgErr = errors.New("reorg is too deep")
+var (
+	ReorgFinalizedErr = errors.New("cannot reorg finalized block")
+	WrongChainErr     = errors.New("wrong chain")
+	TooDeepReorgErr   = errors.New("reorg is too deep")
+)
 
 const MaxReorgSeqWindows = 5
 
@@ -156,6 +158,8 @@ func FindL2Heads(ctx context.Context, cfg *rollup.Config, l1 L1Chain, l2 L2Chain
 	// Once we pass the previous safe head and we have seen enough canonical L1 origins to fill a sequence window worth of data,
 	// then we return the last L2 block of the epoch before that as safe head.
 	// Each loop iteration we traverse a single L2 block, and we check if the L1 origins are consistent.
+	// TODO: maybe check inside here not to go over Interop activation, this should be handled by supervisor
+	// Fine to keep unsafe chain. Safe chain should be capped to stay pre-Interop.
 	for {
 		// Fetch L1 information if we never had it, or if we do not have it for the current origin.
 		// Optimization: as soon as we have a previous L1 block, try to traverse L1 by hash instead of by number, to fill the cache.

op-supervisor/supervisor/backend/backend.go

@@ -81,8 +81,10 @@ type SupervisorBackend struct {
 	rpcVerificationWarnings bool
 }
 
-var _ event.AttachEmitter = (*SupervisorBackend)(nil)
-var _ frontend.Backend = (*SupervisorBackend)(nil)
+var (
+	_ event.AttachEmitter = (*SupervisorBackend)(nil)
+	_ frontend.Backend    = (*SupervisorBackend)(nil)
+)
 
 var (
 	errAlreadyStopped        = errors.New("already stopped")
@@ -97,7 +99,8 @@ var (
 var verifyAccessWithRPCTimeout = 10 * time.Second
 
 func NewSupervisorBackend(ctx context.Context, logger log.Logger,
-	m Metrics, cfg *config.Config, eventExec event.Executor) (*SupervisorBackend, error) {
+	m Metrics, cfg *config.Config, eventExec event.Executor,
+) (*SupervisorBackend, error) {
 	// attempt to prepare the data directory
 	if err := db.PrepDataDir(cfg.Datadir); err != nil {
 		return nil, err
@@ -176,18 +179,37 @@ func NewSupervisorBackend(ctx context.Context, logger log.Logger,
 func (su *SupervisorBackend) OnEvent(ev event.Event) bool {
 	switch x := ev.(type) {
 	case superevents.LocalUnsafeReceivedEvent:
+		if su.cfgSet.IsInteropActivationBlock(x.ChainID, x.NewLocalUnsafe.Time) {
+			su.emitter.Emit(db.UnsafeActivationBlockReceivedEvent{
+				ChainID: x.ChainID,
+				Unsafe:  x.NewLocalUnsafe,
+			})
+			// don't process events of the activation block
+			return true
+		}
 		su.emitter.Emit(superevents.ChainProcessEvent{
 			ChainID: x.ChainID,
 			Target:  x.NewLocalUnsafe.Number,
 		})
 	case superevents.LocalUnsafeUpdateEvent:
+		// TODO: activation block should be directly promoted to cross-safe
+		// because exec msgs aren't allowed in it. Where to best handle this?
 		su.emitter.Emit(superevents.UpdateCrossUnsafeRequestEvent{
 			ChainID: x.ChainID,
 		})
 	case superevents.CrossUnsafeUpdateEvent:
 		su.emitter.Emit(superevents.UpdateCrossUnsafeRequestEvent{
 			ChainID: x.ChainID,
 		})
+	case superevents.LocalDerivedEvent:
+		if su.cfgSet.IsInteropActivationBlock(x.ChainID, x.NewLocalSafe.Derived.Timestamp) {
+			su.emitter.Emit(db.SafeActivationBlockReceivedEvent{
+				ChainID: x.ChainID,
+				Safe:    x.Derived,
+			})
+		}
+		// TODO: activation block should be directly promoted to cross-safe
+		// because exec msgs aren't allowed in it. Where to best handle this?
 	case superevents.LocalSafeUpdateEvent:
 		su.emitter.Emit(superevents.ChainProcessEvent{
 			ChainID: x.ChainID,
@@ -314,7 +336,9 @@ func (su *SupervisorBackend) AttachSyncNode(ctx context.Context, src syncnode.Sy
 		return nil, fmt.Errorf("chain %s is not part of the interop dependency set: %w", chainID, types.ErrUnknownChain)
 	}
 	// before attaching the sync source to the backend at all,
-	// query the anchor point to initialize the database
+	// query the anchor point to initialize the database, if the node has activated Interop already.
+	// TODO: maybe move to end, and just emit QueryAnchorpointEvent instead, removing
+	//  [SupervisorBackend.QueryAnchorpoint].
 	if err := su.QueryAnchorpoint(chainID, src); err != nil {
 		return nil, fmt.Errorf("failed to query anchor point: %w", err)
 	}
@@ -330,8 +354,11 @@ func (su *SupervisorBackend) AttachSyncNode(ctx context.Context, src syncnode.Sy
 }
 
 func (su *SupervisorBackend) QueryAnchorpoint(chainID eth.ChainID, src syncnode.SyncNode) error {
-	anchor, err := src.AnchorPoint(context.Background())
-	if err != nil {
+	anchor, err := src.AnchorPoint(su.sysContext)
+	if errors.Is(err, types.ErrFuture) {
+		su.logger.Info("Interop not activated yet while querying anchor point", "chainID", chainID)
+		return nil
+	} else if err != nil {
 		return fmt.Errorf("failed to get anchor point: %w", err)
 	}
 	su.emitter.Emit(superevents.AnchorEvent{
@@ -522,7 +549,8 @@ func (su *SupervisorBackend) checkSafety(chainID eth.ChainID, blockID eth.BlockI
 }
 
 func (su *SupervisorBackend) CheckAccessList(ctx context.Context, inboxEntries []common.Hash,
-	minSafety types.SafetyLevel, executingDescriptor types.ExecutingDescriptor) error {
+	minSafety types.SafetyLevel, executingDescriptor types.ExecutingDescriptor,
+) error {
 	switch minSafety {
 	case types.LocalUnsafe, types.CrossUnsafe, types.LocalSafe, types.CrossSafe, types.Finalized:
 		// valid safety level

op-supervisor/supervisor/backend/cross/safe_frontier_test.go

@@ -204,6 +204,10 @@ func (m mockDependencySet) ChainIndexFromID(chain eth.ChainID) (types.ChainIndex
 	return types.ChainIndex(v.Uint64() + 1000), nil
 }
 
+func (m mockDependencySet) IsInterop(chainID eth.ChainID, timestamp uint64) bool{
+	return true
+}
+
 func (m mockDependencySet) Chains() []eth.ChainID {
 	return nil
 }

op-supervisor/supervisor/backend/db/anchor.go

@@ -27,15 +27,15 @@ func (db *ChainsDB) initFromAnchor(id eth.ChainID, anchor types.DerivedBlockRefP
 	}
 	db.logger.Debug("initializing chain database from anchor point")
 
-	// Initialize the local and cross safe databases
-	if err := db.maybeInitSafeDB(id, anchor); err != nil {
-		db.logger.Warn("failed to initialize local and cross safe databases", "err", err)
+	// Initialize the events database
+	if err := db.maybeInitEventsDB(id, anchor.Derived); err != nil {
+		db.logger.Warn("failed to initialize events database", "err", err)
 		return
 	}
 
-	// Initialize the events database
-	if err := db.maybeInitEventsDB(id, anchor); err != nil {
-		db.logger.Warn("failed to initialize events database", "err", err)
+	// Initialize the local and cross safe databases
+	if err := db.maybeInitSafeDB(id, anchor); err != nil {
+		db.logger.Warn("failed to initialize local and cross safe databases", "err", err)
 		return
 	}
 
@@ -75,12 +75,12 @@ func (db *ChainsDB) maybeInitSafeDB(id eth.ChainID, anchor types.DerivedBlockRef
 	return nil
 }
 
-func (db *ChainsDB) maybeInitEventsDB(id eth.ChainID, anchor types.DerivedBlockRefPair) error {
-	logger := db.logger.New("chain", id, "derived", anchor.Derived, "source", anchor.Source)
-	seal, _, _, err := db.OpenBlock(id, 0)
+func (db *ChainsDB) maybeInitEventsDB(id eth.ChainID, anchor eth.BlockRef) error {
+	logger := db.logger.New("chain", id, "anchor", anchor)
+	seal, err := db.FindSealedBlock(id, anchor.Number)
 	if errors.Is(err, types.ErrFuture) {
 		logger.Debug("initializing events database")
-		err := db.initializedSealBlock(id, anchor.Derived)
+		err := db.initializedSealBlock(id, anchor)
 		if err != nil {
 			return err
 		}
@@ -89,7 +89,8 @@ func (db *ChainsDB) maybeInitEventsDB(id eth.ChainID, anchor types.DerivedBlockR
 		return fmt.Errorf("failed to check if logDB is initialized: %w", err)
 	} else {
 		logger.Debug("Events database already initialized")
-		if seal.Hash != anchor.Derived.Hash {
+		// TODO: to allow for reorgs, we may want to handle this differently
+		if seal.Hash != anchor.Hash {
 			return fmt.Errorf("events database (%s) does not match anchor point (%s): %w",
 				seal,
 				anchor,

op-supervisor/supervisor/backend/db/db.go

@@ -163,11 +163,42 @@ func (db *ChainsDB) AttachEmitter(em event.Emitter) {
 
 func (db *ChainsDB) OnEvent(ev event.Event) bool {
 	switch x := ev.(type) {
+	case UnsafeActivationBlockReceivedEvent:
+		if !db.isInitialized(x.ChainID) {
+			db.logger.Info("Initializing logs DB from unsafe activation block",
+				"chain", x.ChainID, "block", x.Unsafe)
+			// Note that isInitialized is only true after full initialization,
+			// not only the logs db.
+			db.maybeInitEventsDB(x.ChainID, x.Unsafe)
+		} else {
+			db.logger.Warn("Received unsafe activation block on initialized DB",
+				"chain", x.ChainID, "block", x.Unsafe)
+			// TODO: handle reorg?
+		}
+		return false
+	case SafeActivationBlockReceivedEvent:
+		if !db.isInitialized(x.ChainID) {
+			db.logger.Info("Initializing full DB from safe activation block",
+				"chain", x.ChainID, "block", x.Safe)
+			// Note that isInitialized is only true after full initialization,
+			// not only the logs db.
+			db.initFromAnchor(x.ChainID, x.Safe)
+		} else {
+			db.logger.Warn("Received unsafe activation block on initialized DB",
+				"chain", x.ChainID, "block", x.Safe)
+			// TODO: handle reorg?
+		}
+		return false
 	case superevents.AnchorEvent:
+		// TODO: Anchor should only be used if Interop is active at genesis.
 		db.logger.Info("Received chain anchor information",
 			"chain", x.ChainID, "derived", x.Anchor.Derived, "source", x.Anchor.Source)
 		db.initFromAnchor(x.ChainID, x.Anchor)
 	case superevents.LocalDerivedEvent:
+		if !db.isInitialized(x.ChainID) {
+			// this case is handled by SafeActivationBlockReceivedEvent
+			return false
+		}
 		db.UpdateLocalSafe(x.ChainID, x.Derived.Source, x.Derived.Derived, x.NodeID)
 	case superevents.FinalizedL1RequestEvent:
 		db.onFinalizedL1(x.FinalizedL1)

op-supervisor/supervisor/backend/db/events.go

@@ -0,0 +1,24 @@
+package db
+
+import (
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+)
+
+type UnsafeActivationBlockReceivedEvent struct {
+	Unsafe  eth.BlockRef
+	ChainID eth.ChainID
+}
+
+func (ev UnsafeActivationBlockReceivedEvent) String() string {
+	return "unsafe-activation-block-received"
+}
+
+type SafeActivationBlockReceivedEvent struct {
+	Safe    types.DerivedBlockRefPair
+	ChainID eth.ChainID
+}
+
+func (ev SafeActivationBlockReceivedEvent) String() string {
+	return "safe-activation-block-received"
+}

op-supervisor/supervisor/backend/db/update.go

@@ -101,6 +101,9 @@ func (db *ChainsDB) UpdateLocalSafe(chain eth.ChainID, source eth.BlockRef, last
 }
 
 func (db *ChainsDB) initializedUpdateLocalSafe(chain eth.ChainID, source eth.BlockRef, lastDerived eth.BlockRef, nodeId string) {
+	// TODO: remove notion of anchor block
+	// if first interop activation block is seen, it's set as cross-(un)safe block
+	// pre-interop, don't emit UpdateLocalSafeFailedEvent
 	logger := db.logger.New("chain", chain, "source", source, "lastDerived", lastDerived)
 	localDB, ok := db.localDBs.Get(chain)
 	if !ok {
@@ -114,7 +117,7 @@ func (db *ChainsDB) initializedUpdateLocalSafe(chain eth.ChainID, source eth.Blo
 			return
 		}
 		if errors.Is(err, types.ErrDataCorruption) {
-			logger.Warn("TODO", "err", err)
+			logger.Error("DB coruption occurred", "err", err)
 			return
 		}
 		logger.Warn("Failed to update local safe", "err", err)
@@ -226,11 +229,16 @@ func (db *ChainsDB) onFinalizedL1(finalized eth.BlockRef) {
 	db.logger.Info("Updated finalized L1", "finalizedL1", finalized)
 	db.finalizedL1.Unlock()
 
+	// TODO: There seems to be no consumer of this event?
 	db.emitter.Emit(superevents.FinalizedL1UpdateEvent{
 		FinalizedL1: finalized,
 	})
 	// whenever the L1 Finalized changes, the L2 Finalized may change, notify subscribers
 	for _, chain := range db.depSet.Chains() {
+		if !db.isInitialized(chain) {
+			continue
+		}
+
 		fin, err := db.Finalized(chain)
 		if err != nil {
 			db.logger.Warn("Unable to determine finalized L2 block", "chain", chain, "l1Finalized", finalized)

op-supervisor/supervisor/backend/depset/depset.go

@@ -14,7 +14,6 @@ type DependencySetSource interface {
 // DependencySet is an initialized dependency set, ready to answer queries
 // of what is and what is not part of the dependency set.
 type DependencySet interface {
-
 	// CanExecuteAt determines if an executing message is valid at all.
 	// I.e. if the chain may be executing messages at the given timestamp.
 	// This may return an error if the query temporarily cannot be answered.

op-supervisor/supervisor/backend/depset/depset_test.go

@@ -79,6 +79,8 @@ func testDependencySetSerialization(
 		})
 	require.NoError(t, err)
 
+	id900 := eth.ChainIDFromUInt64(900)
+
 	t.Run("DefaultExpiryWindow", func(t *testing.T) {
 		data, err := marshal(depSet)
 		require.NoError(t, err)
@@ -138,7 +140,6 @@ func testDependencySetSerialization(
 	})
 
 	t.Run("chain index round trip", func(t *testing.T) {
-		id900 := eth.ChainIDFromUInt64(900)
 		idx, _ := depSet.ChainIndexFromID(id900)
 		idBack, _ := depSet.ChainIDFromIndex(idx)
 		require.Equal(t, id900, idBack)
@@ -152,6 +153,12 @@ func testDependencySetSerialization(
 		require.False(t, depSet.HasChain(eth.ChainIDFromUInt64(902)))
 	})
 
+	t.Run("IsInterop", func(t *testing.T) {
+		require.True(t, depSet.IsInterop(id900, 42))
+		require.False(t, depSet.IsInterop(id900, 41))
+		require.False(t, depSet.IsInterop(eth.ChainIDFromUInt64(999), 1000))
+	})
+
 }
 
 func testChainCapabilities(t *testing.T, result DependencySet) {