interop, op-supervisor, op-node: Managed Mode

op-e2e/.gitignore

@@ -1 +1,2 @@
 external_*/shim
+op-e2e/interop/jwt.secret

op-e2e/actions/altda/altda_test.go

@@ -85,7 +85,7 @@ func NewL2AltDA(t helpers.Testing, params ...AltDAParam) *L2AltDA {
 
 	daMgr := altda.NewAltDAWithStorage(log, altDACfg, storage, &altda.NoopMetrics{})
 
-	sequencer := helpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), daMgr, engCl, sd.RollupCfg, 0, nil)
+	sequencer := helpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), daMgr, engCl, sd.RollupCfg, 0)
 	miner.ActL1SetFeeRecipient(common.Address{'A'})
 	sequencer.ActL2PipelineFull(t)
 
@@ -143,7 +143,7 @@ func (a *L2AltDA) NewVerifier(t helpers.Testing) *helpers.L2Verifier {
 
 	daMgr := altda.NewAltDAWithStorage(a.log, a.altDACfg, a.storage, &altda.NoopMetrics{})
 
-	verifier := helpers.NewL2Verifier(t, a.log, l1F, a.miner.BlobStore(), daMgr, engCl, a.sd.RollupCfg, &sync.Config{}, safedb.Disabled, nil)
+	verifier := helpers.NewL2Verifier(t, a.log, l1F, a.miner.BlobStore(), daMgr, engCl, a.sd.RollupCfg, &sync.Config{}, safedb.Disabled)
 
 	return verifier
 }

op-e2e/actions/derivation/batch_queue_test.go

@@ -95,7 +95,7 @@ func TestDeriveChainFromNearL1Genesis(gt *testing.T) {
 	l2Cl, err := sources.NewEngineClient(seqEngine.RPCClient(), logger, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
 	require.NoError(gt, err)
 	verifier := helpers.NewL2Verifier(t, logger, miner.L1Client(t, sd.RollupCfg), miner.BlobStore(), altda.Disabled,
-		l2Cl, sequencer.RollupCfg, &sync.Config{}, safedb.Disabled, nil)
+		l2Cl, sequencer.RollupCfg, &sync.Config{}, safedb.Disabled)
 	verifier.ActL2PipelineFull(t) // Should not get stuck in a reset loop forever
 	require.EqualValues(gt, l2BlockNum, seqEngine.L2Chain().CurrentSafeBlock().Number.Uint64())
 	require.EqualValues(gt, l2BlockNum, seqEngine.L2Chain().CurrentFinalBlock().Number.Uint64())

op-e2e/actions/derivation/reorg_test.go

@@ -596,7 +596,7 @@ func RestartOpGeth(gt *testing.T, deltaTimeOffset *hexutil.Uint64) {
 	engRpc := &rpcWrapper{seqEng.RPCClient()}
 	l2Cl, err := sources.NewEngineClient(engRpc, log, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
 	require.NoError(t, err)
-	sequencer := actionsHelpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), altda.Disabled, l2Cl, sd.RollupCfg, 0, nil)
+	sequencer := actionsHelpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), altda.Disabled, l2Cl, sd.RollupCfg, 0)
 
 	batcher := actionsHelpers.NewL2Batcher(log, sd.RollupCfg, actionsHelpers.DefaultBatcherCfg(dp),
 		sequencer.RollupClient(), miner.EthClient(), seqEng.EthClient(), seqEng.EngineClient(t, sd.RollupCfg))
@@ -684,7 +684,7 @@ func ConflictingL2Blocks(gt *testing.T, deltaTimeOffset *hexutil.Uint64) {
 	require.NoError(t, err)
 	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false, sources.RPCKindStandard))
 	require.NoError(t, err)
-	altSequencer := actionsHelpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), altda.Disabled, altSeqEngCl, sd.RollupCfg, 0, nil)
+	altSequencer := actionsHelpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), altda.Disabled, altSeqEngCl, sd.RollupCfg, 0)
 	altBatcher := actionsHelpers.NewL2Batcher(log, sd.RollupCfg, actionsHelpers.DefaultBatcherCfg(dp),
 		altSequencer.RollupClient(), miner.EthClient(), altSeqEng.EthClient(), altSeqEng.EngineClient(t, sd.RollupCfg))
 

