Struct Chain

pub struct Chain {
    network: Network,
    inner: ChainInner,
    pub(super) last_fork_height: Option<Height>,
}

A single non-finalized partial chain, from the child of the finalized tip, to a non-finalized chain tip.

Fields

network: Network

The configured network for this chain.

inner: ChainInner

The internal state of this chain.

last_fork_height: Option<Height>

The last height this chain forked at. Diagnostics only.

This field is only used for metrics. It is not consensus-critical, and it is not checked for equality.

We keep the same last fork height in both sides of a clone, because every new block clones a chain, even if it’s just growing that chain.

Note

Most diagnostics are implemented on the NonFinalizedState, rather than each chain. Some diagnostics only use the best chain, and others need to modify the Chain state, but that’s difficult with Arc<Chain>s.

Implementations

impl Chain

pub(crate) fn new( network: &Network, finalized_tip_height: Height, sprout_note_commitment_tree: Arc<NoteCommitmentTree>, sapling_note_commitment_tree: Arc<NoteCommitmentTree>, orchard_note_commitment_tree: Arc<NoteCommitmentTree>, history_tree: Arc<HistoryTree>, finalized_tip_chain_value_pools: ValueBalance<NonNegative>, ) -> Self

Create a new Chain with the given finalized tip trees and network.

pub fn eq_internal_state(&self, other: &Chain) -> bool

Is the internal state of self the same as other?

Chain has custom Eq and Ord implementations based on proof of work, which are used to select the best chain. So we can’t derive Eq for Chain.

Unlike the custom trait impls, this method returns true if the entire internal state of two chains is equal.

If the internal states are different, it returns false, even if the blocks in the two chains are equal.

pub fn recent_fork_height(&self) -> Option<Height>

Returns the last fork height if that height is still in the non-finalized state. Otherwise, if that fork has been finalized, returns None.

pub fn recent_fork_length(&self) -> Option<u32>

Returns this chain fork’s length, if its fork is still in the non-finalized state. Otherwise, if the fork has been finalized, returns None.

pub fn push( self, block: ContextuallyVerifiedBlock, ) -> Result<Chain, ValidateContextError>

Push a contextually valid non-finalized block into this chain as the new tip.

If the block is invalid, drops this chain, and returns an error.

Note: a ContextuallyVerifiedBlock isn’t actually contextually valid until Self::update_chain_tip_with returns success.

pub(crate) fn pop_root(&mut self) -> (ContextuallyVerifiedBlock, Treestate)

Pops the lowest height block of the non-finalized portion of a chain, and returns it with its associated treestate.

pub fn non_finalized_root_height(&self) -> Height

Returns the height of the chain root.

pub fn fork(&self, fork_tip: Hash) -> Option<Self>

Fork and return a chain at the block with the given fork_tip, if it is part of this chain. Otherwise, if this chain does not contain fork_tip, returns None.

pub fn network(&self) -> Network

Returns the Network for this chain.

pub fn block( &self, hash_or_height: HashOrHeight, ) -> Option<&ContextuallyVerifiedBlock>

Returns the ContextuallyVerifiedBlock with block::Hash or Height, if it exists in this chain.

pub fn transaction(&self, hash: Hash) -> Option<(&Arc<Transaction>, Height)>

Returns the Transaction with transaction::Hash, if it exists in this chain.

pub fn transaction_by_loc( &self, tx_loc: TransactionLocation, ) -> Option<&Arc<Transaction>>

Returns the Transaction at TransactionLocation, if it exists in this chain.

pub fn transaction_hash_by_loc( &self, tx_loc: TransactionLocation, ) -> Option<&Hash>

Returns the transaction::Hash for the transaction at TransactionLocation, if it exists in this chain.

pub fn transaction_hashes_for_block( &self, hash_or_height: HashOrHeight, ) -> Option<Arc<[Hash]>>

Returns the transaction::Hashes in the block with hash_or_height, if it exists in this chain.

Hashes are returned in block order.

Returns None if the block is not found.

