engine

package
v1.10.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 19, 2024 License: MIT, MIT Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrEngineSyncing = errors.New("engine is syncing")
View Source 
var ErrNoFCUNeeded = errors.New("no FCU call was needed")
View Source 
var Kinds = []Kind{
	Geth,
	Reth,
	Erigon,
}

Functions

func ForceEngineReset 

func ForceEngineReset(ec ResetEngineControl, x ForceEngineResetEvent)

ForceEngineReset is not to be used. The op-program needs it for now, until event processing is adopted there.

func ValidEngineKind 

func ValidEngineKind(value Kind) bool

Types

type BlockInsertionErrType 

type BlockInsertionErrType uint
const (
	// BlockInsertOK indicates that the payload was successfully executed and appended to the canonical chain.
	BlockInsertOK BlockInsertionErrType = iota
	// BlockInsertTemporaryErr indicates that the insertion failed but may succeed at a later time without changes to the payload.
	BlockInsertTemporaryErr
	// BlockInsertPrestateErr indicates that the pre-state to insert the payload could not be prepared, e.g. due to missing chain data.
	BlockInsertPrestateErr
	// BlockInsertPayloadErr indicates that the payload was invalid and cannot become canonical.
	BlockInsertPayloadErr
)

type BuildCancelEvent 

type BuildCancelEvent struct {
	Info  eth.PayloadInfo
	Force bool
}

func (BuildCancelEvent) String 

func (ev BuildCancelEvent) String() string

type BuildInvalidEvent 

type BuildInvalidEvent struct {
	Attributes *derive.AttributesWithParent
	Err        error
}

BuildInvalidEvent is an internal engine event, to post-process upon invalid attributes. Not for temporary processing problems.

func (BuildInvalidEvent) String 

func (ev BuildInvalidEvent) String() string

type BuildSealEvent 

type BuildSealEvent struct {
	Info         eth.PayloadInfo
	BuildStarted time.Time
	// if payload should be promoted to safe (must also be pending safe, see DerivedFrom)
	Concluding bool
	// payload is promoted to pending-safe if non-zero
	DerivedFrom eth.L1BlockRef
}

func (BuildSealEvent) String 

func (ev BuildSealEvent) String() string

type BuildSealedEvent 

type BuildSealedEvent struct {
	// if payload should be promoted to (local) safe (must also be pending safe, see DerivedFrom)
	Concluding bool
	// payload is promoted to pending-safe if non-zero
	DerivedFrom eth.L1BlockRef

	Info     eth.PayloadInfo
	Envelope *eth.ExecutionPayloadEnvelope
	Ref      eth.L2BlockRef
}

BuildSealedEvent is emitted by the engine when a payload finished building, but is not locally inserted as canonical block yet

func (BuildSealedEvent) String 

func (ev BuildSealedEvent) String() string

type BuildStartEvent 

type BuildStartEvent struct {
	Attributes *derive.AttributesWithParent
}

func (BuildStartEvent) String 

func (ev BuildStartEvent) String() string

type BuildStartedEvent 

type BuildStartedEvent struct {
	Info eth.PayloadInfo

	BuildStarted time.Time

	Parent eth.L2BlockRef

	// if payload should be promoted to (local) safe (must also be pending safe, see DerivedFrom)
	Concluding bool
	// payload is promoted to pending-safe if non-zero
	DerivedFrom eth.L1BlockRef
}

func (BuildStartedEvent) String 

func (ev BuildStartedEvent) String() string

type CrossSafeUpdateEvent added in v1.9.3 

type CrossSafeUpdateEvent struct {
	CrossSafe eth.L2BlockRef
	LocalSafe eth.L2BlockRef
}

func (CrossSafeUpdateEvent) String added in v1.9.3 

func (ev CrossSafeUpdateEvent) String() string

type CrossUnsafeUpdateEvent added in v1.9.3 

type CrossUnsafeUpdateEvent struct {
	CrossUnsafe eth.L2BlockRef
	LocalUnsafe eth.L2BlockRef
}

CrossUnsafeUpdateEvent signals that the given block is now considered cross-unsafe.

func (CrossUnsafeUpdateEvent) String added in v1.9.3 

func (ev CrossUnsafeUpdateEvent) String() string

type CrossUpdateRequestEvent added in v1.9.3 

type CrossUpdateRequestEvent struct {
	CrossUnsafe bool
	CrossSafe   bool
}

CrossUpdateRequestEvent triggers update events to be emitted, repeating the current state.

