sysgo

package

Go to main page

Versions in this module

v1

v1.14.1

Oct 8, 2025

Changes in this version

+ const DevstackL1ELKindEnvVar

+ const GethExecPathEnvVar

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

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

+ 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

type L1ELNode

+ AuthRPC func() string

+ UserRPC func() string

+ type L1Geth struct

+ func (g *L1Geth) AuthRPC() string

+ func (g *L1Geth) UserRPC() string

type L2CLConfig

+ EnableReqRespSync bool

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 struct

+ ELSyncActive bool

+ ELSyncTarget uint64

+ FCUState eth.FCUState

+ func DefaultSyncTesterELConfig() *SyncTesterELConfig

+ func (cfg *SyncTesterELConfig) Path() string

+ type SyncTesterELOption interface

+ Apply func(p devtest.P, id stack.L2ELNodeID, cfg *SyncTesterELConfig)

+ type SyncTesterELOptionBundle []SyncTesterELOption

+ func (l SyncTesterELOptionBundle) Apply(p devtest.P, id stack.L2ELNodeID, cfg *SyncTesterELConfig)

+ type SyncTesterELOptionFn func(p devtest.P, id stack.L2ELNodeID, cfg *SyncTesterELConfig)

+ func (fn SyncTesterELOptionFn) Apply(p devtest.P, id stack.L2ELNodeID, cfg *SyncTesterELConfig)

v1.13.6

Sep 2, 2025

Changes in this version

+ var DefaultL1ID = eth.ChainIDFromUInt64(900)

+ var DefaultL2AID = eth.ChainIDFromUInt64(901)

+ var DefaultL2BID = eth.ChainIDFromUInt64(902)

+ 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 ProxyAddr(require *testreq.Assertions, urlStr string) string

+ 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 DeployerOption

+ func WithEmbeddedContractSources() DeployerOption

+ func WithHardforkSequentialActivation(startFork, endFork rollup.ForkName, delta *uint64) DeployerOption

type DeployerPipelineOption

+ func WithDeployerCacheDir(dirPath string) DeployerPipelineOption

+ 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 L2CLConfig struct

+ IndexingMode bool

+ IsSequencer bool

+ SafeDBPath string

+ SequencerSyncMode nodeSync.Mode

+ VerifierSyncMode nodeSync.Mode

+ func DefaultL2CLConfig() *L2CLConfig

type L2CLNode

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

+ UserRPC func() string

type L2CLOption

+ func L2CLIndexing() L2CLOption

+ func L2CLSequencer() L2CLOption

+ Apply func(p devtest.P, id stack.L2CLNodeID, cfg *L2CLConfig)

+ type L2CLOptionBundle []L2CLOption

+ func (l L2CLOptionBundle) Apply(p devtest.P, id stack.L2CLNodeID, cfg *L2CLConfig)

+ type L2CLOptionFn func(p devtest.P, id stack.L2CLNodeID, cfg *L2CLConfig)

+ func (fn L2CLOptionFn) Apply(p devtest.P, id stack.L2CLNodeID, cfg *L2CLConfig)

type L2Deployment

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

+ type L2ELConfig struct

+ SupervisorID *stack.SupervisorID

+ func DefaultL2ELConfig() *L2ELConfig

type L2ELNode

+ EngineRPC func() string

+ JWTPath func() string

+ UserRPC func() string

+ type L2ELOption interface

+ Apply func(p devtest.P, id stack.L2ELNodeID, cfg *L2ELConfig)

+ func L2ELWithSupervisor(supervisorID stack.SupervisorID) L2ELOption

+ type L2ELOptionBundle []L2ELOption

+ func (l L2ELOptionBundle) Apply(p devtest.P, id stack.L2ELNodeID, cfg *L2ELConfig)

+ type L2ELOptionFn func(p devtest.P, id stack.L2ELNodeID, cfg *L2ELConfig)

+ func (fn L2ELOptionFn) Apply(p devtest.P, id stack.L2ELNodeID, cfg *L2ELConfig)

+ 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) 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 SubProcess struct

+ func NewSubProcess(p devtest.P, stdOutLogs, stdErrLogs logpipe.LogProcessor) *SubProcess

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

+ func (sp *SubProcess) Kill() error

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

+ func (sp *SubProcess) Stop() error

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

type Supervisor

+ 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 SyncTesterService struct

v1.13.5

Jul 11, 2025

Changes in this version

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

+ 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 L2CLOption func(p devtest.P, id stack.L2CLNodeID, cfg *config.Config)

type L2ELNode

+ func (n *L2ELNode) Start()

+ func (n *L2ELNode) Stop()

+ type RpcCaller interface

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

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 BatcherOption func(id stack.L2BatcherID, cfg *bss.CLIConfig)

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

+ func WithDisputeGameFinalityDelaySeconds(seconds uint64) DeployerOption

+ func WithFinalizationPeriodSeconds(n uint64) DeployerOption

+ func WithGuardianMatchL1PAO() DeployerOption

+ func WithProofMaturityDelaySeconds(n uint64) DeployerOption

+ func WithSequencingWindow(n uint64) DeployerOption

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

+ func WithDeployerMatchL1PAO() DeployerPipelineOption

+ type FakePoS struct

+ func (f *FakePoS) Start()

+ func (f *FakePoS) Stop()

+ type InteropMigration struct

+ DisputeGameFactory common.Address

+ type L2Challenger struct

+ 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 ProposerOption func(id stack.L2ProposerID, cfg *ps.CLIConfig)

+ 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 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 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 ContractPaths struct

+ FoundryArtifacts string

+ SourceMap string

+ 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 DeployerOption func(p devtest.P, keys devkeys.Keys, builder intentbuilder.Builder)

+ func WithCommons(l1ChainID eth.ChainID) DeployerOption

+ func WithInteropAtGenesis() DeployerOption

+ func WithLocalContractSources() DeployerOption

+ func WithPrefundedL2(chainID eth.ChainID) DeployerOption

+ type FaucetService struct

+ type L1CLNode struct

+ type L1ELNode struct

+ type L1Network struct

+ type L2Batcher struct

+ type L2CLNode struct

+ func (n *L2CLNode) Start()

+ func (n *L2CLNode) Stop()

+ type L2Deployment struct

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

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

+ type L2ELNode struct

+ type L2Network struct

+ type L2Proposer struct

+ 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 SuperchainDeployment struct

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

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

+ type Supervisor struct

+ func (s *Supervisor) Start()

+ func (s *Supervisor) Stop()

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