derive

package

Go to main page

Versions in this module

v0

v0.10.14

Feb 13, 2023

v0.10.13

Feb 6, 2023

Changes in this version

type BatchData

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

type ChannelOut

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

v0.10.12

Jan 31, 2023

Changes in this version

type ChannelOut

+ func (co *ChannelOut) InputBytes() int

type DerivationPipeline

+ 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) StartPayload(ctx context.Context, parent eth.L2BlockRef, attrs *eth.PayloadAttributes, ...) (errType BlockInsertionErrType, err 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

+ 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) StartPayload(ctx context.Context, parent eth.L2BlockRef, attrs *eth.PayloadAttributes, ...) (errType BlockInsertionErrType, err error)

+ type EngineState interface

+ Finalized func() eth.L2BlockRef

+ SafeL2Head func() eth.L2BlockRef

+ UnsafeL2Head func() eth.L2BlockRef

v0.10.11

Jan 24, 2023

Changes in this version

+ type AttributesBuilder interface

+ PreparePayloadAttributes func(ctx context.Context, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err 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)

v0.10.10

Jan 13, 2023

v0.10.9

Jan 12, 2023

v0.10.8

Jan 12, 2023

v0.10.7

Jan 11, 2023

v0.10.6

Jan 3, 2023

v0.10.5

Dec 23, 2022

Changes in this version

+ var SystemConfigUpdateUnsafeBlockSigner = common.Hash

v0.10.4

Dec 14, 2022

v0.10.3

Dec 6, 2022

v0.10.2

Dec 6, 2022

v0.10.1

Nov 21, 2022

v0.10.0

Nov 7, 2022

v0.9.0

Nov 4, 2022

v0.8.10

Oct 5, 2022

v0.8.9

Sep 29, 2022

Changes in this version

+ type PullStage interface

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

v0.8.8

Sep 26, 2022

v0.8.7

Sep 23, 2022

v0.8.6

Sep 9, 2022

v0.8.5

Sep 9, 2022

v0.8.3

Sep 8, 2022

v0.8.2

Sep 8, 2022

v0.8.1

Sep 8, 2022

v0.8.0

Sep 8, 2022

v0.7.0

Sep 7, 2022

v0.6.0

Aug 26, 2022

v0.5.0

Aug 19, 2022

v0.4.0

Aug 10, 2022

Changes in this version

type L1Fetcher

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

v0.3.0

Jul 12, 2022

Changes in this version

+ const ChannelIDDataSize

+ var DifferentEpoch = errors.New("batch is of different epoch")

+ var ReorgErr = errors.New("reorg")

+ func ValidBatch(batch *BatchData, config *rollup.Config, epoch eth.BlockID, minL2Time uint64, ...) error

type AttributesQueue

+ func (aq *AttributesQueue) AddBatch(batch *BatchData)

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

+ func (aq *AttributesQueue) Progress() Progress

+ func (aq *AttributesQueue) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (aq *AttributesQueue) SafeL2Head() eth.L2BlockRef

+ func (aq *AttributesQueue) Step(ctx context.Context, outer Progress) error

+ type AttributesQueueOutput interface

+ AddSafeAttributes func(attributes *eth.PayloadAttributes)

+ SafeL2Head func() eth.L2BlockRef

type BatchData

+ func FillMissingBatches(batches []*BatchData, epoch eth.BlockID, ...) []*BatchData

+ func FilterBatches(log log.Logger, config *rollup.Config, epoch eth.BlockID, minL2Time uint64, ...) (out []*BatchData)

type BatchQueue

+ func (bq *BatchQueue) Progress() Progress

+ func (bq *BatchQueue) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (bq *BatchQueue) Step(ctx context.Context, outer Progress) error

+ type BatchQueueOutput interface

+ AddBatch func(batch *BatchData)

+ SafeL2Head func() eth.L2BlockRef

+ type BatchQueueStage interface

+ AddBatch func(batch *BatchData) error

type BatchWithL1InclusionBlock

+ func (b BatchWithL1InclusionBlock) Epoch() eth.BlockID

+ type CalldataSource struct

+ func NewCalldataSource(log log.Logger, cfg *rollup.Config, fetcher L1TransactionFetcher) *CalldataSource

+ func (cs *CalldataSource) OpenData(ctx context.Context, id eth.BlockID) (DataIter, error)

type ChannelBank

+ func (ib *ChannelBank) IngestData(data []byte) error

+ func (ib *ChannelBank) Progress() Progress

+ func (ib *ChannelBank) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (ib *ChannelBank) Step(ctx context.Context, outer Progress) error

+ type ChannelBankOutput interface