op-e2e/actions/helpers/l1_replica.go

@@ -198,6 +198,12 @@ func (s *L1Replica) L1Client(t Testing, cfg *rollup.Config) *sources.L1Client {
 	return l1F
 }
 
+func (s *L1Replica) L1ClientSimple(t Testing) *sources.L1Client {
+	l1F, err := sources.NewL1Client(s.RPCClient(), s.log, nil, sources.L1ClientSimpleConfig(false, sources.RPCKindStandard, 100))
+	require.NoError(t, err)
+	return l1F
+}
+
 func (s *L1Replica) L1Chain() *core.BlockChain {
 	return s.l1Chain
 }

op-e2e/actions/helpers/l2_sequencer.go

@@ -19,7 +19,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/engine"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/event"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/interop"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/sequencing"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/sync"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
@@ -53,9 +52,8 @@ type L2Sequencer struct {
 
 func NewL2Sequencer(t Testing, log log.Logger, l1 derive.L1Fetcher, blobSrc derive.L1BlobsFetcher,
 	altDASrc driver.AltDAIface, eng L2API, cfg *rollup.Config, seqConfDepth uint64,
-	interopBackend interop.InteropBackend,
 ) *L2Sequencer {
-	ver := NewL2Verifier(t, log, l1, blobSrc, altDASrc, eng, cfg, &sync.Config{}, safedb.Disabled, interopBackend)
+	ver := NewL2Verifier(t, log, l1, blobSrc, altDASrc, eng, cfg, &sync.Config{}, safedb.Disabled)
 	attrBuilder := derive.NewFetchingAttributesBuilder(cfg, l1, eng)
 	seqConfDepthL1 := confdepth.NewConfDepth(seqConfDepth, ver.syncStatus.L1Head, l1)
 	originSelector := sequencing.NewL1OriginSelector(t.Ctx(), log, cfg, seqConfDepthL1)

op-e2e/actions/helpers/l2_verifier.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup/event"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/finality"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/interop"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/interop/managed"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/status"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/sync"
 	"github.com/ethereum-optimism/optimism/op-service/client"
@@ -36,6 +37,16 @@ import (
 	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/backend/syncnode"
 )
 
+var interopJWTSecret = [32]byte{4}
+
+type InteropControl interface {
+	PullEvents(ctx context.Context) (pulledAny bool, err error)
+
+	AwaitSentCrossUnsafeUpdate(ctx context.Context, minNum uint64) error
+	AwaitSentCrossSafeUpdate(ctx context.Context, minNum uint64) error
+	AwaitSentFinalizedUpdate(ctx context.Context, minNum uint64) error
+}
+
 // L2Verifier is an actor that functions like a rollup node,
 // without the full P2P/API/Node stack, but just the derivation state, and simplified driver.
 type L2Verifier struct {
@@ -68,7 +79,9 @@ type L2Verifier struct {
 
 	rpc *rpc.Server
 
-	interopRPC *rpc.Server
+	interopSys interop.SubSystem // may be nil if interop is not active
+
+	InteropControl InteropControl // if managed by an op-supervisor
 
 	failRPC func(call []rpc.BatchElem) error // mock error
 
@@ -98,7 +111,6 @@ type safeDB interface {
 func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 	blobsSrc derive.L1BlobsFetcher, altDASrc driver.AltDAIface,
 	eng L2API, cfg *rollup.Config, syncCfg *sync.Config, safeHeadListener safeDB,
-	interopBackend interop.InteropBackend,
 ) *L2Verifier {
 	ctx, cancel := context.WithCancel(context.Background())
 	t.Cleanup(cancel)
@@ -119,8 +131,14 @@ func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 		},
 	}
 
-	if interopBackend != nil {
-		sys.Register("interop", interop.NewInteropDeriver(log, cfg, ctx, interopBackend, eng), opts)
+	var interopSys interop.SubSystem
+	if cfg.InteropTime != nil {
+		interopSys = managed.NewManagedMode(log, cfg, "127.0.0.1", 0, interopJWTSecret, l1, eng)
+		sys.Register("interop", interopSys, opts)
+		require.NoError(t, interopSys.Start(context.Background()))
+		t.Cleanup(func() {
+			_ = interopSys.Stop(context.Background())
+		})
 	}
 
 	metrics := &testutils.TestDerivationMetrics{}
@@ -144,7 +162,8 @@ func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 	sys.Register("attributes-handler",
 		attributes.NewAttributesHandler(log, cfg, ctx, eng), opts)
 
-	pipeline := derive.NewDerivationPipeline(log, cfg, l1, blobsSrc, altDASrc, eng, metrics)
+	managedMode := interopSys != nil
+	pipeline := derive.NewDerivationPipeline(log, cfg, l1, blobsSrc, altDASrc, eng, metrics, managedMode)
 	sys.Register("pipeline", derive.NewPipelineDeriver(ctx, pipeline), opts)
 
 	testActionEmitter := sys.Register("test-action", nil, opts)
@@ -164,6 +183,7 @@ func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 		Log:            log,
 		Ctx:            ctx,
 		Drain:          executor.Drain,
+		ManagedMode:    false,
 	}, opts)
 
 	sys.Register("engine", engine.NewEngDeriver(log, ctx, cfg, metrics, ec), opts)
@@ -185,18 +205,12 @@ func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 		RollupCfg:         cfg,
 		rpc:               rpc.NewServer(),
 		synchronousEvents: testActionEmitter,
+		interopSys:        interopSys,
 	}
 	sys.Register("verifier", rollupNode, opts)
 
 	t.Cleanup(rollupNode.rpc.Stop)
 
-	if cfg.InteropTime != nil {
-		rollupNode.interopRPC = rpc.NewServer()
-		api := &interop.TemporaryInteropAPI{Eng: eng}
-		require.NoError(t, rollupNode.interopRPC.RegisterName("interop", api))
-		t.Cleanup(rollupNode.interopRPC.Stop)
-	}
-
 	// setup RPC server for rollup node, hooked to the actor as backend
 	m := &testutils.TestRPCMetrics{}
 	backend := &l2VerifierBackend{verifier: rollupNode}
@@ -220,8 +234,12 @@ func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher,
 }
 
 func (v *L2Verifier) InteropSyncNode(t Testing) syncnode.SyncNode {
-	require.NotNil(t, v.interopRPC, "interop rpc must be running")
-	cl := rpc.DialInProc(v.interopRPC)
+	require.NotNil(t, v.interopSys, "interop sub-system must be running")
+	m, ok := v.interopSys.(*managed.ManagedMode)
+	require.True(t, ok, "Interop sub-system must be in managed-mode if used as sync-node")
+	cl, err := client.CheckAndDial(t.Ctx(), v.log, m.WSEndpoint(), rpc.WithHTTPAuth(gnode.NewJWTAuth(m.JWTSecret())))
+	require.NoError(t, err)
+	t.Cleanup(cl.Close)
 	bCl := client.NewBaseRPCClient(cl)
 	return syncnode.NewRPCSyncNode("action-tests-l2-verifier", bCl)
 }
