derive

package

Go to main page

Versions in this module

v1

v1.10.0

Nov 19, 2024

v1.9.5

Nov 8, 2024

Changes in this version

+ const BatchPast

+ var SystemConfigUpdateEIP1559Params = common.Hash

+ var SystemConfigUpdateFeeScalars = common.Hash

type AttributesQueue

+ func (aq *AttributesQueue) DepositsOnlyAttributes(parent eth.BlockID, derivedFrom eth.L1BlockRef) (*AttributesWithParent, error)

type AttributesWithParent

+ Concluding bool

+ func (a *AttributesWithParent) IsDerived() bool

+ func (a *AttributesWithParent) WithDepositsOnly() *AttributesWithParent

+ type BatchMux struct

+ func NewBatchMux(lgr log.Logger, cfg *rollup.Config, prev NextBatchProvider, ...) *BatchMux

+ func (b *BatchMux) Reset(ctx context.Context, base eth.L1BlockRef, sysCfg eth.SystemConfig) error

+ func (b *BatchMux) Transform(f rollup.ForkName)

+ func (b *BatchMux) TransformHolocene()

type BatchQueue

+ func (bq *BatchQueue) FlushChannel()

+ func (bs *BatchQueue) Log() log.Logger

+ type BatchStage struct

+ func NewBatchStage(log log.Logger, cfg *rollup.Config, prev NextBatchProvider, ...) *BatchStage

+ func (bs *BatchStage) FlushChannel()

+ func (bs *BatchStage) Log() log.Logger

+ func (bs *BatchStage) NextBatch(ctx context.Context, parent eth.L2BlockRef) (*SingularBatch, bool, error)

+ func (bs *BatchStage) Origin() eth.L1BlockRef

+ func (bs *BatchStage) Reset(_ context.Context, base eth.L1BlockRef, _ eth.SystemConfig) error

type Channel

+ func (ch *Channel) ID() ChannelID

+ type ChannelAssembler struct

+ func NewChannelAssembler(log log.Logger, spec ChannelStageSpec, prev NextFrameProvider, m Metrics) *ChannelAssembler

+ func (ca *ChannelAssembler) FlushChannel()

+ func (ca *ChannelAssembler) Log() log.Logger

+ func (ca *ChannelAssembler) NextRawChannel(ctx context.Context) ([]byte, error)

+ func (ca *ChannelAssembler) Origin() eth.L1BlockRef

+ func (ca *ChannelAssembler) Reset(context.Context, eth.L1BlockRef, eth.SystemConfig) error

type ChannelBank

+ func (bq *ChannelBank) FlushChannel()

+ func (cb *ChannelBank) NextRawChannel(ctx context.Context) ([]byte, error)

+ type ChannelFlusher interface

+ FlushChannel func()

type ChannelInReader

+ func (cr *ChannelInReader) FlushChannel()

+ type ChannelMux struct

+ func NewChannelMux(log log.Logger, spec *rollup.ChainSpec, prev NextFrameProvider, m Metrics) *ChannelMux

+ func (c *ChannelMux) Reset(ctx context.Context, base eth.L1BlockRef, sysCfg eth.SystemConfig) error

+ func (c *ChannelMux) Transform(f rollup.ForkName)

+ func (c *ChannelMux) TransformHolocene()

+ type ChannelStageSpec interface

+ ChannelTimeout func(t uint64) uint64

+ MaxRLPBytesPerChannel func(t uint64) uint64

+ type DepositsOnlyPayloadAttributesRequestEvent struct

+ DerivedFrom eth.L1BlockRef

+ Parent eth.BlockID

+ func (ev DepositsOnlyPayloadAttributesRequestEvent) String() string

type DerivationPipeline

+ func (dp *DerivationPipeline) DepositsOnlyAttributes(parent eth.BlockID, derivedFrom eth.L1BlockRef) (*AttributesWithParent, error)

type DeriverL1StatusEvent

+ LastL2 eth.L2BlockRef

type FetchingAttributesBuilder

+ func (ba *FetchingAttributesBuilder) TestSkipL1OriginCheck()

+ type ForkTransformer interface

+ Transform func(rollup.ForkName)

type FrameQueue

+ func (fq *FrameQueue) Transform(f rollup.ForkName)

+ type RawChannelProvider interface

+ NextRawChannel func(ctx context.Context) ([]byte, error)

+ Origin func() eth.L1BlockRef

+ type SingularBatchProvider interface

+ NextBatch func(context.Context, eth.L2BlockRef) (*SingularBatch, bool, error)

+ Origin func() eth.L1BlockRef

v1.9.4

Oct 8, 2024

Changes in this version

+ const L1InfoFuncInteropSignature

+ var L1InfoFuncInteropBytes4 = crypto.Keccak256([]byte(L1InfoFuncInteropSignature))[:4]

v1.9.3

Sep 25, 2024

Changes in this version

+ const AfterForceIncludeSourceDomain

+ const DepositsCompleteGas

+ const DepositsCompleteLen

+ const DepositsCompleteSignature

+ const L1InfoFuncIsthmusSignature

+ var DepositsCompleteBytes4 = crypto.Keccak256([]byte(DepositsCompleteSignature))[:4]

+ var L1InfoFuncIsthmusBytes4 = crypto.Keccak256([]byte(L1InfoFuncIsthmusSignature))[:4]

+ func DepositsCompleteBytes(seqNumber uint64, l1Info eth.BlockInfo) ([]byte, error)

+ func DepositsCompleteDeposit(seqNumber uint64, block eth.BlockInfo) (*types.DepositTx, error)

+ type AfterForceIncludeSource struct

+ L1BlockHash common.Hash

+ SeqNumber uint64

+ func (dep *AfterForceIncludeSource) SourceHash() common.Hash

v1.9.2

Sep 5, 2024

v1.9.1

Aug 28, 2024

Changes in this version

+ type AltDADataSource struct

+ func NewAltDADataSource(log log.Logger, src DataIter, l1 L1Fetcher, fetcher AltDAInputFetcher, ...) *AltDADataSource

+ func (s *AltDADataSource) Next(ctx context.Context) (eth.Data, error)

+ type AltDAInputFetcher interface

+ AdvanceL1Origin func(ctx context.Context, l1 altda.L1Fetcher, blockId eth.BlockID) error

+ GetInput func(ctx context.Context, l1 altda.L1Fetcher, c altda.CommitmentData, ...) (eth.Data, error)

+ Reset func(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

+ type SpanChannelOutOption func(co *SpanChannelOut)

+ func WithMaxBlocksPerSpanBatch(maxBlock int) SpanChannelOutOption

v1.9.0

Aug 7, 2024

Changes in this version

+ var ErrInvalidFormat = errors.New("invalid ecotone l1 block info format")

v1.8.0

Jul 17, 2024

Changes in this version

+ func VerifyNewL1Origin(ctx context.Context, unsafeOrigin eth.L1BlockRef, l1 L1BlockRefByNumber, ...) error

type AttributesWithParent

+ DerivedFrom eth.L1BlockRef

+ type ConfirmPipelineResetEvent struct

+ func (d ConfirmPipelineResetEvent) String() string

+ type ConfirmReceivedAttributesEvent struct

+ func (d ConfirmReceivedAttributesEvent) String() string

type DerivationPipeline

+ func (dp *DerivationPipeline) ConfirmEngineReset()

+ func (dp *DerivationPipeline) DerivationReady() bool

+ type DerivedAttributesEvent struct

+ Attributes *AttributesWithParent

+ func (ev DerivedAttributesEvent) String() string

+ type DeriverIdleEvent struct

+ Origin eth.L1BlockRef

+ func (d DeriverIdleEvent) String() string

+ type DeriverL1StatusEvent struct

+ Origin eth.L1BlockRef

+ func (d DeriverL1StatusEvent) String() string

+ type DeriverMoreEvent struct

+ func (d DeriverMoreEvent) String() string

+ type L1BlockRefByNumber interface

+ L1BlockRefByNumber func(context.Context, uint64) (eth.L1BlockRef, error)

type Metrics

+ RecordPipelineReset func()

+ SetDerivationIdle func(idle bool)

+ type PipelineDeriver struct

+ func NewPipelineDeriver(ctx context.Context, pipeline *DerivationPipeline) *PipelineDeriver

+ func (d *PipelineDeriver) AttachEmitter(em event.Emitter)

+ func (d *PipelineDeriver) OnEvent(ev event.Event) bool

+ type PipelineStepEvent struct

+ PendingSafe eth.L2BlockRef

+ func (ev PipelineStepEvent) String() string

type SpanBatch

+ func (b *SpanBatch) TxCount() (count uint64)

v1.7.7

Jun 5, 2024

Changes in this version

+ var ErrNoFCUNeeded = errors.New("no FCU call was needed")

+ type AttributesHandler interface

+ HasAttributes func() bool

+ Proceed func(ctx context.Context) error

+ SetAttributes func(attributes *AttributesWithParent)

type AttributesWithParent

+ IsLastInSpan bool

+ Parent eth.L2BlockRef

+ type FinalizerHooks interface

+ OnDerivationL1End func(ctx context.Context, derivedFrom eth.L1BlockRef) error

+ PostProcessSafeL2 func(l2Safe eth.L2BlockRef, derivedFrom eth.L1BlockRef)

+ Reset func()

v1.7.6

May 23, 2024

Changes in this version

+ const ChannelVersionBrotli

+ const MaxSpanBatchElementCount

+ const ZlibCM15

+ const ZlibCM8

+ var CompressionAlgos = []CompressionAlgo

+ var GasPriceOracleFjordDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000002")

+ func FjordNetworkUpgradeTransactions() ([]hexutil.Bytes, error)

+ func GetBrotliLevel(algo CompressionAlgo) int

+ func ValidCompressionAlgo(value CompressionAlgo) bool

+ type BaseChannelCompressor struct

+ func (bcc *BaseChannelCompressor) GetCompressed() *bytes.Buffer

+ func (bcc *BaseChannelCompressor) Len() int

+ func (bcc *BaseChannelCompressor) Read(p []byte) (int, error)

type Batch

+ AsSingularBatch func() (*SingularBatch, bool)

+ AsSpanBatch func() (*SpanBatch, bool)

type BatchData

+ ComprAlgo CompressionAlgo

+ type BrotliCompressor struct

+ func (bc *BrotliCompressor) Reset()

type Channel

+ func (ch *Channel) HighestBlock() eth.L1BlockRef

+ type ChannelCompressor interface

+ Close func() error

+ Flush func() error

+ GetCompressed func() *bytes.Buffer

+ Len func() int

+ Read func([]byte) (int, error)

+ Reset func()

+ Write func([]byte) (int, error)

+ func NewChannelCompressor(algo CompressionAlgo) (ChannelCompressor, error)

+ type CompressionAlgo string

+ const Brotli

+ const Brotli10

+ const Brotli11

+ const Brotli9

+ const Zlib

+ func (algo *CompressionAlgo) Clone() any

+ func (algo *CompressionAlgo) IsBrotli() bool

+ func (algo *CompressionAlgo) Set(value string) error

+ func (algo CompressionAlgo) String() string

+ type CompressorWriter interface

+ Close func() error

+ Flush func() error

+ Reset func(io.Writer)

+ Write func([]byte) (int, error)

type SingularBatch

+ func (b *SingularBatch) AsSingularBatch() (*SingularBatch, bool)

+ func (b *SingularBatch) AsSpanBatch() (*SpanBatch, bool)

type SpanBatch

+ func (b *SpanBatch) AsSingularBatch() (*SingularBatch, bool)

+ func (b *SpanBatch) AsSpanBatch() (*SpanBatch, bool)

+ type ZlibCompressor struct

+ func (zc *ZlibCompressor) Reset()

v1.7.4

Apr 23, 2024

v1.7.3

Apr 8, 2024

Changes in this version

+ var ErrCompressorFull = errors.New("compressor is full")

type SingularBatch

+ func RandomSingularBatch(rng *rand.Rand, txCount int, chainID *big.Int) *SingularBatch

type SpanBatch

+ ChainID *big.Int

+ GenesisTimestamp uint64

v1.7.2

Mar 20, 2024

Changes in this version

+ const DerivationVersion1

type EngineController

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

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

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

type EngineQueue

+ func (eq *EngineQueue) BackupUnsafeL2Head() eth.L2BlockRef

type LocalEngineControl

+ BackupUnsafeL2Head func() eth.L2BlockRef

+ SetBackupUnsafeL2Head func(block eth.L2BlockRef, triggerReorg bool)

+ TryBackupUnsafeReorg func(ctx context.Context) (bool, error)

type PlasmaInputFetcher

+ AdvanceL1Origin func(ctx context.Context, l1 plasma.L1Fetcher, blockId eth.BlockID) error

+ Finalize func(ref eth.L1BlockRef)

+ OnFinalizedHeadSignal func(f plasma.HeadSignalFn)

+ Reset func(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

+ type SafeHeadListener interface

+ Enabled func() bool

+ SafeHeadReset func(resetSafeHead eth.L2BlockRef) error

+ SafeHeadUpdated func(newSafeHead eth.L2BlockRef, l1Block eth.BlockID) error

v1.7.0

Feb 22, 2024

v1.6.1

Feb 15, 2024

Changes in this version

+ type PlasmaDataSource struct

+ func NewPlasmaDataSource(log log.Logger, src DataIter, fetcher PlasmaInputFetcher, id eth.BlockID) *PlasmaDataSource

+ func (s *PlasmaDataSource) Next(ctx context.Context) (eth.Data, error)

+ type PlasmaInputFetcher interface

+ GetInput func(ctx context.Context, commitment []byte, blockNumber uint64) (plasma.Input, error)

v1.5.1

Feb 8, 2024

v1.5.0

Jan 31, 2024

Changes in this version

+ const L1InfoBedrockLen

+ const L1InfoEcotoneLen

+ const L1InfoFuncBedrockSignature

+ const L1InfoFuncEcotoneSignature

+ const UpgradeDepositSourceDomain

+ const UpgradeToFuncSignature

+ var EIP4788From = common.HexToAddress("0x0B799C86a49DEeb90402691F1041aa3AF2d3C875")

+ var ErrTypedTxTooShort = errors.New("typed transaction data too short")

+ var GasPriceOracleDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000001")

+ var L1BlockDeployerAddress = common.HexToAddress("0x4210000000000000000000000000000000000000")

+ var L1InfoFuncBedrockBytes4 = crypto.Keccak256([]byte(L1InfoFuncBedrockSignature))[:4]

+ var L1InfoFuncEcotoneBytes4 = crypto.Keccak256([]byte(L1InfoFuncEcotoneSignature))[:4]

+ var UpgradeToFuncBytes4 = crypto.Keccak256([]byte(UpgradeToFuncSignature))[:4]

+ func EcotoneNetworkUpgradeTransactions() ([]hexutil.Bytes, error)

type AttributesWithParent

+ func NewAttributesWithParent(attributes *eth.PayloadAttributes, parent eth.L2BlockRef, isLastInSpan bool) *AttributesWithParent

+ func (a *AttributesWithParent) Attributes() *eth.PayloadAttributes

+ type BlobDataSource struct

+ func (ds *BlobDataSource) Next(ctx context.Context) (eth.Data, error)

+ type CalldataSource struct

+ func (ds *CalldataSource) Next(ctx context.Context) (eth.Data, error)

type DataIter

+ func NewBlobDataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, ...) DataIter

+ func NewCalldataSource(ctx context.Context, log log.Logger, dsCfg DataSourceConfig, ...) DataIter

type DerivationPipeline

+ func (dp *DerivationPipeline) LowestQueuedUnsafeBlock() eth.L2BlockRef

+ type EngineController struct

+ func NewEngineController(engine ExecEngine, log log.Logger, metrics Metrics, rollupCfg *rollup.Config, ...) *EngineController

+ func (e *EngineController) BuildingPayload() (eth.L2BlockRef, eth.PayloadID, bool)

+ func (e *EngineController) CancelPayload(ctx context.Context, force bool) error

+ func (e *EngineController) ConfirmPayload(ctx context.Context, agossip async.AsyncGossiper, ...) (out *eth.ExecutionPayloadEnvelope, errTyp BlockInsertionErrType, err error)

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

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

+ func (e *EngineController) IsEngineSyncing() bool

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

+ func (e *EngineController) ResetBuildingState()

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

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

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

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

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

+ func (e *EngineController) StartPayload(ctx context.Context, parent eth.L2BlockRef, attrs *AttributesWithParent, ...) (errType BlockInsertionErrType, err error)

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

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

type EngineQueue

+ func (eq *EngineQueue) LowestQueuedUnsafeBlock() eth.L2BlockRef

type EngineQueueStage

+ LowestQueuedUnsafeBlock func() eth.L2BlockRef

+ type ExecEngine interface

+ ForkchoiceUpdate func(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error)

+ GetPayload func(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayloadEnvelope, error)

+ L2BlockRefByLabel func(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)

+ NewPayload func(ctx context.Context, payload *eth.ExecutionPayload, ...) (*eth.PayloadStatusV1, error)

+ type L1BlobsFetcher interface

+ GetBlobs func(ctx context.Context, ref eth.L1BlockRef, hashes []eth.IndexedBlobHash) ([]*eth.Blob, error)

type L1BlockInfo

+ BaseFeeScalar uint32

+ BlobBaseFee *big.Int

+ BlobBaseFeeScalar uint32

+ func L1BlockInfoFromBytes(rollupCfg *rollup.Config, l2BlockTime uint64, data []byte) (*L1BlockInfo, error)

+ type L2Source interface

+ L2BlockRefByHash func(ctx context.Context, l2Hash common.Hash) (eth.L2BlockRef, error)

+ L2BlockRefByLabel func(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)

+ L2BlockRefByNumber func(ctx context.Context, num uint64) (eth.L2BlockRef, error)

+ PayloadByHash func(context.Context, common.Hash) (*eth.ExecutionPayloadEnvelope, error)

+ PayloadByNumber func(context.Context, uint64) (*eth.ExecutionPayloadEnvelope, error)

+ type LocalEngineControl interface

+ InsertUnsafePayload func(ctx context.Context, payload *eth.ExecutionPayloadEnvelope, ref eth.L2BlockRef) error

+ IsEngineSyncing func() bool

+ PendingSafeL2Head func() eth.L2BlockRef

+ ResetBuildingState func()

+ SetFinalizedHead func(eth.L2BlockRef)

+ SetPendingSafeL2Head func(eth.L2BlockRef)

+ SetSafeHead func(eth.L2BlockRef)

+ SetUnsafeHead func(eth.L2BlockRef)

+ TryUpdateEngine func(ctx context.Context) error

+ type UpgradeDepositSource struct

+ Intent string

+ func (dep *UpgradeDepositSource) SourceHash() common.Hash

v1.5.0-rc.3

Jan 30, 2024

v1.4.3

Jan 6, 2024

Changes in this version

+ var SystemConfigUpdateGasConfigEcotone = common.Hash

v1.4.2

Dec 22, 2023

Changes in this version

+ const MaxSpanBatchSize

+ const SingularBatchType

+ const SpanBatchType

+ var EngineELSyncing = errors.New("engine is performing EL sync")

+ var ErrChannelOutAlreadyClosed = errors.New("channel-out already closed")

+ var ErrEmptySpanBatch = errors.New("span-batch must not be empty")

+ var ErrTooBigSpanBatchSize = errors.New("span batch size limit reached")

+ func BlockToSingularBatch(block *types.Block) (*SingularBatch, L1BlockInfo, error)

+ func ReadTxData(r *bytes.Reader) ([]byte, int, error)

+ type AttributesWithParent struct

+ type Batch interface

+ GetBatchType func() int

+ GetTimestamp func() uint64

+ LogContext func(log.Logger) log.Logger

type BatchData

+ func NewBatchData(inner InnerBatchData) *BatchData

+ func (bd *BatchData) GetBatchType() uint8

type ChannelOut

+ AddSingularBatch func(*SingularBatch, uint64) (uint64, error)

+ type DataSourceConfig struct

type DerivationPipeline

+ func (dp *DerivationPipeline) PendingSafeL2Head() eth.L2BlockRef

type Engine

+ L2BlockRefByNumber func(ctx context.Context, num uint64) (eth.L2BlockRef, error)

type EngineQueue

+ func (eq *EngineQueue) PendingSafeL2Head() eth.L2BlockRef

type EngineQueueStage

+ PendingSafeL2Head func() eth.L2BlockRef

+ type InnerBatchData interface

+ GetBatchType func() int

type Metrics

+ RecordDerivedBatches func(batchType string)

+ type RawSpanBatch struct

+ func (b *RawSpanBatch) GetBatchType() int

+ func (b *RawSpanBatch) ToSpanBatch(blockTime, genesisTimestamp uint64, chainID *big.Int) (*SpanBatch, error)

+ type SafeBlockFetcher interface

+ L2BlockRefByNumber func(context.Context, uint64) (eth.L2BlockRef, error)

+ PayloadByNumber func(context.Context, uint64) (*eth.ExecutionPayload, error)

+ type SingularBatch struct

+ EpochHash common.Hash

+ EpochNum rollup.Epoch

+ ParentHash common.Hash

+ Timestamp uint64

+ Transactions []hexutil.Bytes

+ func GetSingularBatch(batchData *BatchData) (*SingularBatch, error)

+ func (b *SingularBatch) Epoch() eth.BlockID

+ func (b *SingularBatch) GetBatchType() int

+ func (b *SingularBatch) GetEpochNum() rollup.Epoch

+ func (b *SingularBatch) GetTimestamp() uint64

+ func (b *SingularBatch) LogContext(log log.Logger) log.Logger

+ type SingularChannelOut struct

+ func NewSingularChannelOut(compress Compressor) (*SingularChannelOut, error)

+ func (co *SingularChannelOut) AddBlock(block *types.Block) (uint64, error)

+ func (co *SingularChannelOut) AddSingularBatch(batch *SingularBatch, _ uint64) (uint64, error)

+ func (co *SingularChannelOut) Close() error

+ func (co *SingularChannelOut) Flush() error

+ func (co *SingularChannelOut) FullErr() error

+ func (co *SingularChannelOut) ID() ChannelID

+ func (co *SingularChannelOut) InputBytes() int

+ func (co *SingularChannelOut) OutputFrame(w *bytes.Buffer, maxSize uint64) (uint16, error)

+ func (co *SingularChannelOut) ReadyBytes() int

+ func (co *SingularChannelOut) Reset() error

+ type SpanBatch struct

+ Batches []*SpanBatchElement

+ L1OriginCheck [20]byte

+ ParentCheck [20]byte

+ func DeriveSpanBatch(batchData *BatchData, blockTime, genesisTimestamp uint64, chainID *big.Int) (*SpanBatch, error)

+ func NewSpanBatch(singularBatches []*SingularBatch) *SpanBatch

+ func (b *SpanBatch) AppendSingularBatch(singularBatch *SingularBatch)

+ func (b *SpanBatch) CheckOriginHash(hash common.Hash) bool

+ func (b *SpanBatch) CheckParentHash(hash common.Hash) bool

+ func (b *SpanBatch) GetBatchType() int

+ func (b *SpanBatch) GetBlockCount() int

+ func (b *SpanBatch) GetBlockEpochNum(i int) uint64

+ func (b *SpanBatch) GetBlockTimestamp(i int) uint64

+ func (b *SpanBatch) GetBlockTransactions(i int) []hexutil.Bytes

+ func (b *SpanBatch) GetSingularBatches(l1Origins []eth.L1BlockRef, l2SafeHead eth.L2BlockRef) ([]*SingularBatch, error)

+ func (b *SpanBatch) GetStartEpochNum() rollup.Epoch

+ func (b *SpanBatch) GetTimestamp() uint64

+ func (b *SpanBatch) LogContext(log log.Logger) log.Logger

+ func (b *SpanBatch) MarshalJSON() ([]byte, error)

+ func (b *SpanBatch) ToRawSpanBatch(originChangedBit uint, genesisTimestamp uint64, chainID *big.Int) (*RawSpanBatch, error)

+ type SpanBatchBuilder struct

+ func NewSpanBatchBuilder(genesisTimestamp uint64, chainID *big.Int) *SpanBatchBuilder

+ func (b *SpanBatchBuilder) AppendSingularBatch(singularBatch *SingularBatch, seqNum uint64)

+ func (b *SpanBatchBuilder) GetBlockCount() int

+ func (b *SpanBatchBuilder) GetRawSpanBatch() (*RawSpanBatch, error)

+ func (b *SpanBatchBuilder) Reset()

+ type SpanBatchElement struct

+ EpochNum rollup.Epoch

+ Timestamp uint64

+ Transactions []hexutil.Bytes

+ type SpanChannelOut struct

+ func NewSpanChannelOut(compress Compressor, spanBatchBuilder *SpanBatchBuilder) (*SpanChannelOut, error)

+ func (co *SpanChannelOut) AddBlock(block *types.Block) (uint64, error)

+ func (co *SpanChannelOut) AddSingularBatch(batch *SingularBatch, seqNum uint64) (uint64, error)

+ func (co *SpanChannelOut) Close() error

+ func (co *SpanChannelOut) Flush() error

+ func (co *SpanChannelOut) FullErr() error

+ func (co *SpanChannelOut) ID() ChannelID

+ func (co *SpanChannelOut) InputBytes() int

+ func (co *SpanChannelOut) OutputFrame(w *bytes.Buffer, maxSize uint64) (uint16, error)

+ func (co *SpanChannelOut) ReadyBytes() int

+ func (co *SpanChannelOut) Reset() error

v1.4.0-rc.3

Dec 4, 2023

v1.4.0-rc.2

Dec 1, 2023

v1.4.0-rc.1

Nov 30, 2023

v1.2.0

Oct 6, 2023

v1.1.6

Sep 25, 2023

v1.1.6-rc.2

Sep 25, 2023

v1.1.5-rc.1

Sep 6, 2023

v1.1.4

Aug 16, 2023

Changes in this version

+ var EngineP2PSyncing = errors.New("engine is P2P syncing")

type DerivationPipeline

+ func (dp *DerivationPipeline) EngineSyncTarget() eth.L2BlockRef

type EngineQueue

+ func (eq *EngineQueue) EngineSyncTarget() eth.L2BlockRef

+ func (eq *EngineQueue) SetEngineSyncTarget(head eth.L2BlockRef)

type EngineQueueStage

+ EngineSyncTarget func() eth.L2BlockRef

type Metrics

+ RecordChannelTimedOut func()

+ RecordFrame func()

+ RecordHeadChannelOpened func()

v1.1.4-rc.1

Aug 16, 2023

v1.1.2

Jul 25, 2023

Changes in this version

+ type ResettableStage interface

+ Reset func(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

v1.0.9

May 22, 2023

Changes in this version

+ var CompressorFullErr = errors.New("compressor is full")

type ChannelOut

+ func (co *ChannelOut) FullErr() error

+ type Compressor interface

+ Flush func() error

+ FullErr func() error

+ Len func() int

+ Reset func()

v1.0.8

May 15, 2023

v1.0.7

May 8, 2023

v1.0.6

May 1, 2023

v1.0.5

Apr 24, 2023

v1.0.4

Apr 17, 2023

v1.0.3

Apr 10, 2023

Changes in this version

type DerivationPipeline

+ func (dp *DerivationPipeline) UnsafeL2SyncTarget() eth.L2BlockRef

type EngineQueue

+ func (eq *EngineQueue) UnsafeL2SyncTarget() eth.L2BlockRef

type EngineQueueStage

+ UnsafeL2SyncTarget func() eth.L2BlockRef

type Metrics

+ RecordChannelInputBytes func(inputCompresedBytes int)

v1.0.2

Apr 3, 2023

v1.0.1

Mar 27, 2023

Changes in this version

+ const BatchAccept

+ const BatchDrop

+ const BatchFuture

+ const BatchUndecided

+ const BatchV1Type

+ const ChannelIDLength

+ const DerivationVersion0

+ const FrameV0OverHeadSize

+ const L1InfoArguments

+ const L1InfoDepositSourceDomain

+ const L1InfoFuncSignature

+ const L1InfoLen

+ const MaxChannelBankSize

+ const MaxFrameLen

+ const MaxRLPBytesPerChannel

+ const RegolithSystemTxGas

+ const UserDepositSourceDomain

+ var ConfigUpdateEventABI = "ConfigUpdate(uint256,uint8,bytes)"

+ var ConfigUpdateEventABIHash = crypto.Keccak256Hash([]byte(ConfigUpdateEventABI))

+ var ConfigUpdateEventVersion0 = common.Hash

+ var DepositEventABI = "TransactionDeposited(address,address,uint256,bytes)"

+ var DepositEventABIHash = crypto.Keccak256Hash([]byte(DepositEventABI))

+ var DepositEventVersion0 = common.Hash

+ var DuplicateErr = errors.New("duplicate frame")

+ var ErrCritical = NewCriticalError(nil)

+ var ErrMaxFrameSizeTooSmall = errors.New("maxSize is too small to fit the fixed frame overhead")

+ var ErrNotDepositTx = errors.New("first transaction in block is not a deposit tx")

+ var ErrReset = NewResetError(nil)

+ var ErrTemporary = NewTemporaryError(nil)

+ var ErrTooManyRLPBytes = errors.New("batch would cause RLP bytes to go over limit")

+ var L1BlockAddress = predeploys.L1BlockAddr

+ var L1InfoDepositerAddress = common.HexToAddress("0xdeaddeaddeaddeaddeaddeaddeaddeaddead0001")

+ var L1InfoFuncBytes4 = crypto.Keccak256([]byte(L1InfoFuncSignature))[:4]

+ var NotEnoughData = errors.New("not enough data")

+ var SystemConfigUpdateBatcher = common.Hash

+ var SystemConfigUpdateGasConfig = common.Hash

+ var SystemConfigUpdateGasLimit = common.Hash

+ var SystemConfigUpdateUnsafeBlockSigner = common.Hash

+ func AttributesMatchBlock(attrs *eth.PayloadAttributes, parentHash common.Hash, ...) error

+ func BatchReader(r io.Reader, l1InclusionBlock eth.L1BlockRef) (func() (BatchWithL1InclusionBlock, error), error)

+ func BlockToBatch(block *types.Block) (*BatchData, L1BlockInfo, error)

+ func DataFromEVMTransactions(config *rollup.Config, batcherAddr common.Address, txs types.Transactions, ...) []eth.Data

+ func DeriveDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]hexutil.Bytes, error)