pub fn hash_by_height(&self, height: Height) -> Option<Hash>

Returns the block::Hash for height, if it exists in this chain.

pub fn height_by_hash(&self, hash: Hash) -> Option<Height>

Returns the Height for hash, if it exists in this chain.

pub fn contains_block_hash(&self, hash: Hash) -> bool

Returns true is the chain contains the given block hash. Returns false otherwise.

pub fn contains_block_height(&self, height: Height) -> bool

Returns true is the chain contains the given block height. Returns false otherwise.

pub fn contains_hash_or_height( &self, hash_or_height: impl Into<HashOrHeight>, ) -> bool

Returns true is the chain contains the given block hash or height. Returns false otherwise.

pub fn non_finalized_tip(&self) -> (Height, Hash)

Returns the non-finalized tip block height and hash.

pub fn non_finalized_tip_with_value_balance( &self, ) -> (Height, Hash, ValueBalance<NonNegative>)

Returns the non-finalized tip block height, hash, and total pool value balances.

pub fn sprout_note_commitment_tree_for_tip(&self) -> Arc<NoteCommitmentTree>

Returns the Sprout note commitment tree of the tip of this Chain, including all finalized notes, and the non-finalized notes in this chain.

If the chain is empty, instead returns the tree of the finalized tip, which was supplied in Chain::new()

Panics

If this chain has no sprout trees. (This should be impossible.)

pub fn sprout_tree( &self, hash_or_height: HashOrHeight, ) -> Option<Arc<NoteCommitmentTree>>

Returns the Sprout NoteCommitmentTree specified by a HashOrHeight, if it exists in the non-finalized Chain.

fn add_sprout_tree_and_anchor( &mut self, height: Height, tree: Arc<NoteCommitmentTree>, )

Adds the Sprout tree to the tree and anchor indexes at height.

height can be either:

• the height of a new block that has just been added to the chain tip, or
• the finalized tip height—the height of the parent of the first block of a new chain.

Stores only the first tree in each series of identical trees.

Panics

• If there’s a tree already stored at height.
• If there’s an anchor already stored at height.

fn remove_sprout_tree_and_anchor( &mut self, position: RevertPosition, height: Height, )

Removes the Sprout tree and anchor indexes at height.

height can be at two different RevertPositions in the chain:

• a tip block above a chain fork—only the tree and anchor at that height are removed, or

• a root block—all trees and anchors at and below that height are removed, including temporary finalized tip trees.

  Panics

• If the anchor being removed is not present.

• If there is no tree at height.

pub fn sapling_note_commitment_tree_for_tip(&self) -> Arc<NoteCommitmentTree>

Returns the Sapling note commitment tree of the tip of this Chain, including all finalized notes, and the non-finalized notes in this chain.

If the chain is empty, instead returns the tree of the finalized tip, which was supplied in Chain::new()

Panics

If this chain has no sapling trees. (This should be impossible.)

pub fn sapling_tree( &self, hash_or_height: HashOrHeight, ) -> Option<Arc<NoteCommitmentTree>>

Returns the Sapling NoteCommitmentTree specified by a HashOrHeight, if it exists in the non-finalized Chain.

pub fn sapling_subtree( &self, hash_or_height: HashOrHeight, ) -> Option<NoteCommitmentSubtree<Node>>

Returns the Sapling NoteCommitmentSubtree that was completed at a block with HashOrHeight, if it exists in the non-finalized Chain.

Concurrency

This method should not be used to get subtrees in concurrent code by height, because the same heights in different chain forks can have different subtrees.

pub fn sapling_subtrees_in_range( &self, range: impl RangeBounds<NoteCommitmentSubtreeIndex>, ) -> BTreeMap<NoteCommitmentSubtreeIndex, NoteCommitmentSubtreeData<Node>>

Returns a list of Sapling NoteCommitmentSubtrees in the provided range.

Unlike the finalized state and ReadRequest::SaplingSubtrees, the returned subtrees can start after start_index. These subtrees are continuous up to the tip.

