Enum Header

pub enum Header {
    V1(Header),
    V2(Header),
    V3(Header),
    V99(Header),
}

Each variant represents a specific minor version header.

Variants

V1(Header)

V2(Header)

V3(Header)

V99(Header)

Implementations

impl Header

pub fn version(&self) -> Version

pub(crate) fn create( chain_config: ChainConfig, height: u64, timestamp: u64, l1_head: u64, l1_finalized: Option<L1BlockInfo>, payload_commitment: VidCommitment, builder_commitment: BuilderCommitment, ns_table: NsTable, fee_merkle_tree_root: FeeMerkleCommitment, block_merkle_tree_root: BlockMerkleCommitment, reward_merkle_tree_root: Option<RewardMerkleCommitment>, fee_info: Vec<FeeInfo>, builder_signature: Vec<BuilderSignature>, version: Version, ) -> Self

impl Header

fn from_info( payload_commitment: VidCommitment, builder_commitment: BuilderCommitment, ns_table: NsTable, parent_leaf: &Leaf2, l1: L1Snapshot, l1_deposits: &[FeeInfo], builder_fee: Vec<BuilderFee<SeqTypes>>, view_number: u64, timestamp: u64, state: ValidatedState, chain_config: ChainConfig, version: Version, auction_results: Option<SolverAuctionResults>, validator: Option<Validator<BLSPubKey>>, ) -> Result<Self>

async fn get_chain_config( validated_state: &ValidatedState, instance_state: &NodeState, ) -> Result<ChainConfig>

impl Header

pub fn chain_config(&self) -> ResolvableChainConfig

A commitment to a ChainConfig or a full ChainConfig.

pub fn height(&self) -> u64

pub fn height_mut(&mut self) -> &mut u64

pub fn timestamp(&self) -> u64

pub fn timestamp_mut(&mut self) -> &mut u64

pub fn l1_head(&self) -> u64

The Espresso block header includes a reference to the current head of the L1 chain.

Rollups can use this to facilitate bridging between the L1 and L2 in a deterministic way. This field deterministically associates an L2 block with a recent L1 block the instant the L2 block is sequenced. Rollups can then define the L2 state after this block as the state obtained by executing all the transactions in this block plus all the L1 deposits up to the given L1 block number. Since there is no need to wait for the L2 block to be reflected on the L1, this bridge design retains the low confirmation latency of HotShot.

This block number indicates the unsafe head of the L1 chain, so it is subject to reorgs. For this reason, the Espresso header does not include any information that might change in a reorg, such as the L1 block timestamp or hash. It includes only the L1 block number, which will always refer to some block after a reorg: if the L1 head at the time this block was sequenced gets reorged out, the L1 chain will eventually (and probably quickly) grow to the same height once again, and a different block will exist with the same height. In this way, Espresso does not have to handle L1 reorgs, and the Espresso blockchain will always be reflective of the current state of the L1 blockchain. Rollups that use this block number do have to handle L1 reorgs, but each rollup and each rollup client can decide how many confirmations they want to wait for on top of this l1_head before they consider an L2 block finalized. This offers a tradeoff between low-latency L1-L2 bridges and finality.

Rollups that want a stronger guarantee of finality, or that want Espresso to attest to data from the L1 block that might change in reorgs, can instead use the latest L1 finalized block at the time this L2 block was sequenced: Self::l1_finalized.

pub fn l1_head_mut(&mut self) -> &mut u64

pub fn l1_finalized(&self) -> Option<L1BlockInfo>

The Espresso block header includes information about the latest finalized L1 block.

Similar to l1_head, rollups can use this information to implement a bridge between the L1 and L2 while retaining the finality of low-latency block confirmations from HotShot. Since this information describes the finalized L1 block, a bridge using this L1 block will have much higher latency than a bridge using l1_head. In exchange, rollups that use the finalized block do not have to worry about L1 reorgs, and can inject verifiable attestations to the L1 block metadata (such as its timestamp or hash) into their execution layers, since Espresso replicas will sign this information for the finalized L1 block.

This block may be None in the rare case where Espresso has started shortly after the genesis of the L1, and the L1 has yet to finalize a block. In all other cases it will be Some.

pub fn l1_finalized_mut(&mut self) -> &mut Option<L1BlockInfo>

pub fn payload_commitment(&self) -> VidCommitment

pub fn payload_commitment_mut(&mut self) -> &mut VidCommitment

pub fn builder_commitment(&self) -> &BuilderCommitment

pub fn builder_commitment_mut(&mut self) -> &mut BuilderCommitment

pub fn ns_table(&self) -> &NsTable

pub fn block_merkle_tree_root(&self) -> BlockMerkleCommitment

Root Commitment of Block Merkle Tree

pub fn block_merkle_tree_root_mut(&mut self) -> &mut BlockMerkleCommitment

pub fn fee_merkle_tree_root(&self) -> FeeMerkleCommitment