+ func ForceCloseTxData(frames []Frame) ([]byte, error)

+ func L1InfoDeposit(seqNumber uint64, block eth.BlockInfo, sysCfg eth.SystemConfig, regolith bool) (*types.DepositTx, error)

+ func L1InfoDepositBytes(seqNumber uint64, l1Info eth.BlockInfo, sysCfg eth.SystemConfig, regolith bool) ([]byte, error)

+ func L2BlockToBlockRef(block L2BlockRefSource, genesis *rollup.Genesis) (eth.L2BlockRef, error)

+ func MarshalDepositLogEvent(depositContractAddr common.Address, deposit *types.DepositTx) (*types.Log, error)

+ func NewCriticalError(err error) error

+ func NewError(err error, level Level) error

+ func NewResetError(err error) error

+ func NewTemporaryError(err error) error

+ func PayloadToBlockRef(payload *eth.ExecutionPayload, genesis *rollup.Genesis) (eth.L2BlockRef, error)

+ func PayloadToSystemConfig(payload *eth.ExecutionPayload, cfg *rollup.Config) (eth.SystemConfig, error)

+ func ProcessSystemConfigUpdateLogEvent(destSysCfg *eth.SystemConfig, ev *types.Log) error

+ func UnmarshalDepositLogEvent(ev *types.Log) (*types.DepositTx, error)

