synchronizer

Documentation

Index

• func InitStartBlock(parentCtx context.Context, db db.DB, em etherman.Etherman, genesisBlock uint64, ...) error
• func UnpackTxData(txData []byte) ([]common.Hash, error)
• type BatchSynchronizer
  • func NewBatchSynchronizer(cfg config.L1Config, self common.Address, db db.DB, reorgs <-chan BlockReorg, ...) (*BatchSynchronizer, error)
  • func (bs *BatchSynchronizer) Gaps() map[uint64]uint64
  • func (bs *BatchSynchronizer) Start(ctx context.Context)
  • func (bs *BatchSynchronizer) Stop()
• type BlockReorg
• type CommitteeMapSafe
  • func NewCommitteeMapSafe() *CommitteeMapSafe
  • func (t *CommitteeMapSafe) AsSlice() []etherman.DataCommitteeMember
  • func (t *CommitteeMapSafe) Delete(key common.Address)
  • func (t *CommitteeMapSafe) Length() int
  • func (t *CommitteeMapSafe) Load(addr common.Address) (etherman.DataCommitteeMember, bool)
  • func (t *CommitteeMapSafe) Store(member etherman.DataCommitteeMember)
  • func (t *CommitteeMapSafe) StoreBatch(members []etherman.DataCommitteeMember)
• type ReorgDetector
  • func NewReorgDetector(rpcUrl string, pollingPeriod time.Duration) (*ReorgDetector, error)
  • func (rd *ReorgDetector) Start(ctx context.Context) error
  • func (rd *ReorgDetector) Stop()
  • func (rd *ReorgDetector) Subscribe() <-chan BlockReorg
• type SequencerTracker
• type SyncTask

Functions

func InitStartBlock

func InitStartBlock(
	parentCtx context.Context,
	db db.DB, em etherman.Etherman,
	genesisBlock uint64,
	validiumAddr common.Address,
) error

InitStartBlock initializes the L1 sync task by finding the inception block for the CDKValidium contract

func UnpackTxData

func UnpackTxData(txData []byte) ([]common.Hash, error)

UnpackTxData unpacks the keys in a SequenceBatches event

Types

type BatchSynchronizer

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

BatchSynchronizer watches for number events, checks if they are "locally" stored, then retrieves and stores missing data

func NewBatchSynchronizer

func NewBatchSynchronizer(
	cfg config.L1Config,
	self common.Address,
	db db.DB,
	reorgs <-chan BlockReorg,
	ethClient etherman.Etherman,
	sequencer SequencerTracker,
	rpcClientFactory client.Factory,
) (*BatchSynchronizer, error)

NewBatchSynchronizer creates the BatchSynchronizer

func (*BatchSynchronizer) Gaps

func (bs *BatchSynchronizer) Gaps() map[uint64]uint64

Gaps returns the offchain data gaps

func (*BatchSynchronizer) Start

func (bs *BatchSynchronizer) Start(ctx context.Context)

Start starts the synchronizer

func (*BatchSynchronizer) Stop

func (bs *BatchSynchronizer) Stop()

Stop stops the synchronizer

type BlockReorg

type BlockReorg struct {
	Number uint64
	Hash   ethgo.Hash
}

BlockReorg is emitted to subscribers when a reorg is detected. Number is the block to which the chain rewound.

type CommitteeMapSafe

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

CommitteeMapSafe represents a thread-safe implementation for the data availability committee members map.

func NewCommitteeMapSafe

func NewCommitteeMapSafe() *CommitteeMapSafe

NewCommitteeMapSafe creates a new CommitteeMapSafe.

func (*CommitteeMapSafe) AsSlice

func (t *CommitteeMapSafe) AsSlice() []etherman.DataCommitteeMember

AsSlice returns a slice of etherman.DataCommitteeMembers.

func (*CommitteeMapSafe) Delete

func (t *CommitteeMapSafe) Delete(key common.Address)

Delete deletes the value for a key.

func (*CommitteeMapSafe) Length

func (t *CommitteeMapSafe) Length() int

Length returns the current length of the map.

func (*CommitteeMapSafe) Load

func (t *CommitteeMapSafe) Load(addr common.Address) (etherman.DataCommitteeMember, bool)

Load returns the value stored in the map for a key, or false if no value is present.

func (*CommitteeMapSafe) Store

func (t *CommitteeMapSafe) Store(member etherman.DataCommitteeMember)

Store sets the value for a key.

func (*CommitteeMapSafe) StoreBatch

func (t *CommitteeMapSafe) StoreBatch(members []etherman.DataCommitteeMember)

StoreBatch sets the range of values and keys.

type ReorgDetector

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

ReorgDetector watches for block reorganizations on chain, and sends messages to subscribing components when a reorg is detected.

func NewReorgDetector

func NewReorgDetector(rpcUrl string, pollingPeriod time.Duration) (*ReorgDetector, error)

NewReorgDetector creates a new ReorgDetector

func (*ReorgDetector) Start

func (rd *ReorgDetector) Start(ctx context.Context) error

Start starts the ReorgDetector tracking for reorg events

func (*ReorgDetector) Stop

func (rd *ReorgDetector) Stop()

Stop stops the chain reorganization detector loop

func (*ReorgDetector) Subscribe

func (rd *ReorgDetector) Subscribe() <-chan BlockReorg

Subscribe returns a channel on which the caller can receive reorg messages

type SequencerTracker

type SequencerTracker interface {
	GetSequenceBatch(ctx context.Context, batchNum uint64) (*sequencer.SeqBatch, error)
}

SequencerTracker is an interface that defines functions that a sequencer tracker must implement

type SyncTask

type SyncTask string

SyncTask is the type of the sync task

const (
	// L1SyncTask is the name of the L1 sync task
	L1SyncTask SyncTask = "L1"
)