rollup

package
v1.9.4 Latest Latest
Warning

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

 Go to latest Published: Oct 8, 2024 License: MIT, MIT Imports: 15 Imported by: 66

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrBlockTimeZero                 = errors.New("block time cannot be 0")
	ErrMissingChannelTimeout         = errors.New("channel timeout must be set, this should cover at least a L1 block time")
	ErrInvalidSeqWindowSize          = errors.New("sequencing window size must at least be 2")
	ErrInvalidMaxSeqDrift            = errors.New("maximum sequencer drift must be greater than 0")
	ErrMissingGenesisL1Hash          = errors.New("genesis L1 hash cannot be empty")
	ErrMissingGenesisL2Hash          = errors.New("genesis L2 hash cannot be empty")
	ErrGenesisHashesSame             = errors.New("achievement get! rollup inception: L1 and L2 genesis cannot be the same")
	ErrMissingGenesisL2Time          = errors.New("missing L2 genesis time")
	ErrMissingBatcherAddr            = errors.New("missing genesis system config batcher address")
	ErrMissingScalar                 = errors.New("missing genesis system config scalar")
	ErrMissingGasLimit               = errors.New("missing genesis system config gas limit")
	ErrMissingBatchInboxAddress      = errors.New("missing batch inbox address")
	ErrMissingDepositContractAddress = errors.New("missing deposit contract address")
	ErrMissingL1ChainID              = errors.New("L1 chain ID must not be nil")
	ErrMissingL2ChainID              = errors.New("L2 chain ID must not be nil")
	ErrChainIDsSame                  = errors.New("L1 and L2 chain IDs must be different")
	ErrL1ChainIDNotPositive          = errors.New("L1 chain ID must be non-zero and positive")
	ErrL2ChainIDNotPositive          = errors.New("L2 chain ID must be non-zero and positive")
)
View Source 
var ErrNilProof = errors.New("output root proof is nil")
View Source 
var OPStackSupport = params.ProtocolVersionV0{Build: [8]byte{}, Major: 8, Minor: 0, Patch: 0, PreRelease: 0}.Encode()

Functions

func ComputeL2OutputRoot 

func ComputeL2OutputRoot(proofElements *bindings.TypesOutputRootProof) (eth.Bytes32, error)

ComputeL2OutputRoot computes the L2 output root by hashing an output root proof.

func ComputeL2OutputRootV0 added in v1.0.4 

func ComputeL2OutputRootV0(block eth.BlockInfo, storageRoot [32]byte) (eth.Bytes32, error)

Types

type AltDAConfig added in v1.9.1 

type AltDAConfig struct {
	// L1 DataAvailabilityChallenge contract proxy address
	DAChallengeAddress common.Address `json:"da_challenge_contract_address,omitempty"`
	// CommitmentType specifies which commitment type can be used. Defaults to Keccak (type 0) if not present
	CommitmentType string `json:"da_commitment_type"`
	// DA challenge window value set on the DAC contract. Used in alt-da mode
	// to compute when a commitment can no longer be challenged.
	DAChallengeWindow uint64 `json:"da_challenge_window"`
	// DA resolve window value set on the DAC contract. Used in alt-da mode
	// to compute when a challenge expires and trigger a reorg if needed.
	DAResolveWindow uint64 `json:"da_resolve_window"`
}

type ChainSpec added in v1.7.6 

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

func NewChainSpec added in v1.7.6 

func NewChainSpec(config *Config) *ChainSpec

func (*ChainSpec) ChannelTimeout added in v1.7.6 

func (s *ChainSpec) ChannelTimeout(t uint64) uint64

ChannelTimeout returns the channel timeout constant.

func (*ChainSpec) CheckForkActivation added in v1.7.6 

func (s *ChainSpec) CheckForkActivation(log log.Logger, block eth.L2BlockRef)

func (*ChainSpec) IsCanyon added in v1.7.6 

func (s *ChainSpec) IsCanyon(t uint64) bool

IsCanyon returns true if t >= canyon_time

func (*ChainSpec) IsFeatMaxSequencerDriftConstant added in v1.7.6 

func (s *ChainSpec) IsFeatMaxSequencerDriftConstant(t uint64) bool

IsFeatMaxSequencerDriftConstant specifies in which fork the max sequencer drift change to a constant will be performed.