+ WriteChannel func(data []byte)

type ChannelID

+ Data [ChannelIDDataSize]byte

+ Time uint64

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

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

+ type ChannelIn struct

+ func (ch *ChannelIn) IngestData(frameNum uint64, isLast bool, frameData []byte) error

+ func (ch *ChannelIn) Read() (out []byte)

type ChannelInReader

+ func (cr *ChannelInReader) Progress() Progress

+ func (cr *ChannelInReader) ReadBatch(dest *BatchData) error

+ func (cr *ChannelInReader) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (cr *ChannelInReader) Step(ctx context.Context, outer Progress) error

+ type DataSlice []eth.Data

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

type DerivationPipeline

+ func (dp *DerivationPipeline) Progress() Progress

type Engine

+ L2BlockRefHead func(ctx context.Context) (eth.L2BlockRef, error)

type EngineQueue

+ func (eq *EngineQueue) Progress() Progress

+ func (eq *EngineQueue) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

type EngineQueueStage

+ Progress func() Progress

type L1ReceiptsFetcher

+ Fetch func(ctx context.Context, blockHash common.Hash) (eth.L1Info, types.Transactions, types.Receipts, error)

type L1Retrieval

+ func (l1r *L1Retrieval) Progress() Progress

+ func (l1r *L1Retrieval) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (l1r *L1Retrieval) Step(ctx context.Context, outer Progress) error

+ type L1SourceOutput interface

+ IngestData func(data []byte) error

type L1Traversal

+ func (l1t *L1Traversal) Progress() Progress

+ func (l1t *L1Traversal) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error

+ func (l1t *L1Traversal) Step(ctx context.Context, outer Progress) error

+ type Progress struct

+ Closed bool

+ Origin eth.L1BlockRef

+ func (pr *Progress) Update(outer Progress) (changed bool, err error)

+ type Stage interface

+ ResetStep func(ctx context.Context, l1Fetcher L1Fetcher) error

+ Step func(ctx context.Context, outer Progress) error

+ type StageProgress interface

+ Progress func() Progress

v0.0.1

Dec 6, 2022

Changes in this version

+ const BatchAccept

+ const BatchDrop

+ const BatchFuture

+ const BatchUndecided

+ const BatchV1Type

+ const ChannelIDLength

+ const DerivationVersion0

+ const L1InfoArguments

+ const L1InfoDepositSourceDomain

+ const L1InfoFuncSignature

+ const L1InfoLen

+ const MaxChannelBankSize

+ const MaxFrameLen

+ const MaxRLPBytesPerChannel

+ 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 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

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

+ func BatchReader(r io.Reader, l1InclusionBlock eth.L1BlockRef) (func() (BatchWithL1InclusionBlock, error), 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 L1InfoDeposit(seqNumber uint64, block eth.BlockInfo, sysCfg eth.SystemConfig) (*types.DepositTx, error)

+ func L1InfoDepositBytes(seqNumber uint64, l1Info eth.BlockInfo, sysCfg eth.SystemConfig) ([]byte, 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 PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1ReceiptsFetcher, ...) (attrs *eth.PayloadAttributes, err 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 AttributesQueue struct

+ func NewAttributesQueue(log log.Logger, cfg *rollup.Config, l1Fetcher L1ReceiptsFetcher, ...) *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 InsertHeadBlock(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) 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) AddBlock(block *types.Block) error

+ func (co *ChannelOut) Close() error

+ func (co *ChannelOut) Flush() error

+ func (co *ChannelOut) ID() ChannelID

+ func (co *ChannelOut) OutputFrame(w *bytes.Buffer, maxSize uint64) 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) Finalize(l1Origin eth.L1BlockRef)

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

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

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

+ func (dp *DerivationPipeline) Reset()

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

+ func (dp *DerivationPipeline) SetUnsafeHead(head eth.L2BlockRef)

+ 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 EngineQueue struct

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

+ func (eq *EngineQueue) AddSafeAttributes(attributes *eth.PayloadAttributes)

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

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

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

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

+ func (eq *EngineQueue) LastL2Time() 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) Step(ctx context.Context) error

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

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

+ type EngineQueueStage interface

+ AddSafeAttributes func(attributes *eth.PayloadAttributes)

+ AddUnsafePayload func(payload *eth.ExecutionPayload)

+ Finalize func(l1Origin eth.L1BlockRef)

+ Finalized func() eth.L2BlockRef

+ FinalizedL1 func() eth.L1BlockRef

+ 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 Error struct

+ func (e Error) Error() string

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

+ func (e Error) Unwrap() 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(ctx context.Context, base eth.L1BlockRef) 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 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 (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 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

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