There is no API for retrieving single subtrees by index, because it can accidentally be used to create an inconsistent list of subtrees after concurrent non-finalized and finalized updates.

pub fn sapling_subtree_for_tip(&self) -> Option<NoteCommitmentSubtree<Node>>

Returns the Sapling NoteCommitmentSubtree if it was completed at the tip height.

fn add_sapling_tree_and_anchor( &mut self, height: Height, tree: Arc<NoteCommitmentTree>, )

Adds the Sapling tree to the tree and anchor indexes at height.

height can be either:

• the height of a new block that has just been added to the chain tip, or
• the finalized tip height—the height of the parent of the first block of a new chain.

Stores only the first tree in each series of identical trees.

Panics

• If there’s a tree already stored at height.
• If there’s an anchor already stored at height.

fn remove_sapling_tree_and_anchor( &mut self, position: RevertPosition, height: Height, )

Removes the Sapling tree and anchor indexes at height.

height can be at two different RevertPositions in the chain:

• a tip block above a chain fork—only the tree and anchor at that height are removed, or

• a root block—all trees and anchors at and below that height are removed, including temporary finalized tip trees.

  Panics

• If the anchor being removed is not present.

• If there is no tree at height.

pub fn orchard_note_commitment_tree_for_tip(&self) -> Arc<NoteCommitmentTree>

Returns the Orchard note commitment tree of the tip of this Chain, including all finalized notes, and the non-finalized notes in this chain.

If the chain is empty, instead returns the tree of the finalized tip, which was supplied in Chain::new()

Panics

If this chain has no orchard trees. (This should be impossible.)

pub fn orchard_tree( &self, hash_or_height: HashOrHeight, ) -> Option<Arc<NoteCommitmentTree>>

Returns the Orchard NoteCommitmentTree specified by a HashOrHeight, if it exists in the non-finalized Chain.

pub fn orchard_subtree( &self, hash_or_height: HashOrHeight, ) -> Option<NoteCommitmentSubtree<Node>>

Returns the Orchard NoteCommitmentSubtree that was completed at a block with HashOrHeight, if it exists in the non-finalized Chain.

Concurrency

This method should not be used to get subtrees in concurrent code by height, because the same heights in different chain forks can have different subtrees.

pub fn orchard_subtrees_in_range( &self, range: impl RangeBounds<NoteCommitmentSubtreeIndex>, ) -> BTreeMap<NoteCommitmentSubtreeIndex, NoteCommitmentSubtreeData<Node>>

Returns a list of Orchard NoteCommitmentSubtrees in the provided range.

Unlike the finalized state and ReadRequest::OrchardSubtrees, the returned subtrees can start after start_index. These subtrees are continuous up to the tip.

There is no API for retrieving single subtrees by index, because it can accidentally be used to create an inconsistent list of subtrees after concurrent non-finalized and finalized updates.

pub fn orchard_subtree_for_tip(&self) -> Option<NoteCommitmentSubtree<Node>>

Returns the Orchard NoteCommitmentSubtree if it was completed at the tip height.

fn add_orchard_tree_and_anchor( &mut self, height: Height, tree: Arc<NoteCommitmentTree>, )

Adds the Orchard tree to the tree and anchor indexes at height.

height can be either:

• the height of a new block that has just been added to the chain tip, or
• the finalized tip height—the height of the parent of the first block of a new chain.

Stores only the first tree in each series of identical trees.

Panics

• If there’s a tree already stored at height.
• If there’s an anchor already stored at height.

fn remove_orchard_tree_and_anchor( &mut self, position: RevertPosition, height: Height, )

Removes the Orchard tree and anchor indexes at height.

height can be at two different RevertPositions in the chain:

• a tip block above a chain fork—only the tree and anchor at that height are removed, or

• a root block—all trees and anchors at and below that height are removed, including temporary finalized tip trees.

  Panics

• If the anchor being removed is not present.

• If there is no tree at height.

pub fn history_block_commitment_tree(&self) -> Arc<HistoryTree>

Returns the History tree of the tip of this Chain, including all finalized blocks, and the non-finalized blocks below the chain tip.

If the chain is empty, instead returns the tree of the finalized tip, which was supplied in Chain::new()

Panics

If this chain has no history trees. (This should be impossible.)

pub fn history_tree( &self, hash_or_height: HashOrHeight, ) -> Option<Arc<HistoryTree>>

Returns the HistoryTree specified by a HashOrHeight, if it exists in the non-finalized Chain.

fn add_history_tree(&mut self, height: Height, tree: Arc<HistoryTree>)

Add the History tree to the history tree index at height.

height can be either:

• the height of a new block that has just been added to the chain tip, or
• the finalized tip height: the height of the parent of the first block of a new chain.

fn remove_history_tree(&mut self, position: RevertPosition, height: Height)

Remove the History tree index at height.

height can be at two different RevertPositions in the chain:

• a tip block above a chain fork: only that height is removed, or
• a root block: all trees below that height are removed, including temporary finalized tip trees.

fn treestate(&self, hash_or_height: HashOrHeight) -> Option<Treestate>

pub fn non_finalized_tip_hash(&self) -> Hash

Returns the block hash of the tip block.

pub fn non_finalized_root(&self) -> (Hash, Height)

Returns the non-finalized root block hash and height.

pub fn non_finalized_root_hash(&self) -> Hash

Returns the block hash of the non-finalized root block.

pub fn non_finalized_nth_hash(&self, n: usize) -> Option<Hash>

Returns the block hash of the nth block from the non-finalized root.

This is the block at non_finalized_root_height() + n.

fn pop_tip(&mut self)

Remove the highest height block of the non-finalized portion of a chain.

pub fn non_finalized_tip_height(&self) -> Height

Return the non-finalized tip height for this chain.

Panics

Panics if called while the chain is empty, or while the chain is updating its internal state with the first block.

fn max_block_height(&self) -> Option<Height>

Return the non-finalized tip height for this chain, or None if self.blocks is empty.

pub fn tip_block(&self) -> Option<&ContextuallyVerifiedBlock>

Return the non-finalized tip block for this chain, or None if self.blocks is empty.

pub fn is_empty(&self) -> bool

Returns true if the non-finalized part of this chain is empty.

pub fn len(&self) -> usize

Returns the non-finalized length of this chain.

pub fn unspent_utxos(&self) -> HashMap<OutPoint, OrderedUtxo>

Returns the unspent transaction outputs (UTXOs) in this non-finalized chain.

Callers should also check the finalized state for available UTXOs. If UTXOs remain unspent when a block is finalized, they are stored in the finalized state, and removed from the relevant chain(s).

pub fn created_utxo(&self, outpoint: &OutPoint) -> Option<Utxo>

Returns the transparent::Utxo pointed to by the given transparent::OutPoint if it was created by this chain.

UTXOs are returned regardless of whether they have been spent.

pub fn partial_transparent_indexes<'a>( &'a self, addresses: &'a HashSet<Address>, ) -> impl Iterator<Item = &'a TransparentTransfers>

Returns the transparent transfers for addresses in this non-finalized chain.

If none of the addresses have an address index, returns an empty iterator.

Correctness

Callers should apply the returned indexes to the corresponding finalized state indexes.

The combined result will only be correct if the chains match. The exact type of match varies by query.

pub fn partial_transparent_balance_change( &self, addresses: &HashSet<Address>, ) -> Amount<NegativeAllowed>

Returns the transparent balance change for addresses in this non-finalized chain.

If the balance doesn’t change for any of the addresses, returns zero.

Correctness

Callers should apply this balance change to the finalized state balance for addresses.

The total balance will only be correct if this partial chain matches the finalized state. Specifically, the root of this partial chain must be a child block of the finalized tip.

pub fn partial_transparent_utxo_changes( &self, addresses: &HashSet<Address>, ) -> (BTreeMap<OutputLocation, Output>, BTreeSet<OutputLocation>)

Returns the transparent UTXO changes for addresses in this non-finalized chain.