func (*ChainSpec) L2ChainID added in v1.9.3 

func (s *ChainSpec) L2ChainID() *big.Int

L2ChainID returns the chain ID of the L2 chain.

func (*ChainSpec) L2GenesisTime added in v1.9.3 

func (s *ChainSpec) L2GenesisTime() uint64

L2GenesisTime returns the genesis time of the L2 chain.

func (*ChainSpec) MaxChannelBankSize added in v1.7.6 

func (s *ChainSpec) MaxChannelBankSize(t uint64) uint64

MaxChannelBankSize returns the maximum number of bytes the can allocated inside the channel bank before pruning occurs at the given timestamp.

func (*ChainSpec) MaxRLPBytesPerChannel added in v1.7.6 

func (s *ChainSpec) MaxRLPBytesPerChannel(t uint64) uint64

MaxRLPBytesPerChannel returns the maximum amount of bytes that will be read from a channel at a given timestamp.

func (*ChainSpec) MaxSequencerDrift added in v1.7.6 

func (s *ChainSpec) MaxSequencerDrift(t uint64) uint64

MaxSequencerDrift returns the maximum sequencer drift for the given block timestamp. Until Fjord, this was a rollup configuration parameter. Since Fjord, it is a constant, so its effective value should always be queried via the ChainSpec.

type Config 

type Config struct {
	// Genesis anchor point of the rollup
	Genesis Genesis `json:"genesis"`
	// Seconds per L2 block
	BlockTime uint64 `json:"block_time"`
	// Sequencer batches may not be more than MaxSequencerDrift seconds after
	// the L1 timestamp of their L1 origin time.
	//
	// Note: When L1 has many 1 second consecutive blocks, and L2 grows at fixed 2 seconds,
	// the L2 time may still grow beyond this difference.
	//
	// With Fjord, the MaxSequencerDrift becomes a constant. Use the ChainSpec
	// instead of reading this rollup configuration field directly to determine
	// the max sequencer drift for a given block based on the block's L1 origin.
	// Chains that activate Fjord at genesis may leave this field empty.
	MaxSequencerDrift uint64 `json:"max_sequencer_drift,omitempty"`
	// Number of epochs (L1 blocks) per sequencing window, including the epoch L1 origin block itself
	SeqWindowSize uint64 `json:"seq_window_size"`
	// Number of L1 blocks between when a channel can be opened and when it must be closed by.
	ChannelTimeoutBedrock uint64 `json:"channel_timeout"`
	// Required to verify L1 signatures
	L1ChainID *big.Int `json:"l1_chain_id"`
	// Required to identify the L2 network and create p2p signatures unique for this chain.
	L2ChainID *big.Int `json:"l2_chain_id"`

	// RegolithTime sets the activation time of the Regolith network-upgrade:
	// a pre-mainnet Bedrock change that addresses findings of the Sherlock contest related to deposit attributes.
	// "Regolith" is the loose deposited rock that sits on top of Bedrock.
	// Active if RegolithTime != nil && L2 block timestamp >= *RegolithTime, inactive otherwise.
	RegolithTime *uint64 `json:"regolith_time,omitempty"`

	// CanyonTime sets the activation time of the Canyon network upgrade.
	// Active if CanyonTime != nil && L2 block timestamp >= *CanyonTime, inactive otherwise.
	CanyonTime *uint64 `json:"canyon_time,omitempty"`

	// DeltaTime sets the activation time of the Delta network upgrade.
	// Active if DeltaTime != nil && L2 block timestamp >= *DeltaTime, inactive otherwise.
	DeltaTime *uint64 `json:"delta_time,omitempty"`

	// EcotoneTime sets the activation time of the Ecotone network upgrade.
	// Active if EcotoneTime != nil && L2 block timestamp >= *EcotoneTime, inactive otherwise.
	EcotoneTime *uint64 `json:"ecotone_time,omitempty"`

	// FjordTime sets the activation time of the Fjord network upgrade.
	// Active if FjordTime != nil && L2 block timestamp >= *FjordTime, inactive otherwise.
	FjordTime *uint64 `json:"fjord_time,omitempty"`

	// GraniteTime sets the activation time of the Granite network upgrade.
	// Active if GraniteTime != nil && L2 block timestamp >= *GraniteTime, inactive otherwise.
	GraniteTime *uint64 `json:"granite_time,omitempty"`

	// HoloceneTime sets the activation time of the Holocene network upgrade.
	// Active if HoloceneTime != nil && L2 block timestamp >= *HoloceneTime, inactive otherwise.
	HoloceneTime *uint64 `json:"holocene_time,omitempty"`

	// InteropTime sets the activation time for an experimental feature-set, activated like a hardfork.
	// Active if InteropTime != nil && L2 block timestamp >= *InteropTime, inactive otherwise.
	InteropTime *uint64 `json:"interop_time,omitempty"`

	// L1 address that batches are sent to.
	BatchInboxAddress common.Address `json:"batch_inbox_address"`
	// L1 Deposit Contract Address
	DepositContractAddress common.Address `json:"deposit_contract_address"`
	// L1 System Config Address
	L1SystemConfigAddress common.Address `json:"l1_system_config_address"`

	// L1 address that declares the protocol versions, optional (Beta feature)
	ProtocolVersionsAddress common.Address `json:"protocol_versions_address,omitempty"`

	// AltDAConfig. We are in the process of migrating to the AltDAConfig from these legacy top level values
	AltDAConfig *AltDAConfig `json:"alt_da,omitempty"`
}

