work

type Block interface {
	ID() eth.BlockID
	String() string
}

type BuildJob interface {
	ID() seqtypes.BuildJobID
	Cancel(ctx context.Context) error
	Seal(ctx context.Context) (Block, error)
	String() string
	Close() // cleans up and unregisters the job
}

type Builder interface {
	NewJob(ctx context.Context, opts *seqtypes.BuildOpts) (BuildJob, error)
	String() string
	ID() seqtypes.BuilderID
	io.Closer
}

type Collection interface {
	Builder(id seqtypes.BuilderID) Builder
	Signer(id seqtypes.SignerID) Signer
	Committer(id seqtypes.CommitterID) Committer
	Publisher(id seqtypes.PublisherID) Publisher
	Sequencer(id seqtypes.SequencerID) Sequencer
}

type Committer interface {
	String() string
	ID() seqtypes.CommitterID
	io.Closer
	Commit(ctx context.Context, block SignedBlock) error
}

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

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

type Jobs interface {
	// RegisterJob registers the given block-building job.
	// It may return an error if there already exists a job with the same ID.
	RegisterJob(job BuildJob) error
	// GetJob returns nil if the job isn't known.
	GetJob(id seqtypes.BuildJobID) BuildJob
	// UnregisterJob removes the block-building job from the tracker.
	UnregisterJob(id seqtypes.BuildJobID)
	// Clear unregisters all jobs
	Clear()
	// Len returns the number of registered jobs
	Len() int
}

type Loader interface {
	Load(ctx context.Context) (Starter, error)
}

type Publisher interface {
	String() string
	ID() seqtypes.PublisherID
	io.Closer
	Publish(ctx context.Context, block SignedBlock) error
}

type Sequencer interface {
	String() string
	ID() seqtypes.SequencerID

	// Close the sequencer. After closing successfully the sequencer is no longer usable.
	Close() error

	// Open starts a next sequencing slot
	Open(ctx context.Context) error

	// BuildJob identifies the current block-building work.
	// This work may be interacted with through the block-building API.
	// This may returns nil if there is no active job.
	BuildJob() BuildJob

	// Seal seals the current ongoing block-building job.
	// Returns an error if there was no block-building job open.
	Seal(ctx context.Context) error

	// Prebuilt inserts a pre-built block, skipping block-building.
	Prebuilt(ctx context.Context, block Block) error

	// Sign the previously built block.
	// Returns seqtypes.ErrAlreadySigned if already signed.
	// Returns an error if the block could not be signed.
	Sign(ctx context.Context) error

	// Commit the previously signed block, this ensures we can persist it before relying on it as canonical block.
	// Returns seqtypes.ErrAlreadyCommitted if already committed.
	// Returns an error if the block failed to commit.
	Commit(ctx context.Context) error

	// Publish the previously committed block.
	// Publishing is not respected by next steps.
	// For harder guarantees, use Commit to ensure the payload is successfully shared before the next phase.
	// Re-publishing is allowed.
	// Returns an error if none was previously successfully committed.
	// Returns an error if publishing fails.
	Publish(ctx context.Context) error

	// Next continues to the next sequencing slot.
	// If the current slot is unfinished, then it will finish the current slot.
	// If the current slot is fresh, it will be built.
	// An error is returned if any step fails. It is safe to re-attempt with Next if so.
	Next(ctx context.Context) error

	// Start starts automatic sequencing, on top of the given chain head.
	// An error is returned if the head of the chain does not match the provided head,
	// as safety measure to prevent reorgs during sequencer rotations.
	// An seqtypes.ErrSequencerAlreadyActive error is returned if the sequencer has already been started.
	Start(ctx context.Context, head common.Hash) error

	// Stop stops automatic sequencing, and returns the block-hash of the last sequenced block.
	// An seqtypes.ErrSequencerInactive error is returned if the sequencer has already been stopped.
	Stop(ctx context.Context) (last common.Hash, err error)

	// Active returns true if the automatic sequencing (see Start and Stop) is actively running.
	Active() bool
}

type ServiceOpts struct {
	*StartOpts
	Services Collection
}

type SignedBlock interface {
	Block
	opsigner.SignedObject
}

type Signer interface {
	String() string
	ID() seqtypes.SignerID
	io.Closer
	Sign(ctx context.Context, block Block) (SignedBlock, error)
}

type StartOpts struct {
	Log     log.Logger
	Metrics metrics.Metricer
	Jobs    Jobs
}

type Starter interface {
	Start(ctx context.Context, opts *StartOpts) (*Ensemble, error)
}