Struct SeqTypes 

pub struct SeqTypes;

Trait Implementations

impl BlockHeader<SeqTypes> for Header

fn builder_commitment(&self) -> BuilderCommitment

From 0.7 the header carries none. The trait wants a value, so those headers report the digest of no bytes.

type Error = InvalidBlockHeader

Error type for this type of block header

async fn new( 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: <SeqTypes as NodeType>::BlockPayload, metadata: &<<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata, _: Version, ) -> Self

Build the genesis header, payload, and metadata.

fn timestamp(&self) -> u64

Get the timestamp.

fn timestamp_millis(&self) -> u64

Get the timestamp in milliseconds.

fn block_number(&self) -> u64

Get the block number.

fn version(&self) -> Version

Get the protocol version for this block.

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: ViewNumber) -> Result<LightClientState>

Get the light client state

fn auth_root(&self) -> Result<B256>

Returns the auth_root value for versions >= V4 (DrbAndHeaderUpgrade).

impl BlockPayload<SeqTypes> for Payload

fn transaction_commitments( &self, metadata: &Self::Metadata, ) -> Vec<Commitment<Self::Transaction>>

The per-transaction Keccak256 is the serial tail of block recovery: it runs between the parallel erasure decode and the vote, and grows linearly with the block’s transaction count. Each hash is independent. Each runs in a tx_hash debug span.

Indices are materialized first — an NsIndex plus a position, far smaller than the transactions themselves — so only the hashing goes wide, and only past MIN_PARALLEL_TRANSACTIONS or MIN_PARALLEL_BYTES.

Order must match Self::transactions: callers pair a commitment index with a transaction index. par_iter is an indexed parallel iterator, so collect preserves it, and the index sequence is iter’s, exactly as the serial default gets it through enumerate.

fn num_transactions(&self, metadata: &Self::Metadata) -> usize

Counts the indices iter yields. The default builds every transaction, copying its bytes, only to count it.

type Error = BlockBuildingError

The error type for this type of block

type Transaction = Transaction

The type of the transitions we are applying

type Instance = NodeState

The type of the instance-level state this state is associated with

type Metadata = NsTable

Data created during block building which feeds into the block header

type ValidatedState = ValidatedState

Validated State

fn from_transactions<'life0, 'life1, 'life2, 'async_trait>( transactions: &'life0 [Self::Transaction], validated_state: &'life1 Self::ValidatedState, instance_state: &'life2 Self::Instance, ) -> Pin<Box<dyn Future<Output = Result<(Self, Self::Metadata), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Build a payload and associated metadata with the transactions. This function is asynchronous because it may need to request updated state from the peers via GET requests.

fn from_bytes(block_payload_bytes: &[u8], ns_table: &Self::Metadata) -> Self

Build a payload with the encoded transaction bytes, metadata, and the associated number of VID storage nodes

fn empty() -> (Self, Self::Metadata)

Build the payload and metadata for genesis/null block.

fn builder_commitment(&self, metadata: &Self::Metadata) -> BuilderCommitment

Generate commitment that builders use to sign block options.

fn transactions<'a>( &'a self, metadata: &'a Self::Metadata, ) -> impl 'a + Iterator<Item = Self::Transaction>

Get the transactions in the payload.

fn txn_bytes(&self) -> usize

Get the number of bytes of transactions in the payload.

impl Clone for SeqTypes

fn clone(&self) -> SeqTypes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SeqTypes

impl Debug for SeqTypes

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

Formats the value using the given formatter.

impl Default for SeqTypes

fn default() -> SeqTypes

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SeqTypes

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SeqTypes

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-network/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.

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

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

impl ExplorerTransaction<SeqTypes> for Transaction

fn namespace_id(&self) -> NamespaceId

namespace_id returns the namespace id of the individual transaction.

fn payload_size(&self) -> u64

payload_size returns the size of the payload of the transaction.

impl Hash for SeqTypes

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 Membership<SeqTypes> for EpochCommittees

async fn load_stake_table(&self, epoch: EpochNumber) -> bool

Load the committee for epoch from storage.

Everything persisted for the epoch is restored: the stake table, the epoch root header, and the randomized committee (rebuilt from the DRB result).

async fn add_epoch_root( &self, block_header: Header, coordinator: &EpochMembershipCoordinator<SeqTypes>, ) -> Result<(), Self::Error>

Adds the epoch committee and block reward for a given epoch, either by fetching from L1 or using local state if available. It also calculates and stores the block reward based on header version.

type Error = EpochCommitteesError

type Snapshot = EpochSnapshot

A consistent per-epoch view, returned by Self::snapshot.

fn snapshot(&self, epoch: EpochNumber) -> Option<Self::Snapshot>

Capture a consistent per-epoch view.

fn genesis_stake_tables(&self) -> Arc<GenesisStakeTables<SeqTypes>>

The stake tables of views before the first epoch.

async fn get_epoch_root( &self, epoch: EpochNumber, coordinator: &EpochMembershipCoordinator<SeqTypes>, ) -> Result<Leaf2, Self::Error>

Gets the validated block header and epoch number of the epoch root at the given block height.

async fn get_epoch_drb( &self, epoch: EpochNumber, coordinator: &EpochMembershipCoordinator<SeqTypes>, ) -> Result<DrbResult, Self::Error>

Gets the DRB result for the given epoch.

fn add_drb_result(&self, epoch: EpochNumber, drb: DrbResult)

Called to notify the Membership when a new DRB result has been calculated.

fn first_epoch(&self) -> EpochNumber

The first epoch, which runs on the genesis stake table.

fn highest_known_epoch(&self) -> Option<EpochNumber>

Get the highest epoch for which a stake table is currently in memory, or None if no stake tables are loaded. It is where catchup resumes from, so an implementation that leaves it at None makes catchup rediscover that point one epoch at a time.

fn add_da_committee( &self, first_epoch: EpochNumber, committee: Vec<PeerConfig<SeqTypes>>, )

Register a DA committee that takes effect starting at first_epoch.

impl MembershipSnapshot<SeqTypes> for EpochSnapshot

fn lookup_leader(&self, view: ViewNumber) -> Result<PubKey, Self::Error>

Returns the leader’s public key for a given view number in this epoch.

Errors

Returns LeaderLookupError if the snapshot’s epoch is before first_epoch, the randomized committee is missing, or the epoch has no eligible leader.

type Error = EpochCommitteesError

type StakeTableHash = StakeTableState

fn epoch(&self) -> EpochNumber

The epoch this snapshot is bound to.

fn first_epoch(&self) -> EpochNumber

The first epoch of the membership.

fn has_drb(&self) -> bool

Whether a randomized stake table (DRB result) was available for this epoch at the time the snapshot was captured.

fn stake_table( &self, ) -> impl ExactSizeIterator<Item = &PeerConfig<SeqTypes>> + Send

The (non-DA) stake table for this epoch.

fn da_stake_table( &self, ) -> impl ExactSizeIterator<Item = &PeerConfig<SeqTypes>> + Send

The DA stake table for this epoch.

fn committee_members( &self, _: ViewNumber, ) -> impl ExactSizeIterator<Item = &PubKey> + Send

The set of public keys with stake in this epoch, in stake-table order.

fn da_committee_members( &self, _: ViewNumber, ) -> impl ExactSizeIterator<Item = &PubKey> + Send

The set of public keys in the DA committee for this epoch.

fn stake(&self, key: &PubKey) -> Option<PeerConfig<SeqTypes>>

The stake-table entry for key, or None if the key is not in the committee for this epoch.

fn da_stake(&self, key: &PubKey) -> Option<PeerConfig<SeqTypes>>

The DA stake-table entry for key, or None.

fn has_stake(&self, key: &PubKey) -> bool

Whether key has stake in this epoch.

fn has_da_stake(&self, key: &PubKey) -> bool

Whether key has DA stake in this epoch.

fn stake_table_hash(&self) -> Option<Commitment<Self::StakeTableHash>>

The commitment of the stake table for this epoch, if available.

fn total_nodes(&self) -> usize

Number of members in this epoch’s stake table.

fn da_total_nodes(&self) -> usize

Number of members in this epoch’s DA committee.

fn total_stake(&self) -> Uint<256, 4>

Sum of all stake in this epoch.

fn total_da_stake(&self) -> Uint<256, 4>

Sum of all DA stake in this epoch.

fn success_threshold(&self) -> Uint<256, 4>

Quorum (supermajority) threshold for this epoch.

fn da_success_threshold(&self) -> Uint<256, 4>

DA quorum threshold for this epoch.

fn failure_threshold(&self) -> Uint<256, 4>

Failure threshold (1/3 + 1) for this epoch.

fn upgrade_threshold(&self) -> Uint<256, 4>

Threshold required for a protocol upgrade.

fn leader( &self, view: ViewNumber, ) -> Result<<T as NodeType>::SignatureKey, Error>

The leader for view in this epoch, returning a HotShot-internal error type. Default impl wraps Self::lookup_leader.

impl MerklizedState<SeqTypes, { Self::ARITY }> for BlockMerkleTree

type Key = <LightWeightMerkleTree<Commitment<Header>, Sha3Digest, u64, 3, Sha3Node> as MerkleTreeScheme>::Index

type Entry = Commitment<Header>

type T = Sha3Node

type Commit = <LightWeightMerkleTree<Commitment<Header>, Sha3Digest, u64, 3, Sha3Node> as MerkleTreeScheme>::Commitment

type Digest = Sha3Digest

fn state_type() -> &'static str

Retrieves the name of the state being queried.

fn header_state_commitment_field() -> &'static str

Retrieves the field in the header containing the Merkle tree commitment for the state implementing this trait.

fn tree_height() -> usize

Get the height of the tree

fn insert_path( &mut self, key: Self::Key, proof: &MerkleProof<Self::Entry, Self::Key, Self::T, { Self::ARITY }>, ) -> Result<()>

Insert a forgotten path into the tree.

impl MerklizedState<SeqTypes, { Self::ARITY }> for FeeMerkleTree

type Key = <UniversalMerkleTree<FeeAmount, Sha3Digest, FeeAccount, FEE_MERKLE_TREE_ARITY, Sha3Node> as MerkleTreeScheme>::Index

type Entry = <UniversalMerkleTree<FeeAmount, Sha3Digest, FeeAccount, FEE_MERKLE_TREE_ARITY, Sha3Node> as MerkleTreeScheme>::Element

type T = Sha3Node

type Commit = <UniversalMerkleTree<FeeAmount, Sha3Digest, FeeAccount, FEE_MERKLE_TREE_ARITY, Sha3Node> as MerkleTreeScheme>::Commitment

type Digest = Sha3Digest

fn state_type() -> &'static str

Retrieves the name of the state being queried.

fn header_state_commitment_field() -> &'static str

Retrieves the field in the header containing the Merkle tree commitment for the state implementing this trait.

fn tree_height() -> usize

Get the height of the tree

fn insert_path( &mut self, key: Self::Key, proof: &MerkleProof<Self::Entry, Self::Key, Self::T, { Self::ARITY }>, ) -> Result<()>

Insert a forgotten path into the tree.

impl MerklizedState<SeqTypes, { Self::ARITY }> for RewardMerkleTreeV2

type Key = <UniversalMerkleTree<RewardAmount, Keccak256Hasher, RewardAccountV2, REWARD_MERKLE_TREE_V2_ARITY, KeccakNode> as MerkleTreeScheme>::Index

type Entry = <UniversalMerkleTree<RewardAmount, Keccak256Hasher, RewardAccountV2, REWARD_MERKLE_TREE_V2_ARITY, KeccakNode> as MerkleTreeScheme>::Element

type T = KeccakNode

type Commit = <UniversalMerkleTree<RewardAmount, Keccak256Hasher, RewardAccountV2, REWARD_MERKLE_TREE_V2_ARITY, KeccakNode> as MerkleTreeScheme>::Commitment

type Digest = Keccak256Hasher

fn state_type() -> &'static str

Retrieves the name of the state being queried.

fn header_state_commitment_field() -> &'static str

Retrieves the field in the header containing the Merkle tree commitment for the state implementing this trait.

fn tree_height() -> usize

Get the height of the tree

fn insert_path( &mut self, key: Self::Key, proof: &MerkleProof<Self::Entry, Self::Key, Self::T, { Self::ARITY }>, ) -> Result<()>

Insert a forgotten path into the tree.

impl MerklizedState<SeqTypes, { Self::ARITY }> for RewardMerkleTreeV1

type Key = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccountV1, REWARD_MERKLE_TREE_V1_ARITY, Sha3Node> as MerkleTreeScheme>::Index

type Entry = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccountV1, REWARD_MERKLE_TREE_V1_ARITY, Sha3Node> as MerkleTreeScheme>::Element

type T = Sha3Node

type Commit = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccountV1, REWARD_MERKLE_TREE_V1_ARITY, Sha3Node> as MerkleTreeScheme>::Commitment

type Digest = Sha3Digest

fn state_type() -> &'static str

Retrieves the name of the state being queried.

fn header_state_commitment_field() -> &'static str

Retrieves the field in the header containing the Merkle tree commitment for the state implementing this trait.

fn tree_height() -> usize

Get the height of the tree

fn insert_path( &mut self, key: Self::Key, proof: &MerkleProof<Self::Entry, Self::Key, Self::T, { Self::ARITY }>, ) -> Result<()>

Insert a forgotten path into the tree.

impl<P: SequencerPersistence> NewProtocolStorage<SeqTypes> for Arc<P>

fn append_high_qc2<'life0, 'async_trait>( &'life0 self, high_qc: Certificate1<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Persist the locked QC, written before each phase-2 vote so the lock survives a restart instead of regressing to the decided-anchor QC.

fn load_high_qc2<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Certificate1<SeqTypes>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the persisted locked QC, if any.

fn append_boundary_qc2<'life0, 'async_trait>( &'life0 self, qc: Certificate1<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Persist the own Certificate1 of the last block of an epoch, at the block’s own view.

fn load_boundary_qc2<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Certificate1<SeqTypes>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the persisted boundary certificate, if any.

impl NodeType for SeqTypes

type BlockHeader = Header

The block header type that this hotshot setup is using.

type BlockPayload = Payload

The block type that this hotshot setup is using.

type SignatureKey = VerKey

The signature key that this hotshot setup is using.

type Transaction = Transaction

The transaction type that this hotshot setup is using.

type InstanceState = NodeState

The instance-level state type that this hotshot setup is using.

type ValidatedState = ValidatedState

The validated state type that this hotshot setup is using.

type Membership = EpochCommittees

Membership used for this implementation

type BuilderSignatureKey = FeeAccount

The type builder uses to sign its messages

type StateSignatureKey = VerKey<EdwardsConfig>

The type replica uses to sign the light client state

const UPGRADE_CONSTANTS: UpgradeConstants = DEFAULT_UPGRADE_CONSTANTS

Constants used to construct upgrade proposals

impl Ord for SeqTypes

fn cmp(&self, other: &SeqTypes) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SeqTypes

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for SeqTypes

fn partial_cmp(&self, other: &SeqTypes) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl QueryableHeader<SeqTypes> for Header

type NamespaceId = NamespaceId

Serialized representation of a namespace.

type NamespaceIndex = NsIndex

Index for looking up a namespace.

fn namespace_id(&self, i: &NsIndex) -> Option<NamespaceId>

Resolve a namespace index to the serialized identifier for that namespace.

fn namespace_size(&self, i: &NsIndex, payload_size: usize) -> u64

Get the size taken up by the given namespace in the payload.

fn ns_table(&self) -> String

Get the namespace table as a VARCHAR.

impl QueryablePayload<SeqTypes> for Payload

type Iter<'a> = Iter<'a>

Enumerate the transactions in this block.

type InclusionProof = TxProof

A proof that a certain transaction exists in the block.

fn len(&self, _meta: &Self::Metadata) -> usize

The number of transactions in the block.

fn iter<'a>(&'a self, _meta: &'a Self::Metadata) -> Self::Iter<'a>

List the transaction indices in the block.

fn transaction( &self, _meta: &Self::Metadata, index: &Index, ) -> Option<Self::Transaction>

Get a transaction by its block-specific index.

fn transaction_proof( &self, _meta: &Self::Metadata, vid: &VidCommonQueryData<SeqTypes>, index: &Index, ) -> Option<Self::InclusionProof>

Get an inclusion proof for the given transaction.

fn is_empty(&self, meta: &Self::Metadata) -> bool

Whether this block is empty of transactions.

fn enumerate<'a>( &'a self, meta: &'a Self::Metadata, ) -> Box<dyn Iterator<Item = (TransactionIndex<Types>, Self::Transaction)> + 'a>

Enumerate the transactions in the block with their indices.

fn nth( &self, meta: &Self::Metadata, n: usize, ) -> Option<TransactionIndex<Types>>

Get the index of the nth transaction.

fn nth_transaction( &self, meta: &Self::Metadata, n: usize, ) -> Option<Self::Transaction>

Get the nth transaction.

fn by_hash( &self, meta: &Self::Metadata, hash: Commitment<Self::Transaction>, ) -> Option<TransactionIndex<Types>>

Get the index of the transaction with a given hash, if it is in the block.

fn transaction_by_hash( &self, meta: &Self::Metadata, hash: Commitment<Self::Transaction>, ) -> Option<Self::Transaction>

Get the transaction with a given hash, if it is in the block.

impl Serialize for SeqTypes

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P: SequencerPersistence> Storage<SeqTypes> for Arc<P>

fn append_vid<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, VidDisperseShare<SeqTypes>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a proposal to the stored VID proposals.

fn append_da<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, DaProposal<SeqTypes>>, vid_commit: VidCommitment, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a proposal to the stored DA proposals.

fn append_da2<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, DaProposal2<SeqTypes>>, vid_commit: VidCommitment, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a proposal to the stored DA proposals.

fn record_action<'life0, 'async_trait>( &'life0 self, view: ViewNumber, action: HotShotAction, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Record a HotShotAction taken.

fn append_proposal_wrapper<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, QuorumProposalWrapper<SeqTypes>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a proposal we sent to the store

fn update_decided_upgrade_certificate<'life0, 'async_trait>( &'life0 self, decided_upgrade_certificate: Option<UpgradeCertificate<SeqTypes>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Upgrade the current decided upgrade certificate in storage.

fn store_drb_result<'life0, 'async_trait>( &'life0 self, epoch: EpochNumber, drb_result: DrbResult, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Add a drb result

fn store_epoch_root<'life0, 'async_trait>( &'life0 self, epoch: EpochNumber, block_header: <SeqTypes as NodeType>::BlockHeader, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Add an epoch block header

fn store_drb_input<'life0, 'async_trait>( &'life0 self, drb_input: DrbInput, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn load_drb_input<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<DrbInput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn update_state_cert<'life0, 'async_trait>( &'life0 self, state_cert: LightClientStateUpdateCertificateV2<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update the light client state update certificate in storage.

fn load_drb_result<'life0, 'async_trait>( &'life0 self, epoch: EpochNumber, ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

impl StructuralPartialEq for SeqTypes

impl ValidatedState<SeqTypes> for ValidatedState

async fn validate_and_apply_header( &self, instance: &Self::Instance, parent_leaf: &Leaf2, proposed_header: &Header, payload_byte_len: Option<u32>, version: Version, view_number: u64, ) -> Result<(Self, Self::Delta), Self::Error>

Validate parent against known values (from state) and validate proposal descends from parent. Returns updated ValidatedState.

fn from_header(block_header: &Header) -> Self

Construct the state with the given block header.

This can also be used to rebuild the state for catchup.

fn genesis(instance: &Self::Instance) -> (Self, Self::Delta)

Construct a genesis validated state.

type Error = BlockError

The error type for this particular type of ledger state

type Instance = NodeState

The type of the instance-level state this state is associated with

type Delta = Delta

The type of the state delta this state is associated with.

fn on_commit(&self)

Gets called to notify the persistence backend that this state has been committed

impl VerifiableInclusion<SeqTypes> for TxProof

fn verify( &self, ns_table: &NsTable, tx: &Transaction, commit: &VidCommitment, common: &VidCommon, ) -> bool

Verify the inclusion proof against a payload commitment. Returns None on error.