[PoC] op-node: Light CL

op-acceptance-tests/tests/safe_source_l2/seq/init_test.go

@@ -0,0 +1,17 @@
+package safe_source_l2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/compat"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+)
+
+func TestMain(m *testing.M) {
+	presets.DoMain(m,
+		presets.WithSingleChainMultiNodeWithSafeSourceL2(true /* seqWithSafeSourceL2 */),
+		presets.WithCompatibleTypes(compat.SysGo),
+		// test should work w/wo WithExecutionLayerSyncOnVerifiers.
+		// presets.WithExecutionLayerSyncOnVerifiers(),
+	)
+}

op-acceptance-tests/tests/safe_source_l2/seq/safe_source_l2_test.go

@@ -0,0 +1,39 @@
+package safe_source_l2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/dsl"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+)
+
+// TestSafeSourceL2BasicSync verifies that a verifier node configured with --safe-source=l2
+// can follow the safe head of another verifier without performing derivation.
+func TestSafeSourceL2BasicSync(gt *testing.T) {
+	t := devtest.SerialT(gt)
+	sys := presets.NewSingleChainMultiNodeWithSafeSourceL2(t)
+
+	// Advance the normal verifier's safe head
+	dsl.CheckAll(t,
+		sys.L2CL.AdvancedFn(types.LocalSafe, 5, 30),
+	)
+
+	// Verify the safe-source=l2 verifier matches the normal verifier
+	sys.L2CLB.Matched(sys.L2CL, types.LocalSafe, 30)
+
+	// Get sync status from both nodes
+	l2CLStatus := sys.L2CL.SyncStatus()
+	l2CLBStatus := sys.L2CLB.SyncStatus()
+
+	require := t.Require()
+	require.Equal(l2CLStatus.SafeL2.Hash, l2CLBStatus.SafeL2.Hash, "Safe heads should match")
+	require.Equal(l2CLStatus.SafeL2.Number, l2CLBStatus.SafeL2.Number, "Safe block numbers should match")
+	require.Equal(l2CLStatus.FinalizedL2.Hash, l2CLBStatus.FinalizedL2.Hash, "Finalized heads should match")
+	require.Equal(l2CLStatus.FinalizedL2.Number, l2CLBStatus.FinalizedL2.Number, "Finalized block numbers should match")
+
+	// Advance further to ensure continued sync
+	sys.L2CL.Advanced(types.LocalSafe, 5, 30)
+	sys.L2CLB.Matched(sys.L2CL, types.LocalSafe, 30)
+}

op-acceptance-tests/tests/safe_source_l2/ver/init_test.go

@@ -0,0 +1,17 @@
+package safe_source_l2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/compat"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+)
+
+func TestMain(m *testing.M) {
+	presets.DoMain(m,
+		presets.WithSingleChainMultiNodeWithSafeSourceL2(false /* seqWithSafeSourceL2 */),
+		presets.WithCompatibleTypes(compat.SysGo),
+		// test should work w/wo WithExecutionLayerSyncOnVerifiers.
+		// presets.WithExecutionLayerSyncOnVerifiers(),
+	)
+}

op-acceptance-tests/tests/safe_source_l2/ver/safe_source_l2_test.go

@@ -0,0 +1,39 @@
+package safe_source_l2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/dsl"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+)
+
+// TestSafeSourceL2BasicSync verifies that a verifier node configured with --safe-source=l2
+// can follow the safe head of another verifier without performing derivation.
+func TestSafeSourceL2BasicSync(gt *testing.T) {
+	t := devtest.SerialT(gt)
+	sys := presets.NewSingleChainMultiNodeWithSafeSourceL2(t)
+
+	// Advance the normal verifier's safe head
+	dsl.CheckAll(t,
+		sys.L2CL.AdvancedFn(types.LocalSafe, 5, 30),
+	)
+
+	// Verify the safe-source=l2 verifier matches the normal verifier
+	sys.L2CLB.Matched(sys.L2CL, types.LocalSafe, 30)
+
+	// Get sync status from both nodes
+	l2CLStatus := sys.L2CL.SyncStatus()
+	l2CLBStatus := sys.L2CLB.SyncStatus()
+
+	require := t.Require()
+	require.Equal(l2CLStatus.SafeL2.Hash, l2CLBStatus.SafeL2.Hash, "Safe heads should match")
+	require.Equal(l2CLStatus.SafeL2.Number, l2CLBStatus.SafeL2.Number, "Safe block numbers should match")
+	require.Equal(l2CLStatus.FinalizedL2.Hash, l2CLBStatus.FinalizedL2.Hash, "Finalized heads should match")
+	require.Equal(l2CLStatus.FinalizedL2.Number, l2CLBStatus.FinalizedL2.Number, "Finalized block numbers should match")
+
+	// Advance further to ensure continued sync
+	sys.L2CL.Advanced(types.LocalSafe, 5, 30)
+	sys.L2CLB.Matched(sys.L2CL, types.LocalSafe, 30)
+}

