Struct SeqTypes 

pub struct SeqTypes;

Trait Implementations

impl BlockHeader<SeqTypes> for Header

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

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, 'async_trait>( transactions: impl 'async_trait + IntoIterator<Item = Self::Transaction> + Send, validated_state: &'life0 Self::ValidatedState, instance_state: &'life1 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,

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.

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

List of transaction commitments.

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

Number of transactions in the block.

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 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 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 add_epoch_root(&self, block_header: Header) -> 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.

type NonEpochSnapshot = NonEpochSnapshot

A consistent pre-epoch view, returned by Self::non_epoch_snapshot.

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

Capture a consistent per-epoch view.

fn non_epoch_snapshot(&self) -> Self::NonEpochSnapshot

Capture a consistent pre-epoch view.

async fn get_epoch_root(&self, epoch: EpochNumber) -> 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, ) -> 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 set_first_epoch(&self, epoch: EpochNumber, initial_drb_result: DrbResult)

Called to notify the Membership that Epochs are enabled. Implementations should copy the pre-epoch stake table into epoch and epoch+1 when this is called. The value of initial_drb_result should be used for DRB calculations for epochs (epoch+1) and earlier.

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

Get first epoch if epochs are enabled, None otherwise.

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. Used at startup to find the point from which to walk forward catching up missing epochs.

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 first_epoch is unset, the snapshot’s epoch is before first_epoch, or the randomized committee is missing.

type Error = EpochCommitteesError

type StakeTableHash = StakeTableState

fn epoch(&self) -> EpochNumber

The epoch this snapshot is bound to.

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

The first epoch known to the membership (cached at snapshot creation).

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_cert2<'life0, 'async_trait>( &'life0 self, view: ViewNumber, cert: Certificate2<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

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 NonEpochMembershipSnapshot<SeqTypes> for NonEpochSnapshot

type Error = EpochCommitteesError

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

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

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

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

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

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

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

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

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

fn total_nodes(&self) -> usize

fn da_total_nodes(&self) -> usize

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

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

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

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

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

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

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

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

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 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 update_eqc<'life0, 'async_trait>( &'life0 self, high_qc: QuorumCertificate2<SeqTypes>, next_epoch_high_qc: NextEpochQuorumCertificate2<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Update the current eQC in storage.

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, epoch: Option<EpochNumber>, action: HotShotAction, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Record a HotShotAction taken.

fn update_high_qc<'life0, 'async_trait>( &'life0 self, _high_qc: QuorumCertificate<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Update the current high QC in storage.

fn append_proposal<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, QuorumProposal<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 append_proposal2<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, QuorumProposal2<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_high_qc2<'life0, 'async_trait>( &'life0 self, _high_qc: QuorumCertificate2<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Update the current high QC in storage.

fn update_next_epoch_high_qc2<'life0, 'async_trait>( &'life0 self, _next_epoch_high_qc: NextEpochQuorumCertificate2<SeqTypes>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Update the current high QC in storage.

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 append_proposal_wrapper<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<TYPES, QuorumProposalWrapper<TYPES>>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Add a proposal we sent to the store

fn update_high_qc2_and_state_cert<'life0, 'async_trait>( &'life0 self, high_qc: SimpleCertificate<TYPES, QuorumData2<TYPES>, SuccessThreshold>, state_cert: LightClientStateUpdateCertificateV2<TYPES>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

fn migrate_storage<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Migrate leaves from Leaf to Leaf2, and proposals from QuorumProposal to QuorumProposal2

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 TestableBlock<SeqTypes> for Payload

Available on crate features testing only.

fn genesis() -> Self

generate a genesis block

fn txn_count(&self) -> u64

the number of transactions in this block

impl TestableState<SeqTypes> for ValidatedState

Available on crate features testing only.

fn create_random_transaction( _state: Option<&Self>, rng: &mut dyn RngCore, _padding: u64, ) -> Transaction

Creates random transaction if possible otherwise panics padding is the bytes of padding to add to the transaction

impl ValidatedState<SeqTypes> for ValidatedState

async fn validate_and_apply_header( &self, instance: &Self::Instance, parent_leaf: &Leaf2, proposed_header: &Header, payload_byte_len: 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.

impl Copy for SeqTypes

impl Eq for SeqTypes

impl StructuralPartialEq for SeqTypes