func LoadOPStackRollupConfig added in v1.1.6 

func LoadOPStackRollupConfig(chainID uint64) (*Config, error)

LoadOPStackRollupConfig loads the rollup configuration of the requested chain ID from the superchain-registry. Some chains may require a SystemConfigProvider to retrieve any values not part of the registry.

func (*Config) ActivateAtGenesis added in v1.9.3 

func (c *Config) ActivateAtGenesis(hardfork ForkName)

func (*Config) AltDAEnabled added in v1.9.1 

func (c *Config) AltDAEnabled() bool

func (*Config) Check 

func (cfg *Config) Check() error

Check verifies that the given configuration makes sense

func (*Config) CheckL1ChainID 

func (cfg *Config) CheckL1ChainID(ctx context.Context, client L1Client) error

CheckL1ChainID checks that the configured L1 chain ID matches the client's chain ID.

func (*Config) CheckL1GenesisBlockHash 

func (cfg *Config) CheckL1GenesisBlockHash(ctx context.Context, client L1Client) error

CheckL1GenesisBlockHash checks that the configured L1 genesis block hash is valid for the given client.

func (*Config) CheckL2ChainID 

func (cfg *Config) CheckL2ChainID(ctx context.Context, client L2Client) error

CheckL2ChainID checks that the configured L2 chain ID matches the client's chain ID.

func (*Config) CheckL2GenesisBlockHash 

func (cfg *Config) CheckL2GenesisBlockHash(ctx context.Context, client L2Client) error

CheckL2GenesisBlockHash checks that the configured L2 genesis block hash is valid for the given client.

func (*Config) Description 

func (c *Config) Description(l2Chains map[string]string) string

Description outputs a banner describing the important parts of rollup configuration in a human-readable form. Optionally provide a mapping of L2 chain IDs to network names to label the L2 chain with if not unknown. The config should be config.Check()-ed before creating a description.

func (*Config) ForkchoiceUpdatedVersion added in v1.5.1 

func (c *Config) ForkchoiceUpdatedVersion(attr *eth.PayloadAttributes) eth.EngineAPIMethod

ForkchoiceUpdatedVersion returns the EngineAPIMethod suitable for the chain hard fork version.

func (*Config) GetOPAltDAConfig added in v1.9.1 

func (c *Config) GetOPAltDAConfig() (altda.Config, error)

GetOPAltDAConfig validates and returns the altDA config from the rollup config.

func (*Config) GetPayloadVersion added in v1.5.1 

func (c *Config) GetPayloadVersion(timestamp uint64) eth.EngineAPIMethod

GetPayloadVersion returns the EngineAPIMethod suitable for the chain hard fork version.

func (*Config) IsCanyon added in v1.1.6 

func (c *Config) IsCanyon(timestamp uint64) bool

IsCanyon returns true if the Canyon hardfork is active at or past the given timestamp.

func (*Config) IsCanyonActivationBlock added in v1.7.6 

