sysgo

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

type ComponentTarget struct {
	Name    string
	ChainID eth.ChainID
}

type Conductor struct {
	// contains filtered or unexported fields
}

type ContractPaths struct {
	// must be absolute paths, without file:// prefix
	FoundryArtifacts string
	SourceMap        string
}

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

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

type DisputeGameConfigV2 struct {
	Enabled  bool
	InitBond *big.Int
	GameType uint32
	GameArgs []byte
}

type DisputeMonConfig struct {
	L1RPC              string
	GameFactoryAddress common.Address
	RollupRPCs         []string
	SupernodeRPCs      []string
	HonestActors       []common.Address
	Clock              clock.Clock
}

type DisputeMonRuntime struct {
	// contains filtered or unexported fields
}

type ELNodeIdentity struct {
	Key  *ecdsa.PrivateKey
	Port int
}

type FakePoS struct {
	// contains filtered or unexported fields
}

type InteropFilter struct {
	// contains filtered or unexported fields
}

type KonaNode struct {
	// contains filtered or unexported fields
}

type L1CLNode struct {
	// contains filtered or unexported fields
}

type L1ELNode interface {
	UserRPC() string
	AuthRPC() string
	// contains filtered or unexported methods
}

type L1Geth struct {
	// contains filtered or unexported fields
}

type L1Network struct {
	// contains filtered or unexported fields
}

type L2Batcher struct {
	// contains filtered or unexported fields
}

type L2CLConfig struct {
	// SyncMode to run, if this is a sequencer
	SequencerSyncMode nodeSync.Mode
	// SyncMode to run, if this is a verifier
	VerifierSyncMode nodeSync.Mode

	// SafeDBPath is the path to the safe DB to use. Disabled if empty.
	SafeDBPath string

	IsSequencer bool

	// EnableReqRespSync enables/disables the req-resp sync server (serving payloads to peers).
	EnableReqRespSync bool

	// NoDiscovery is the flag to enable/disable discovery
	NoDiscovery bool

	FollowSource string

	// OffsetELSafe retracts safe and finalized from the EL-sync tip by floor(OffsetELSafe / L2BlockTime) blocks.
	OffsetELSafe time.Duration

	// SequencerMaxSafeLag caps the gap between unsafe and safe L2 heads;
	// the sequencer stalls block production when the gap is exceeded. 0 disables.
	SequencerMaxSafeLag uint64
}

type L2CLNode interface {
	stack.Lifecycle
	UserRPC() string
}

type L2CLOption interface {
	Apply(p devtest.T, target ComponentTarget, cfg *L2CLConfig)
}

type L2CLOptionBundle []L2CLOption

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

type L2Challenger struct {
	// contains filtered or unexported fields
}

type L2Deployment struct {
	// contains filtered or unexported fields
}

type L2ELConfig struct {
	P2PAddr       string
	P2PPort       int
	P2PNodeKeyHex string
	StaticPeers   []string
	TrustedPeers  []string
	ProofHistory  bool
}

type L2ELNode interface {
	stack.Lifecycle
	UserRPC() string
	EngineRPC() string
	JWTPath() string
}

type L2ELOption interface {
	Apply(p devtest.T, target ComponentTarget, cfg *L2ELConfig)
}

type L2ELOptionBundle []L2ELOption

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

type L2MetricsRegistrar interface {
	RegisterL2MetricsTargets(serviceName string, endpoints ...PrometheusMetricsTarget)
}

type L2Network struct {
	// contains filtered or unexported fields
}

type L2Proposer struct {
	// contains filtered or unexported fields
}

type MigrateInputV2 struct {
	ChainSystemConfigs        []common.Address
	DisputeGameConfigs        []DisputeGameConfigV2
	StartingAnchorRoot        Proposal
	StartingRespectedGameType uint32
}

type MixedL2CLKind string

type MixedL2ELKind string

type MixedSingleChainNodeRefs struct {
	Spec MixedSingleChainNodeSpec
	EL   L2ELNode
	CL   L2CLNode
}

type MixedSingleChainNodeSpec struct {
	ELKey       string
	CLKey       string
	ELKind      MixedL2ELKind
	CLKind      MixedL2CLKind
	IsSequencer bool
	// IsolateFromL2P2P keeps this node off the L2 CL/EL P2P mesh: it is never peered with the
	// other nodes, so it receives no gossiped or req-resp'd unsafe blocks and must advance purely
	// by deriving from L1. Used to exercise the derivation/force-build path (FCU-with-attributes)
	// rather than the consolidation path. Defaults to false (fully peered).
	IsolateFromL2P2P bool
	// OpRethOpts are per-node op-reth options applied AFTER the shared cfg.OpRethOptions, only to
	// this node's EL. Use for options that must not reach every node — e.g. a per-node binary
	// override (OpRethWithBinary) or a flag a single node should receive while its peers reject it.
	// Ignored for non-op-reth EL kinds.
	OpRethOpts []OpRethOption
}