+ func UpdateSystemConfigWithL1Receipts(sysCfg *eth.SystemConfig, receipts []*types.Receipt, cfg *rollup.Config) error

+ func UserDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]*types.DepositTx, error)

+ type AttributesBuilder interface

+ PreparePayloadAttributes func(ctx context.Context, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err error)

+ type AttributesQueue struct

+ func NewAttributesQueue(log log.Logger, cfg *rollup.Config, builder AttributesBuilder, ...) *AttributesQueue

+ func (aq *AttributesQueue) NextAttributes(ctx context.Context, l2SafeHead eth.L2BlockRef) (*eth.PayloadAttributes, error)

+ func (aq *AttributesQueue) Origin() eth.L1BlockRef

+ func (aq *AttributesQueue) Reset(ctx context.Context, _ eth.L1BlockRef, _ eth.SystemConfig) error

+ type BatchData struct

+ func (b *BatchData) DecodeRLP(s *rlp.Stream) error

+ func (b *BatchData) EncodeRLP(w io.Writer) error

+ func (b *BatchData) MarshalBinary() ([]byte, error)

+ func (b *BatchData) UnmarshalBinary(data []byte) error

+ type BatchQueue struct

+ func NewBatchQueue(log log.Logger, cfg *rollup.Config, prev NextBatchProvider) *BatchQueue