func (CrossUpdateRequestEvent) String added in v1.9.3 

func (ev CrossUpdateRequestEvent) String() string

type EngDeriver 

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

func NewEngDeriver 

func NewEngDeriver(log log.Logger, ctx context.Context, cfg *rollup.Config,
	metrics Metrics, ec *EngineController,
) *EngDeriver

func (*EngDeriver) AttachEmitter 

func (d *EngDeriver) AttachEmitter(em event.Emitter)

func (*EngDeriver) OnEvent 

func (d *EngDeriver) OnEvent(ev event.Event) bool

type Engine 

type Engine interface {
	ExecEngine
	derive.L2Source
}

type EngineController 

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

func NewEngineController 

func NewEngineController(engine ExecEngine, log log.Logger, metrics derive.Metrics,
	rollupCfg *rollup.Config, syncCfg *sync.Config, emitter event.Emitter,
) *EngineController

func (*EngineController) BackupUnsafeL2Head 

func (e *EngineController) BackupUnsafeL2Head() eth.L2BlockRef

func (*EngineController) CrossUnsafeL2Head added in v1.9.3 

func (e *EngineController) CrossUnsafeL2Head() eth.L2BlockRef

func (*EngineController) Finalized 

func (e *EngineController) Finalized() eth.L2BlockRef

func (*EngineController) InsertUnsafePayload 

func (e *EngineController) InsertUnsafePayload(ctx context.Context, envelope *eth.ExecutionPayloadEnvelope, ref eth.L2BlockRef) error

func (*EngineController) IsEngineSyncing 

func (e *EngineController) IsEngineSyncing() bool

func (*EngineController) LocalSafeL2Head added in v1.9.3 

func (e *EngineController) LocalSafeL2Head() eth.L2BlockRef

func (*EngineController) PendingSafeL2Head 

func (e *EngineController) PendingSafeL2Head() eth.L2BlockRef

func (*EngineController) SafeL2Head 

func (e *EngineController) SafeL2Head() eth.L2BlockRef

func (*EngineController) SetBackupUnsafeL2Head 

func (e *EngineController) SetBackupUnsafeL2Head(r eth.L2BlockRef, triggerReorg bool)

SetBackupUnsafeL2Head implements LocalEngineControl.

func (*EngineController) SetCrossUnsafeHead added in v1.9.3 

func (e *EngineController) SetCrossUnsafeHead(r eth.L2BlockRef)

SetCrossUnsafeHead the cross-unsafe head.

func (*EngineController) SetFinalizedHead 

func (e *EngineController) SetFinalizedHead(r eth.L2BlockRef)

SetFinalizedHead implements LocalEngineControl.

func (*EngineController) SetLocalSafeHead added in v1.9.3 

func (e *EngineController) SetLocalSafeHead(r eth.L2BlockRef)

SetLocalSafeHead sets the local-safe head.

func (*EngineController) SetPendingSafeL2Head 

func (e *EngineController) SetPendingSafeL2Head(r eth.L2BlockRef)

SetPendingSafeL2Head implements LocalEngineControl.

func (*EngineController) SetSafeHead 

func (e *EngineController) SetSafeHead(r eth.L2BlockRef)

SetSafeHead sets the cross-safe head.

func (*EngineController) SetUnsafeHead 

func (e *EngineController) SetUnsafeHead(r eth.L2BlockRef)

SetUnsafeHead sets the local-unsafe head.

func (*EngineController) TryBackupUnsafeReorg 

func (e *EngineController) TryBackupUnsafeReorg(ctx context.Context) (bool, error)

TryBackupUnsafeReorg attempts to reorg(restore) unsafe head to backupUnsafeHead. If succeeds, update current forkchoice state to the rollup node.

func (*EngineController) TryUpdateEngine 

func (e *EngineController) TryUpdateEngine(ctx context.Context) error

TryUpdateEngine attempts to update the engine with the current forkchoice state of the rollup node, this is a no-op if the nodes already agree on the forkchoice state.

func (*EngineController) UnsafeL2Head 

func (e *EngineController) UnsafeL2Head() eth.L2BlockRef

type EngineResetConfirmedEvent 

type EngineResetConfirmedEvent struct {
	Unsafe, Safe, Finalized eth.L2BlockRef
}

func (EngineResetConfirmedEvent) String 

func (ev EngineResetConfirmedEvent) String() string

type EngineResetDeriver 

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

func NewEngineResetDeriver 

func NewEngineResetDeriver(ctx context.Context, log log.Logger, cfg *rollup.Config,
	l1 sync.L1Chain, l2 sync.L2Chain, syncCfg *sync.Config) *EngineResetDeriver

func (*EngineResetDeriver) AttachEmitter 

func (d *EngineResetDeriver) AttachEmitter(em event.Emitter)

func (*EngineResetDeriver) OnEvent 

func (d *EngineResetDeriver) OnEvent(ev event.Event) bool

type EngineState 

type EngineState interface {
	Finalized() eth.L2BlockRef
	UnsafeL2Head() eth.L2BlockRef
	SafeL2Head() eth.L2BlockRef
}

EngineState provides a read-only interface of the forkchoice state properties of the L2 Engine.

type ExecEngine 

type ExecEngine interface {
	GetPayload(ctx context.Context, payloadInfo eth.PayloadInfo) (*eth.ExecutionPayloadEnvelope, error)
	ForkchoiceUpdate(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error)
	NewPayload(ctx context.Context, payload *eth.ExecutionPayload, parentBeaconBlockRoot *common.Hash) (*eth.PayloadStatusV1, error)
	L2BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)
}

type FinalizedUpdateEvent added in v1.9.5 

type FinalizedUpdateEvent struct {
	Ref eth.L2BlockRef
}

FinalizedUpdateEvent signals that a block has been marked as finalized.

func (FinalizedUpdateEvent) String added in v1.9.5 

func (ev FinalizedUpdateEvent) String() string

type ForceEngineResetEvent 

type ForceEngineResetEvent struct {
	Unsafe, Safe, Finalized eth.L2BlockRef
}

func (ForceEngineResetEvent) String 

func (ev ForceEngineResetEvent) String() string

type ForkchoiceRequestEvent 

type ForkchoiceRequestEvent struct{}

ForkchoiceRequestEvent signals to the engine that it should emit an artificial forkchoice-update event, to signal the latest forkchoice to other derivers. This helps decouple derivers from the actual engine state, while also not making the derivers wait for a forkchoice update at random.

func (ForkchoiceRequestEvent) String 

func (ev ForkchoiceRequestEvent) String() string

type ForkchoiceUpdateEvent 

type ForkchoiceUpdateEvent struct {
	UnsafeL2Head, SafeL2Head, FinalizedL2Head eth.L2BlockRef
}

func (ForkchoiceUpdateEvent) String 

func (ev ForkchoiceUpdateEvent) String() string

type InteropPendingSafeChangedEvent added in v1.9.5 

type InteropPendingSafeChangedEvent struct {
	Ref         eth.L2BlockRef
	DerivedFrom eth.L1BlockRef
}

func (InteropPendingSafeChangedEvent) String added in v1.9.5 

func (ev InteropPendingSafeChangedEvent) String() string

type InvalidPayloadAttributesEvent 

type InvalidPayloadAttributesEvent struct {
	Attributes *derive.AttributesWithParent
	Err        error
}

InvalidPayloadAttributesEvent is a signal to external derivers that the attributes were invalid.

func (InvalidPayloadAttributesEvent) String 

func (ev InvalidPayloadAttributesEvent) String() string

type Kind 

type Kind string

Kind identifies the engine client's kind, used to control the behavior of optimism in different engine clients. 

const (
	Geth   Kind = "geth"
	Reth   Kind = "reth"
	Erigon Kind = "erigon"
)

func (*Kind) Clone 

func (kind *Kind) Clone() any

func (*Kind) Set 

func (kind *Kind) Set(value string) error

func (Kind) String 

func (kind Kind) String() string

func (Kind) SupportsPostFinalizationELSync 

func (kind Kind) SupportsPostFinalizationELSync() bool

type LocalEngineControl 

type LocalEngineControl interface {
	LocalEngineState
	ResetEngineControl
}

type LocalEngineState 

type LocalEngineState interface {
	EngineState

	PendingSafeL2Head() eth.L2BlockRef
	BackupUnsafeL2Head() eth.L2BlockRef
}

type LocalSafeUpdateEvent added in v1.9.3 

type LocalSafeUpdateEvent struct {
	Ref         eth.L2BlockRef
	DerivedFrom eth.L1BlockRef
}

LocalSafeUpdateEvent signals that a block is now considered to be local-safe.

func (LocalSafeUpdateEvent) String added in v1.9.3 

func (ev LocalSafeUpdateEvent) String() string

type Metrics 

type Metrics interface {
	CountSequencedTxs(count int)

	RecordSequencerBuildingDiffTime(duration time.Duration)
	RecordSequencerSealingTime(duration time.Duration)
}

type PayloadInvalidEvent 

type PayloadInvalidEvent struct {
	Envelope *eth.ExecutionPayloadEnvelope
	Err      error
}

func (PayloadInvalidEvent) String 

func (ev PayloadInvalidEvent) String() string

type PayloadProcessEvent 

type PayloadProcessEvent struct {
	// if payload should be promoted to (local) safe (must also be pending safe, see DerivedFrom)
	Concluding bool
	// payload is promoted to pending-safe if non-zero
	DerivedFrom eth.L1BlockRef

	Envelope *eth.ExecutionPayloadEnvelope
	Ref      eth.L2BlockRef
}

func (PayloadProcessEvent) String 

func (ev PayloadProcessEvent) String() string

type PayloadSealExpiredErrorEvent 

type PayloadSealExpiredErrorEvent struct {
	Info eth.PayloadInfo
	Err  error

	Concluding  bool
	DerivedFrom eth.L1BlockRef
}

PayloadSealExpiredErrorEvent identifies a form of failed payload-sealing that is not coupled to the attributes themselves, but rather the build-job process. The user should re-attempt by starting a new build process. The payload-sealing job should not be re-attempted, as it most likely expired, timed out, or referenced an otherwise invalidated block-building job identifier.

func (PayloadSealExpiredErrorEvent) String 

func (ev PayloadSealExpiredErrorEvent) String() string

type PayloadSealInvalidEvent 

type PayloadSealInvalidEvent struct {
	Info eth.PayloadInfo
	Err  error

	Concluding  bool
	DerivedFrom eth.L1BlockRef
}

PayloadSealInvalidEvent identifies a permanent in-consensus problem with the payload sealing.

func (PayloadSealInvalidEvent) String 

func (ev PayloadSealInvalidEvent) String() string

type PayloadSuccessEvent 

type PayloadSuccessEvent struct {
	// if payload should be promoted to (local) safe (must also be pending safe, see DerivedFrom)
	Concluding bool
	// payload is promoted to pending-safe if non-zero
	DerivedFrom eth.L1BlockRef

	Envelope *eth.ExecutionPayloadEnvelope
	Ref      eth.L2BlockRef
}

func (PayloadSuccessEvent) String 

func (ev PayloadSuccessEvent) String() string

type PendingSafeRequestEvent 

type PendingSafeRequestEvent struct{}

func (PendingSafeRequestEvent) String 

func (ev PendingSafeRequestEvent) String() string

type PendingSafeUpdateEvent 

type PendingSafeUpdateEvent struct {
	PendingSafe eth.L2BlockRef
	Unsafe      eth.L2BlockRef // tip, added to the signal, to determine if there are existing blocks to consolidate
}

func (PendingSafeUpdateEvent) String 

func (ev PendingSafeUpdateEvent) String() string

type ProcessAttributesEvent 

type ProcessAttributesEvent struct {
	Attributes *derive.AttributesWithParent
}

ProcessAttributesEvent signals to immediately process the attributes.

func (ProcessAttributesEvent) String 

func (ev ProcessAttributesEvent) String() string

type ProcessUnsafePayloadEvent 

type ProcessUnsafePayloadEvent struct {
	Envelope *eth.ExecutionPayloadEnvelope
}

func (ProcessUnsafePayloadEvent) String 

func (ev ProcessUnsafePayloadEvent) String() string

type PromoteCrossUnsafeEvent added in v1.9.3 

type PromoteCrossUnsafeEvent struct {
	Ref eth.L2BlockRef
}

PromoteCrossUnsafeEvent signals that the given block may be promoted to cross-unsafe.

func (PromoteCrossUnsafeEvent) String added in v1.9.3 

func (ev PromoteCrossUnsafeEvent) String() string

type PromoteFinalizedEvent 

type PromoteFinalizedEvent struct {
	Ref eth.L2BlockRef
}

PromoteFinalizedEvent signals that a block can be marked as finalized.

func (PromoteFinalizedEvent) String 

func (ev PromoteFinalizedEvent) String() string

type PromoteLocalSafeEvent added in v1.9.3 

type PromoteLocalSafeEvent struct {
	Ref         eth.L2BlockRef
	DerivedFrom eth.L1BlockRef
}

PromoteLocalSafeEvent signals that a block can be promoted to local-safe.

func (PromoteLocalSafeEvent) String added in v1.9.3 

func (ev PromoteLocalSafeEvent) String() string