type MixedSingleChainPresetConfig struct {
	NodeSpecs                  []MixedSingleChainNodeSpec
	WithTestSequencer          bool
	TestSequencerName          string
	LocalContractArtifactsPath string
	DeployerOptions            []DeployerOption
	BatcherOptions             []BatcherOption
	OpRethOptions              []OpRethOption
	// InteropAtGenesis activates the Lagoon hardfork at genesis on the L2 chain and provides
	// the resulting dependency set to op-node CL startup. Required by any test that exercises
	// interop-gated consensus features (e.g. SDM PostExec) without a supervisor.
	InteropAtGenesis bool
}

type MixedSingleChainRuntime struct {
	L1Network     *L1Network
	L1EL          *L1Geth
	L1CL          *L1CLNode
	L2Network     *L2Network
	Nodes         []MixedSingleChainNodeRefs
	L2Batcher     *L2Batcher
	TestSequencer *TestSequencerRuntime
}

type MultiChainNodeRuntime struct {
	Name    string
	Network *L2Network
	// EL is the chain's primary EL. In light-sequencer presets it is the
	// follow-mode sequencer's own EL; in virtual-sequencer presets it is the
	// same EL the supernode VN drives.
	EL          L2ELNode
	CL          L2CLNode
	SupernodeCL L2CLNode
	// SupernodeEL is the EL the supernode VN reads/writes. In light-sequencer
	// presets it is distinct from EL (production topology: separate ELs joined
	// only by L1 + P2P); in virtual-sequencer presets it equals EL.
	SupernodeEL L2ELNode
	Batcher     *L2Batcher
	Proposer    *L2Proposer
	Followers   map[string]*SingleChainNodeRuntime
}

type MultiChainRuntime struct {
	Keys          devkeys.Keys
	Migration     *interopMigrationState
	FullConfigSet config.FullConfigSetMerged
	DependencySet coredepset.DependencySet

	L1Network *L1Network
	L1EL      *L1Geth
	L1CL      *L1CLNode

	Chains map[string]*MultiChainNodeRuntime

	Supernode *SuperNode

	TimeTravel         *clock.AdvancingClock
	TestSequencer      *TestSequencerRuntime
	L2ChallengerConfig *challengerconfig.Config

	DelaySeconds  uint64
	InteropFilter *InteropFilter // nil if not using interop filter
	SyncTester    *SyncTesterRuntime
	// contains filtered or unexported fields
}

type OpGeth struct {
	// contains filtered or unexported fields
}

type OpNode struct {
	// contains filtered or unexported fields
}

type OpReth struct {
	// contains filtered or unexported fields
}

type OpRethConfig struct {
	// ExtraArgs are appended to the generated CLI args.
	ExtraArgs []string
	// Binary selects the EL binary to launch. Empty means "op-reth". A CLI-compatible superset
	// (any binary that accepts every op-reth subcommand/flag, plus optionally its own additive
	// flags) may be selected via OpRethWithBinary.
	Binary string
	// DisableProofsHistory skips the proofs-history init + runtime flags for this node. The mixed
	// runtime otherwise enables proofs-history on every op-reth node; some CLI-superset binaries
	// reject --proofs-history in the mode under test.
	DisableProofsHistory bool
}

type OpRethOption interface {
	Apply(p devtest.T, target ComponentTarget, cfg *OpRethConfig)
}

type OpRethOptionBundle []OpRethOption

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

type PreGenesisSuperGameConfig struct {
	ClaimedOutputs []eth.Bytes32
}