@@ -358,13 +376,6 @@ func (s *L2Verifier) ActL1FinalizedSignal(t Testing) {
 	require.Equal(t, finalized, s.syncStatus.SyncStatus().FinalizedL1)
 }
 
-func (s *L2Verifier) ActInteropBackendCheck(t Testing) {
-	s.synchronousEvents.Emit(engine.CrossUpdateRequestEvent{
-		CrossUnsafe: true,
-		CrossSafe:   true,
-	})
-}
-
 func (s *L2Verifier) OnEvent(ev event.Event) bool {
 	switch x := ev.(type) {
 	case rollup.L1TemporaryErrorEvent:
@@ -436,3 +447,24 @@ func (s *L2Verifier) ActL2InsertUnsafePayload(payload *eth.ExecutionPayloadEnvel
 		require.NoError(t, err)
 	}
 }
+
+func (s *L2Verifier) AwaitSentCrossUnsafeUpdate(t Testing, minNum uint64) {
+	require.NotNil(t, s.InteropControl, "must be managed by op-supervisor")
+	require.NoError(t, s.InteropControl.AwaitSentCrossUnsafeUpdate(t.Ctx(), minNum))
+}
+
+func (s *L2Verifier) AwaitSentCrossSafeUpdate(t Testing, minNum uint64) {
+	require.NotNil(t, s.InteropControl, "must be managed by op-supervisor")
+	require.NoError(t, s.InteropControl.AwaitSentCrossSafeUpdate(t.Ctx(), minNum))
+}
+
+func (s *L2Verifier) AwaitSentFinalizedUpdate(t Testing, minNum uint64) {
+	require.NotNil(t, s.InteropControl, "must be managed by op-supervisor")
+	require.NoError(t, s.InteropControl.AwaitSentFinalizedUpdate(t.Ctx(), minNum))
+}
+
+func (s *L2Verifier) SyncSupervisor(t Testing) {
+	require.NotNil(t, s.InteropControl, "must be managed by op-supervisor")
+	_, err := s.InteropControl.PullEvents(t.Ctx())
+	require.NoError(t, err)
+}

op-e2e/actions/helpers/setups.go

@@ -29,7 +29,7 @@ func SetupSequencerTest(t Testing, sd *e2eutils.SetupData, log log.Logger, opts
 	l2Cl, err := sources.NewEngineClient(engine.RPCClient(), log, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
 	require.NoError(t, err)
 
-	sequencer := NewL2Sequencer(t, log.New("role", "sequencer"), l1F, miner.BlobStore(), altda.Disabled, l2Cl, sd.RollupCfg, 0, cfg.InteropBackend)
+	sequencer := NewL2Sequencer(t, log.New("role", "sequencer"), l1F, miner.BlobStore(), altda.Disabled, l2Cl, sd.RollupCfg, 0)
 	return miner, engine, sequencer
 }
 
@@ -42,7 +42,7 @@ func SetupVerifier(t Testing, sd *e2eutils.SetupData, log log.Logger,
 	jwtPath := e2eutils.WriteDefaultJWT(t)
 	engine := NewL2Engine(t, log.New("role", "verifier-engine"), sd.L2Cfg, jwtPath, EngineWithP2P())
 	engCl := engine.EngineClient(t, sd.RollupCfg)
-	verifier := NewL2Verifier(t, log.New("role", "verifier"), l1F, blobSrc, altda.Disabled, engCl, sd.RollupCfg, syncCfg, cfg.SafeHeadListener, cfg.InteropBackend)
+	verifier := NewL2Verifier(t, log.New("role", "verifier"), l1F, blobSrc, altda.Disabled, engCl, sd.RollupCfg, syncCfg, cfg.SafeHeadListener)
 	return engine, verifier
 }
 

op-e2e/actions/helpers/utils.go

@@ -4,7 +4,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-e2e/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-node/node/safedb"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/interop"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/node"
@@ -25,7 +24,6 @@ var DefaultAlloc = &e2eutils.AllocParams{PrefundTestUsers: true}
 
 type VerifierCfg struct {
 	SafeHeadListener safeDB
-	InteropBackend   interop.InteropBackend
 }
 
 type VerifierOpt func(opts *VerifierCfg)
@@ -36,12 +34,6 @@ func WithSafeHeadListener(l safeDB) VerifierOpt {
 	}
 }
 
-func WithInteropBackend(b interop.InteropBackend) VerifierOpt {
-	return func(opts *VerifierCfg) {
-		opts.InteropBackend = b
-	}
-}
-
 func DefaultVerifierCfg() *VerifierCfg {
 	return &VerifierCfg{
 		SafeHeadListener: safedb.Disabled,

op-e2e/actions/interop/interop.go

@@ -20,7 +20,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-e2e/actions/helpers"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/interop"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/optimism/op-service/sources"
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
@@ -104,17 +103,22 @@ func SetupInterop(t helpers.Testing) *InteropSetup {
 func (is *InteropSetup) CreateActors() *InteropActors {
 	l1Miner := helpers.NewL1Miner(is.T, is.Log.New("role", "l1Miner"), is.Out.L1.Genesis)
 	supervisorAPI := NewSupervisor(is.T, is.Log, is.DepSet)
+	supervisorAPI.backend.AttachL1Source(l1Miner.L1ClientSimple(is.T))
 	require.NoError(is.T, supervisorAPI.Start(is.T.Ctx()))
 	is.T.Cleanup(func() {
 		require.NoError(is.T, supervisorAPI.Stop(context.Background()))
 	})
-	chainA := createL2Services(is.T, is.Log, l1Miner, is.Keys, is.Out.L2s["900200"], supervisorAPI)
-	chainB := createL2Services(is.T, is.Log, l1Miner, is.Keys, is.Out.L2s["900201"], supervisorAPI)
+	chainA := createL2Services(is.T, is.Log, l1Miner, is.Keys, is.Out.L2s["900200"])
+	chainB := createL2Services(is.T, is.Log, l1Miner, is.Keys, is.Out.L2s["900201"])
 	// Hook up L2 RPCs to supervisor, to fetch event data from
 	srcA := chainA.Sequencer.InteropSyncNode(is.T)
 	srcB := chainB.Sequencer.InteropSyncNode(is.T)
-	require.NoError(is.T, supervisorAPI.backend.AttachSyncNode(is.T.Ctx(), srcA))
-	require.NoError(is.T, supervisorAPI.backend.AttachSyncNode(is.T.Ctx(), srcB))
+	nodeA, err := supervisorAPI.backend.AttachSyncNode(is.T.Ctx(), srcA, true)
+	require.NoError(is.T, err)
+	nodeB, err := supervisorAPI.backend.AttachSyncNode(is.T.Ctx(), srcB, true)
+	require.NoError(is.T, err)
+	chainA.Sequencer.InteropControl = nodeA
+	chainB.Sequencer.InteropControl = nodeB
 	return &InteropActors{
 		L1Miner:    l1Miner,
 		Supervisor: supervisorAPI,
@@ -128,19 +132,24 @@ type SupervisorActor struct {
 	backend *backend.SupervisorBackend
 	frontend.QueryFrontend
 	frontend.AdminFrontend
-	frontend.UpdatesFrontend
 }
 
 func (sa *SupervisorActor) SyncEvents(t helpers.Testing, chainID types.ChainID) {
 	require.NoError(t, sa.backend.SyncEvents(chainID))
 }
 
 func (sa *SupervisorActor) SyncCrossUnsafe(t helpers.Testing, chainID types.ChainID) {
-	require.NoError(t, sa.backend.SyncCrossUnsafe(chainID))
+	err := sa.backend.SyncCrossUnsafe(chainID)
+	if err != nil {
+		require.ErrorIs(t, err, types.ErrFuture)
+	}
 }
 
 func (sa *SupervisorActor) SyncCrossSafe(t helpers.Testing, chainID types.ChainID) {
-	require.NoError(t, sa.backend.SyncCrossSafe(chainID))
+	err := sa.backend.SyncCrossSafe(chainID)
+	if err != nil {
+		require.ErrorIs(t, err, types.ErrFuture)
+	}
 }
 
 func (sa *SupervisorActor) SyncFinalizedL1(t helpers.Testing, ref eth.BlockRef) {
@@ -185,9 +194,6 @@ func NewSupervisor(t helpers.Testing, logger log.Logger, depSet depset.Dependenc
 		AdminFrontend: frontend.AdminFrontend{
 			Supervisor: b,
 		},
-		UpdatesFrontend: frontend.UpdatesFrontend{
-			Supervisor: b,
-		},
 	}
 }
 
@@ -198,7 +204,6 @@ func createL2Services(
 	l1Miner *helpers.L1Miner,
 	keys devkeys.Keys,
 	output *interopgen.L2Output,
-	interopBackend interop.InteropBackend,
 ) *Chain {
 	logger = logger.New("chain", output.Genesis.Config.ChainID)
 
@@ -215,7 +220,7 @@ func createL2Services(
 
 	seq := helpers.NewL2Sequencer(t, logger.New("role", "sequencer"), l1F,
 		l1Miner.BlobStore(), altda.Disabled, seqCl, output.RollupCfg,
-		0, interopBackend)
+		0)
 
 	batcherKey, err := keys.Secret(devkeys.ChainOperatorKey{
 		ChainID: output.Genesis.Config.ChainID,