func (c *Config) IsCanyonActivationBlock(l2BlockTime uint64) bool

func (*Config) IsDelta added in v1.4.2 

func (c *Config) IsDelta(timestamp uint64) bool

IsDelta returns true if the Delta hardfork is active at or past the given timestamp.

func (*Config) IsDeltaActivationBlock added in v1.7.6 

func (c *Config) IsDeltaActivationBlock(l2BlockTime uint64) bool

func (*Config) IsEcotone added in v1.4.2 

func (c *Config) IsEcotone(timestamp uint64) bool

IsEcotone returns true if the Ecotone hardfork is active at or past the given timestamp.

func (*Config) IsEcotoneActivationBlock added in v1.5.0 

func (c *Config) IsEcotoneActivationBlock(l2BlockTime uint64) bool

IsEcotoneActivationBlock returns whether the specified block is the first block subject to the Ecotone upgrade. Ecotone activation at genesis does not count.

func (*Config) IsFjord added in v1.4.2 

func (c *Config) IsFjord(timestamp uint64) bool

IsFjord returns true if the Fjord hardfork is active at or past the given timestamp.

func (*Config) IsFjordActivationBlock added in v1.7.6 

func (c *Config) IsFjordActivationBlock(l2BlockTime uint64) bool

IsFjordActivationBlock returns whether the specified block is the first block subject to the Fjord upgrade.

func (*Config) IsGranite added in v1.9.0 

func (c *Config) IsGranite(timestamp uint64) bool

IsGranite returns true if the Granite hardfork is active at or past the given timestamp.

func (*Config) IsGraniteActivationBlock added in v1.9.0 

func (c *Config) IsGraniteActivationBlock(l2BlockTime uint64) bool

IsGraniteActivationBlock returns whether the specified block is the first block subject to the Granite upgrade.

func (*Config) IsHolocene added in v1.9.0 

func (c *Config) IsHolocene(timestamp uint64) bool

IsHolocene returns true if the Holocene hardfork is active at or past the given timestamp.

func (*Config) IsHoloceneActivationBlock added in v1.9.0 

func (c *Config) IsHoloceneActivationBlock(l2BlockTime uint64) bool

IsHoloceneActivationBlock returns whether the specified block is the first block subject to the Holocene upgrade.

func (*Config) IsInterop added in v1.4.2 

func (c *Config) IsInterop(timestamp uint64) bool

IsInterop returns true if the Interop hardfork is active at or past the given timestamp.

func (*Config) IsInteropActivationBlock added in v1.7.6 

func (c *Config) IsInteropActivationBlock(l2BlockTime uint64) bool

func (*Config) IsRegolith 

func (c *Config) IsRegolith(timestamp uint64) bool

IsRegolith returns true if the Regolith hardfork is active at or past the given timestamp.

func (*Config) IsRegolithActivationBlock added in v1.7.6 

func (c *Config) IsRegolithActivationBlock(l2BlockTime uint64) bool

func (*Config) L1Signer 

func (c *Config) L1Signer() types.Signer

func (*Config) LogDescription 

func (c *Config) LogDescription(log log.Logger, l2Chains map[string]string)

LogDescription outputs a banner describing the important parts of rollup configuration in a log format. Optionally provide a mapping of L2 chain IDs to network names to label the L2 chain with if not unknown. The config should be config.Check()-ed before creating a description.

func (*Config) NewPayloadVersion added in v1.5.1 

func (c *Config) NewPayloadVersion(timestamp uint64) eth.EngineAPIMethod

NewPayloadVersion returns the EngineAPIMethod suitable for the chain hard fork version.

func (*Config) SyncLookback added in v1.7.2 

func (c *Config) SyncLookback() uint64

SyncLookback computes the number of blocks to walk back in order to find the correct L1 origin. In alt-da mode longest possible window is challenge + resolve windows.

func (*Config) TargetBlockNumber added in v1.0.3 

func (cfg *Config) TargetBlockNumber(timestamp uint64) (num uint64, err error)

func (*Config) TimestampForBlock added in v1.4.2 

func (cfg *Config) TimestampForBlock(blockNumber uint64) uint64

func (*Config) ValidateL1Config 

func (cfg *Config) ValidateL1Config(ctx context.Context, client L1Client) error