If the UTXOs don’t change for any of the addresses, returns empty lists.

Correctness

Callers should apply these non-finalized UTXO changes to the finalized state UTXOs.

The UTXOs will only be correct if the non-finalized chain matches or overlaps with the finalized state.

Specifically, a block in the partial chain must be a child block of the finalized tip. (But the child block does not have to be the partial chain root.)

pub fn partial_transparent_tx_ids( &self, addresses: &HashSet<Address>, query_height_range: RangeInclusive<Height>, ) -> BTreeMap<TransactionLocation, Hash>

Returns the transaction::Hashes used by addresses to receive or spend funds, in the non-finalized chain, filtered using the query_height_range.

If none of the addresses receive or spend funds in this partial chain, returns an empty list.

Correctness

Callers should combine these non-finalized transactions with the finalized state transactions.

The transaction IDs will only be correct if the non-finalized chain matches or overlaps with the finalized state.

Specifically, a block in the partial chain must be a child block of the finalized tip. (But the child block does not have to be the partial chain root.)

This condition does not apply if there is only one address. Since address transactions are only appended by blocks, and the finalized state query reads them in order, it is impossible to get inconsistent transactions for a single address.

fn update_chain_tip_with_block_parallel( &mut self, contextually_valid: &ContextuallyVerifiedBlock, ) -> Result<(), ValidateContextError>

Update the chain tip with the contextually_valid block, running note commitment tree updates in parallel with other updates.

Used to implement update_chain_tip_with::<ContextuallyVerifiedBlock>.

fn update_chain_tip_with_block_except_trees( &mut self, contextually_valid: &ContextuallyVerifiedBlock, ) -> Result<(), ValidateContextError>

Update the chain tip with the contextually_valid block, except for the note commitment and history tree updates.

Used to implement update_chain_tip_with::<ContextuallyVerifiedBlock>.

Trait Implementations

impl Clone for Chain

fn clone(&self) -> Chain

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Chain

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

Formats the value using the given formatter.

impl Default for Chain

fn default() -> Chain

Returns the “default value” for a type.

impl DerefMut for Chain

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Ord for Chain

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

Chain order for the NonFinalizedState’s chain_set.

Chains with higher cumulative Proof of Work are Ordering::Greater, breaking ties using the tip block hash.

Despite the consensus rules, Zebra uses the tip block hash as a tie-breaker. Zebra blocks are downloaded in parallel, so download timestamps may not be unique. (And Zebra currently doesn’t track download times, because Blocks are immutable.)

This departure from the consensus rules may delay network convergence, for as long as the greater hash belongs to the later mined block. But Zebra nodes should converge as soon as the tied work is broken.

“At a given point in time, each full validator is aware of a set of candidate blocks. These form a tree rooted at the genesis block, where each node in the tree refers to its parent via the hashPrevBlock block header field.

A path from the root toward the leaves of the tree consisting of a sequence of one or more valid blocks consistent with consensus rules, is called a valid block chain.

In order to choose the best valid block chain in its view of the overall block tree, a node sums the work … of all blocks in each valid block chain, and considers the valid block chain with greatest total work to be best.

To break ties between leaf blocks, a node will prefer the block that it received first.

The consensus protocol is designed to ensure that for any given block height, the vast majority of nodes should eventually agree on their best valid block chain up to that height.“

https://zips.z.cash/protocol/protocol.pdf#blockchain

Correctness

Chain::cmp is used in a BTreeSet, so the fields accessed by cmp must not have interior mutability.

Panics

If two chains compare equal.

This panic enforces the NonFinalizedState::chain_set unique chain invariant.

If the chain set contains duplicate chains, the non-finalized state might handle new blocks or block finalization incorrectly.

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 Chain

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

Chain equality for NonFinalizedState::chain_set, using proof of work, then the tip block hash as a tie-breaker.

Panics

If two chains compare equal.

See Chain::cmp for details.

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 Chain

fn partial_cmp(&self, other: &Self) -> 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 UpdateWith<(&Vec<Input>, &Hash, &HashMap<OutPoint, OrderedUtxo>)> for Chain

