driver

Documentation

Index

• func NewConfDepth(depth uint64, l1Head func() eth.L1BlockRef, fetcher derive.L1Fetcher) *confDepth
• func NewState(driverCfg *Config, log log.Logger, snapshotLog log.Logger, ...) *state
• type Config
• type DerivationPipeline
• type Downloader
• type Driver
  • func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, network Network, ...) *Driver
  • func (d *Driver) Close() error
  • func (d *Driver) OnL1Finalized(ctx context.Context, finalized eth.L1BlockRef) error
  • func (d *Driver) OnL1Head(ctx context.Context, head eth.L1BlockRef) error
  • func (d *Driver) OnL1Safe(ctx context.Context, safe eth.L1BlockRef) error
  • func (d *Driver) OnUnsafeL2Payload(ctx context.Context, payload *eth.ExecutionPayload) error
  • func (d *Driver) ResetDerivationPipeline(ctx context.Context) error
  • func (d *Driver) Start(ctx context.Context) error
  • func (d *Driver) SyncStatus(ctx context.Context) (*SyncStatus, error)
• type L1Chain
• type L2Chain
• type Metrics
• type Network
• type SyncStatus

Functions

func NewConfDepth

func NewConfDepth(depth uint64, l1Head func() eth.L1BlockRef, fetcher derive.L1Fetcher) *confDepth

func NewState

func NewState(driverCfg *Config, log log.Logger, snapshotLog log.Logger, config *rollup.Config, l1Chain L1Chain, l2Chain L2Chain,
	output outputInterface, derivationPipeline DerivationPipeline, network Network, metrics Metrics) *state

NewState creates a new driver state. State changes take effect though the given output, derivation pipeline and network interfaces.

Types

type Config

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"`
}

type DerivationPipeline

type DerivationPipeline interface {
	Reset()
	Step(ctx context.Context) error
	SetUnsafeHead(head eth.L2BlockRef)
	AddUnsafePayload(payload *eth.ExecutionPayload)
	Finalized() eth.L2BlockRef
	SafeL2Head() eth.L2BlockRef
	UnsafeL2Head() eth.L2BlockRef
	Progress() derive.Progress
}

type Downloader

type Downloader interface {
	InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)
	Fetch(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Transactions, eth.ReceiptsFetcher, error)
}

type Driver

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

func NewDriver

func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, network Network, log log.Logger, snapshotLog log.Logger, metrics Metrics) *Driver

func (*Driver) Close

func (d *Driver) Close() error

func (*Driver) OnL1Finalized

func (d *Driver) OnL1Finalized(ctx context.Context, finalized eth.L1BlockRef) error

func (*Driver) OnL1Head

func (d *Driver) OnL1Head(ctx context.Context, head eth.L1BlockRef) error

func (*Driver) OnL1Safe

func (d *Driver) OnL1Safe(ctx context.Context, safe eth.L1BlockRef) error

func (*Driver) OnUnsafeL2Payload

func (d *Driver) OnUnsafeL2Payload(ctx context.Context, payload *eth.ExecutionPayload) error

func (*Driver) ResetDerivationPipeline

func (d *Driver) ResetDerivationPipeline(ctx context.Context) error

func (*Driver) Start

func (d *Driver) Start(ctx context.Context) error

func (*Driver) SyncStatus

func (d *Driver) SyncStatus(ctx context.Context) (*SyncStatus, error)

type L1Chain

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

type L2Chain

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

type Metrics

type Metrics interface {
	RecordPipelineReset()
	RecordSequencingError()
	RecordPublishingError()
	RecordDerivationError()

	RecordReceivedUnsafePayload(payload *eth.ExecutionPayload)

	RecordL1Ref(name string, ref eth.L1BlockRef)
	RecordL2Ref(name string, ref eth.L2BlockRef)

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

	SetDerivationIdle(idle bool)

	RecordL1ReorgDepth(d uint64)
	CountSequencedTxs(count int)
}

type Network

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

type SyncStatus

type SyncStatus struct {
	// CurrentL1 is the block that the derivation process is currently at,
	// this may not be fully derived into L2 data yet.
	// If the node is synced, this matches the HeadL1, minus the verifier confirmation distance.
	CurrentL1 eth.L1BlockRef `json:"current_l1"`
	// HeadL1 is the perceived head of the L1 chain, no confirmation distance.
	// The head is not guaranteed to build on the other L1 sync status fields,
	// as the node may be in progress of resetting to adapt to a L1 reorg.
	HeadL1      eth.L1BlockRef `json:"head_l1"`
	SafeL1      eth.L1BlockRef `json:"safe_l1"`
	FinalizedL1 eth.L1BlockRef `json:"finalized_l1"`
	// UnsafeL2 is the absolute tip of the L2 chain,
	// pointing to block data that has not been submitted to L1 yet.
	// The sequencer is building this, and verifiers may also be ahead of the
	// SafeL2 block if they sync blocks via p2p or other offchain sources.
	UnsafeL2 eth.L2BlockRef `json:"unsafe_l2"`
	// SafeL2 points to the L2 block that was derived from the L1 chain.
	// This point may still reorg if the L1 chain reorgs.
	SafeL2 eth.L2BlockRef `json:"safe_l2"`
	// FinalizedL2 points to the L2 block that was derived fully from
	// finalized L1 information, thus irreversible.
	FinalizedL2 eth.L2BlockRef `json:"finalized_l2"`
}

SyncStatus is a snapshot of the driver. Values may be zeroed if not yet initialized.