+ func (bq *BatchQueue) AddBatch(batch *BatchData, l2SafeHead eth.L2BlockRef)

+ func (bq *BatchQueue) NextBatch(ctx context.Context, safeL2Head eth.L2BlockRef) (*BatchData, error)

+ func (bq *BatchQueue) Origin() eth.L1BlockRef

+ func (bq *BatchQueue) Reset(ctx context.Context, base eth.L1BlockRef, _ eth.SystemConfig) error

+ type BatchV1 struct

+ EpochHash common.Hash

+ EpochNum rollup.Epoch

+ ParentHash common.Hash

+ Timestamp uint64

+ Transactions []hexutil.Bytes

+ func (b *BatchV1) Epoch() eth.BlockID

+ type BatchValidity uint8

+ func CheckBatch(cfg *rollup.Config, log log.Logger, l1Blocks []eth.L1BlockRef, ...) BatchValidity

+ type BatchWithL1InclusionBlock struct

+ Batch *BatchData

+ L1InclusionBlock eth.L1BlockRef

+ type BlockInsertionErrType uint

+ const BlockInsertOK

+ const BlockInsertPayloadErr

+ const BlockInsertPrestateErr

+ const BlockInsertTemporaryErr

+ func ConfirmPayload(ctx context.Context, log log.Logger, eng Engine, fc eth.ForkchoiceState, ...) (out *eth.ExecutionPayload, errTyp BlockInsertionErrType, err error)

