sysgo

package

Go to main page

Versions in this module

v1

v1.18.1

May 14, 2026

Changes in this version

type PresetConfig

+ SkipHonestProposer bool

v1.18.0

May 6, 2026

Changes in this version

type L1Network

+ func (n *L1Network) Genesis() *core.Genesis

type MixedL2ELKind

+ const MixedL2ELOpRethV2

type MixedSingleChainPresetConfig

+ BatcherOptions []BatcherOption

+ OpRethOptions []OpRethOption

+ type OpRethConfig struct

+ ExtraArgs []string

+ func DefaultOpRethConfig() *OpRethConfig

+ type OpRethOption interface

+ Apply func(p devtest.T, target ComponentTarget, cfg *OpRethConfig)

+ func OpRethWithExtraArgs(args ...string) OpRethOption

+ func OpRethWithSDMEnabled() OpRethOption

+ func OpRethWithSupervisorURL(supervisorURL string) OpRethOption

+ type OpRethOptionBundle []OpRethOption

+ func (b OpRethOptionBundle) Apply(p devtest.T, target ComponentTarget, cfg *OpRethConfig)

+ type OpRethOptionFn func(p devtest.T, target ComponentTarget, cfg *OpRethConfig)

+ func (fn OpRethOptionFn) Apply(p devtest.T, target ComponentTarget, cfg *OpRethConfig)

type SingleChainRuntime

+ func (r *SingleChainRuntime) VMConfig(t devtest.T, dir string) *vm.Config

v1.17.0

Apr 28, 2026

Changes in this version

+ func ZKDisputeGameConfigForRuntime(t devtest.CommonT) *embedded.ZKDisputeGameConfig

v1.16.13

Apr 16, 2026

v1.16.12

Apr 9, 2026

v1.16.11

Apr 1, 2026

Changes in this version

+ func SkipUnlessOpGeth(t devtest.T, reason string)

v1.16.10

Mar 25, 2026

Changes in this version

+ const DevstackL2ELKindEnvVar

v1.16.9

Mar 18, 2026

Changes in this version

+ type PresetOption interface

+ func WithOPRBuilderOption(opt OPRBuilderNodeOption) PresetOption

+ func WithRespectedGameTypeOverride(gameType gameTypes.GameType) PresetOption

+ func WithTimeTravelEnabled() PresetOption

v1.16.7

Feb 19, 2026

Changes in this version

+ func DefaultMinimalInteropSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator]

+ func DefaultSupernodeInteropProofsSystem(dest *DefaultSupernodeInteropProofsSystemIDs) stack.Option[*Orchestrator]

+ func DefaultSupernodeInteropTwoL2System(dest *DefaultTwoL2SystemIDs, delaySeconds uint64) stack.Option[*Orchestrator]

+ func DefaultSupernodeIsthmusSuperProofsSystem(dest *DefaultSupernodeInteropProofsSystemIDs) stack.Option[*Orchestrator]

+ func WithSharedSupernodeCLsInterop(supernodeID stack.SupernodeID, cls []L2CLs, l1CLID stack.L1CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithSharedSupernodeCLsInteropDelayed(supernodeID stack.SupernodeID, cls []L2CLs, l1CLID stack.L1CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithSuperRootsFromSupernode(l1ChainID eth.ChainID, l1ELID stack.L1ELNodeID, clIDs []stack.L2CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithSupernode(supernodeID stack.SupernodeID, l2CLID stack.L2CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithSupernodeL2Challenger(challengerID stack.L2ChallengerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithSupernodeProposer(proposerID stack.L2ProposerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ type DefaultSupernodeInteropProofsSystemIDs struct

+ Supernode stack.SupernodeID

+ func NewDefaultSupernodeInteropProofsSystemIDs(l1ID, l2AID, l2BID eth.ChainID) DefaultSupernodeInteropProofsSystemIDs

type DefaultTwoL2SystemIDs

+ Supernode stack.SupernodeID

type Orchestrator

+ func (o *Orchestrator) InteropTestControl(id stack.SupernodeID) stack.InteropTestControl

type SuperNode

+ func (n *SuperNode) PauseInteropActivity(ts uint64)

+ func (n *SuperNode) ResumeInteropActivity()

v1.16.6

Jan 19, 2026

v1.16.5

Jan 13, 2026

Changes in this version

+ func WithKonaNodeFollowL2(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

v1.16.4

Dec 18, 2025

Changes in this version

+ func DefaultSingleChainTwoVerifiersFollowL2System(dest *DefaultSingleChainTwoVerifiersSystemIDs) stack.Option[*Orchestrator]

+ func EnsureRustBinary(p devtest.P, spec RustBinarySpec) (string, error)

+ func WithL2CLNodeFollowL2(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithOpNodeFollowL2(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

type DefaultSingleChainTwoVerifiersSystemIDs

+ TestSequencer stack.TestSequencerID

+ type RustBinarySpec struct

+ Binary string

+ Package string

+ SrcDir string

v1.16.3

Dec 4, 2025

Changes in this version

+ func DefaultSingleChainSystemWithFlashblocks(dest *SingleChainSystemWithFlashblocksIDs) stack.Option[*Orchestrator]

+ func DefaultSingleChainTwoVerifiersSystem(dest *DefaultSingleChainTwoVerifiersSystemIDs) stack.Option[*Orchestrator]

+ func WithChallengerCannonKonaEnabled() stack.Option[*Orchestrator]

+ func WithGameTypeAdded(gameType gameTypes.GameType) stack.Option[*Orchestrator]

+ func WithOPRBuilderNode(id stack.OPRBuilderNodeID, opts ...OPRBuilderNodeOption) stack.Option[*Orchestrator]

+ func WithRespectedGameType(gameType gameTypes.GameType) stack.Option[*Orchestrator]

+ func WithRollupBoost(id stack.RollupBoostNodeID, l2ELID stack.L2ELNodeID, opts ...RollupBoostOption) stack.Option[*Orchestrator]

type ControlPlane

+ func (c *ControlPlane) OPRBuilderNodeState(id stack.OPRBuilderNodeID, mode stack.ControlAction)

+ func (c *ControlPlane) RollupBoostNodeState(id stack.RollupBoostNodeID, mode stack.ControlAction)

+ type DefaultSingleChainTwoVerifiersSystemIDs struct

+ L2CLC stack.L2CLNodeID

+ L2ELC stack.L2ELNodeID

+ func NewDefaultSingleChainTwoVerifiersSystemIDs(l1ID, l2ID eth.ChainID) DefaultSingleChainTwoVerifiersSystemIDs

type ELNodeIdentity

+ Enode string

type L2CLConfig

+ SequencerUnsafeOnly bool

+ VerifierUnsafeOnly bool

type L2CLOption

+ func L2CLVerifierDisableUnsafeOnly() L2CLOption

type Orchestrator

+ func (o *Orchestrator) GetL2EL(id stack.L2ELNodeID) (L2ELNode, bool)

+ type RollupBoostOption interface

+ Apply func(orch *Orchestrator, id stack.RollupBoostNodeID, cfg *RollupBoostConfig)

+ func RollupBoostWithBuilderNode(id stack.OPRBuilderNodeID) RollupBoostOption

+ func RollupBoostWithEnv(env ...string) RollupBoostOption

+ func RollupBoostWithExecutionMode(mode string) RollupBoostOption

+ func RollupBoostWithExtraArgs(args ...string) RollupBoostOption

+ func RollupBoostWithFlashblocksDisabled() RollupBoostOption

+ type RollupBoostOptionBundle []RollupBoostOption

+ func (b RollupBoostOptionBundle) Apply(orch *Orchestrator, id stack.RollupBoostNodeID, cfg *RollupBoostConfig)

+ type RollupBoostOptionFn func(orch *Orchestrator, id stack.RollupBoostNodeID, cfg *RollupBoostConfig)

+ func (fn RollupBoostOptionFn) Apply(orch *Orchestrator, id stack.RollupBoostNodeID, cfg *RollupBoostConfig)

+ type SingleChainSystemWithFlashblocksIDs struct

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2 stack.L2NetworkID

+ L2Batcher stack.L2BatcherID

+ L2Builder stack.OPRBuilderNodeID

+ L2CL stack.L2CLNodeID

+ L2Challenger stack.L2ChallengerID

+ L2EL stack.L2ELNodeID

+ L2Proposer stack.L2ProposerID

+ L2RollupBoost stack.RollupBoostNodeID

+ TestSequencer stack.TestSequencerID

+ func NewDefaultSingleChainSystemWithFlashblocksIDs(l1ID, l2ID eth.ChainID) SingleChainSystemWithFlashblocksIDs

v1.16.2

Nov 14, 2025

Changes in this version

+ func WithCannonKonaGameTypeAdded() stack.Option[*Orchestrator]

+ func WithEmptyDepSet(l2NetworkID stack.L2NetworkID, networkName string) stack.Option[*Orchestrator]

type DeployerOption

+ func WithRevenueShare(enabled bool, chainFeesRecipient common.Address) DeployerOption

v1.16.1

Nov 4, 2025

Changes in this version

+ func WithL2MetricsDashboard() stack.Option[*Orchestrator]

+ type L2MetricsDashboard struct

+ func (g *L2MetricsDashboard) Start()

+ func (g *L2MetricsDashboard) Stop()

type Orchestrator

+ func (o *Orchestrator) RegisterL2MetricsTargets(id stack.IDWithChain, endpoints ...PrometheusMetricsTarget)

v1.16.0

Oct 28, 2025

v1.14.3

Oct 23, 2025

Changes in this version

+ func DefaultSingleChainMultiNodeWithTestSeqSystem(dest *DefaultSingleChainMultiNodeWithTestSeqSystemIDs) stack.Option[*Orchestrator]

+ func DefaultSupernodeTwoL2System(dest *DefaultTwoL2SystemIDs) stack.Option[*Orchestrator]

+ func DefaultTwoL2System(dest *DefaultTwoL2SystemIDs) stack.Option[*Orchestrator]

+ func ProofSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator]

+ func WithCannonGameTypeAdded(l1ELID stack.L1ELNodeID, l2ChainID eth.ChainID) stack.Option[*Orchestrator]

+ func WithSharedSupernodeCLs(cls []L2CLs, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID) stack.Option[*Orchestrator]

+ func WithSuperNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ type DefaultSingleChainMultiNodeWithTestSeqSystemIDs struct

+ TestSequencer stack.TestSequencerID

+ func NewDefaultSingleChainMultiNodeWithTestSeqSystemIDs(l1ID, l2ID eth.ChainID) DefaultSingleChainMultiNodeWithTestSeqSystemIDs

+ type DefaultTwoL2SystemIDs struct

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2A stack.L2NetworkID

+ L2ABatcher stack.L2BatcherID

+ L2ACL stack.L2CLNodeID

+ L2AEL stack.L2ELNodeID

+ L2AProposer stack.L2ProposerID

+ L2B stack.L2NetworkID

+ L2BBatcher stack.L2BatcherID

+ L2BCL stack.L2CLNodeID

+ L2BEL stack.L2ELNodeID

+ L2BProposer stack.L2ProposerID

+ func NewDefaultTwoL2SystemIDs(l1ID, l2AID, l2BID eth.ChainID) DefaultTwoL2SystemIDs

+ type L2CLs struct

+ CLID stack.L2CLNodeID

+ ELID stack.L2ELNodeID

v1.14.1

Oct 8, 2025

v1.14.0

Oct 7, 2025

Changes in this version

+ func DefaultSingleChainMultiNodeSystemWithoutP2P(dest *DefaultSingleChainMultiNodeSystemIDs) stack.Option[*Orchestrator]

+ func WithExtL2Node(id stack.L2ELNodeID, elRPCEndpoint string) stack.Option[*Orchestrator]

+ func WithL1NodesInProcess(l1ELID stack.L1ELNodeID, l1CLID stack.L1CLNodeID) stack.Option[*Orchestrator]

+ func WithL1NodesSubprocess(id stack.L1ELNodeID, clID stack.L1CLNodeID) stack.Option[*Orchestrator]

type DefaultMinimalExternalELSystemIDs

+ L2ELReadOnly stack.L2ELNodeID

+ type ExternalL1Geth struct

+ func (n *ExternalL1Geth) AuthRPC() string

+ func (n *ExternalL1Geth) Start()

+ func (n *ExternalL1Geth) Stop()

+ func (n *ExternalL1Geth) UserRPC() string

v1.13.7

Sep 19, 2025

Changes in this version

+ func ExternalELSystemWithEndpointAndSuperchainRegistry(dest *DefaultMinimalExternalELSystemIDs, networkPreset stack.ExtNetworkConfig) stack.Option[*Orchestrator]

+ func WithExtL1Nodes(l1ELID stack.L1ELNodeID, l1CLID stack.L1CLNodeID, elRPCEndpoint string, ...) stack.Option[*Orchestrator]

+ func WithGlobalSyncTesterELOption(opt SyncTesterELOption) stack.Option[*Orchestrator]

+ func WithL2NetworkFromSuperchainRegistry(l2NetworkID stack.L2NetworkID, networkName string) stack.Option[*Orchestrator]

+ func WithL2NetworkFromSuperchainRegistryWithDependencySet(l2NetworkID stack.L2NetworkID, networkName string) stack.Option[*Orchestrator]

+ func WithSyncTesterWithExternalEndpoint(syncTesterID stack.SyncTesterID, endpointRPC string, chainID eth.ChainID) stack.Option[*Orchestrator]

+ type DefaultMinimalExternalELSystemIDs struct

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2 stack.L2NetworkID

+ L2CL stack.L2CLNodeID

+ L2EL stack.L2ELNodeID

+ SyncTester stack.SyncTesterID

+ func NewExternalELSystemIDs(l1ID, l2ID eth.ChainID) DefaultMinimalExternalELSystemIDs

type DeployerOption

+ func WithDevFeatureBitmap(devFlags common.Hash) DeployerOption

type Orchestrator

+ SyncTesterELOptions SyncTesterELOptionBundle

type SyncTesterELConfig

+ ELSyncTarget uint64

v1.13.6

Sep 2, 2025

Changes in this version

+ func DefaultIsthmusSuperProofsSystem(dest *DefaultInteropSystemIDs) stack.Option[*Orchestrator]

+ func DefaultMinimalSystemWithSyncTester(dest *DefaultMinimalSystemWithSyncTesterIDs, fcu eth.FCUState) stack.Option[*Orchestrator]

+ func DefaultSimpleSystemWithSyncTester(dest *DefaultSimpleSystemWithSyncTesterIDs, fcu eth.FCUState) stack.Option[*Orchestrator]

+ func WithGlobalL2CLOption(opt L2CLOption) stack.Option[*Orchestrator]

+ func WithGlobalL2ELOption(opt L2ELOption) stack.Option[*Orchestrator]

+ func WithKonaNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithKonaSupervisor(supervisorID stack.SupervisorID, clusterID stack.ClusterID, ...) stack.Option[*Orchestrator]

+ func WithOPSupervisor(supervisorID stack.SupervisorID, clusterID stack.ClusterID, ...) stack.Option[*Orchestrator]

+ func WithOpGeth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestrator]

+ func WithOpNode(l2CLID stack.L2CLNodeID, l1CLID stack.L1CLNodeID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithOpReth(id stack.L2ELNodeID, opts ...L2ELOption) stack.Option[*Orchestrator]

+ func WithSyncTester(syncTesterID stack.SyncTesterID, l2ELs []stack.L2ELNodeID) stack.Option[*Orchestrator]

+ func WithSyncTesterL2ELNode(id, readonlyEL stack.L2ELNodeID, fcuState eth.FCUState, opts ...L2ELOption) stack.Option[*Orchestrator]

+ type DefaultMinimalSystemWithSyncTesterIDs struct

+ SyncTester stack.SyncTesterID

+ func NewDefaultMinimalSystemWithSyncTesterIDs(l1ID, l2ID eth.ChainID) DefaultMinimalSystemWithSyncTesterIDs

+ type DefaultSimpleSystemWithSyncTesterIDs struct

+ L2CL2 stack.L2CLNodeID

+ SyncTester stack.SyncTesterID

+ SyncTesterL2EL stack.L2ELNodeID

+ func NewDefaultSimpleSystemWithSyncTesterIDs(l1ID, l2ID eth.ChainID) DefaultSimpleSystemWithSyncTesterIDs

type L2ELConfig

+ SupervisorID *stack.SupervisorID

type L2ELOption

+ func L2ELWithSupervisor(supervisorID stack.SupervisorID) L2ELOption

type SubProcess

+ func (sp *SubProcess) GracefulStop(ctx context.Context) error

+ func (sp *SubProcess) Kill() error

+ func (sp *SubProcess) Wait(ctx context.Context) error

v1.13.5

Jul 11, 2025

Changes in this version

+ func DefaultSingleChainMultiNodeSystem(dest *DefaultSingleChainMultiNodeSystemIDs) stack.Option[*Orchestrator]

+ func WithL2CLOption(opt L2CLOption) stack.Option[*Orchestrator]

+ func WithL2ELP2PConnection(l2EL1ID, l2EL2ID stack.L2ELNodeID) stack.Option[*Orchestrator]

type ControlPlane

+ func (c *ControlPlane) L2ELNodeState(id stack.L2ELNodeID, mode stack.ControlAction)

type DefaultMinimalSystemIDs

+ L2Challenger stack.L2ChallengerID

+ type DefaultSingleChainMultiNodeSystemIDs struct

+ L2CLB stack.L2CLNodeID

+ L2ELB stack.L2ELNodeID

+ func NewDefaultSingleChainMultiNodeSystemIDs(l1ID, l2ID eth.ChainID) DefaultSingleChainMultiNodeSystemIDs

type L2ELNode

+ func (n *L2ELNode) Start()

+ func (n *L2ELNode) Stop()

v1.13.4

Jun 17, 2025

Changes in this version

+ func DefaultInteropProofsSystem(dest *DefaultInteropSystemIDs) stack.Option[*Orchestrator]

+ func DefaultMinimalSystem(dest *DefaultMinimalSystemIDs) stack.Option[*Orchestrator]

+ func DefaultSingleChainInteropSystem(dest *DefaultSingleChainInteropSystemIDs) stack.Option[*Orchestrator]

+ func MultiSupervisorInteropSystem(dest *MultiSupervisorInteropSystemIDs) stack.Option[*Orchestrator]

+ func WithBatcherOption(opt BatcherOption) stack.Option[*Orchestrator]

+ func WithDeployerPipelineOption(opt DeployerPipelineOption) stack.Option[*Orchestrator]

+ func WithL2Challenger(challengerID stack.L2ChallengerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithL2ChallengerPostDeploy(orch *Orchestrator, challengerID stack.L2ChallengerID, l1ELID stack.L1ELNodeID, ...)

+ func WithProposerOption(opt ProposerOption) stack.Option[*Orchestrator]

+ func WithProposerPostDeploy(orch *Orchestrator, proposerID stack.L2ProposerID, l1ELID stack.L1ELNodeID, ...)

+ func WithSuperL2Challenger(challengerID stack.L2ChallengerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithSuperProposer(proposerID stack.L2ProposerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithSuperRoots(l1ChainID eth.ChainID, l1ELID stack.L1ELNodeID, l2CLID stack.L2CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithTestSequencer(testSequencerID stack.TestSequencerID, l1CLID stack.L1CLNodeID, ...) stack.Option[*Orchestrator]

type Cluster

+ func (c *Cluster) DepSet() *depset.StaticConfigDependencySet

type ControlPlane

+ func (c *ControlPlane) FakePoSState(id stack.L1CLNodeID, mode stack.ControlAction)

type DefaultInteropSystemIDs

+ L2ChallengerB stack.L2ChallengerID

+ type DefaultMinimalSystemIDs struct

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2 stack.L2NetworkID

+ L2Batcher stack.L2BatcherID

+ L2CL stack.L2CLNodeID

+ L2EL stack.L2ELNodeID

+ L2Proposer stack.L2ProposerID

+ TestSequencer stack.TestSequencerID

+ func NewDefaultMinimalSystemIDs(l1ID, l2ID eth.ChainID) DefaultMinimalSystemIDs

+ type DefaultSingleChainInteropSystemIDs struct

+ Cluster stack.ClusterID

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2A stack.L2NetworkID

+ L2ABatcher stack.L2BatcherID

+ L2ACL stack.L2CLNodeID

+ L2AEL stack.L2ELNodeID

+ L2AProposer stack.L2ProposerID

+ L2ChallengerA stack.L2ChallengerID

+ Superchain stack.SuperchainID

+ Supervisor stack.SupervisorID

+ TestSequencer stack.TestSequencerID

+ func NewDefaultSingleChainInteropSystemIDs(l1ID, l2AID eth.ChainID) DefaultSingleChainInteropSystemIDs

type DeployerOption

+ func WithAdditionalDisputeGames(games []state.AdditionalDisputeGame) DeployerOption

+ type InteropMigration struct

+ DisputeGameFactory common.Address

+ type MultiSupervisorInteropSystemIDs struct

+ L2A2CL stack.L2CLNodeID

+ L2A2EL stack.L2ELNodeID

+ L2B2CL stack.L2CLNodeID

+ L2B2EL stack.L2ELNodeID

+ SupervisorSecondary stack.SupervisorID

type Orchestrator

+ func (o *Orchestrator) ClusterForL2(chainID eth.ChainID) (*Cluster, bool)

+ func (o *Orchestrator) EnableTimeTravel()

+ func (o *Orchestrator) Type() compat.Type

+ type TestSequencer struct

v1.13.3

May 15, 2025

Changes in this version

+ func DefaultInteropSystem(dest *DefaultInteropSystemIDs) stack.Option[*Orchestrator]

+ func DisconnectL2CLP2P(l2CL1ID, l2CL2ID stack.L2CLNodeID) stack.Option[*Orchestrator]

+ func RedundantInteropSystem(dest *RedundantInteropSystemIDs) stack.Option[*Orchestrator]

+ func WithBatcher(batcherID stack.L2BatcherID, l1ELID stack.L1ELNodeID, l2CLID stack.L2CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithDeployer() stack.Option[*Orchestrator]

+ func WithDeployerOptions(opts ...DeployerOption) stack.Option[*Orchestrator]

+ func WithFaucets(l1ELs []stack.L1ELNodeID, l2ELs []stack.L2ELNodeID) stack.Option[*Orchestrator]

+ func WithInteropGen(l1ID stack.L1NetworkID, superchainID stack.SuperchainID, ...) stack.Option[*Orchestrator]

+ func WithL1Nodes(l1ELID stack.L1ELNodeID, l1CLID stack.L1CLNodeID) stack.Option[*Orchestrator]

+ func WithL2CLNode(l2CLID stack.L2CLNodeID, isSequencer bool, l1CLID stack.L1CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithL2CLP2PConnection(l2CL1ID, l2CL2ID stack.L2CLNodeID) stack.Option[*Orchestrator]

+ func WithL2ELNode(id stack.L2ELNodeID, supervisorID *stack.SupervisorID) stack.Option[*Orchestrator]

+ func WithManagedBySupervisor(l2CLID stack.L2CLNodeID, supervisorID stack.SupervisorID) stack.Option[*Orchestrator]

+ func WithMnemonicKeys(mnemonic string) stack.Option[*Orchestrator]

+ func WithProposer(proposerID stack.L2ProposerID, l1ELID stack.L1ELNodeID, ...) stack.Option[*Orchestrator]

+ func WithSequencer(sequencerID stack.SequencerID, l2CLID stack.L2CLNodeID, ...) stack.Option[*Orchestrator]

+ func WithSupervisor(supervisorID stack.SupervisorID, clusterID stack.ClusterID, ...) stack.Option[*Orchestrator]

+ type Cluster struct

+ type ControlPlane struct

+ func (c *ControlPlane) L2CLNodeState(id stack.L2CLNodeID, mode stack.ControlAction)

+ func (c *ControlPlane) SupervisorState(id stack.SupervisorID, mode stack.ControlAction)

+ type DefaultInteropSystemIDs struct

+ Cluster stack.ClusterID

+ L1 stack.L1NetworkID

+ L1CL stack.L1CLNodeID

+ L1EL stack.L1ELNodeID

+ L2A stack.L2NetworkID

+ L2ABatcher stack.L2BatcherID

+ L2ACL stack.L2CLNodeID

+ L2AEL stack.L2ELNodeID

+ L2AProposer stack.L2ProposerID

+ L2B stack.L2NetworkID

+ L2BBatcher stack.L2BatcherID

+ L2BCL stack.L2CLNodeID

+ L2BEL stack.L2ELNodeID

+ L2BProposer stack.L2ProposerID

+ Sequencer stack.SequencerID

+ Superchain stack.SuperchainID

+ Supervisor stack.SupervisorID

+ func NewDefaultInteropSystemIDs(l1ID, l2AID, l2BID eth.ChainID) DefaultInteropSystemIDs

+ type FaucetService struct

type L2CLNode

+ func (n *L2CLNode) Start()

+ func (n *L2CLNode) Stop()

+ type Orchestrator struct

+ func NewOrchestrator(p devtest.P, hook stack.SystemHook) *Orchestrator

+ func (o *Orchestrator) ControlPlane() stack.ControlPlane

+ func (o *Orchestrator) Hydrate(sys stack.ExtensibleSystem)

+ func (o *Orchestrator) P() devtest.P

+ type RedundantInteropSystemIDs struct

+ L2A2CL stack.L2CLNodeID

+ L2A2EL stack.L2ELNodeID

+ type Sequencer struct

+ type Superchain struct

type Supervisor

+ func (s *Supervisor) Start()

+ func (s *Supervisor) Stop()

v0

v0.32.0

Apr 27, 2026

Changes in this version

+ const DevstackL1ELKindEnvVar

+ const GethExecPathEnvVar

+ var DefaultL1ID = eth.ChainIDFromUInt64(900)

+ var DefaultL2AID = eth.ChainIDFromUInt64(901)

+ var DefaultL2BID = eth.ChainIDFromUInt64(902)

+ func ConnectP2P(ctx context.Context, require *testreq.Assertions, initiator RpcCaller, ...)

+ func DisconnectP2P(ctx context.Context, require *testreq.Assertions, initiator RpcCaller, ...)

+ func FlakyOnKonaNode(t devtest.T, reason string)

+ func FlakyOnOpReth(t devtest.T, reason string)

+ func GetP2PClient(ctx context.Context, logger log.Logger, l2CLNode L2CLNode) (*sources.P2PClient, error)

+ func GetPeerInfo(ctx context.Context, p2pClient *sources.P2PClient) (*apis.PeerInfo, error)

+ func GetPeers(ctx context.Context, p2pClient *sources.P2PClient) (*apis.PeerDump, error)

+ func LocalArtifacts(t devtest.T) *artifacts.Locator

+ func OPContractsManagerMigratorABI() (*abi.ABI, error)

+ func PrestateForGameType(t devtest.CommonT, gameType gameTypes.GameType) common.Hash

+ func ProxyAddr(require *testreq.Assertions, urlStr string) string

+ func SkipOnKonaNode(t devtest.T, reason string)

+ func SkipOnOpGeth(t devtest.T, reason string)

+ func SkipOnOpReth(t devtest.T, reason string)

+ func WithDefaultBPOBlobSchedule(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder)

+ func WithEcotoneAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder)

+ func WithJovianAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder)

+ func WithKarstAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder)

+ type BatcherOption func(target ComponentTarget, cfg *bss.CLIConfig)

+ type ComponentTarget struct

+ ChainID eth.ChainID

+ Name string

+ func NewComponentTarget(name string, chainID eth.ChainID) ComponentTarget

+ func (t ComponentTarget) String() string

+ type Conductor struct

+ func (c *Conductor) ConsensusEndpoint() string

+ func (c *Conductor) HTTPEndpoint() string

+ func (c *Conductor) ServerID() string

+ type ContractPaths struct

+ FoundryArtifacts string

+ SourceMap string

+ type DeployerOption func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder)

+ func WithCommons(l1ChainID eth.ChainID) DeployerOption

+ func WithCustomGasToken(name, symbol string, initialLiquidity *big.Int, ...) DeployerOption

+ func WithDAFootprintGasScalar(scalar uint16, l2ChainIDs ...eth.ChainID) DeployerOption

+ func WithDevFeatureEnabled(flag common.Hash) DeployerOption

+ func WithDisputeGameFinalityDelaySeconds(seconds uint64) DeployerOption

+ func WithEmbeddedContractSources() DeployerOption

+ func WithFinalizationPeriodSeconds(n uint64) DeployerOption

+ func WithForkAtL1Genesis(fork forks.Fork) DeployerOption

+ func WithForkAtL1Offset(fork forks.Fork, offset uint64) DeployerOption

+ func WithGuardianMatchL1PAO() DeployerOption

+ func WithHardforkSequentialActivation(startFork, endFork opforks.Name, delta *uint64) DeployerOption

+ func WithInteropAtGenesis() DeployerOption

+ func WithKarstAtOffset(offset *uint64) DeployerOption

+ func WithL2BlockTimes(blockTimes map[eth.ChainID]uint64) DeployerOption

+ func WithL2GasLimit(gasLimit uint64) DeployerOption

+ func WithLocalContractSources() DeployerOption

+ func WithLocalContractSourcesAt(artifactsPath string) DeployerOption

+ func WithPrefundedL2(l1ChainID, l2ChainID eth.ChainID) DeployerOption

+ func WithProofMaturityDelaySeconds(n uint64) DeployerOption

+ func WithSequencingWindow(n uint64) DeployerOption

+ type DeployerPipelineOption func(wb *worldBuilder, intent *state.Intent, cfg *deployer.ApplyPipelineOpts)

+ func WithDeployerCacheDir(dirPath string) DeployerPipelineOption

+ func WithDeployerMatchL1PAO() DeployerPipelineOption

+ type DisputeGameConfigV2 struct

+ Enabled bool

+ GameArgs []byte

+ GameType uint32

+ InitBond *big.Int

+ type ELNodeIdentity struct

+ Key *ecdsa.PrivateKey

+ Port int

+ func NewELNodeIdentity(port int) *ELNodeIdentity

+ func (id *ELNodeIdentity) KeyHex() string

+ type FakePoS struct

+ func (f *FakePoS) Start()

+ func (f *FakePoS) Stop()

+ type FlashblocksRuntimeSupport struct

+ Builder *OPRBuilderNode

+ RollupBoost *RollupBoostNode

+ type InteropFilter struct

+ func (f *InteropFilter) FailsafeEnabled() bool

+ func (f *InteropFilter) HTTPEndpoint() string

+ func (f *InteropFilter) Ready() bool

+ func (f *InteropFilter) SetFailsafeEnabled(enabled bool)

+ func (f *InteropFilter) Stop()

+ func (f *InteropFilter) WaitForReady(t devtest.T, timeout time.Duration)

+ type KonaNode struct

+ func (k *KonaNode) InteropRPC() (endpoint string, jwtSecret eth.Bytes32)

+ func (k *KonaNode) Start()

+ func (k *KonaNode) Stop()

+ func (k *KonaNode) UserRPC() string

+ type KonaSupervisor struct

+ func (s *KonaSupervisor) Start()

+ func (s *KonaSupervisor) Stop()

+ func (s *KonaSupervisor) UserRPC() string

+ type L1CLNode struct

+ func (n *L1CLNode) BeaconHTTPAddr() string

+ func (n *L1CLNode) FakePoS() stack.Lifecycle

+ type L1ELNode interface

+ AuthRPC func() string

+ UserRPC func() string

+ type L1Geth struct

+ func (g *L1Geth) AuthRPC() string

+ func (g *L1Geth) UserRPC() string

+ type L1Network struct

+ func (n *L1Network) ChainConfig() *params.ChainConfig

+ func (n *L1Network) ChainID() eth.ChainID

+ func (n *L1Network) Name() string

+ type L2Batcher struct

+ func (b *L2Batcher) UserRPC() string

+ type L2CLConfig struct

+ EnableReqRespSync bool

+ FollowSource string

+ IndexingMode bool

+ IsSequencer bool

+ NoDiscovery bool

+ OffsetELSafe time.Duration

+ SafeDBPath string

+ SequencerSyncMode nodeSync.Mode

+ UseReqRespSync bool

+ VerifierSyncMode nodeSync.Mode

+ func DefaultL2CLConfig() *L2CLConfig

+ type L2CLNode interface

+ InteropRPC func() (endpoint string, jwtSecret eth.Bytes32)

+ UserRPC func() string

+ type L2CLOption interface

+ Apply func(p devtest.T, target ComponentTarget, cfg *L2CLConfig)

+ func L2CLFollowSource(source string) L2CLOption

+ func L2CLIndexing() L2CLOption

+ func L2CLSequencer() L2CLOption

+ type L2CLOptionBundle []L2CLOption

+ func (l L2CLOptionBundle) Apply(p devtest.T, target ComponentTarget, cfg *L2CLConfig)

+ type L2CLOptionFn func(p devtest.T, target ComponentTarget, cfg *L2CLConfig)

+ func (fn L2CLOptionFn) Apply(p devtest.T, target ComponentTarget, cfg *L2CLConfig)

+ type L2Challenger struct

+ func (p *L2Challenger) Config() *config.Config

+ type L2Deployment struct

+ func (d *L2Deployment) DisputeGameFactoryProxyAddr() common.Address

+ func (d *L2Deployment) L1StandardBridgeProxyAddr() common.Address

+ func (d *L2Deployment) PermissionlessDelayedWETHProxyAddr() common.Address

+ func (d *L2Deployment) ProxyAdminAddr() common.Address

+ func (d *L2Deployment) SystemConfigProxyAddr() common.Address

+ type L2ELConfig struct

+ P2PAddr string

+ P2PNodeKeyHex string

+ P2PPort int

+ ProofHistory bool

+ StaticPeers []string

+ TrustedPeers []string

+ func DefaultL2ELConfig() *L2ELConfig

+ type L2ELNode interface

+ EngineRPC func() string

+ JWTPath func() string

+ UserRPC func() string

+ type L2ELOption interface

+ Apply func(p devtest.T, target ComponentTarget, cfg *L2ELConfig)

+ func L2ELWithP2PConfig(addr string, port int, nodeKeyHex string, staticPeers, trustedPeers []string) L2ELOption

+ func L2ELWithProofHistory(enable bool) L2ELOption

+ type L2ELOptionBundle []L2ELOption

+ func (l L2ELOptionBundle) Apply(p devtest.T, target ComponentTarget, cfg *L2ELConfig)

+ type L2ELOptionFn func(p devtest.T, target ComponentTarget, cfg *L2ELConfig)

+ func (fn L2ELOptionFn) Apply(p devtest.T, target ComponentTarget, cfg *L2ELConfig)

+ type L2MetricsRegistrar interface

+ RegisterL2MetricsTargets func(serviceName string, endpoints ...PrometheusMetricsTarget)

+ type L2Network struct

+ func (c *L2Network) ChainConfig() *params.ChainConfig

+ func (c *L2Network) ChainID() eth.ChainID

+ func (c *L2Network) Deployment() stack.L2Deployment

+ func (c *L2Network) Keys() devkeys.Keys

+ func (c *L2Network) L1ChainID() eth.ChainID

+ func (c *L2Network) Name() string

+ func (c *L2Network) RollupConfig() *rollup.Config

+ type L2Proposer struct

+ type MigrateInputV2 struct

+ ChainSystemConfigs []common.Address

+ DisputeGameConfigs []DisputeGameConfigV2

+ StartingAnchorRoot Proposal

+ StartingRespectedGameType uint32

+ type MixedL2CLKind string

+ const MixedL2CLKona

+ const MixedL2CLOpNode

+ type MixedL2ELKind string

+ const MixedL2ELOpGeth

+ const MixedL2ELOpReth

+ type MixedSingleChainNodeRefs struct

+ CL L2CLNode

+ EL L2ELNode

+ Spec MixedSingleChainNodeSpec

+ type MixedSingleChainNodeSpec struct

+ CLKey string

+ CLKind MixedL2CLKind

+ ELKey string

+ ELKind MixedL2ELKind

+ IsSequencer bool

+ type MixedSingleChainPresetConfig struct

+ DeployerOptions []DeployerOption

+ LocalContractArtifactsPath string

+ NodeSpecs []MixedSingleChainNodeSpec

+ TestSequencerName string

+ WithTestSequencer bool

+ type MixedSingleChainRuntime struct

+ FaucetService *faucet.Service

+ L1CL *L1CLNode

+ L1EL *L1Geth

+ L1Network *L1Network

+ L2Batcher *L2Batcher

+ L2Network *L2Network

+ Nodes []MixedSingleChainNodeRefs

+ TestSequencer *TestSequencerRuntime

+ func NewMixedSingleChainRuntime(t devtest.T, cfg MixedSingleChainPresetConfig) *MixedSingleChainRuntime

+ type MultiChainNodeRuntime struct

+ Batcher *L2Batcher

+ CL L2CLNode

+ EL L2ELNode

+ Followers map[string]*SingleChainNodeRuntime

+ Name string

+ Network *L2Network

+ Proposer *L2Proposer

+ type MultiChainRuntime struct

+ Chains map[string]*MultiChainNodeRuntime

+ DelaySeconds uint64

+ DependencySet depset.DependencySet

+ FaucetService *faucet.Service

+ FullConfigSet depset.FullConfigSetMerged

+ InteropFilter *InteropFilter

+ Keys devkeys.Keys

+ L1CL *L1CLNode

+ L1EL *L1Geth

+ L1Network *L1Network

+ L2ChallengerConfig *challengerconfig.Config

+ Migration *interopMigrationState

+ PrimarySupervisor Supervisor

+ SecondarySupervisor Supervisor

+ Supernode *SuperNode

+ TestSequencer *TestSequencerRuntime

+ TimeTravel *clock.AdvancingClock

+ func NewMultiSupervisorInteropRuntime(t devtest.T) *MultiChainRuntime

+ func NewSimpleInteropRuntime(t devtest.T) *MultiChainRuntime

+ func NewSimpleInteropRuntimeWithConfig(t devtest.T, cfg PresetConfig) *MultiChainRuntime

+ func NewSimpleInteropSuperProofsRuntimeWithConfig(t devtest.T, cfg PresetConfig) *MultiChainRuntime

+ func NewSingleChainInteropRuntime(t devtest.T) *MultiChainRuntime

+ func NewSingleChainInteropRuntimeWithConfig(t devtest.T, cfg PresetConfig) *MultiChainRuntime

+ func NewSingleChainSuperRootAtGenesisRuntimeWithConfig(t devtest.T, cfg PresetConfig) *MultiChainRuntime

+ func NewSingleChainSupernodeProofsRuntimeWithConfig(t devtest.T, interopAtGenesis bool, cfg PresetConfig) *MultiChainRuntime

+ func NewTwoL2SupernodeFollowL2RuntimeWithConfig(t devtest.T, delaySeconds uint64, cfg PresetConfig) *MultiChainRuntime

+ func NewTwoL2SupernodeInteropRuntime(t devtest.T, delaySeconds uint64) *MultiChainRuntime

+ func NewTwoL2SupernodeInteropRuntimeWithConfig(t devtest.T, delaySeconds uint64, cfg PresetConfig) *MultiChainRuntime

+ func NewTwoL2SupernodeProofsRuntimeWithConfig(t devtest.T, interopAtGenesis bool, cfg PresetConfig) *MultiChainRuntime

+ func NewTwoL2SupernodeRuntime(t devtest.T) *MultiChainRuntime

+ func NewTwoL2SupernodeRuntimeWithConfig(t devtest.T, cfg PresetConfig) *MultiChainRuntime

+ type OPRBuilderNode struct

+ func (b *OPRBuilderNode) EngineRPC() string

+ func (b *OPRBuilderNode) FlashblocksWSURL() string

+ func (b *OPRBuilderNode) JWTPath() string

+ func (b *OPRBuilderNode) Start()

+ func (b *OPRBuilderNode) Stop()

+ func (b *OPRBuilderNode) UpdateRuleSet(rulesYaml string) error

+ func (b *OPRBuilderNode) UserRPC() string

+ type OPRBuilderNodeConfig struct

+ AuthRPCAddr string

+ AuthRPCJWTPath string

+ AuthRPCPort int

+ Chain string

+ ChainBlockTime time.Duration

+ DataDir string

+ DisableDiscovery bool

+ EnableFlashblocks bool

+ EnableRPC bool

+ Env []string

+ ExtraArgs []string

+ FlashblocksAddr string

+ FlashblocksPort int

+ Full bool

+ LogFileFormat string

+ LogStdoutFormat string

+ P2PAddr string

+ P2PNodeKeyHex string

+ P2PPort int

+ RPCAPI string

+ RPCAddr string

+ RPCJWTPath string

+ RPCPort int

+ RulesConfigPath string

+ RulesEnabled bool

+ StaticPeers []string

+ TrustedPeers []string

+ WithUnusedPorts bool

+ func DefaultOPRbuilderNodeConfig() *OPRBuilderNodeConfig

+ func (cfg *OPRBuilderNodeConfig) LaunchSpec(p devtest.CommonT) (args []string, env []string)

+ type OPRBuilderNodeOption interface

+ Apply func(p devtest.CommonT, target ComponentTarget, cfg *OPRBuilderNodeConfig)

+ func OPRBuilderNodeWithEnv(env ...string) OPRBuilderNodeOption

+ func OPRBuilderNodeWithExtraArgs(args ...string) OPRBuilderNodeOption

+ func OPRBuilderWithNodeIdentity(identity *ELNodeIdentity, addr string, staticPeers, trustedPeers []string) OPRBuilderNodeOption

+ func OPRBuilderWithP2PConfig(addr string, port int, nodeKeyHex string, staticPeers, trustedPeers []string) OPRBuilderNodeOption

+ type OPRBuilderNodeOptionBundle []OPRBuilderNodeOption

+ func (b OPRBuilderNodeOptionBundle) Apply(p devtest.CommonT, target ComponentTarget, cfg *OPRBuilderNodeConfig)

+ type OPRBuilderNodeOptionFn func(p devtest.CommonT, target ComponentTarget, cfg *OPRBuilderNodeConfig)

+ func (fn OPRBuilderNodeOptionFn) Apply(p devtest.CommonT, target ComponentTarget, cfg *OPRBuilderNodeConfig)

+ type OpGeth struct

+ func (n *OpGeth) EngineRPC() string

+ func (n *OpGeth) JWTPath() string

+ func (n *OpGeth) Start()

+ func (n *OpGeth) Stop()

+ func (n *OpGeth) UserRPC() string

+ type OpNode struct

+ func (n *OpNode) InteropRPC() (endpoint string, jwtSecret eth.Bytes32)

+ func (n *OpNode) Start()

+ func (n *OpNode) Stop()

+ func (n *OpNode) SyncMode() nodeSync.Mode

+ func (n *OpNode) UserRPC() string

+ type OpReth struct

+ func (n *OpReth) EngineRPC() string

+ func (n *OpReth) JWTPath() string

+ func (n *OpReth) Start()

+ func (n *OpReth) Stop()

+ func (n *OpReth) UserRPC() string

+ type OpSupervisor struct

+ func (s *OpSupervisor) Start()

+ func (s *OpSupervisor) Stop()

+ func (s *OpSupervisor) UserRPC() string

+ type PreGenesisSuperGameConfig struct

+ ClaimedOutputs []eth.Bytes32

+ type PresetConfig struct

+ AddedGameTypes []gameTypes.GameType

+ BatcherOptions []BatcherOption

+ DeployerOptions []DeployerOption

+ EnableCannonKonaForChall bool

+ EnableTimeTravel bool

+ GlobalL2CLOptions []L2CLOption

+ GlobalSyncTesterELOptions []SyncTesterELOption

+ InteropLogBackfillDepth time.Duration

+ L1ELKind string

+ L1GethExecPath string

+ LocalContractArtifactsPath string

+ MaxSequencingWindow *uint64

+ MessageExpiryWindow *uint64

+ OPRBuilderOptions []OPRBuilderNodeOption

+ PreGenesisSuperGame *PreGenesisSuperGameConfig

+ ProposerOptions []ProposerOption

+ RequireInteropNotAtGen bool

+ RespectedGameTypes []gameTypes.GameType

+ UseInteropFilter bool

+ func NewPresetConfig() PresetConfig

+ type PrometheusMetricsTarget string

+ func NewPrometheusMetricsTarget(host string, port string, isRunningInDocker bool) PrometheusMetricsTarget

+ type Proposal struct

+ L2SequenceNumber *big.Int

+ Root common.Hash

+ type ProposerOption func(target ComponentTarget, cfg *ps.CLIConfig)

+ type RollupBoostConfig struct

+ BuilderJWTPath string

+ BuilderURL string

+ DebugHost string

+ DebugPort int

+ EnableFlashblocks bool

+ Env []string

+ ExecutionMode string

+ ExtraArgs []string

+ FlashblocksBuilderURL string

+ FlashblocksHost string

+ FlashblocksPort int

+ Headers http.Header

+ L2EngineURL string

+ L2JWTPath string

+ LogFormat string

+ RPCHost string

+ RPCPort uint16

+ func DefaultRollupBoostConfig() *RollupBoostConfig

+ func (cfg *RollupBoostConfig) LaunchSpec(p devtest.CommonT) (args []string, env []string)

+ type RollupBoostNode struct

+ func (r *RollupBoostNode) EngineRPC() string

+ func (r *RollupBoostNode) FlashblocksWSURL() string

+ func (r *RollupBoostNode) JWTPath() string

+ func (r *RollupBoostNode) Start()

+ func (r *RollupBoostNode) Stop()

+ func (r *RollupBoostNode) UserRPC() string

+ type RpcCaller interface

+ CallContext func(ctx context.Context, result interface{}, method string, args ...interface{}) error

+ type RulesConfig struct

+ File []struct{ ... }

+ RefreshInterval int

+ type SingleChainInteropSupport struct

+ DependencySet depset.DependencySet

+ FullConfigSet depset.FullConfigSetMerged

+ Migration *interopMigrationState

+ Supervisor Supervisor

+ type SingleChainNodeRuntime struct

+ CL L2CLNode

+ EL L2ELNode

+ IsSequencer bool

+ Name string

+ type SingleChainRuntime struct

+ Conductors map[string]*Conductor

+ FaucetService *faucet.Service

+ Flashblocks *FlashblocksRuntimeSupport

+ Interop *SingleChainInteropSupport

+ Keys devkeys.Keys

+ L1CL *L1CLNode

+ L1EL *L1Geth

+ L1Network *L1Network

+ L2Batcher *L2Batcher

+ L2CL L2CLNode

+ L2Challenger *L2Challenger

+ L2EL L2ELNode

+ L2Network *L2Network

+ L2Proposer *L2Proposer

+ Nodes map[string]*SingleChainNodeRuntime

+ P2PEnabled bool

+ SyncTester *SyncTesterRuntime

+ TestSequencer *TestSequencerRuntime

+ TimeTravel *clock.AdvancingClock

+ func NewFlashblocksRuntime(t devtest.T) *SingleChainRuntime

+ func NewFlashblocksRuntimeWithConfig(t devtest.T, cfg PresetConfig) *SingleChainRuntime

+ func NewMinimalInteropNoSupervisorRuntime(t devtest.T) *SingleChainRuntime

+ func NewMinimalRuntime(t devtest.T) *SingleChainRuntime

+ func NewMinimalRuntimeWithConfig(t devtest.T, cfg PresetConfig) *SingleChainRuntime

+ func NewMinimalWithConductorsRuntime(t devtest.T) *SingleChainRuntime

+ func NewMinimalWithConductorsRuntimeWithConfig(t devtest.T, cfg PresetConfig) *SingleChainRuntime

+ func NewSimpleWithSyncTesterRuntime(t devtest.T) *SingleChainRuntime

+ func NewSimpleWithSyncTesterRuntimeWithConfig(t devtest.T, cfg PresetConfig) *SingleChainRuntime

+ func NewSingleChainMultiNodeRuntime(t devtest.T, withP2P bool) *SingleChainRuntime

+ func NewSingleChainMultiNodeRuntimeWithConfig(t devtest.T, withP2P bool, cfg PresetConfig) *SingleChainRuntime

+ func NewSingleChainTwoVerifiersRuntime(t devtest.T) *SingleChainRuntime

+ func NewSingleChainTwoVerifiersRuntimeWithConfig(t devtest.T, cfg PresetConfig) *SingleChainRuntime

+ type SubProcess struct

+ func NewSubProcess(p devtest.CommonT, stdOutCallback, stdErrCallback logpipe.LogCallback) *SubProcess

+ func (sp *SubProcess) Start(cmdPath string, args []string, env []string) error

+ func (sp *SubProcess) Stop(interrupt bool) error

+ type SuperNode struct

+ func (n *SuperNode) InteropActivity() *interop.Interop

+ func (n *SuperNode) InteropRPC() (endpoint string, jwtSecret eth.Bytes32)

+ func (n *SuperNode) RestartInteropActivity(wipeLogsDBs bool) error

+ func (n *SuperNode) Start()

+ func (n *SuperNode) Stop()

+ func (n *SuperNode) UserRPC() string

+ type SuperNodeProxy struct

+ func (n *SuperNodeProxy) InteropRPC() (endpoint string, jwtSecret eth.Bytes32)

+ func (n *SuperNodeProxy) Start()

+ func (n *SuperNodeProxy) Stop()

+ func (n *SuperNodeProxy) UserRPC() string

+ type SuperchainDeployment struct

+ func (d *SuperchainDeployment) ProtocolVersionsAddr() common.Address

+ func (d *SuperchainDeployment) SuperchainConfigAddr() common.Address

+ type SupernodeConfig struct

+ InteropActivationTimestamp *uint64

+ UseGenesisInterop bool

+ type SupernodeOption func(*SupernodeConfig)

+ func WithSupernodeInterop(activationTimestamp uint64) SupernodeOption

+ func WithSupernodeInteropAtGenesis() SupernodeOption

+ type Supervisor interface

+ UserRPC func() string

+ type SyncTesterEL struct

+ func (n *SyncTesterEL) EngineRPC() string

+ func (n *SyncTesterEL) JWTPath() string

+ func (n *SyncTesterEL) Start()

+ func (n *SyncTesterEL) Stop()

+ func (n *SyncTesterEL) UserRPC() string

+ type SyncTesterELConfig struct

+ ELSyncActive bool

+ FCUState eth.FCUState

+ func DefaultSyncTesterELConfig() *SyncTesterELConfig

+ func (cfg *SyncTesterELConfig) Path() string

+ type SyncTesterELOption interface

+ Apply func(p devtest.T, target ComponentTarget, cfg *SyncTesterELConfig)

+ type SyncTesterELOptionBundle []SyncTesterELOption

+ func (l SyncTesterELOptionBundle) Apply(p devtest.T, target ComponentTarget, cfg *SyncTesterELConfig)

+ type SyncTesterELOptionFn func(p devtest.T, target ComponentTarget, cfg *SyncTesterELConfig)

+ func (fn SyncTesterELOptionFn) Apply(p devtest.T, target ComponentTarget, cfg *SyncTesterELConfig)

+ type SyncTesterRuntime struct

+ Node *SingleChainNodeRuntime

+ Service *SyncTesterService

+ type SyncTesterService struct

+ func (n *SyncTesterService) DefaultEndpoint(chainID eth.ChainID) (string, string, bool)

+ func (n *SyncTesterService) RPC() string

+ func (n *SyncTesterService) SyncTesterRPCPath(chainID eth.ChainID, withSessionID bool) string

+ type TestSequencerRuntime struct

+ AdminRPC string

+ ControlRPC map[eth.ChainID]string

+ JWTSecret [32]byte

+ Name string

+ Service *sequencer.Service

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL