refactor(op-devstack): remove backward compatibility type aliases to align on single ComponentID type

op-acceptance-tests/tests/base/conductor/leadership_transfer_test.go

@@ -50,7 +50,7 @@ func TestConductorLeadershipTransfer(gt *testing.T) {
 
 		idToConductor := make(map[string]conductorWithInfo)
 		for _, conductor := range conductors {
-			conductorId := strings.TrimPrefix(conductor.String(), stack.ConductorKind.String()+"-")
+			conductorId := strings.TrimPrefix(conductor.String(), stack.KindConductor.String()+"-")
 			idToConductor[conductorId] = conductorWithInfo{conductor, consensus.ServerInfo{}}
 		}
 		for _, memberInfo := range membership.Servers {

op-acceptance-tests/tests/batcher/init_test.go

@@ -17,7 +17,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithNoDiscovery(),
 		presets.WithTimeTravel(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 
 			// set the blob max size to 40_000 bytes for test purposes

op-acceptance-tests/tests/batcher/throttling/init_test.go

@@ -18,7 +18,7 @@ func TestMain(m *testing.M) {
 	presets.DoMain(m,
 		presets.WithMinimal(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// Enable throttling with step controller for predictable behavior
 			cfg.ThrottleConfig.LowerThreshold = 99 // > 0 enables the throttling loop.
 			cfg.ThrottleConfig.UpperThreshold = 100

op-acceptance-tests/tests/depreqres/reqressyncdisabled/clsync/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithReqRespSyncDisabled(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/depreqres/reqressyncdisabled/divergence/divergence_test.go

@@ -21,7 +21,7 @@ func TestMain(m *testing.M) {
 		presets.WithExecutionLayerSyncOnVerifiers(),
 		presets.WithReqRespSyncDisabled(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/depreqres/reqressyncdisabled/elsync/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithReqRespSyncDisabled(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/depreqres/reqressyncdisabled/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithReqRespSyncDisabled(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/depreqres/syncmodereqressync/clsync/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithSyncModeReqRespSync(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/depreqres/syncmodereqressync/elsync/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithSyncModeReqRespSync(),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			cfg.Stopped = true
 		})),
 	)

op-acceptance-tests/tests/fusaka/init_test.go

@@ -24,7 +24,7 @@ func TestMain(m *testing.M) {
 			sysgo.WithForkAtL1Offset(forks.Osaka, 0),
 			sysgo.WithForkAtL1Offset(forks.BPO1, 1),
 		),
-		sysgo.WithBatcherOption(func(_ stack.L2BatcherID, cfg *batcher.CLIConfig) {
+		sysgo.WithBatcherOption(func(_ stack.ComponentID, cfg *batcher.CLIConfig) {
 			cfg.DataAvailabilityType = flags.BlobsType
 			cfg.TxMgrConfig.CellProofTime = 0 // Force cell proofs to be used
 		}),

op-acceptance-tests/tests/interop/seqwindow/init_test.go

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		// Short enough that we can run the test,
 		// long enough that the batcher can still submit something before we make things expire.
 		presets.WithSequencingWindow(10, 30),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// Span-batches during recovery don't appear to align well with the starting-point.
 			// It can be off by ~6 L2 blocks, possibly due to off-by-one
 			// in L1 block sync considerations in batcher stop or start.

op-acceptance-tests/tests/interop/sync/multisupervisor_interop/init_test.go

@@ -13,7 +13,7 @@ import (
 func TestMain(m *testing.M) {
 	presets.DoMain(m, presets.WithMultiSupervisorInterop(),
 		presets.WithLogFilter(logfilter.DefaultMute(
-			stack.KindSelector(stack.SupervisorKind).And(logfilter.Level(log.LevelInfo)).Show(),
+			stack.KindSelector(stack.KindSupervisor).And(logfilter.Level(log.LevelInfo)).Show(),
 			logfilter.Level(log.LevelError).Show(),
 		)))
 }

op-acceptance-tests/tests/sync/clsync/gap_clp2p/init_test.go

@@ -14,7 +14,7 @@ func TestMain(m *testing.M) {
 	// No ELP2P, CLP2P to control the supply of unsafe payload to the CL
 	presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For stopping derivation, not to advance safe heads
 			cfg.Stopped = true
 		})),

op-acceptance-tests/tests/sync/elsync/gap_clp2p/init_test.go

@@ -15,7 +15,7 @@ func TestMain(m *testing.M) {
 	presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(),
 		presets.WithExecutionLayerSyncOnVerifiers(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For stopping derivation, not to advance safe heads
 			cfg.Stopped = true
 		})),

op-acceptance-tests/tests/sync/elsync/gap_elp2p/init_test.go

@@ -14,7 +14,7 @@ func TestMain(m *testing.M) {
 	// No ELP2P, CLP2P to control the supply of unsafe payload to the CL
 	presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For stopping derivation, not to advance safe heads
 			cfg.Stopped = true
 		})),

op-acceptance-tests/tests/sync/manual/init_test.go

@@ -14,7 +14,7 @@ func TestMain(m *testing.M) {
 	// No ELP2P, CLP2P to control the supply of unsafe payload to the CL
 	presets.DoMain(m, presets.WithSingleChainMultiNodeWithoutP2P(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For stopping derivation, not to advance safe heads
 			cfg.Stopped = true
 		})),

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

@@ -16,7 +16,7 @@ func TestMain(m *testing.M) {
 		presets.WithSimpleWithSyncTester(),
 		presets.WithELSyncActive(),
 		presets.WithCompatibleTypes(compat.SysGo),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For stopping derivation, not to advance safe heads
 			cfg.Stopped = true
 		})),

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

@@ -17,7 +17,7 @@ func TestMain(m *testing.M) {
 		presets.WithCompatibleTypes(compat.SysGo),
 		presets.WithHardforkSequentialActivation(forks.Bedrock, forks.Jovian, 6),
 		presets.WithNoDiscovery(),
-		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.L2BatcherID, cfg *bss.CLIConfig) {
+		stack.MakeCommon(sysgo.WithBatcherOption(func(id stack.ComponentID, cfg *bss.CLIConfig) {
 			// For supporting pre-delta batches
 			cfg.BatchType = derive.SingularBatchType
 			// For supporting pre-Fjord batches

op-devstack/dsl/l2_cl.go

@@ -32,7 +32,7 @@ func NewL2CLNode(inner stack.L2CLNode, control stack.ControlPlane) *L2CLNode {
 	}
 }
 
-func (cl *L2CLNode) ID() stack.L2CLNodeID {
+func (cl *L2CLNode) ID() stack.ComponentID {
 	return cl.inner.ID()
 }
 

op-devstack/dsl/l2_el.go

@@ -45,7 +45,7 @@ func (el *L2ELNode) Escape() stack.L2ELNode {
 	return el.inner
 }
 
-func (el *L2ELNode) ID() stack.L2ELNodeID {
+func (el *L2ELNode) ID() stack.ComponentID {
 	return el.inner.ID()
 }
 

op-devstack/example/init_test.go

@@ -16,9 +16,9 @@ func TestMain(m *testing.M) {
 		// Logging can be adjusted with filters globally
 		presets.WithPkgLogFilter(
 			logfilter.DefaultShow( // Random configuration
-				stack.KindSelector(stack.L2ProposerKind).Mute(),
-				stack.KindSelector(stack.L2BatcherKind).And(logfilter.Level(log.LevelError)).Show(),
-				stack.KindSelector(stack.L2CLNodeKind).Mute(),
+				stack.KindSelector(stack.KindL2Proposer).Mute(),
+				stack.KindSelector(stack.KindL2Batcher).And(logfilter.Level(log.LevelError)).Show(),
+				stack.KindSelector(stack.KindL2CLNode).Mute(),
 			),
 			// E.g. allow test interactions through while keeping background resource logs quiet
 		),

op-devstack/presets/cl_config.go

@@ -10,15 +10,15 @@ import (
 func WithExecutionLayerSyncOnVerifiers() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.VerifierSyncMode = sync.ELSync
 			})))
 }
 
 func WithConsensusLayerSync() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.SequencerSyncMode = sync.CLSync
 				cfg.VerifierSyncMode = sync.CLSync
 			})))
@@ -27,15 +27,15 @@ func WithConsensusLayerSync() stack.CommonOption {
 func WithSafeDBEnabled() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(p devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(p devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.SafeDBPath = p.TempDir()
 			})))
 }
 
 func WithReqRespSyncDisabled() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.EnableReqRespSync = false
 				cfg.UseReqRespSync = false
 			})))