Root Commitment of FeeMerkleTree

pub fn fee_merkle_tree_root_mut(&mut self) -> &mut FeeMerkleCommitment

pub fn fee_info(&self) -> Vec<FeeInfo>

Fee paid by the block builder

pub fn reward_merkle_tree_root(&self) -> RewardMerkleCommitment

Fee paid by the block builder

pub fn builder_signature(&self) -> Vec<BuilderSignature>

Account (etheruem address) of builder

This signature is not considered formally part of the header; it is just evidence proving that other parts of the header (fee_info) are correct. It exists in the header so that it is available to all nodes to be used during validation. But since it is checked during consensus, any downstream client who has a proof of consensus finality of a header can trust that fee_info is correct without relying on the signature. Thus, this signature is not included in the header commitment.

Trait Implementations

impl BlockHeader<SeqTypes> for Header

fn get_auction_results(&self) -> Option<SolverAuctionResults>

Get the results of the auction for this Header. Only used in post-marketplace versions

async fn new_marketplace( parent_state: &<SeqTypes as NodeType>::ValidatedState, instance_state: &<<SeqTypes as NodeType>::ValidatedState as ValidatedState<SeqTypes>>::Instance, parent_leaf: &Leaf2<SeqTypes>, payload_commitment: VidCommitment, builder_commitment: BuilderCommitment, metadata: <<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata, builder_fee: Vec<BuilderFee<SeqTypes>>, view_number: u64, auction_results: Option<SolverAuctionResults>, version: Version, ) -> Result<Self, Self::Error>

Build a header with the parent validate state, instance-level state, parent leaf, payload commitment, metadata, and auction results. This is only used in post-marketplace versions

fn builder_commitment(&self) -> BuilderCommitment

Commit over fee_amount, payload_commitment and metadata

type Error = InvalidBlockHeader

Error type for this type of block header

async fn new_legacy( parent_state: &ValidatedState, instance_state: &NodeState, parent_leaf: &Leaf2, payload_commitment: VidCommitment, builder_commitment: BuilderCommitment, metadata: <<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata, builder_fee: BuilderFee<SeqTypes>, version: Version, view_number: u64, ) -> Result<Self, Self::Error>

Build a header with the parent validate state, instance-level state, parent leaf, payload and builder commitments, and metadata. This is only used in pre-marketplace versions

fn genesis( instance_state: &NodeState, payload_commitment: VidCommitment, builder_commitment: BuilderCommitment, ns_table: <<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata, ) -> Self

Build the genesis header, payload, and metadata.

fn block_number(&self) -> u64

Get the block number.

fn payload_commitment(&self) -> VidCommitment

Get the payload commitment.

fn metadata( &self, ) -> &<<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata

Get the metadata.

fn get_light_client_state( &self, view: <SeqTypes as NodeType>::View, ) -> Result<LightClientState>

Get the light client state

impl Clone for Header

fn clone(&self) -> Header

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Committable for Header

fn commit(&self) -> Commitment<Self>

Create a binding commitment to self.

fn tag() -> String

Tag that should be used when serializing commitments to this type.

impl Debug for Header

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Header

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExplorerHeader<SeqTypes> for Header

fn reward_balance(&self) -> Self::BalanceAmount

reward_balance at the moment is only implemented as a stub, as block rewards have not yet been implemented.

TODO: update implementation when rewards have been created / supported. Issue: https://github.com/EspressoSystems/espresso-sequencer/issues/1453

type BalanceAmount = FeeAmount

BalanceAmount is a type that represents a general balance amount. It does not indicate how this balance is represented, just that there is a representation of it that adheres to the trait restrictions specified.

type WalletAddress = Vec<FeeAccount>

WalletAddress is a type that represents the address of a Wallet. It does not indicate how this address is represented, just that there is a representation of it that adheres to the trait restrictions specified.

type ProposerId = Vec<FeeAccount>

ProposerId is a type that represents the proposer id of the block. It does not indicate how this proposer id is represented, just that there is a representation of it that adheres to the trait restrictions specified.

type NamespaceId = NamespaceId

NamespaceId is a type that represents the id of a namespace. It does not indicate how this namespace id is represented, just that there is a representation of it that adheres to the trait restrictions specified.

fn proposer_id(&self) -> Self::ProposerId

The proposer id of the block as stored within the block header.

fn fee_info_account(&self) -> Self::WalletAddress

The wallet address of the fee info account contained within the block header.

fn fee_info_balance(&self) -> Self::BalanceAmount

The balance amount of the fee info contained within the block header.

fn namespace_ids(&self) -> Vec<Self::NamespaceId>

A collection of namespace ids that are contained within the block header.

impl Hash for Header

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Header

fn eq(&self, other: &Header) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl QueryableHeader<SeqTypes> for Header

fn timestamp(&self) -> u64

impl Serialize for Header

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Header

impl StructuralPartialEq for Header