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<V: Versions>( instance_state: &NodeState, payload: <SeqTypes as NodeType>::BlockPayload, metadata: &<<SeqTypes as NodeType>::BlockPayload as BlockPayload<SeqTypes>>::Metadata, ) -> 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 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

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

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

fn stake_table( &self, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> HSStakeTable<SeqTypes>

Get the stake table for the current view

fn da_stake_table( &self, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> HSStakeTable<SeqTypes>

Get the stake table for the current view

fn committee_members( &self, _view_number: <SeqTypes as NodeType>::View, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> BTreeSet<PubKey>

Get all members of the committee for the current view

fn da_committee_members( &self, _view_number: <SeqTypes as NodeType>::View, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> BTreeSet<PubKey>

Get all members of the committee for the current view

fn stake( &self, pub_key: &PubKey, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> Option<PeerConfig<SeqTypes>>

Get the stake table entry for a public key

fn da_stake( &self, pub_key: &PubKey, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> Option<PeerConfig<SeqTypes>>

Get the DA stake table entry for a public key

fn has_stake( &self, pub_key: &PubKey, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> bool

Check if a node has stake in the committee

fn has_da_stake( &self, pub_key: &PubKey, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> bool

Check if a node has stake in the committee

fn lookup_leader( &self, view_number: <SeqTypes as NodeType>::View, epoch: Option<<SeqTypes as NodeType>::Epoch>, ) -> Result<PubKey, Self::Error>

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

If an epoch is provided and a randomized committee exists for that epoch, the leader is selected from the randomized committee. Otherwise, the leader is selected from the non-epoch committee.

Arguments

• view_number - The view number to index into the committee.
• epoch - The epoch for which to determine the leader. If None, uses the non-epoch committee.

Errors

Returns LeaderLookupError if the epoch is before the first epoch or if the committee is missing.

fn total_nodes(&self, epoch: Option<<SeqTypes as NodeType>::Epoch>) -> usize

Get the total number of nodes in the committee

fn da_total_nodes(&self, epoch: Option<<SeqTypes as NodeType>::Epoch>) -> usize

Get the total number of DA nodes in the committee

async fn add_epoch_root( membership: Arc<RwLock<Self>>, epoch: <SeqTypes as NodeType>::Epoch, block_header: Header, ) -> Result<()>

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.

fn has_randomized_stake_table( &self, epoch: <SeqTypes as NodeType>::Epoch, ) -> Result<bool>

Checks if the randomized stake table is available for the given epoch.

Returns Ok(true) if a randomized committee exists for the specified epoch and the epoch is not before the first epoch. Returns an error if first_epoch is None or if the provided epoch is before the first epoch.

Arguments

• epoch - The epoch for which to check the presence of a randomized stake table.

Errors

Returns an error if first_epoch is None or if epoch is before first_epoch.

type Error = LeaderLookupError

The error type returned by methods like lookup_leader.

type Storage = ()

Storage type used by the underlying fetcher

type StakeTableHash = StakeTableState

fn new<I: NodeImplementation<SeqTypes>>( _committee_members: Vec<PeerConfig<SeqTypes>>, _da_members: Vec<PeerConfig<SeqTypes>>, _storage: Self::Storage, _network: Arc<<I as NodeImplementation<SeqTypes>>::Network>, _public_key: <SeqTypes as NodeType>::SignatureKey, _epoch_height: u64, ) -> Self

Create a committee

fn has_stake_table(&self, epoch: <SeqTypes as NodeType>::Epoch) -> bool

Returns if the stake table is available for the given epoch

async fn get_epoch_root( membership: Arc<RwLock<Self>>, block_height: u64, epoch: <SeqTypes as NodeType>::Epoch, ) -> Result<Leaf2>

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

async fn get_epoch_drb( membership: Arc<RwLock<Self>>, epoch: <SeqTypes as NodeType>::Epoch, ) -> Result<DrbResult>

Gets the DRB result for the given epoch

fn add_drb_result( &mut self, epoch: <SeqTypes as NodeType>::Epoch, drb: DrbResult, )

Called to notify the Membership when a new DRB result has been calculated. Observes the same semantics as add_epoch_root

fn set_first_epoch( &mut self, epoch: <SeqTypes as NodeType>::Epoch, 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<<SeqTypes as NodeType>::Epoch>

Get first epoch if epochs are enabled, None otherwise

fn stake_table_hash( &self, epoch: <SeqTypes as NodeType>::Epoch, ) -> Option<StakeTableHash>

Returns the commitment of the stake table for the given epoch, Errors if the stake table is not available for the given epoch

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

fn set_external_channel( &mut self, _external_channel: Receiver<Event<TYPES>>, ) -> impl Future<Output = ()> + Send

fn total_stake(&self, epoch: Option<<TYPES as NodeType>::Epoch>) -> Uint<256, 4>

fn total_da_stake( &self, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Uint<256, 4>

fn leader( &self, view: <TYPES as NodeType>::View, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Result<<TYPES as NodeType>::SignatureKey, Error>

The leader of the committee for view view_number in epoch.

fn success_threshold( &self, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Uint<256, 4>

Returns the threshold for a specific Membership implementation

fn da_success_threshold( &self, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Uint<256, 4>

Returns the DA threshold for a specific Membership implementation

fn failure_threshold( &self, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Uint<256, 4>

Returns the threshold for a specific Membership implementation

fn upgrade_threshold( &self, epoch: Option<<TYPES as NodeType>::Epoch>, ) -> Uint<256, 4>

Returns the threshold required to upgrade the network protocol

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 NodeType for SeqTypes

type View = ViewNumber

The time type that this hotshot setup is using.

type Epoch = EpochNumber

Same as above but for epoch.

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

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.

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, ADVZDisperseShare<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_vid2<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<SeqTypes, VidDisperseShare2<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: <SeqTypes as NodeType>::Epoch, 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: <SeqTypes as NodeType>::Epoch, 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_vid_general<'life0, 'life1, 'async_trait>( &'life0 self, proposal: &'life1 Proposal<TYPES, VidDisperseShare<TYPES>>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

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: <TYPES as NodeType>::Epoch, ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], Error>> + Send + 'async_trait>>

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

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 Time = ViewNumber

Time compatibility needed for reward collection

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