@@ -44,15 +44,15 @@ func WithReqRespSyncDisabled() stack.CommonOption {
 func WithSyncModeReqRespSync() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.UseReqRespSync = true
 			})))
 }
 
 func WithNoDiscovery() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalL2CLOption(sysgo.L2CLOptionFn(
-			func(_ devtest.P, id stack.L2CLNodeID, cfg *sysgo.L2CLConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.L2CLConfig) {
 				cfg.NoDiscovery = true
 			})))
 }

op-devstack/presets/minimal_with_conductors.go

@@ -14,7 +14,7 @@ import (
 type MinimalWithConductors struct {
 	*Minimal
 
-	ConductorSets map[stack.L2NetworkID]dsl.ConductorSet
+	ConductorSets map[stack.ComponentID]dsl.ConductorSet
 }
 
 // TODO(#16418): shift this to a different sysgo constructor once the sysgo implementation supports conductors
@@ -34,7 +34,7 @@ func NewMinimalWithConductors(t devtest.T) *MinimalWithConductors {
 	orch := Orchestrator()
 	orch.Hydrate(system)
 	chains := system.L2Networks()
-	conductorSets := make(map[stack.L2NetworkID]dsl.ConductorSet)
+	conductorSets := make(map[stack.ComponentID]dsl.ConductorSet)
 	for _, chain := range chains {
 		chainMatcher := match.L2ChainById(chain.ID())
 		l2 := system.L2Network(match.Assume(t, chainMatcher))

op-devstack/presets/op_rbuilder_rules.go

@@ -13,7 +13,7 @@ import (
 func WithOPRBuilderRules(ruleContent string, refreshInterval uint64) stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalOPRBuilderNodeOption(sysgo.OPRBuilderNodeOptionFn(
-			func(p devtest.P, id stack.OPRBuilderNodeID, cfg *sysgo.OPRBuilderNodeConfig) {
+			func(p devtest.P, id stack.ComponentID, cfg *sysgo.OPRBuilderNodeConfig) {
 				cfg.RulesEnabled = true
 				// Create a fixed directory for rules config
 				rulesDir := filepath.Join(os.TempDir(), "rules")

op-devstack/presets/proof.go

@@ -75,7 +75,7 @@ func RequireRespectedGameType(gameType gameTypes.GameType) stack.CommonOption {
 func WithProposerGameType(gameType gameTypes.GameType) stack.CommonOption {
 	return stack.Combine(
 		stack.MakeCommon(
-			sysgo.WithProposerOption(func(id stack.L2ProposerID, cfg *ps.CLIConfig) {
+			sysgo.WithProposerOption(func(id stack.ComponentID, cfg *ps.CLIConfig) {
 				cfg.DisputeGameType = uint32(gameType)
 			})))
 }

op-devstack/presets/singlechain_multinode.go

@@ -40,12 +40,12 @@ func NewSingleChainMultiNodeWithoutCheck(t devtest.T) *SingleChainMultiNode {
 	verifierCL := l2.L2CLNode(match.Assume(t,
 		match.And(
 			match.Not(match.WithSequencerActive(t.Ctx())),
-			match.Not[stack.L2CLNodeID, stack.L2CLNode](minimal.L2CL.ID()),
+			match.Not(stack.ByID[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()))))
+			match.Not(stack.ByID[stack.L2ELNode](minimal.L2EL.ID())))))
 	preset := &SingleChainMultiNode{
 		Minimal: *minimal,
 		L2ELB:   dsl.NewL2ELNode(verifierEL, orch.ControlPlane()),
@@ -73,12 +73,12 @@ func NewSingleChainMultiNodeWithTestSeq(t devtest.T) *SingleChainMultiNodeWithTe
 	verifierCL := l2.L2CLNode(match.Assume(t,
 		match.And(
 			match.Not(match.WithSequencerActive(t.Ctx())),
-			match.Not[stack.L2CLNodeID, stack.L2CLNode](minimal.L2CL.ID()),
+			match.Not(stack.ByID[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()))))
+			match.Not(stack.ByID[stack.L2ELNode](minimal.L2EL.ID())))))
 	preset := &SingleChainMultiNode{
 		Minimal: *minimal,
 		L2ELB:   dsl.NewL2ELNode(verifierEL, orch.ControlPlane()),

op-devstack/presets/singlechain_twoverifiers.go

@@ -27,13 +27,13 @@ func NewSingleChainTwoVerifiersWithoutCheck(t devtest.T) *SingleChainTwoVerifier
 	verifierCL := l2.L2CLNode(match.Assume(t,
 		match.And(
 			match.Not(match.WithSequencerActive(t.Ctx())),
-			match.Not[stack.L2CLNodeID, stack.L2CLNode](singleChainMultiNode.L2CL.ID()),
-			match.Not[stack.L2CLNodeID, stack.L2CLNode](singleChainMultiNode.L2CLB.ID()),
+			match.Not(stack.ByID[stack.L2CLNode](singleChainMultiNode.L2CL.ID())),
+			match.Not(stack.ByID[stack.L2CLNode](singleChainMultiNode.L2CLB.ID())),
 		)))
 	verifierEL := l2.L2ELNode(match.Assume(t,
 		match.And(
-			match.Not[stack.L2ELNodeID, stack.L2ELNode](singleChainMultiNode.L2EL.ID()),
-			match.Not[stack.L2ELNodeID, stack.L2ELNode](singleChainMultiNode.L2ELB.ID()),
+			match.Not(stack.ByID[stack.L2ELNode](singleChainMultiNode.L2EL.ID())),
+			match.Not(stack.ByID[stack.L2ELNode](singleChainMultiNode.L2ELB.ID())),
 		)))
 	preset := &SingleChainTwoVerifiers{
 		SingleChainMultiNode: *singleChainMultiNode,

op-devstack/presets/sync_tester_config.go

@@ -10,15 +10,15 @@ import (
 func WithSyncTesterELInitialState(fcu eth.FCUState) stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalSyncTesterELOption(sysgo.SyncTesterELOptionFn(
-			func(_ devtest.P, id stack.L2ELNodeID, cfg *sysgo.SyncTesterELConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.SyncTesterELConfig) {
 				cfg.FCUState = fcu
 			})))
 }
 
 func WithELSyncActive() stack.CommonOption {
 	return stack.MakeCommon(
 		sysgo.WithGlobalSyncTesterELOption(sysgo.SyncTesterELOptionFn(
-			func(_ devtest.P, id stack.L2ELNodeID, cfg *sysgo.SyncTesterELConfig) {
+			func(_ devtest.P, id stack.ComponentID, cfg *sysgo.SyncTesterELConfig) {
 				cfg.ELSyncActive = true
 			})))
 }

op-devstack/presets/twol2_follow_l2.go

@@ -41,17 +41,17 @@ func NewTwoL2SupernodeFollowL2(t devtest.T, delaySeconds uint64) *TwoL2Supernode
 	followerELBID := stack.NewL2ELNodeID("follower", l2b.ID().ChainID())
 	followerCLBID := stack.NewL2CLNodeID("follower", l2b.ID().ChainID())
 
-	followerELA := l2a.L2ELNode(match.MatchElemFn[stack.L2ELNodeID, stack.L2ELNode](func(elem stack.L2ELNode) bool {
+	followerELA := l2a.L2ELNode(match.MatchElemFn[stack.L2ELNode](func(elem stack.L2ELNode) bool {
 		return elem.ID() == followerELAID
 	}))
-	followerCLA := l2a.L2CLNode(match.MatchElemFn[stack.L2CLNodeID, stack.L2CLNode](func(elem stack.L2CLNode) bool {
+	followerCLA := l2a.L2CLNode(match.MatchElemFn[stack.L2CLNode](func(elem stack.L2CLNode) bool {
 		return elem.ID() == followerCLAID
 	}))
 
-	followerELB := l2b.L2ELNode(match.MatchElemFn[stack.L2ELNodeID, stack.L2ELNode](func(elem stack.L2ELNode) bool {
+	followerELB := l2b.L2ELNode(match.MatchElemFn[stack.L2ELNode](func(elem stack.L2ELNode) bool {
 		return elem.ID() == followerELBID
 	}))
-	followerCLB := l2b.L2CLNode(match.MatchElemFn[stack.L2CLNodeID, stack.L2CLNode](func(elem stack.L2CLNode) bool {
+	followerCLB := l2b.L2CLNode(match.MatchElemFn[stack.L2CLNode](func(elem stack.L2CLNode) bool {
 		return elem.ID() == followerCLBID
 	}))
 

op-devstack/shim/cluster.go

@@ -9,14 +9,14 @@ import (
 type ClusterConfig struct {
 	CommonConfig
 	DependencySet depset.DependencySet
-	ID            stack.ClusterID
+	ID            stack.ComponentID
 }
 
 // presetCluster implements Cluster with preset values
 type presetCluster struct {
 	commonImpl
 	depSet depset.DependencySet
-	id     stack.ClusterID
+	id     stack.ComponentID
 }
 
 var _ stack.Cluster = (*presetCluster)(nil)
@@ -30,7 +30,7 @@ func NewCluster(cfg ClusterConfig) stack.Cluster {
 	}
 }
 
-func (p *presetCluster) ID() stack.ClusterID {
+func (p *presetCluster) ID() stack.ComponentID {
 	return p.id
 }