+ func StartPayload(ctx context.Context, eng Engine, fc eth.ForkchoiceState, ...) (id eth.PayloadID, errType BlockInsertionErrType, err error)

+ type ByteReader interface

+ type Channel struct

+ func NewChannel(id ChannelID, openBlock eth.L1BlockRef) *Channel

+ func (ch *Channel) AddFrame(frame Frame, l1InclusionBlock eth.L1BlockRef) error

+ func (ch *Channel) IsReady() bool

+ func (ch *Channel) OpenBlockNumber() uint64

+ func (ch *Channel) Reader() io.Reader

+ func (ch *Channel) Size() uint64

+ type ChannelBank struct

+ func NewChannelBank(log log.Logger, cfg *rollup.Config, prev NextFrameProvider, fetcher L1Fetcher) *ChannelBank

+ func (cb *ChannelBank) IngestFrame(f Frame)

+ func (cb *ChannelBank) NextData(ctx context.Context) ([]byte, error)

+ func (cb *ChannelBank) Origin() eth.L1BlockRef

+ func (cb *ChannelBank) Read() (data []byte, err error)

+ func (cb *ChannelBank) Reset(ctx context.Context, base eth.L1BlockRef, _ eth.SystemConfig) error

+ type ChannelID [ChannelIDLength]byte

+ func (id *ChannelID) UnmarshalText(text []byte) error

+ func (id ChannelID) MarshalText() ([]byte, error)

+ func (id ChannelID) String() string

+ func (id ChannelID) TerminalString() string

+ type ChannelInReader struct

+ func NewChannelInReader(log log.Logger, prev *ChannelBank) *ChannelInReader

+ func (cr *ChannelInReader) NextBatch(ctx context.Context) (*BatchData, error)

+ func (cr *ChannelInReader) NextChannel()

+ func (cr *ChannelInReader) Origin() eth.L1BlockRef

+ func (cr *ChannelInReader) Reset(ctx context.Context, _ eth.L1BlockRef, _ eth.SystemConfig) error

+ func (cr *ChannelInReader) WriteChannel(data []byte) error

+ type ChannelOut struct

+ func NewChannelOut() (*ChannelOut, error)

+ func (co *ChannelOut) AddBatch(batch *BatchData) (uint64, error)

+ func (co *ChannelOut) AddBlock(block *types.Block) (uint64, error)

+ func (co *ChannelOut) Close() error

+ func (co *ChannelOut) Flush() error

+ func (co *ChannelOut) ID() ChannelID

+ func (co *ChannelOut) InputBytes() int

+ func (co *ChannelOut) OutputFrame(w *bytes.Buffer, maxSize uint64) (uint16, error)

+ func (co *ChannelOut) ReadyBytes() int

+ func (co *ChannelOut) Reset() error

+ type DataAvailabilitySource interface

+ OpenData func(ctx context.Context, id eth.BlockID, batcherAddr common.Address) DataIter