type PresetConfig struct {
	LocalContractArtifactsPath string
	DeployerOptions            []DeployerOption
	BatcherOptions             []BatcherOption
	ProposerOptions            []ProposerOption
	OpRethOptions              []OpRethOption
	GlobalL2CLOptions          []L2CLOption
	GlobalSyncTesterELOptions  []SyncTesterELOption
	L1ELKind                   string
	L1GethExecPath             string
	AddedGameTypes             []gameTypes.GameType
	RespectedGameTypes         []gameTypes.GameType
	EnableTimeTravel           bool
	MaxSequencingWindow        *uint64
	RequireInteropNotAtGen     bool
	MessageExpiryWindow        *uint64
	UseInteropFilter           bool
	// InteropLogBackfillDepth, if non-zero, configures the supernode to backfill
	// initiating-message logs backward from the tip by this duration at startup.
	InteropLogBackfillDepth time.Duration
	PreGenesisSuperGame     *PreGenesisSuperGameConfig
	ZKDisputeGame           *ZKDisputeGameConfig
	ZKProposerOptions       []ZKProposerOption
	// SkipHonestProposer skips starting the honest proposer (op-proposer, or kona-sp1-proposer for the ZK preset).
	SkipHonestProposer bool
	// SkipHonestChallenger skips starting the honest challenger.
	SkipHonestChallenger bool
	// SupernodeVerifierSyncMode overrides the supernode VN's sync mode when set.
	SupernodeVerifierSyncMode *nodeSync.Mode
	// InteropActivationDelaySeconds offsets Interop activation past genesis (0 = at genesis).
	InteropActivationDelaySeconds uint64
	// InteropAtGenesis activates Interop on the L2 chain at genesis and provisions a
	// DependencySet for op-node startup (without a supervisor). Required by tests that
	// exercise Interop-gated consensus features (e.g. SDM PostExec) on the default
	// single-chain runtime.
	InteropAtGenesis bool
	// SupernodeVNSequencerForBootstrap, in the light-sequencer supernode interop preset,
	// enables sequencing on the supernode VN and starts the light follow-mode ELSync
	// sequencers stopped, so the VN can bootstrap the chain the light sequencers EL-sync
	// from before a test hands off sequencing to them.
	SupernodeVNSequencerForBootstrap bool
}

type PrometheusMetricsTarget string

type Proposal struct {
	Root             common.Hash
	L2SequenceNumber *big.Int
}

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

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

type SingleChainInteropSupport struct {
	Migration     *interopMigrationState
	FullConfigSet config.FullConfigSetMerged
	DependencySet coredepset.DependencySet
}

type SingleChainNodeRuntime struct {
	Name        string
	IsSequencer bool
	EL          L2ELNode
	CL          L2CLNode
}

type SingleChainRuntime struct {
	Keys devkeys.Keys

	L1Network *L1Network
	L2Network *L2Network

	L1EL *L1Geth
	L1CL *L1CLNode

	L2EL L2ELNode
	L2CL L2CLNode

	L2Batcher    *L2Batcher
	L2Proposer   *L2Proposer
	L2Challenger *L2Challenger
	// ZKChallengerSuperRootRPCProxy is set when the runtime starts a ZK challenger.
	ZKChallengerSuperRootRPCProxy *StallableProxy

	TimeTravel    *clock.AdvancingClock
	TestSequencer *TestSequencerRuntime

	Nodes      map[string]*SingleChainNodeRuntime
	SyncTester *SyncTesterRuntime
	Conductors map[string]*Conductor
	Interop    *SingleChainInteropSupport
	P2PEnabled bool
}

type StallableFollowSourceProxies struct {
	// contains filtered or unexported fields
}

type StallableProxy struct {
	// contains filtered or unexported fields
}

type SubProcess struct {
	// contains filtered or unexported fields
}

type SuperNode struct {
	// contains filtered or unexported fields
}

type SuperNodeProxy struct {
	// contains filtered or unexported fields
}

type SuperchainDeployment struct {
	// contains filtered or unexported fields
}

type SupernodeConfig struct {
	// InteropActivationTimestamp enables the interop activity at the given timestamp.
	// Set to nil to disable interop (default). Non-nil (including 0) enables interop.
	InteropActivationTimestamp *uint64

	// UseGenesisInterop, when true, sets InteropActivationTimestamp to the genesis
	// timestamp of the first configured chain at deploy time. Takes effect inside
	// withSharedSupernodeCLsImpl after deployment, when the genesis time is known.
	UseGenesisInterop bool
}

type SupernodeOption func(*SupernodeConfig)

type SyncTesterEL struct {
	// contains filtered or unexported fields
}

type SyncTesterELConfig struct {
	FCUState     eth.FCUState
	ELSyncActive bool
}

type SyncTesterELOption interface {
	Apply(p devtest.T, target ComponentTarget, cfg *SyncTesterELConfig)
}

type SyncTesterELOptionBundle []SyncTesterELOption

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

type SyncTesterRuntime struct {
	Service *SyncTesterService
	// Node is set on the op-node-verifier path; nil on the supernode path.
	Node *SingleChainNodeRuntime
	// EL is the sync-tester-backed L2ELNode.
	EL L2ELNode
	// CL drives the sync-tester EL (op-node or SuperNodeProxy).
	CL L2CLNode
}

type SyncTesterService struct {
	// contains filtered or unexported fields
}

type TestSequencerRuntime struct {
	Name       string
	AdminRPC   string
	JWTSecret  [32]byte
	ControlRPC map[eth.ChainID]string
	Service    *sequencer.Service
}

type ZKDisputeGameConfig struct {
	MaxChallengeDuration time.Duration
	MaxProveDuration     time.Duration
}

type ZKProposerOption func(cfg *zkProposerConfig)