type PromotePendingSafeEvent 

type PromotePendingSafeEvent struct {
	Ref         eth.L2BlockRef
	Concluding  bool // Concludes the pending phase, so can be promoted to (local) safe
	DerivedFrom eth.L1BlockRef
}

PromotePendingSafeEvent signals that a block can be marked as pending-safe, and/or safe.

func (PromotePendingSafeEvent) String 

func (ev PromotePendingSafeEvent) String() string

type PromoteSafeEvent added in v1.9.3 

type PromoteSafeEvent struct {
	Ref         eth.L2BlockRef
	DerivedFrom eth.L1BlockRef
}

PromoteSafeEvent signals that a block can be promoted to cross-safe.

func (PromoteSafeEvent) String added in v1.9.3 

func (ev PromoteSafeEvent) String() string

type PromoteUnsafeEvent added in v1.9.3 

type PromoteUnsafeEvent struct {
	Ref eth.L2BlockRef
}

PromoteUnsafeEvent signals that the given block may now become a canonical unsafe block. This is pre-forkchoice update; the change may not be reflected yet in the EL. Note that the legacy pre-event-refactor code-path (processing P2P blocks) does fire this, but manually, duplicate with the newer events processing code-path. See EngineController.InsertUnsafePayload.

func (PromoteUnsafeEvent) String added in v1.9.3 

func (ev PromoteUnsafeEvent) String() string

type RequestCrossSafeEvent added in v1.9.3 

type RequestCrossSafeEvent struct{}

RequestCrossSafeEvent signals that a CrossSafeUpdate is needed.

func (RequestCrossSafeEvent) String added in v1.9.3 

func (ev RequestCrossSafeEvent) String() string

type RequestCrossUnsafeEvent added in v1.9.3 

type RequestCrossUnsafeEvent struct{}

RequestCrossUnsafeEvent signals that a CrossUnsafeUpdateEvent is needed.

func (RequestCrossUnsafeEvent) String added in v1.9.3 

func (ev RequestCrossUnsafeEvent) String() string

type RequestFinalizedUpdateEvent added in v1.9.5 

type RequestFinalizedUpdateEvent struct{}

RequestFinalizedUpdateEvent signals that a FinalizedUpdateEvent is needed.

func (RequestFinalizedUpdateEvent) String added in v1.9.5 

func (ev RequestFinalizedUpdateEvent) String() string

type ResetEngineControl 

type ResetEngineControl interface {
	SetUnsafeHead(eth.L2BlockRef)
	SetSafeHead(eth.L2BlockRef)
	SetFinalizedHead(eth.L2BlockRef)
	SetLocalSafeHead(ref eth.L2BlockRef)
	SetCrossUnsafeHead(ref eth.L2BlockRef)
	SetBackupUnsafeL2Head(block eth.L2BlockRef, triggerReorg bool)
	SetPendingSafeL2Head(eth.L2BlockRef)
}

type ResetEngineRequestEvent 

type ResetEngineRequestEvent struct{}

ResetEngineRequestEvent requests the EngineResetDeriver to walk the L2 chain backwards until it finds a plausible unsafe head, and find an L2 safe block that is guaranteed to still be from the L1 chain.

func (ResetEngineRequestEvent) String 

func (ev ResetEngineRequestEvent) String() string

type SafeDerivedEvent 

type SafeDerivedEvent struct {
	Safe        eth.L2BlockRef
	DerivedFrom eth.L1BlockRef
}

SafeDerivedEvent signals that a block was determined to be safe, and derived from the given L1 block. This is signaled upon successful processing of PromoteSafeEvent.

func (SafeDerivedEvent) String 

func (ev SafeDerivedEvent) String() string

type TryBackupUnsafeReorgEvent 

type TryBackupUnsafeReorgEvent struct{}

func (TryBackupUnsafeReorgEvent) String 

func (ev TryBackupUnsafeReorgEvent) String() string

type TryUpdateEngineEvent 

type TryUpdateEngineEvent struct{}

func (TryUpdateEngineEvent) String 

func (ev TryUpdateEngineEvent) String() string

type UnsafeUpdateEvent added in v1.9.3 

type UnsafeUpdateEvent struct {
	Ref eth.L2BlockRef
}

UnsafeUpdateEvent signals that the given block is now considered safe. This is pre-forkchoice update; the change may not be reflected yet in the EL.

func (UnsafeUpdateEvent) String added in v1.9.3 

func (ev UnsafeUpdateEvent) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.