+ type DataIter interface

+ Next func(ctx context.Context) (eth.Data, error)

+ func NewDataSource(ctx context.Context, log log.Logger, cfg *rollup.Config, ...) DataIter

+ type DataSource struct

+ func (ds *DataSource) Next(ctx context.Context) (eth.Data, error)

+ type DataSourceFactory struct

+ func NewDataSourceFactory(log log.Logger, cfg *rollup.Config, fetcher L1TransactionFetcher) *DataSourceFactory

+ func (ds *DataSourceFactory) OpenData(ctx context.Context, id eth.BlockID, batcherAddr common.Address) DataIter

+ type DerivationPipeline struct

+ func NewDerivationPipeline(log log.Logger, cfg *rollup.Config, l1Fetcher L1Fetcher, engine Engine, ...) *DerivationPipeline

+ func (dp *DerivationPipeline) AddUnsafePayload(payload *eth.ExecutionPayload)

+ func (dp *DerivationPipeline) BuildingPayload() (onto eth.L2BlockRef, id eth.PayloadID, safe bool)

+ func (dp *DerivationPipeline) CancelPayload(ctx context.Context, force bool) error

+ func (dp *DerivationPipeline) ConfirmPayload(ctx context.Context) (out *eth.ExecutionPayload, errTyp BlockInsertionErrType, err error)

+ func (dp *DerivationPipeline) EngineReady() bool

+ func (dp *DerivationPipeline) Finalize(l1Origin eth.L1BlockRef)

+ func (dp *DerivationPipeline) Finalized() eth.L2BlockRef

+ func (dp *DerivationPipeline) FinalizedL1() eth.L1BlockRef

+ func (dp *DerivationPipeline) GetUnsafeQueueGap(expectedNumber uint64) (uint64, uint64)

+ func (dp *DerivationPipeline) Origin() eth.L1BlockRef

+ func (dp *DerivationPipeline) Reset()

+ func (dp *DerivationPipeline) SafeL2Head() eth.L2BlockRef

+ func (dp *DerivationPipeline) StartPayload(ctx context.Context, parent eth.L2BlockRef, attrs *eth.PayloadAttributes, ...) (errType BlockInsertionErrType, err error)

+ func (dp *DerivationPipeline) Step(ctx context.Context) error

+ func (dp *DerivationPipeline) UnsafeL2Head() eth.L2BlockRef

+ type Engine interface

+ ForkchoiceUpdate func(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error)

+ GetPayload func(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayload, error)

+ L2BlockRefByHash func(ctx context.Context, l2Hash common.Hash) (eth.L2BlockRef, error)

+ L2BlockRefByLabel func(ctx context.Context, label eth.BlockLabel) (eth.L2BlockRef, error)

+ NewPayload func(ctx context.Context, payload *eth.ExecutionPayload) (*eth.PayloadStatusV1, error)

+ PayloadByHash func(context.Context, common.Hash) (*eth.ExecutionPayload, error)

+ PayloadByNumber func(context.Context, uint64) (*eth.ExecutionPayload, error)

+ type EngineControl interface

+ BuildingPayload func() (onto eth.L2BlockRef, id eth.PayloadID, safe bool)

+ CancelPayload func(ctx context.Context, force bool) error

+ ConfirmPayload func(ctx context.Context) (out *eth.ExecutionPayload, errTyp BlockInsertionErrType, err error)

+ StartPayload func(ctx context.Context, parent eth.L2BlockRef, attrs *eth.PayloadAttributes, ...) (errType BlockInsertionErrType, err error)

+ type EngineQueue struct

+ func NewEngineQueue(log log.Logger, cfg *rollup.Config, engine Engine, metrics Metrics, ...) *EngineQueue

+ func (eq *EngineQueue) AddUnsafePayload(payload *eth.ExecutionPayload)

+ func (eq *EngineQueue) BuildingPayload() (onto eth.L2BlockRef, id eth.PayloadID, safe bool)

+ func (eq *EngineQueue) CancelPayload(ctx context.Context, force bool) error

+ func (eq *EngineQueue) ConfirmPayload(ctx context.Context) (out *eth.ExecutionPayload, errTyp BlockInsertionErrType, err error)

+ func (eq *EngineQueue) Finalize(l1Origin eth.L1BlockRef)

+ func (eq *EngineQueue) Finalized() eth.L2BlockRef

+ func (eq *EngineQueue) FinalizedL1() eth.L1BlockRef

+ func (eq *EngineQueue) GetUnsafeQueueGap(expectedNumber uint64) (start uint64, end uint64)

+ func (eq *EngineQueue) Origin() eth.L1BlockRef

+ func (eq *EngineQueue) Reset(ctx context.Context, _ eth.L1BlockRef, _ eth.SystemConfig) error

+ func (eq *EngineQueue) SafeL2Head() eth.L2BlockRef

+ func (eq *EngineQueue) SetUnsafeHead(head eth.L2BlockRef)

+ func (eq *EngineQueue) StartPayload(ctx context.Context, parent eth.L2BlockRef, attrs *eth.PayloadAttributes, ...) (errType BlockInsertionErrType, err error)

+ func (eq *EngineQueue) Step(ctx context.Context) error

+ func (eq *EngineQueue) SystemConfig() eth.SystemConfig

+ func (eq *EngineQueue) UnsafeL2Head() eth.L2BlockRef

+ type EngineQueueStage interface

+ AddUnsafePayload func(payload *eth.ExecutionPayload)

+ Finalize func(l1Origin eth.L1BlockRef)

+ Finalized func() eth.L2BlockRef

+ FinalizedL1 func() eth.L1BlockRef

+ GetUnsafeQueueGap func(expectedNumber uint64) (uint64, uint64)

+ Origin func() eth.L1BlockRef

+ SafeL2Head func() eth.L2BlockRef

+ SetUnsafeHead func(head eth.L2BlockRef)

+ Step func(context.Context) error

+ SystemConfig func() eth.SystemConfig

+ UnsafeL2Head func() eth.L2BlockRef

+ type EngineState interface

+ Finalized func() eth.L2BlockRef

+ SafeL2Head func() eth.L2BlockRef

+ UnsafeL2Head func() eth.L2BlockRef

+ type Error struct

+ func (e Error) Error() string

+ func (e Error) Is(target error) bool