op-acceptance-tests/tests/sync_tester/sync_tester_safesourcel2/init_test.go

@@ -0,0 +1,17 @@
+package sync_tester_safesourcel2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/compat"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+)
+
+func TestMain(m *testing.M) {
+	presets.DoMain(m,
+		presets.WithELSyncActive(),
+		presets.WithSimpleWithSyncTesterSafeSourceL2(),
+		presets.WithExecutionLayerSyncOnVerifiers(),
+		presets.WithCompatibleTypes(compat.SysGo),
+	)
+}

op-acceptance-tests/tests/sync_tester/sync_tester_safesourcel2/safesourcel2_test.go

@@ -0,0 +1,65 @@
+package sync_tester_safesourcel2
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/dsl"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+)
+
+func TestSyncTesterSafeSourceL2(gt *testing.T) {
+	t := devtest.SerialT(gt)
+	sys := presets.NewSimpleWithSyncTesterSafeSourceL2(t)
+	require := t.Require()
+	logger := t.Logger()
+	ctx := t.Ctx()
+
+	target := uint64(5)
+	dsl.CheckAll(t,
+		sys.L2CL.AdvancedFn(types.LocalUnsafe, target, 30),
+		sys.L2CL2.AdvancedFn(types.LocalUnsafe, target, 30),
+	)
+
+	// Stop L2CL2 which is using safe-source=l2
+	sys.L2CL2.Stop()
+
+	// Reset Sync Tester EL
+	sessionIDs := sys.SyncTester.ListSessions()
+	require.GreaterOrEqual(len(sessionIDs), 1, "at least one session")
+	sessionID := sessionIDs[0]
+	logger.Info("SyncTester EL", "sessionID", sessionID)
+	syncTesterClient := sys.SyncTester.Escape().APIWithSession(sessionID)
+	require.NoError(syncTesterClient.ResetSession(ctx))
+
+	// Wait for L2CL to advance more unsafe and safe blocks
+	sys.L2CL.Advanced(types.LocalUnsafe, target+5, 30)
+	sys.L2CL.Advanced(types.LocalSafe, target+3, 30)
+
+	// Restarting will allow L2CL2 to query safe head from L2CL via safe-source=l2
+	sys.L2CL2.Start()
+
+	// Wait until P2P is connected for unsafe head gossip
+	sys.L2CL2.IsP2PConnected(sys.L2CL)
+
+	// L2CL2 should catch up via safe-source=l2
+	target = uint64(20)
+	sys.L2CL.Reached(types.LocalSafe, target, 30)
+	sys.L2CL2.Reached(types.LocalSafe, target, 30)
+
+	sys.L2CL.Matched(sys.L2CL2, types.LocalSafe, 30)
+
+	logger.Info("SyncTester SafeSourceL2 test completed successfully")
+
+	logger.Info("### Safe  ", "ver", sys.L2CL2.SafeL2BlockRef(), "seq", sys.L2CL.SafeL2BlockRef())
+	logger.Info("### Unsafe", "ver", sys.L2CL2.UnsafeHead(), "seq", sys.L2CL.UnsafeHead())
+	// Safe matches but unsafe gap still happen
+
+	sys.L2CL.Matched(sys.L2CL2, types.LocalUnsafe, 100)
+
+	logger.Info("### Safe  ", "ver", sys.L2CL2.SafeL2BlockRef(), "seq", sys.L2CL.SafeL2BlockRef())
+	logger.Info("### Unsafe", "ver", sys.L2CL2.UnsafeHead(), "seq", sys.L2CL.UnsafeHead())
+	logger.Info("### Finalzed", "ver", sys.L2CL2.SyncStatus().FinalizedL2, "seq", sys.L2CL.SyncStatus().FinalizedL2)
+
+}

op-devstack/presets/orchestrator.go

@@ -64,7 +64,7 @@ func DoMain(m TestingM, opts ...stack.CommonOption) {
 		cfg := flags.ReadTestConfig()
 		logHandler := oplog.NewLogHandler(os.Stdout, cfg.LogConfig)
 		logHandler = logfilter.WrapFilterHandler(logHandler)
-		logHandler.(logfilter.FilterHandler).Set(logfilter.DefaultMute(logfilter.Level(log.LevelInfo).Show()))
+		// logHandler.(logfilter.FilterHandler).Set(logfilter.DefaultMute(logfilter.Level(log.LevelInfo).Show()))
 		logHandler = logfilter.WrapContextHandler(logHandler)
 		// The default can be changed using the WithLogFilters option which replaces this default
 		logger := log.NewLogger(logHandler)

op-devstack/presets/simple_with_synctester_safesourcel2.go

@@ -0,0 +1,43 @@
+package presets
+
+import (
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/dsl"
+	"github.com/ethereum-optimism/optimism/op-devstack/shim"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack/match"
+	"github.com/ethereum-optimism/optimism/op-devstack/sysgo"
+)
+
+type SimpleWithSyncTesterSafeSourceL2 struct {
+	Minimal
+
+	SyncTester     *dsl.SyncTester
+	SyncTesterL2EL *dsl.L2ELNode
+	L2CL2          *dsl.L2CLNode
+}
+
+func WithSimpleWithSyncTesterSafeSourceL2() stack.CommonOption {
+	return stack.MakeCommon(sysgo.DefaultSimpleSystemWithSyncTesterSafeSourceL2(&sysgo.DefaultSimpleSystemWithSyncTesterSafeSourceL2IDs{}))
+}
+
+func NewSimpleWithSyncTesterSafeSourceL2(t devtest.T) *SimpleWithSyncTesterSafeSourceL2 {
+	system := shim.NewSystem(t)
+	orch := Orchestrator()
+	orch.Hydrate(system)
+	minimal := minimalFromSystem(t, system, orch)
+	l2 := system.L2Network(match.L2ChainA)
+	syncTester := l2.SyncTester(match.FirstSyncTester)
+
+	// L2CL2 connected to L2EL initialized by sync tester, with safe-source=l2
+	l2CL2 := l2.L2CLNode(match.SecondL2CL)
+	// L2EL initialized by sync tester
+	syncTesterL2EL := l2.L2ELNode(match.SecondL2EL)
+
+	return &SimpleWithSyncTesterSafeSourceL2{
+		Minimal:        *minimal,
+		SyncTester:     dsl.NewSyncTester(syncTester),
+		SyncTesterL2EL: dsl.NewL2ELNode(syncTesterL2EL, orch.ControlPlane()),
+		L2CL2:          dsl.NewL2CLNode(l2CL2, orch.ControlPlane()),
+	}
+}

op-devstack/presets/singlechain_multinode_safesourcel2.go

@@ -0,0 +1,55 @@
+package presets
+
+import (
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/dsl"
+	"github.com/ethereum-optimism/optimism/op-devstack/shim"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack/match"
+	"github.com/ethereum-optimism/optimism/op-devstack/sysgo"
+	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+)
+
+type SingleChainMultiNodeWithSafeSourceL2 struct {
+	Minimal
+
+	L2ELB *dsl.L2ELNode
+	L2CLB *dsl.L2CLNode
+}
+
+func WithSingleChainMultiNodeWithSafeSourceL2(seqWithSafeSourceL2 bool) stack.CommonOption {
+	return stack.MakeCommon(sysgo.DefaultSingleChainMultiNodeWithSafeSourceL2System(&sysgo.DefaultSingleChainMultiNodeWithSafeSourceL2SystemIDs{}, seqWithSafeSourceL2))
+}
+
+func NewSingleChainMultiNodeWithSafeSourceL2(t devtest.T) *SingleChainMultiNodeWithSafeSourceL2 {
+	preset := NewSingleChainMultiNodeWithSafeSourceL2WithoutCheck(t)
+	// Ensure the L2 sourced node is in sync with the sequencer before starting tests
+	dsl.CheckAll(t,
+		preset.L2CLB.MatchedFn(preset.L2CL, types.CrossSafe, 30),
+		preset.L2CLB.MatchedFn(preset.L2CL, types.LocalUnsafe, 30),
+	)
+	return preset
+}
+
+func NewSingleChainMultiNodeWithSafeSourceL2WithoutCheck(t devtest.T) *SingleChainMultiNodeWithSafeSourceL2 {
+	system := shim.NewSystem(t)
+	orch := Orchestrator()
+	orch.Hydrate(system)
+	minimal := minimalFromSystem(t, system, orch)
+	l2 := system.L2Network(match.Assume(t, match.L2ChainA))
+	verifierCL := l2.L2CLNode(match.Assume(t,
+		match.And(
+			match.Not(match.WithSequencerActive(t.Ctx())),
+			match.Not[stack.L2CLNodeID, stack.L2CLNode](minimal.L2CL.ID()),
+		)))
+	verifierEL := l2.L2ELNode(match.Assume(t,
+		match.And(
+			match.EngineFor(verifierCL),
+			match.Not[stack.L2ELNodeID, stack.L2ELNode](minimal.L2EL.ID()))))
+	preset := &SingleChainMultiNodeWithSafeSourceL2{
+		Minimal: *minimal,
+		L2ELB:   dsl.NewL2ELNode(verifierEL, orch.ControlPlane()),
+		L2CLB:   dsl.NewL2CLNode(verifierCL, orch.ControlPlane()),
+	}
+	return preset
+}

op-devstack/sysgo/l2_cl.go

@@ -33,6 +33,11 @@ type L2CLConfig struct {
 
 	// NoDiscovery is the flag to enable/disable discovery
 	NoDiscovery bool
+
+	// SafeSource determines where the safe head comes from (L1 derivation or L2 RPC)
+	SafeSource nodeSync.SafeSource
+	// SafeSourceL2RPC is the RPC endpoint for L2 safe source (when SafeSource is L2)
+	SafeSourceL2RPC string
 }
 
 func L2CLSequencer() L2CLOption {
@@ -56,6 +61,8 @@ func DefaultL2CLConfig() *L2CLConfig {
 		IndexingMode:      false,
 		EnableReqRespSync: true,
 		NoDiscovery:       false,
+		SafeSource:        nodeSync.SafeSourceL1,
+		SafeSourceL2RPC:   "",
 	}
 }
 

op-devstack/sysgo/l2_cl_opnode.go

@@ -290,6 +290,8 @@ func WithOpNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L
 				SyncMode:                       syncMode,
 				SkipSyncStartCheck:             false,
 				SupportsPostFinalizationELSync: false,
+				SafeSource:                     cfg.SafeSource,
+				SafeSourceL2RPC:                cfg.SafeSourceL2RPC,
 			},
 			ConfigPersistence:               config.DisabledConfigPersistence{},
 			Metrics:                         opmetrics.CLIConfig{},

