sequencing

type AsyncGossiper interface {
	Gossip(payload *eth.ExecutionPayloadEnvelope)
	Get() *eth.ExecutionPayloadEnvelope
	Clear()
	Stop()
	Start()
}

type BuildingState struct {
	Onto eth.L2BlockRef
	Info eth.PayloadInfo

	Started time.Time

	// Set once known
	Ref eth.L2BlockRef
}

type DisabledSequencer struct{}

type L1Blocks interface {
	derive.L1BlockRefByHashFetcher
	derive.L1BlockRefByNumberFetcher
}

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

type L1OriginSelectorIface interface {
	FindL1Origin(ctx context.Context, l2Head eth.L2BlockRef) (eth.L1BlockRef, error)
	SetRecoverMode(bool)
}

type Metrics interface {
	SetSequencerState(active bool)
	RecordSequencerInconsistentL1Origin(from eth.BlockID, to eth.BlockID)
	RecordSequencerReset()
	RecordSequencingError()
}

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

type SequencerEngine interface {
	// RequestForkchoiceUpdate requests the engine to emit a ForkchoiceUpdateEvent,
	// for when no L2 head data is available yet.
	RequestForkchoiceUpdate(ctx context.Context)

	// StartBuild starts a block-building job, returning the payload info and build
	// metadata. Errors: engine.ErrStaleBuild if the parent is no longer the unsafe
	// head (a forkchoice update has been requested, so waiting for the next head
	// update is the way forward), engine.ErrBuildInvalid if the engine rejected the
	// attributes, otherwise a temporary, reset, or critical failure for which the
	// matching event has been emitted.
	StartBuild(ctx context.Context, attrs *derive.AttributesWithParent) (*engine.BuildStartResult, error)

	// SealBuild retrieves a built payload via GetPayload, returning the sealed
	// envelope and block ref. Emits no events. Errors wrap engine.ErrSealExpired
	// (job timed out or is unknown; the same attributes may be rebuilt) or
	// engine.ErrSealInvalid (payload contents rejected), or are
	// engine.ErrStaleBuild when the sealed block no longer extends the unsafe head.
	SealBuild(ctx context.Context, info eth.PayloadInfo, buildStarted time.Time) (*engine.SealResult, error)

	// ProcessPayload inserts a payload via NewPayload, updates the unsafe head, and
	// finalizes via forkchoice update, emitting UnsafeUpdateEvent on success.
	// Errors: engine.ErrStaleBuild if the payload no longer extends the unsafe head
	// and engine.ErrPayloadDenied if the SuperAuthority denied it, both emitting
	// nothing; engine.ErrPayloadInvalid if the engine rejected the block; otherwise
	// a temporary failure whose EngineTemporaryErrorEvent has been emitted.
	ProcessPayload(ctx context.Context, envelope *eth.ExecutionPayloadEnvelope, ref eth.L2BlockRef, buildStarted time.Time) error
}

type SequencerIface interface {
	event.Deriver
	// RunAction performs one sequencer action: start, seal, or (re)process a
	// block. Engine calls inside it use the sequencer's own lifetime context, so
	// it takes none. Called from the sequencer goroutine, or directly by tests.
	RunAction()
	// RunLoop runs the sequencer scheduling loop, and blocks until ctx is canceled.
	RunLoop(ctx context.Context)
	Active() bool
	Init(ctx context.Context, active bool) error
	Start(ctx context.Context, head common.Hash) error
	Stop(ctx context.Context) (hash common.Hash, err error)
	SetMaxSafeLag(ctx context.Context, v uint64) error
	OverrideLeader(ctx context.Context) error
	ConductorEnabled(ctx context.Context) bool
	SetRecoverMode(mode bool)
	Close()
}

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