+ func (e Error) Unwrap() error

+ type FetchingAttributesBuilder struct

+ func NewFetchingAttributesBuilder(cfg *rollup.Config, l1 L1ReceiptsFetcher, l2 SystemConfigL2Fetcher) *FetchingAttributesBuilder

+ func (ba *FetchingAttributesBuilder) PreparePayloadAttributes(ctx context.Context, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err error)

+ type FinalityData struct

+ L1Block eth.BlockID

+ L2Block eth.L2BlockRef

+ type Frame struct

+ Data []byte

+ FrameNumber uint16

+ ID ChannelID

+ IsLast bool

+ func ParseFrames(data []byte) ([]Frame, error)

+ func (f *Frame) MarshalBinary(w io.Writer) error

+ func (f *Frame) UnmarshalBinary(r ByteReader) error

+ type FrameQueue struct

+ func NewFrameQueue(log log.Logger, prev NextDataProvider) *FrameQueue

+ func (fq *FrameQueue) NextFrame(ctx context.Context) (Frame, error)

+ func (fq *FrameQueue) Origin() eth.L1BlockRef

+ func (fq *FrameQueue) Reset(_ context.Context, _ eth.L1BlockRef, _ eth.SystemConfig) error

+ type L1BlockInfo struct

+ BaseFee *big.Int

+ BatcherAddr common.Address

+ BlockHash common.Hash

+ L1FeeOverhead eth.Bytes32

+ L1FeeScalar eth.Bytes32

+ Number uint64

+ SequenceNumber uint64

+ Time uint64

+ func L1InfoDepositTxData(data []byte) (L1BlockInfo, error)

+ func (info *L1BlockInfo) MarshalBinary() ([]byte, error)

+ func (info *L1BlockInfo) UnmarshalBinary(data []byte) error

+ type L1BlockRefByHashFetcher interface

+ L1BlockRefByHash func(context.Context, common.Hash) (eth.L1BlockRef, error)

+ type L1BlockRefByNumberFetcher interface

+ FetchReceipts func(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error)

+ L1BlockRefByNumber func(context.Context, uint64) (eth.L1BlockRef, error)

+ type L1Fetcher interface

+ L1BlockRefByLabel func(ctx context.Context, label eth.BlockLabel) (eth.L1BlockRef, error)

+ type L1InfoDepositSource struct

+ L1BlockHash common.Hash

+ SeqNumber uint64

+ func (dep *L1InfoDepositSource) SourceHash() common.Hash

+ type L1ReceiptsFetcher interface

+ FetchReceipts func(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error)

+ InfoByHash func(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)

+ type L1Retrieval struct

+ func NewL1Retrieval(log log.Logger, dataSrc DataAvailabilitySource, prev NextBlockProvider) *L1Retrieval

+ func (l1r *L1Retrieval) NextData(ctx context.Context) ([]byte, error)

+ func (l1r *L1Retrieval) Origin() eth.L1BlockRef

+ func (l1r *L1Retrieval) Reset(ctx context.Context, base eth.L1BlockRef, sysCfg eth.SystemConfig) error

+ type L1TransactionFetcher interface

+ InfoAndTxsByHash func(ctx context.Context, hash common.Hash) (eth.BlockInfo, types.Transactions, error)

+ type L1Traversal struct

+ func NewL1Traversal(log log.Logger, cfg *rollup.Config, l1Blocks L1BlockRefByNumberFetcher) *L1Traversal

+ func (l1c *L1Traversal) SystemConfig() eth.SystemConfig

+ func (l1t *L1Traversal) AdvanceL1Block(ctx context.Context) error

+ func (l1t *L1Traversal) NextL1Block(_ context.Context) (eth.L1BlockRef, error)

+ func (l1t *L1Traversal) Origin() eth.L1BlockRef

+ func (l1t *L1Traversal) Reset(ctx context.Context, base eth.L1BlockRef, cfg eth.SystemConfig) error

+ type L2BlockRefSource interface

+ Hash func() common.Hash

+ NumberU64 func() uint64

+ ParentHash func() common.Hash

+ Time func() uint64

+ Transactions func() types.Transactions

+ type Level uint

+ const LevelCritical

+ const LevelReset

+ const LevelTemporary

+ func (lvl Level) String() string

+ type Metrics interface

+ RecordL1Ref func(name string, ref eth.L1BlockRef)

+ RecordL2Ref func(name string, ref eth.L2BlockRef)

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

+ type NextAttributesProvider interface

+ NextAttributes func(context.Context, eth.L2BlockRef) (*eth.PayloadAttributes, error)

+ Origin func() eth.L1BlockRef

+ type NextBatchProvider interface

+ NextBatch func(ctx context.Context) (*BatchData, error)

+ Origin func() eth.L1BlockRef

+ type NextBlockProvider interface

+ NextL1Block func(context.Context) (eth.L1BlockRef, error)

+ Origin func() eth.L1BlockRef

+ SystemConfig func() eth.SystemConfig

+ type NextDataProvider interface

+ NextData func(context.Context) ([]byte, error)

+ Origin func() eth.L1BlockRef

+ type NextFrameProvider interface

+ NextFrame func(ctx context.Context) (Frame, error)

+ Origin func() eth.L1BlockRef

+ type PayloadsQueue struct

+ MaxSize uint64

+ SizeFn func(p *eth.ExecutionPayload) uint64

+ func NewPayloadsQueue(maxSize uint64, sizeFn func(p *eth.ExecutionPayload) uint64) *PayloadsQueue

+ func (upq *PayloadsQueue) Len() int

+ func (upq *PayloadsQueue) MemSize() uint64

+ func (upq *PayloadsQueue) Peek() *eth.ExecutionPayload

+ func (upq *PayloadsQueue) Pop() *eth.ExecutionPayload

+ func (upq *PayloadsQueue) Push(p *eth.ExecutionPayload) error

+ type ResetableStage interface

+ Reset func(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

+ type ResettableEngineControl interface

+ Reset func()

+ type SystemConfigL2Fetcher interface

+ SystemConfigByL2Hash func(ctx context.Context, hash common.Hash) (eth.SystemConfig, error)

+ type UserDepositSource struct

+ L1BlockHash common.Hash

+ LogIndex uint64

+ func (dep *UserDepositSource) SourceHash() common.Hash

Other modules containing this package

github.com/ethereum-optimism/optimism/op-node

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL