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 ELNodeIdentity struct {
	Key  *ecdsa.PrivateKey
	Port int
}

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

type FlashblocksRuntimeSupport struct {
	Builder     *OPRBuilderNode
	RollupBoost *RollupBoostNode
}

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

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

type KonaSupervisor 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
	IndexingMode bool

	// EnableReqRespSync is the flag to enable/disable req-resp sync.
	EnableReqRespSync bool

	// UseReqRespSync controls whether to use the req-resp sync protocol. EnableReqRespSync == false && UseReqRespSync == true is not allowed, and node will fail to start.
	UseReqRespSync 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
}

type L2CLNode interface {
	stack.Lifecycle
	UserRPC() string
	InteropRPC() (endpoint string, jwtSecret eth.Bytes32)
}

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
}

type MixedSingleChainPresetConfig struct {
	NodeSpecs                  []MixedSingleChainNodeSpec
	WithTestSequencer          bool
	TestSequencerName          string
	LocalContractArtifactsPath string
	DeployerOptions            []DeployerOption
	BatcherOptions             []BatcherOption
	OpRethOptions              []OpRethOption
}

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

type MultiChainNodeRuntime struct {
	Name      string
	Network   *L2Network
	EL        L2ELNode
	CL        L2CLNode
	Batcher   *L2Batcher
	Proposer  *L2Proposer
	Followers map[string]*SingleChainNodeRuntime
}

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

	L1Network *L1Network
	L1EL      *L1Geth
	L1CL      *L1CLNode

	Chains map[string]*MultiChainNodeRuntime

	PrimarySupervisor   Supervisor
	SecondarySupervisor Supervisor
	Supernode           *SuperNode

	FaucetService      *faucet.Service
	TimeTravel         *clock.AdvancingClock
	TestSequencer      *TestSequencerRuntime
	L2ChallengerConfig *challengerconfig.Config
	DelaySeconds       uint64
	InteropFilter      *InteropFilter // nil if not using interop filter
}

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

type OPRBuilderNodeConfig struct {
	// Chain selector (defaults to "dev" to avoid mainnet imports during tests)
	Chain string

	// DataDir for op-OPRbuilderNode. If empty, a temp dir is created and cleaned up.
	DataDir string

	// Logging formats
	LogStdoutFormat string // e.g. "json"
	LogFileFormat   string // e.g. "json"

	// Flashblocks websocket bind address (host)
	FlashblocksAddr string
	// Flashblocks websocket port. 0 means auto-allocate an available local port.
	FlashblocksPort int
	// EnableFlashblocks enables the flashblocks feature.
	EnableFlashblocks bool

	// --http
	EnableRPC  bool
	RPCAPI     string
	RPCAddr    string
	RPCPort    int
	RPCJWTPath string

	AuthRPCJWTPath string
	AuthRPCAddr    string
	AuthRPCPort    int

	ChainBlockTime time.Duration

	// P2P
	P2PPort       int
	P2PAddr       string
	P2PNodeKeyHex string
	StaticPeers   []string
	TrustedPeers  []string

	// Misc process toggles
	WithUnusedPorts  bool // choose unused ports for subsystems
	DisableDiscovery bool // avoid discv5 UDP socket collisions

	Full bool

	RulesEnabled    bool
	RulesConfigPath string

	// ExtraArgs are appended to the generated CLI allowing callers to override defaults
	// if the binary respects "last flag wins".
	ExtraArgs []string
	// Env is passed to the subprocess environment.
	Env []string
}

type OPRBuilderNodeOption interface {
	Apply(p devtest.CommonT, target ComponentTarget, cfg *OPRBuilderNodeConfig)
}

type OPRBuilderNodeOptionBundle []OPRBuilderNodeOption

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

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
}

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 OpSupervisor struct {
	// contains filtered or unexported fields
}

type PreGenesisSuperGameConfig struct {
	ClaimedOutputs []eth.Bytes32
}

type PresetConfig struct {
	LocalContractArtifactsPath string
	DeployerOptions            []DeployerOption
	BatcherOptions             []BatcherOption
	ProposerOptions            []ProposerOption
	OPRBuilderOptions          []OPRBuilderNodeOption
	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
	// SkipHonestProposer skips starting op-proposer.
	SkipHonestProposer bool
}

type PrometheusMetricsTarget string

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

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

type RollupBoostConfig struct {
	// RPC endpoint for rollup-boost itself
	RPCHost string
	RPCPort uint16

	// Flashblocks proxy WebSocket exposure
	EnableFlashblocks bool
	FlashblocksHost   string
	FlashblocksPort   int

	// L2 engine connection details (HTTP(S))
	L2EngineURL string
	L2JWTPath   string

	// Builder engine connection details (HTTP(S))
	BuilderURL            string
	BuilderJWTPath        string
	FlashblocksBuilderURL string // upstream builder WS url (e.g. op-rbuilder ws)

	// Other settings
	ExecutionMode string // e.g. "enabled"
	LogFormat     string // e.g. "json"

	// Debug server
	DebugHost string
	DebugPort int

	// Optional WS headers to expose to clients through the proxy
	Headers http.Header

	// Env variables for the subprocess
	Env []string
	// ExtraArgs appended to the generated CLI (last-flag-wins semantics)
	ExtraArgs []string
}

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

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

type RulesConfig struct {
	File []struct {
		Path string `yaml:"path"`
	} `yaml:"file"`
	RefreshInterval int `yaml:"refresh_interval"`
}

type SingleChainInteropSupport struct {
	Migration     *interopMigrationState
	FullConfigSet depset.FullConfigSetMerged
	DependencySet depset.DependencySet
	Supervisor    Supervisor
}

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

	FaucetService *faucet.Service
	TimeTravel    *clock.AdvancingClock
	TestSequencer *TestSequencerRuntime

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

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 Supervisor interface {
	stack.Lifecycle
	UserRPC() string
}

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    *SingleChainNodeRuntime
}

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
}