op-devstack/sysgo/system.go

@@ -91,6 +91,54 @@ func defaultMinimalSystemOpts(ids *DefaultMinimalSystemIDs, dest *DefaultMinimal
 	return opt
 }
 
+func DefaultMinimalSystemNoSeq(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator] {
+	ids := NewDefaultMinimalSystemIDs(DefaultL1ID, DefaultL2AID)
+	ids.L2CL = stack.NewL2CLNodeID("verifier", DefaultL2AID)
+	ids.L2EL = stack.NewL2ELNodeID("verifier", DefaultL2AID)
+	return defaultMinimalSystemNoSeqOpts(&ids, dest)
+}
+
+func defaultMinimalSystemNoSeqOpts(ids *DefaultMinimalSystemIDs, dest *DefaultMinimalSystemIDs) stack.CombinedOption[*Orchestrator] {
+	opt := stack.Combine[*Orchestrator]()
+	opt.Add(stack.BeforeDeploy(func(o *Orchestrator) {
+		o.P().Logger().Info("Setting up")
+	}))
+
+	opt.Add(WithMnemonicKeys(devkeys.TestMnemonic))
+
+	opt.Add(WithDeployer(),
+		WithDeployerOptions(
+			WithLocalContractSources(),
+			WithCommons(ids.L1.ChainID()),
+			WithPrefundedL2(ids.L1.ChainID(), ids.L2.ChainID()),
+		),
+	)
+
+	opt.Add(WithL1Nodes(ids.L1EL, ids.L1CL))
+
+	opt.Add(WithL2ELNode(ids.L2EL))
+	opt.Add(WithL2CLNode(ids.L2CL, ids.L1CL, ids.L1EL, ids.L2EL))
+
+	opt.Add(WithBatcher(ids.L2Batcher, ids.L1EL, ids.L2CL, ids.L2EL))
+	opt.Add(WithProposer(ids.L2Proposer, ids.L1EL, &ids.L2CL, nil))
+
+	opt.Add(WithFaucets([]stack.L1ELNodeID{ids.L1EL}, []stack.L2ELNodeID{ids.L2EL}))
+
+	opt.Add(WithTestSequencer(ids.TestSequencer, ids.L1CL, ids.L2CL, ids.L1EL, ids.L2EL))
+
+	opt.Add(WithL2Challenger(ids.L2Challenger, ids.L1EL, ids.L1CL, nil, nil, &ids.L2CL, []stack.L2ELNodeID{
+		ids.L2EL,
+	}))
+
+	opt.Add(WithL2MetricsDashboard())
+
+	opt.Add(stack.Finally(func(orch *Orchestrator) {
+		*dest = *ids
+	}))
+
+	return opt
+}
+
 // DefaultTwoL2System defines a minimal system with a single L1 and two L2 chains,
 // without interop or supervisor: both L2s get their own ELs, and we attach L2CL nodes
 // via the default L2CL selector (which can be set to supernode to share a single process).