Struct SeqTypes

pub struct SeqTypes;

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

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

Index the vector of public keys with the current view number

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

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

Get the voting success threshold for the committee

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

Get the voting success threshold for the committee

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

Get the voting failure threshold for the committee

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

Get the voting upgrade threshold for the committee

type Error = LeaderLookupError

The error type returned by methods like lookup_leader.

fn new( _committee_members: Vec<PeerConfig<SeqTypes>>, _da_members: Vec<PeerConfig<SeqTypes>>, ) -> Self

Create a committee

async fn add_epoch_root( &self, epoch: <SeqTypes as NodeType>::Epoch, block_header: Header, ) -> Option<Box<dyn FnOnce(&mut Self) + Send>>

Handles notifications that a new epoch root has been created Is called under a read lock to the Membership. Return a callback with Some to have that callback invoked under a write lock.

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

Returns if the stake table is available for the given epoch

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

Returns if the randomized 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>>, block_height: u64, 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 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.

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 RewardMerkleTree

type Key = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccount, REWARD_MERKLE_TREE_ARITY, Sha3Node> as MerkleTreeScheme>::Index

type Entry = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccount, REWARD_MERKLE_TREE_ARITY, Sha3Node> as MerkleTreeScheme>::Element

type T = Sha3Node

type Commit = <UniversalMerkleTree<RewardAmount, Sha3Digest, RewardAccount, REWARD_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 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 AuctionResult = SolverAuctionResults

The AuctionSolverResult is a type that holds the data associated with a particular solver run, for a particular view.

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

fn timestamp(&self) -> u64

impl QueryablePayload<SeqTypes> for Payload

type TransactionIndex = Index

An index which can be used to efficiently retrieve a transaction for the block.

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_with_proof( &self, _meta: &Self::Metadata, index: &Self::TransactionIndex, ) -> Option<(Self::Transaction, Self::InclusionProof)>

Get a transaction by its block-specific index, along with an inclusion proof.

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

Get a transaction by its block-specific index.

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 = (Self::TransactionIndex, Self::Transaction)> + 'a>

Enumerate the transactions in the block with their indices.

fn proof( &self, meta: &Self::Metadata, index: &Self::TransactionIndex, ) -> Option<Self::InclusionProof>

Get an inclusion proof for a transaction with a given index.

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

Get the index of the nth transaction.

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

Get the nth transaction.

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

Get the nth transaction, along with an inclusion proof.

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

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.

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

Get the transaction with a given hash, if it is in the block, along with an inclusion proof.

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, 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. TODO(Chengyu): fix this

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_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 add_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 add_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 update_state_cert<'life0, 'async_trait>( &'life0 self, state_cert: LightClientStateUpdateCertificate<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: LightClientStateUpdateCertificate<TYPES>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

fn update_next_epoch_high_qc2<'life0, 'async_trait>( &'life0 self, _next_epoch_high_qc: SimpleCertificate<TYPES, NextEpochQuorumData2<TYPES>, SuccessThreshold>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Update the current high QC in storage.

fn migrate_consensus<'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 add_drb_input<'life0, 'async_trait>( &'life0 self, _epoch: u64, _iteration: u64, _drb_input: [u8; 32], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

fn load_drb_input<'life0, 'async_trait>( &'life0 self, _epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<DrbInput, 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 Copy for SeqTypes

impl Eq for SeqTypes

impl StructuralPartialEq for SeqTypes