fn update_chain_tip_with( &mut self, (spending_inputs, spending_tx_hash, spent_outputs): &(&Vec<Input>, &Hash, &HashMap<OutPoint, OrderedUtxo>), ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

fn revert_chain_with( &mut self, (spending_inputs, spending_tx_hash, spent_outputs): &(&Vec<Input>, &Hash, &HashMap<OutPoint, OrderedUtxo>), position: RevertPosition, )

When T is removed from position in the chain, revert Chain cumulative data members to remove data that are derived from T.

impl UpdateWith<(&Vec<Output>, &Hash, &HashMap<OutPoint, OrderedUtxo>)> for Chain

fn update_chain_tip_with( &mut self, (created_outputs, creating_tx_hash, block_created_outputs): &(&Vec<Output>, &Hash, &HashMap<OutPoint, OrderedUtxo>), ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

fn revert_chain_with( &mut self, (created_outputs, creating_tx_hash, block_created_outputs): &(&Vec<Output>, &Hash, &HashMap<OutPoint, OrderedUtxo>), position: RevertPosition, )

When T is removed from position in the chain, revert Chain cumulative data members to remove data that are derived from T.

impl UpdateWith<ContextuallyVerifiedBlock> for Chain

fn update_chain_tip_with( &mut self, contextually_valid: &ContextuallyVerifiedBlock, ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

fn revert_chain_with( &mut self, contextually_valid: &ContextuallyVerifiedBlock, position: RevertPosition, )

When T is removed from position in the chain, revert Chain cumulative data members to remove data that are derived from T.

impl UpdateWith<Option<JoinSplitData<Groth16Proof>>> for Chain

fn revert_chain_with( &mut self, joinsplit_data: &Option<JoinSplitData<Groth16Proof>>, _position: RevertPosition, )

Panics

Panics if any nullifier is missing from the chain when we try to remove it.

See check::nullifier::remove_from_non_finalized_chain for details.

fn update_chain_tip_with( &mut self, joinsplit_data: &Option<JoinSplitData<Groth16Proof>>, ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

impl<AnchorV> UpdateWith<Option<ShieldedData<AnchorV>>> for Chain

where AnchorV: AnchorVariant + Clone,

fn revert_chain_with( &mut self, sapling_shielded_data: &Option<ShieldedData<AnchorV>>, _position: RevertPosition, )

Panics

Panics if any nullifier is missing from the chain when we try to remove it.

See check::nullifier::remove_from_non_finalized_chain for details.

fn update_chain_tip_with( &mut self, sapling_shielded_data: &Option<ShieldedData<AnchorV>>, ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

impl UpdateWith<Option<ShieldedData>> for Chain

fn revert_chain_with( &mut self, orchard_shielded_data: &Option<ShieldedData>, _position: RevertPosition, )

Panics

Panics if any nullifier is missing from the chain when we try to remove it.

See check::nullifier::remove_from_non_finalized_chain for details.

fn update_chain_tip_with( &mut self, orchard_shielded_data: &Option<ShieldedData>, ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

impl UpdateWith<ValueBalance<NegativeAllowed>> for Chain

fn revert_chain_with( &mut self, block_value_pool_change: &ValueBalance<NegativeAllowed>, position: RevertPosition, )

Revert the chain state using a block chain value pool change.

When forking from the tip, subtract the block’s chain value pool change.

When finalizing the root, leave the chain value pool balances unchanged. ChainInner::chain_value_pools tracks the chain value pools for all finalized blocks, and the non-finalized blocks in this chain. So finalizing the root doesn’t change the set of blocks it tracks.

Panics

Panics if the chain pool value balance is invalid after we subtract the block value pool change.

fn update_chain_tip_with( &mut self, block_value_pool_change: &ValueBalance<NegativeAllowed>, ) -> Result<(), ValidateContextError>

When T is added to the chain tip, update Chain cumulative data members to add data that are derived from T.

impl Deref for Chain

type Target = ChainInner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Eq for Chain