ValidateL1Config checks L1 config variables for errors.

func (*Config) ValidateL2Config 

func (cfg *Config) ValidateL2Config(ctx context.Context, client L2Client, skipL2GenesisBlockHash bool) error

ValidateL2Config checks L2 config variables for errors.

type CriticalErrorEvent added in v1.8.0 

type CriticalErrorEvent = event.CriticalErrorEvent

CriticalErrorEvent is an alias for event.CriticalErrorEvent

type EngineTemporaryErrorEvent added in v1.8.0 

type EngineTemporaryErrorEvent struct {
	Err error
}

EngineTemporaryErrorEvent identifies a temporary processing issue. It applies to both L1 and L2 data, often inter-related. This scope will be reduced over time, to only capture L2-engine specific temporary errors. See L1TemporaryErrorEvent for L1 related temporary errors.

func (EngineTemporaryErrorEvent) String added in v1.8.0 

func (ev EngineTemporaryErrorEvent) String() string

type Epoch 

type Epoch uint64

type ForkName added in v1.7.6 

type ForkName string
const (
	Bedrock  ForkName = "bedrock"
	Regolith ForkName = "regolith"
	Canyon   ForkName = "canyon"
	Delta    ForkName = "delta"
	Ecotone  ForkName = "ecotone"
	Fjord    ForkName = "fjord"
	Granite  ForkName = "granite"
	Holocene ForkName = "holocene"
	Interop  ForkName = "interop"
	None     ForkName = "none"
)

type Genesis 

type Genesis struct {
	// The L1 block that the rollup starts *after* (no derived transactions)
	L1 eth.BlockID `json:"l1"`
	// The L2 block the rollup starts from (no transactions, pre-configured state)
	L2 eth.BlockID `json:"l2"`
	// Timestamp of L2 block
	L2Time uint64 `json:"l2_time"`
	// Initial system configuration values.
	// The L2 genesis block may not include transactions, and thus cannot encode the config values,
	// unlike later L2 blocks.
	SystemConfig eth.SystemConfig `json:"system_config"`
}

type L1Client 

type L1Client interface {
	ChainID(context.Context) (*big.Int, error)
	L1BlockRefByNumber(context.Context, uint64) (eth.L1BlockRef, error)
}

type L1TemporaryErrorEvent added in v1.8.0 

type L1TemporaryErrorEvent struct {
	Err error
}

L1TemporaryErrorEvent identifies a temporary issue with the L1 data.

func (L1TemporaryErrorEvent) String added in v1.8.0 

func (ev L1TemporaryErrorEvent) String() string

type L2Client 

type L2Client interface {
	ChainID(context.Context) (*big.Int, error)
	L2BlockRefByNumber(context.Context, uint64) (eth.L2BlockRef, error)
}

type ResetEvent added in v1.8.0 

type ResetEvent struct {
	Err error
}

func (ResetEvent) String added in v1.8.0 

func (ev ResetEvent) String() string

type SafeHeadListener added in v1.8.0 

type SafeHeadListener interface {

	// Enabled reports if this safe head listener is actively using the posted data. This allows the engine queue to
	// optionally skip making calls that may be expensive to prepare.
	// Callbacks may still be made if Enabled returns false but are not guaranteed.
	Enabled() bool

	// SafeHeadUpdated indicates that the safe head has been updated in response to processing batch data
	// The l1Block specified is the first L1 block containing all required batch data to derive newSafeHead
	SafeHeadUpdated(newSafeHead eth.L2BlockRef, l1Block eth.BlockID) error

	// SafeHeadReset indicates that the derivation pipeline reset back to the specified safe head
	// The L1 block that made the new safe head safe is unknown.
	SafeHeadReset(resetSafeHead eth.L2BlockRef) error
}

SafeHeadListener is called when the safe head is updated. The safe head may advance by more than one block in a single update The l1Block specified is the first L1 block that includes sufficient information to derive the new safe head

Source Files

View all Source files

Directories

Path Synopsis
Package derive provides the data transformation functions that take L1 data and turn it into L2 blocks and results.
 Package derive provides the data transformation functions that take L1 data and turn it into L2 blocks and results.
mocks
test
Package sync is responsible for reconciling L1 and L2.
 Package sync is responsible for reconciling L1 and L2.

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.