Struct ValidatedState

pub struct ValidatedState {
    pub block_merkle_tree: BlockMerkleTree,
    pub fee_merkle_tree: FeeMerkleTree,
    pub reward_merkle_tree: RewardMerkleTree,
    pub chain_config: ResolvableChainConfig,
}

State to be validated by replicas.

Fields

block_merkle_tree: BlockMerkleTree

Frontier of BlockMerkleTree

fee_merkle_tree: FeeMerkleTree

Frontier of FeeMerkleTree

reward_merkle_tree: RewardMerkleTree

chain_config: ResolvableChainConfig

Configuration Header proposals will be validated against.

Implementations

impl ValidatedState

pub fn prefund_account(&mut self, account: FeeAccount, amount: FeeAmount)

Prefund an account with a given amount. Only for demo purposes.

pub fn balance(&mut self, account: FeeAccount) -> Option<FeeAmount>

pub fn forgotten_accounts( &self, accounts: impl IntoIterator<Item = FeeAccount>, ) -> Vec<FeeAccount>

Find accounts that are not in memory.

As an optimization we could try to apply updates and return the forgotten accounts to be fetched from peers and update them later.

pub fn forgotten_reward_accounts( &self, accounts: impl IntoIterator<Item = RewardAccount>, ) -> Vec<RewardAccount>

pub fn need_to_fetch_blocks_mt_frontier(&self) -> bool

Check if the merkle tree is available

pub fn insert_fee_deposit( &mut self, fee_info: FeeInfo, ) -> Result<LookupResult<FeeAmount, (), ()>>

Insert a fee deposit receipt

pub fn apply_proposal( &mut self, delta: &mut Delta, parent_leaf: &Leaf2, l1_deposits: Vec<FeeInfo>, )

pub fn charge_fees( &mut self, delta: &mut Delta, fee_info: Vec<FeeInfo>, recipient: FeeAccount, ) -> Result<(), FeeError>

pub fn distribute_rewards( &mut self, delta: &mut Delta, validator: Validator<BLSPubKey>, ) -> Result<()>

pub fn charge_fee( &mut self, fee_info: FeeInfo, recipient: FeeAccount, ) -> Result<(), FeeError>

Charge a fee to an account, transferring the funds to the fee recipient account.

impl ValidatedState

pub async fn apply_header( &self, instance: &NodeState, peers: &impl StateCatchup, parent_leaf: &Leaf2, proposed_header: &Header, version: Version, view_number: ViewNumber, ) -> Result<(Self, Delta)>

Updates state with Header proposal.

• Clones and updates ValidatedState (avoiding mutation).
• Resolves ChainConfig.
• Performs catchup.
• Charges fees.

pub(crate) fn apply_upgrade(&mut self, instance: &NodeState, version: Version)

Updates the ValidatedState if a protocol upgrade has occurred.

pub(crate) async fn get_chain_config( &self, instance: &NodeState, peers: &impl StateCatchup, header_cf: &ResolvableChainConfig, ) -> Result<ChainConfig>

Retrieves the ChainConfig.

Returns the NodeState ChainConfig if the ValidatedState ChainConfig commitment matches the NodeState ChainConfig`` commitment. If the commitments do not match, it returns the ChainConfigavailable in eitherValidatedStateor proposed header. If neither has theChainConfig`, it fetches the config from the peers.

Returns an error if it fails to fetch the ChainConfig from the peers.

Trait Implementations

impl Clone for ValidatedState

fn clone(&self) -> ValidatedState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidatedState

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

Formats the value using the given formatter.

impl Default for ValidatedState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ValidatedState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ValidatedState

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ValidatedState

fn eq(&self, other: &ValidatedState) -> 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 Serialize for ValidatedState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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 Eq for ValidatedState

impl StructuralPartialEq for ValidatedState