driver

type AltDAIface interface {
	// Notify L1 finalized head so AltDA finality is always behind L1
	Finalize(ref eth.L1BlockRef)
	// Set the engine finalization signal callback
	OnFinalizedHeadSignal(f altda.HeadSignalFn)

	derive.AltDAInputFetcher
}

type AttributesHandler interface {
	// HasAttributes returns if there are any block attributes to process.
	// HasAttributes is for EngineQueue testing only, and can be removed when attribute processing is fully independent.
	HasAttributes() bool
	// SetAttributes overwrites the set of attributes. This may be nil, to clear what may be processed next.
	SetAttributes(attributes *derive.AttributesWithParent)
	// Proceed runs one attempt of processing attributes, if any.
	// Proceed returns io.EOF if there are no attributes to process.
	Proceed(ctx context.Context) error
}

type Config struct {
	// VerifierConfDepth is the distance to keep from the L1 head when reading L1 data for L2 derivation.
	VerifierConfDepth uint64 `json:"verifier_conf_depth"`

	// SequencerConfDepth is the distance to keep from the L1 head as origin when sequencing new L2 blocks.
	// If this distance is too large, the sequencer may:
	// - not adopt a L1 origin within the allowed time (rollup.Config.MaxSequencerDrift)
	// - not adopt a L1 origin that can be included on L1 within the allowed range (rollup.Config.SeqWindowSize)
	// and thus fail to produce a block with anything more than deposits.
	SequencerConfDepth uint64 `json:"sequencer_conf_depth"`

	// SequencerEnabled is true when the driver should sequence new blocks.
	SequencerEnabled bool `json:"sequencer_enabled"`

	// SequencerStopped is false when the driver should sequence new blocks.
	SequencerStopped bool `json:"sequencer_stopped"`

	// SdmPostExecOptIn is the persisted operator preference for local SDM/PostExec sequencing.
	SdmPostExecOptIn bool `json:"sdm_post_exec_opt_in"`

	// SequencerMaxSafeLag is the maximum number of L2 blocks for restricting the distance between L2 safe and unsafe.
	// Disabled if 0.
	SequencerMaxSafeLag uint64 `json:"sequencer_max_safe_lag"`

	// RecoverMode forces the sequencer to select the next L1 Origin exactly, and create an empty block,
	// to be compatible with verifiers forcefully generating the same block while catching up the sequencing window timeout.
	RecoverMode bool `json:"recover_mode"`

	// SequencerSealingDuration is the amount of the time the sequencer allocates to sealing the block
	// (i.e. it will fetch the payload from the execution engine this much prior to the block's timestamp).
	// If this is <= 0 it is automatically adjusted to 50ms.
	SequencerSealingDuration time.Duration `json:"sequencer_sealing_duration"`

	// Finalizer contains runtime configuration for finality behavior.
	Finalizer *finality.Config `json:"finalizer,omitempty"`
}

type DerivationPipeline interface {
	Reset()
	Step(ctx context.Context, pendingSafeHead eth.L2BlockRef) (*derive.AttributesWithParent, error)
	Origin() eth.L1BlockRef
	DerivationReady() bool
	ConfirmEngineReset()
}

type Drain interface {
	Drain() error
	Await() <-chan struct{}
}

type Driver struct {
	StatusTracker SyncStatusTracker
	Finalizer     Finalizer

	SyncDeriver *SyncDeriver
	// contains filtered or unexported fields
}

type Finalizer interface {
	FinalizedL1() eth.L1BlockRef
	OnL1Finalized(x eth.L1BlockRef)
	event.Deriver
}

type L1Chain interface {
	derive.L1Fetcher
	L1BlockRefByLabel(context.Context, eth.BlockLabel) (eth.L1BlockRef, error)
}

type L1FollowSource interface {
	L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1BlockRef, error)
}

type L2Chain interface {
	engine.Engine
	L2BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)
	L2BlockRefByHash(ctx context.Context, l2Hash common.Hash) (eth.L2BlockRef, error)
	L2BlockRefByNumber(ctx context.Context, num uint64) (eth.L2BlockRef, error)
}

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

type Metrics interface {
	RecordPipelineReset()
	RecordFollowSourceRequest(result string)
	RecordPublishingError()
	RecordDerivationError()

	RecordL1Ref(name string, ref eth.L1BlockRef)
	RecordL2Ref(name string, ref eth.L2BlockRef)
	RecordChannelInputBytes(inputCompressedBytes int)
	RecordHeadChannelOpened()
	RecordChannelTimedOut()
	RecordFrame()

	RecordDerivedBatches(batchType string)

	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)

	SetDerivationIdle(idle bool)
	SetSequencerState(active bool)

	RecordL1ReorgDepth(d uint64)

	opnodemetrics.Metricer
	metered.L1FetcherMetrics
	event.Metrics
	sequencing.Metrics
}

type Network interface {
	// SignAndPublishL2Payload is called by the driver whenever there is a new payload to publish, synchronously with the driver main loop.
	SignAndPublishL2Payload(ctx context.Context, payload *eth.ExecutionPayloadEnvelope) error
}

type SequencerStateListener interface {
	SequencerStarted() error
	SequencerStopped() error
}

type StepDeriver interface {
	event.AttachEmitter
	NextStep() <-chan struct{}
	NextDelayedStep() <-chan time.Time
	RequestStep(ctx context.Context, resetBackoff bool)
	AttemptStep(ctx context.Context)
	ResetStepBackoff(ctx context.Context)
}

type StepEvent struct {
}

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

type SyncDeriver struct {
	// The derivation pipeline is reset whenever we reorg.
	// The derivation pipeline determines the new l2Safe.
	Derivation DerivationPipeline

	SafeHeadNotifs rollup.SafeHeadListener // notified when safe head is updated

	// The engine controller is used by the sequencer & Derivation components.
	// We will also use it for EL sync in a future PR.
	Engine *engine.EngineController

	// Sync Mod Config
	SyncCfg *sync.Config

	Config *rollup.Config

	L1 L1Chain
	// Track L1 view when new unsafe L1 block is observed
	L1Tracker *status.L1Tracker
	L2        L2Chain

	Emitter event.Emitter

	Log log.Logger

	Ctx context.Context

	StepDeriver StepDeriver
}

type SyncStatusTracker interface {
	event.Deriver
	SyncStatus() *eth.SyncStatus
	L1Head() eth.L1BlockRef
	OnL1Unsafe(x eth.L1BlockRef)
	OnL1Safe(x eth.L1BlockRef)
	OnL1Finalized(x eth.L1BlockRef)
}

type UpstreamFollowSource interface {
	L1FollowSource
	GetFollowStatus(ctx context.Context) (*sources.FollowStatus, error)
}