2020-11-09 10:05:18 -08:00
|
|
|
use std::{
|
|
|
|
cmp::Ordering,
|
|
|
|
collections::{BTreeMap, HashMap, HashSet},
|
|
|
|
ops::Deref,
|
|
|
|
};
|
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
use multiset::HashMultiSet;
|
2021-07-14 05:06:43 -07:00
|
|
|
use tracing::instrument;
|
|
|
|
|
2020-11-09 10:05:18 -08:00
|
|
|
use zebra_chain::{
|
2021-08-11 06:42:40 -07:00
|
|
|
block, history_tree::HistoryTree, orchard, parameters::Network, primitives::Groth16Proof,
|
|
|
|
sapling, sprout, transaction, transaction::Transaction::*, transparent,
|
|
|
|
work::difficulty::PartialCumulativeWork,
|
2020-11-09 10:05:18 -08:00
|
|
|
};
|
|
|
|
|
2021-07-19 06:52:32 -07:00
|
|
|
use crate::{service::check, ContextuallyValidBlock, PreparedBlock, ValidateContextError};
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
#[derive(Debug, Clone)]
|
2020-11-09 10:05:18 -08:00
|
|
|
pub struct Chain {
|
2021-08-11 06:42:40 -07:00
|
|
|
network: Network,
|
2021-07-19 06:52:32 -07:00
|
|
|
/// The contextually valid blocks which form this non-finalized partial chain, in height order.
|
|
|
|
pub(crate) blocks: BTreeMap<block::Height, ContextuallyValidBlock>,
|
|
|
|
|
|
|
|
/// An index of block heights for each block hash in `blocks`.
|
2020-11-09 10:05:18 -08:00
|
|
|
pub height_by_hash: HashMap<block::Hash, block::Height>,
|
2021-07-19 06:52:32 -07:00
|
|
|
/// An index of block heights and transaction indexes for each transaction hash in `blocks`.
|
2020-11-09 10:05:18 -08:00
|
|
|
pub tx_by_hash: HashMap<transaction::Hash, (block::Height, usize)>,
|
|
|
|
|
2021-07-19 06:52:32 -07:00
|
|
|
/// The [`Utxo`]s created by `blocks`.
|
|
|
|
///
|
|
|
|
/// Note that these UTXOs may not be unspent.
|
|
|
|
/// Outputs can be spent by later transactions or blocks in the chain.
|
2021-07-22 16:40:15 -07:00
|
|
|
pub(crate) created_utxos: HashMap<transparent::OutPoint, transparent::Utxo>,
|
2021-07-19 06:52:32 -07:00
|
|
|
/// The [`OutPoint`]s spent by `blocks`,
|
|
|
|
/// including those created by earlier transactions or blocks in the chain.
|
2021-07-22 16:40:15 -07:00
|
|
|
pub(crate) spent_utxos: HashSet<transparent::OutPoint>,
|
2021-07-14 15:23:54 -07:00
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
/// The Sapling note commitment tree of the tip of this Chain.
|
|
|
|
pub(super) sapling_note_commitment_tree: sapling::tree::NoteCommitmentTree,
|
|
|
|
/// The Orchard note commitment tree of the tip of this Chain.
|
|
|
|
pub(super) orchard_note_commitment_tree: orchard::tree::NoteCommitmentTree,
|
2021-08-11 06:42:40 -07:00
|
|
|
/// The ZIP-221 history tree of the tip of this Chain.
|
|
|
|
pub(crate) history_tree: HistoryTree,
|
2021-07-29 06:37:18 -07:00
|
|
|
|
|
|
|
/// The Sapling anchors created by `blocks`.
|
|
|
|
pub(super) sapling_anchors: HashMultiSet<sapling::tree::Root>,
|
|
|
|
/// The Sapling anchors created by each block in the chain.
|
|
|
|
pub(super) sapling_anchors_by_height: BTreeMap<block::Height, sapling::tree::Root>,
|
|
|
|
/// The Orchard anchors created by `blocks`.
|
|
|
|
pub(super) orchard_anchors: HashMultiSet<orchard::tree::Root>,
|
|
|
|
/// The Orchard anchors created by each block in the chain.
|
|
|
|
pub(super) orchard_anchors_by_height: BTreeMap<block::Height, orchard::tree::Root>,
|
|
|
|
|
|
|
|
/// The Sprout nullifiers revealed by `blocks`.
|
2021-07-14 15:23:54 -07:00
|
|
|
pub(super) sprout_nullifiers: HashSet<sprout::Nullifier>,
|
2021-07-29 06:37:18 -07:00
|
|
|
/// The Sapling nullifiers revealed by `blocks`.
|
2021-07-14 15:23:54 -07:00
|
|
|
pub(super) sapling_nullifiers: HashSet<sapling::Nullifier>,
|
2021-07-29 06:37:18 -07:00
|
|
|
/// The Orchard nullifiers revealed by `blocks`.
|
2021-07-14 15:23:54 -07:00
|
|
|
pub(super) orchard_nullifiers: HashSet<orchard::Nullifier>,
|
|
|
|
|
2021-07-19 06:52:32 -07:00
|
|
|
/// The cumulative work represented by this partial non-finalized chain.
|
2021-07-14 15:23:54 -07:00
|
|
|
pub(super) partial_cumulative_work: PartialCumulativeWork,
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Chain {
|
2021-08-11 06:42:40 -07:00
|
|
|
/// Create a new Chain with the given trees and network.
|
2021-07-29 06:37:18 -07:00
|
|
|
pub(crate) fn new(
|
2021-08-11 06:42:40 -07:00
|
|
|
network: Network,
|
2021-07-29 06:37:18 -07:00
|
|
|
sapling_note_commitment_tree: sapling::tree::NoteCommitmentTree,
|
|
|
|
orchard_note_commitment_tree: orchard::tree::NoteCommitmentTree,
|
2021-08-11 06:42:40 -07:00
|
|
|
history_tree: HistoryTree,
|
2021-07-29 06:37:18 -07:00
|
|
|
) -> Self {
|
|
|
|
Self {
|
2021-08-11 06:42:40 -07:00
|
|
|
network,
|
2021-07-29 06:37:18 -07:00
|
|
|
blocks: Default::default(),
|
|
|
|
height_by_hash: Default::default(),
|
|
|
|
tx_by_hash: Default::default(),
|
|
|
|
created_utxos: Default::default(),
|
|
|
|
sapling_note_commitment_tree,
|
|
|
|
orchard_note_commitment_tree,
|
|
|
|
spent_utxos: Default::default(),
|
|
|
|
sapling_anchors: HashMultiSet::new(),
|
|
|
|
sapling_anchors_by_height: Default::default(),
|
|
|
|
orchard_anchors: HashMultiSet::new(),
|
|
|
|
orchard_anchors_by_height: Default::default(),
|
|
|
|
sprout_nullifiers: Default::default(),
|
|
|
|
sapling_nullifiers: Default::default(),
|
|
|
|
orchard_nullifiers: Default::default(),
|
|
|
|
partial_cumulative_work: Default::default(),
|
2021-08-11 06:42:40 -07:00
|
|
|
history_tree,
|
2021-07-29 06:37:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-14 15:23:54 -07:00
|
|
|
/// 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.
|
|
|
|
#[cfg(test)]
|
|
|
|
pub(crate) fn eq_internal_state(&self, other: &Chain) -> bool {
|
2021-08-11 06:42:40 -07:00
|
|
|
use zebra_chain::history_tree::NonEmptyHistoryTree;
|
|
|
|
|
2021-07-14 15:23:54 -07:00
|
|
|
// this method must be updated every time a field is added to Chain
|
|
|
|
|
|
|
|
// blocks, heights, hashes
|
|
|
|
self.blocks == other.blocks &&
|
|
|
|
self.height_by_hash == other.height_by_hash &&
|
|
|
|
self.tx_by_hash == other.tx_by_hash &&
|
|
|
|
|
|
|
|
// transparent UTXOs
|
|
|
|
self.created_utxos == other.created_utxos &&
|
|
|
|
self.spent_utxos == other.spent_utxos &&
|
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
// note commitment trees
|
|
|
|
self.sapling_note_commitment_tree.root() == other.sapling_note_commitment_tree.root() &&
|
|
|
|
self.orchard_note_commitment_tree.root() == other.orchard_note_commitment_tree.root() &&
|
|
|
|
|
2021-08-11 06:42:40 -07:00
|
|
|
// history tree
|
|
|
|
self.history_tree.as_ref().map(NonEmptyHistoryTree::hash) == other.history_tree.as_ref().map(NonEmptyHistoryTree::hash) &&
|
|
|
|
|
2021-07-14 15:23:54 -07:00
|
|
|
// anchors
|
|
|
|
self.sapling_anchors == other.sapling_anchors &&
|
2021-07-29 06:37:18 -07:00
|
|
|
self.sapling_anchors_by_height == other.sapling_anchors_by_height &&
|
2021-07-14 15:23:54 -07:00
|
|
|
self.orchard_anchors == other.orchard_anchors &&
|
2021-07-29 06:37:18 -07:00
|
|
|
self.orchard_anchors_by_height == other.orchard_anchors_by_height &&
|
2021-07-14 15:23:54 -07:00
|
|
|
|
|
|
|
// nullifiers
|
|
|
|
self.sprout_nullifiers == other.sprout_nullifiers &&
|
|
|
|
self.sapling_nullifiers == other.sapling_nullifiers &&
|
|
|
|
self.orchard_nullifiers == other.orchard_nullifiers &&
|
|
|
|
|
|
|
|
// proof of work
|
|
|
|
self.partial_cumulative_work == other.partial_cumulative_work
|
|
|
|
}
|
|
|
|
|
2021-07-09 07:22:15 -07:00
|
|
|
/// Push a contextually valid non-finalized block into this chain as the new tip.
|
|
|
|
///
|
|
|
|
/// If the block is invalid, drop this chain and return an error.
|
2020-11-21 10:41:53 -08:00
|
|
|
#[instrument(level = "debug", skip(self, block), fields(block = %block.block))]
|
2021-07-09 07:22:15 -07:00
|
|
|
pub fn push(mut self, block: PreparedBlock) -> Result<Chain, ValidateContextError> {
|
2021-07-19 06:52:32 -07:00
|
|
|
// the block isn't contextually valid until `update_chain_state_with` returns success
|
|
|
|
let block = ContextuallyValidBlock::from(block);
|
|
|
|
|
2020-11-09 10:05:18 -08:00
|
|
|
// update cumulative data members
|
2021-06-29 20:52:31 -07:00
|
|
|
self.update_chain_state_with(&block)?;
|
2020-11-24 19:30:29 -08:00
|
|
|
tracing::debug!(block = %block.block, "adding block to chain");
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
self.blocks.insert(block.height, block);
|
2021-07-09 07:22:15 -07:00
|
|
|
Ok(self)
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Remove the lowest height block of the non-finalized portion of a chain.
|
2020-11-21 10:41:53 -08:00
|
|
|
#[instrument(level = "debug", skip(self))]
|
2021-07-19 06:52:32 -07:00
|
|
|
pub(crate) fn pop_root(&mut self) -> ContextuallyValidBlock {
|
2020-11-09 10:05:18 -08:00
|
|
|
let block_height = self.lowest_height();
|
|
|
|
|
|
|
|
// remove the lowest height block from self.blocks
|
|
|
|
let block = self
|
|
|
|
.blocks
|
|
|
|
.remove(&block_height)
|
|
|
|
.expect("only called while blocks is populated");
|
|
|
|
|
|
|
|
// update cumulative data members
|
|
|
|
self.revert_chain_state_with(&block);
|
|
|
|
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
// return the prepared block
|
2020-11-09 10:05:18 -08:00
|
|
|
block
|
|
|
|
}
|
|
|
|
|
|
|
|
fn lowest_height(&self) -> block::Height {
|
|
|
|
self.blocks
|
|
|
|
.keys()
|
|
|
|
.next()
|
|
|
|
.cloned()
|
|
|
|
.expect("only called while blocks is populated")
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Fork a chain at the block with the given hash, if it is part of this
|
|
|
|
/// chain.
|
2021-07-29 06:37:18 -07:00
|
|
|
///
|
2021-08-11 06:42:40 -07:00
|
|
|
/// The trees must match the trees of the finalized tip and are used
|
|
|
|
/// to rebuild them after the fork.
|
2021-07-29 06:37:18 -07:00
|
|
|
pub fn fork(
|
|
|
|
&self,
|
|
|
|
fork_tip: block::Hash,
|
|
|
|
sapling_note_commitment_tree: sapling::tree::NoteCommitmentTree,
|
|
|
|
orchard_note_commitment_tree: orchard::tree::NoteCommitmentTree,
|
2021-08-11 06:42:40 -07:00
|
|
|
history_tree: HistoryTree,
|
2021-07-29 06:37:18 -07:00
|
|
|
) -> Result<Option<Self>, ValidateContextError> {
|
2020-11-09 10:05:18 -08:00
|
|
|
if !self.height_by_hash.contains_key(&fork_tip) {
|
2021-06-29 20:52:31 -07:00
|
|
|
return Ok(None);
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
2021-08-11 06:42:40 -07:00
|
|
|
let mut forked = self.with_trees(
|
|
|
|
sapling_note_commitment_tree,
|
|
|
|
orchard_note_commitment_tree,
|
|
|
|
history_tree,
|
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
while forked.non_finalized_tip_hash() != fork_tip {
|
|
|
|
forked.pop_tip();
|
|
|
|
}
|
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
// Rebuild the note commitment trees, starting from the finalized tip tree.
|
|
|
|
// TODO: change to a more efficient approach by removing nodes
|
|
|
|
// from the tree of the original chain (in `pop_tip()`).
|
|
|
|
// See https://github.com/ZcashFoundation/zebra/issues/2378
|
|
|
|
for block in forked.blocks.values() {
|
|
|
|
for transaction in block.block.transactions.iter() {
|
|
|
|
for sapling_note_commitment in transaction.sapling_note_commitments() {
|
|
|
|
forked
|
|
|
|
.sapling_note_commitment_tree
|
|
|
|
.append(*sapling_note_commitment)
|
|
|
|
.expect("must work since it was already appended before the fork");
|
|
|
|
}
|
|
|
|
for orchard_note_commitment in transaction.orchard_note_commitments() {
|
|
|
|
forked
|
|
|
|
.orchard_note_commitment_tree
|
|
|
|
.append(*orchard_note_commitment)
|
|
|
|
.expect("must work since it was already appended before the fork");
|
|
|
|
}
|
|
|
|
}
|
2021-08-11 06:42:40 -07:00
|
|
|
|
|
|
|
// Note that anchors don't need to be recreated since they are already
|
|
|
|
// handled in revert_chain_state_with.
|
|
|
|
|
|
|
|
let sapling_root = forked
|
|
|
|
.sapling_anchors_by_height
|
|
|
|
.get(&block.height)
|
|
|
|
.expect("Sapling anchors must exist for pre-fork blocks");
|
|
|
|
let orchard_root = forked
|
|
|
|
.orchard_anchors_by_height
|
|
|
|
.get(&block.height)
|
|
|
|
.expect("Orchard anchors must exist for pre-fork blocks");
|
|
|
|
forked.history_tree.push(
|
|
|
|
self.network,
|
|
|
|
block.block.clone(),
|
|
|
|
*sapling_root,
|
|
|
|
*orchard_root,
|
|
|
|
)?;
|
2021-07-29 06:37:18 -07:00
|
|
|
}
|
|
|
|
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(Some(forked))
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn non_finalized_tip_hash(&self) -> block::Hash {
|
|
|
|
self.blocks
|
|
|
|
.values()
|
|
|
|
.next_back()
|
|
|
|
.expect("only called while blocks is populated")
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
.hash
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Remove the highest height block of the non-finalized portion of a chain.
|
|
|
|
fn pop_tip(&mut self) {
|
|
|
|
let block_height = self.non_finalized_tip_height();
|
|
|
|
|
|
|
|
let block = self
|
|
|
|
.blocks
|
|
|
|
.remove(&block_height)
|
|
|
|
.expect("only called while blocks is populated");
|
|
|
|
|
|
|
|
assert!(
|
|
|
|
!self.blocks.is_empty(),
|
|
|
|
"Non-finalized chains must have at least one block to be valid"
|
|
|
|
);
|
|
|
|
|
|
|
|
self.revert_chain_state_with(&block);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn non_finalized_tip_height(&self) -> block::Height {
|
|
|
|
*self
|
|
|
|
.blocks
|
|
|
|
.keys()
|
|
|
|
.next_back()
|
|
|
|
.expect("only called while blocks is populated")
|
|
|
|
}
|
2020-11-06 14:31:25 -08:00
|
|
|
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
|
|
self.blocks.is_empty()
|
|
|
|
}
|
2021-07-22 16:40:15 -07:00
|
|
|
|
|
|
|
/// 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 unspent_utxos(&self) -> HashMap<transparent::OutPoint, transparent::Utxo> {
|
|
|
|
let mut unspent_utxos = self.created_utxos.clone();
|
|
|
|
unspent_utxos.retain(|out_point, _utxo| !self.spent_utxos.contains(out_point));
|
|
|
|
unspent_utxos
|
|
|
|
}
|
2021-07-29 06:37:18 -07:00
|
|
|
|
|
|
|
/// Clone the Chain but not the history and note commitment trees, using
|
|
|
|
/// the specified trees instead.
|
|
|
|
///
|
|
|
|
/// Useful when forking, where the trees are rebuilt anyway.
|
|
|
|
fn with_trees(
|
|
|
|
&self,
|
|
|
|
sapling_note_commitment_tree: sapling::tree::NoteCommitmentTree,
|
|
|
|
orchard_note_commitment_tree: orchard::tree::NoteCommitmentTree,
|
2021-08-11 06:42:40 -07:00
|
|
|
history_tree: HistoryTree,
|
2021-07-29 06:37:18 -07:00
|
|
|
) -> Self {
|
|
|
|
Chain {
|
2021-08-11 06:42:40 -07:00
|
|
|
network: self.network,
|
2021-07-29 06:37:18 -07:00
|
|
|
blocks: self.blocks.clone(),
|
|
|
|
height_by_hash: self.height_by_hash.clone(),
|
|
|
|
tx_by_hash: self.tx_by_hash.clone(),
|
|
|
|
created_utxos: self.created_utxos.clone(),
|
|
|
|
spent_utxos: self.spent_utxos.clone(),
|
|
|
|
sapling_note_commitment_tree,
|
|
|
|
orchard_note_commitment_tree,
|
|
|
|
sapling_anchors: self.sapling_anchors.clone(),
|
|
|
|
orchard_anchors: self.orchard_anchors.clone(),
|
|
|
|
sapling_anchors_by_height: self.sapling_anchors_by_height.clone(),
|
|
|
|
orchard_anchors_by_height: self.orchard_anchors_by_height.clone(),
|
|
|
|
sprout_nullifiers: self.sprout_nullifiers.clone(),
|
|
|
|
sapling_nullifiers: self.sapling_nullifiers.clone(),
|
|
|
|
orchard_nullifiers: self.orchard_nullifiers.clone(),
|
|
|
|
partial_cumulative_work: self.partial_cumulative_work,
|
2021-08-11 06:42:40 -07:00
|
|
|
history_tree,
|
2021-07-29 06:37:18 -07:00
|
|
|
}
|
|
|
|
}
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Helper trait to organize inverse operations done on the `Chain` type. Used to
|
|
|
|
/// overload the `update_chain_state_with` and `revert_chain_state_with` methods
|
|
|
|
/// based on the type of the argument.
|
|
|
|
///
|
|
|
|
/// This trait was motivated by the length of the `push` and `pop_root` functions
|
|
|
|
/// and fear that it would be easy to introduce bugs when updating them unless
|
|
|
|
/// the code was reorganized to keep related operations adjacent to eachother.
|
|
|
|
trait UpdateWith<T> {
|
|
|
|
/// Update `Chain` cumulative data members to add data that are derived from
|
|
|
|
/// `T`
|
2021-06-29 20:52:31 -07:00
|
|
|
fn update_chain_state_with(&mut self, _: &T) -> Result<(), ValidateContextError>;
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
/// Update `Chain` cumulative data members to remove data that are derived
|
|
|
|
/// from `T`
|
|
|
|
fn revert_chain_state_with(&mut self, _: &T);
|
|
|
|
}
|
|
|
|
|
2021-07-19 06:52:32 -07:00
|
|
|
impl UpdateWith<ContextuallyValidBlock> for Chain {
|
|
|
|
#[instrument(skip(self, contextually_valid), fields(block = %contextually_valid.block))]
|
2021-06-29 20:52:31 -07:00
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
2021-07-19 06:52:32 -07:00
|
|
|
contextually_valid: &ContextuallyValidBlock,
|
2021-06-29 20:52:31 -07:00
|
|
|
) -> Result<(), ValidateContextError> {
|
2021-07-19 06:52:32 -07:00
|
|
|
let (block, hash, height, new_outputs, transaction_hashes) = (
|
|
|
|
contextually_valid.block.as_ref(),
|
|
|
|
contextually_valid.hash,
|
|
|
|
contextually_valid.height,
|
|
|
|
&contextually_valid.new_outputs,
|
|
|
|
&contextually_valid.transaction_hashes,
|
2020-11-24 19:55:15 -08:00
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
// add hash to height_by_hash
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
let prior_height = self.height_by_hash.insert(hash, height);
|
2020-11-09 10:05:18 -08:00
|
|
|
assert!(
|
|
|
|
prior_height.is_none(),
|
|
|
|
"block heights must be unique within a single chain"
|
|
|
|
);
|
|
|
|
|
|
|
|
// add work to partial cumulative work
|
|
|
|
let block_work = block
|
|
|
|
.header
|
|
|
|
.difficulty_threshold
|
|
|
|
.to_work()
|
|
|
|
.expect("work has already been validated");
|
|
|
|
self.partial_cumulative_work += block_work;
|
|
|
|
|
|
|
|
// for each transaction in block
|
2020-11-24 19:55:15 -08:00
|
|
|
for (transaction_index, (transaction, transaction_hash)) in block
|
|
|
|
.transactions
|
|
|
|
.iter()
|
|
|
|
.zip(transaction_hashes.iter().cloned())
|
|
|
|
.enumerate()
|
|
|
|
{
|
2021-06-01 00:53:13 -07:00
|
|
|
let (
|
|
|
|
inputs,
|
|
|
|
joinsplit_data,
|
|
|
|
sapling_shielded_data_per_spend_anchor,
|
|
|
|
sapling_shielded_data_shared_anchor,
|
|
|
|
orchard_shielded_data,
|
|
|
|
) = match transaction.deref() {
|
2021-03-03 13:56:41 -08:00
|
|
|
V4 {
|
2020-11-09 10:05:18 -08:00
|
|
|
inputs,
|
|
|
|
joinsplit_data,
|
2021-03-31 14:34:25 -07:00
|
|
|
sapling_shielded_data,
|
2020-11-09 10:05:18 -08:00
|
|
|
..
|
2021-06-01 00:53:13 -07:00
|
|
|
} => (inputs, joinsplit_data, sapling_shielded_data, &None, &None),
|
|
|
|
V5 {
|
|
|
|
inputs,
|
|
|
|
sapling_shielded_data,
|
|
|
|
orchard_shielded_data,
|
|
|
|
..
|
|
|
|
} => (
|
|
|
|
inputs,
|
|
|
|
&None,
|
|
|
|
&None,
|
|
|
|
sapling_shielded_data,
|
|
|
|
orchard_shielded_data,
|
|
|
|
),
|
2021-03-03 13:56:41 -08:00
|
|
|
V1 { .. } | V2 { .. } | V3 { .. } => unreachable!(
|
2021-06-01 00:53:13 -07:00
|
|
|
"older transaction versions only exist in finalized blocks, because of the mandatory canopy checkpoint",
|
2020-11-09 10:05:18 -08:00
|
|
|
),
|
|
|
|
};
|
|
|
|
|
|
|
|
// add key `transaction.hash` and value `(height, tx_index)` to `tx_by_hash`
|
|
|
|
let prior_pair = self
|
|
|
|
.tx_by_hash
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
.insert(transaction_hash, (height, transaction_index));
|
2020-11-09 10:05:18 -08:00
|
|
|
assert!(
|
|
|
|
prior_pair.is_none(),
|
|
|
|
"transactions must be unique within a single chain"
|
|
|
|
);
|
|
|
|
|
|
|
|
// add the utxos this produced
|
2021-07-19 06:52:32 -07:00
|
|
|
self.update_chain_state_with(new_outputs)?;
|
2020-11-09 10:05:18 -08:00
|
|
|
// add the utxos this consumed
|
2021-06-29 20:52:31 -07:00
|
|
|
self.update_chain_state_with(inputs)?;
|
2021-06-01 00:53:13 -07:00
|
|
|
|
|
|
|
// add the shielded data
|
2021-06-29 20:52:31 -07:00
|
|
|
self.update_chain_state_with(joinsplit_data)?;
|
|
|
|
self.update_chain_state_with(sapling_shielded_data_per_spend_anchor)?;
|
|
|
|
self.update_chain_state_with(sapling_shielded_data_shared_anchor)?;
|
|
|
|
self.update_chain_state_with(orchard_shielded_data)?;
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
2021-06-29 20:52:31 -07:00
|
|
|
|
2021-07-29 06:37:18 -07:00
|
|
|
// Having updated all the note commitment trees and nullifier sets in
|
|
|
|
// this block, the roots of the note commitment trees as of the last
|
|
|
|
// transaction are the treestates of this block.
|
2021-08-11 06:42:40 -07:00
|
|
|
let sapling_root = self.sapling_note_commitment_tree.root();
|
|
|
|
self.sapling_anchors.insert(sapling_root);
|
|
|
|
self.sapling_anchors_by_height.insert(height, sapling_root);
|
|
|
|
let orchard_root = self.orchard_note_commitment_tree.root();
|
|
|
|
self.orchard_anchors.insert(orchard_root);
|
|
|
|
self.orchard_anchors_by_height.insert(height, orchard_root);
|
|
|
|
|
|
|
|
self.history_tree.push(
|
|
|
|
self.network,
|
|
|
|
contextually_valid.block.clone(),
|
|
|
|
sapling_root,
|
|
|
|
orchard_root,
|
|
|
|
)?;
|
2021-07-29 06:37:18 -07:00
|
|
|
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
2021-07-19 06:52:32 -07:00
|
|
|
#[instrument(skip(self, contextually_valid), fields(block = %contextually_valid.block))]
|
|
|
|
fn revert_chain_state_with(&mut self, contextually_valid: &ContextuallyValidBlock) {
|
2021-07-29 06:37:18 -07:00
|
|
|
let (block, hash, height, new_outputs, transaction_hashes) = (
|
2021-07-19 06:52:32 -07:00
|
|
|
contextually_valid.block.as_ref(),
|
|
|
|
contextually_valid.hash,
|
2021-07-29 06:37:18 -07:00
|
|
|
contextually_valid.height,
|
2021-07-19 06:52:32 -07:00
|
|
|
&contextually_valid.new_outputs,
|
|
|
|
&contextually_valid.transaction_hashes,
|
2020-11-24 19:55:15 -08:00
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
// remove the blocks hash from `height_by_hash`
|
|
|
|
assert!(
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
self.height_by_hash.remove(&hash).is_some(),
|
2021-07-14 05:06:43 -07:00
|
|
|
"hash must be present if block was added to chain"
|
2020-11-09 10:05:18 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// remove work from partial_cumulative_work
|
|
|
|
let block_work = block
|
|
|
|
.header
|
|
|
|
.difficulty_threshold
|
|
|
|
.to_work()
|
|
|
|
.expect("work has already been validated");
|
|
|
|
self.partial_cumulative_work -= block_work;
|
|
|
|
|
2021-08-11 06:42:40 -07:00
|
|
|
// Note: the history tree is not modified in this method.
|
|
|
|
// This method is called on two scenarios:
|
|
|
|
// - When popping the root: the history tree does not change.
|
|
|
|
// - When popping the tip: the history tree is rebuilt in fork().
|
|
|
|
|
2020-11-09 10:05:18 -08:00
|
|
|
// for each transaction in block
|
2020-11-24 19:55:15 -08:00
|
|
|
for (transaction, transaction_hash) in
|
|
|
|
block.transactions.iter().zip(transaction_hashes.iter())
|
|
|
|
{
|
2021-06-01 00:53:13 -07:00
|
|
|
let (
|
|
|
|
inputs,
|
|
|
|
joinsplit_data,
|
|
|
|
sapling_shielded_data_per_spend_anchor,
|
|
|
|
sapling_shielded_data_shared_anchor,
|
|
|
|
orchard_shielded_data,
|
|
|
|
) = match transaction.deref() {
|
2021-03-03 13:56:41 -08:00
|
|
|
V4 {
|
2020-11-09 10:05:18 -08:00
|
|
|
inputs,
|
|
|
|
joinsplit_data,
|
2021-03-31 14:34:25 -07:00
|
|
|
sapling_shielded_data,
|
2020-11-09 10:05:18 -08:00
|
|
|
..
|
2021-06-01 00:53:13 -07:00
|
|
|
} => (inputs, joinsplit_data, sapling_shielded_data, &None, &None),
|
|
|
|
V5 {
|
|
|
|
inputs,
|
|
|
|
sapling_shielded_data,
|
|
|
|
orchard_shielded_data,
|
|
|
|
..
|
|
|
|
} => (
|
|
|
|
inputs,
|
|
|
|
&None,
|
|
|
|
&None,
|
|
|
|
sapling_shielded_data,
|
|
|
|
orchard_shielded_data,
|
|
|
|
),
|
2021-03-03 13:56:41 -08:00
|
|
|
V1 { .. } | V2 { .. } | V3 { .. } => unreachable!(
|
2021-06-01 00:53:13 -07:00
|
|
|
"older transaction versions only exist in finalized blocks, because of the mandatory canopy checkpoint",
|
2020-11-09 10:05:18 -08:00
|
|
|
),
|
|
|
|
};
|
|
|
|
|
|
|
|
// remove `transaction.hash` from `tx_by_hash`
|
|
|
|
assert!(
|
2020-11-24 19:55:15 -08:00
|
|
|
self.tx_by_hash.remove(transaction_hash).is_some(),
|
2021-07-14 05:06:43 -07:00
|
|
|
"transactions must be present if block was added to chain"
|
2020-11-09 10:05:18 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// remove the utxos this produced
|
2021-07-19 06:52:32 -07:00
|
|
|
self.revert_chain_state_with(new_outputs);
|
2020-11-09 10:05:18 -08:00
|
|
|
// remove the utxos this consumed
|
|
|
|
self.revert_chain_state_with(inputs);
|
2021-06-01 00:53:13 -07:00
|
|
|
|
|
|
|
// remove the shielded data
|
2020-11-09 10:05:18 -08:00
|
|
|
self.revert_chain_state_with(joinsplit_data);
|
2021-06-01 00:53:13 -07:00
|
|
|
self.revert_chain_state_with(sapling_shielded_data_per_spend_anchor);
|
|
|
|
self.revert_chain_state_with(sapling_shielded_data_shared_anchor);
|
|
|
|
self.revert_chain_state_with(orchard_shielded_data);
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
2021-07-29 06:37:18 -07:00
|
|
|
let anchor = self
|
|
|
|
.sapling_anchors_by_height
|
|
|
|
.remove(&height)
|
|
|
|
.expect("Sapling anchor must be present if block was added to chain");
|
|
|
|
assert!(
|
|
|
|
self.sapling_anchors.remove(&anchor),
|
|
|
|
"Sapling anchor must be present if block was added to chain"
|
|
|
|
);
|
|
|
|
let anchor = self
|
|
|
|
.orchard_anchors_by_height
|
|
|
|
.remove(&height)
|
|
|
|
.expect("Orchard anchor must be present if block was added to chain");
|
|
|
|
assert!(
|
|
|
|
self.orchard_anchors.remove(&anchor),
|
|
|
|
"Orchard anchor must be present if block was added to chain"
|
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-11 19:49:33 -07:00
|
|
|
impl UpdateWith<HashMap<transparent::OutPoint, transparent::Utxo>> for Chain {
|
2021-06-29 20:52:31 -07:00
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
2021-07-11 19:49:33 -07:00
|
|
|
utxos: &HashMap<transparent::OutPoint, transparent::Utxo>,
|
2021-06-29 20:52:31 -07:00
|
|
|
) -> Result<(), ValidateContextError> {
|
2020-11-23 12:02:57 -08:00
|
|
|
self.created_utxos
|
|
|
|
.extend(utxos.iter().map(|(k, v)| (*k, v.clone())));
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
2021-07-11 19:49:33 -07:00
|
|
|
fn revert_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
utxos: &HashMap<transparent::OutPoint, transparent::Utxo>,
|
|
|
|
) {
|
2020-11-23 12:02:57 -08:00
|
|
|
self.created_utxos
|
|
|
|
.retain(|outpoint, _| !utxos.contains_key(outpoint));
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UpdateWith<Vec<transparent::Input>> for Chain {
|
2021-06-29 20:52:31 -07:00
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
inputs: &Vec<transparent::Input>,
|
|
|
|
) -> Result<(), ValidateContextError> {
|
2020-11-09 10:05:18 -08:00
|
|
|
for consumed_utxo in inputs {
|
|
|
|
match consumed_utxo {
|
|
|
|
transparent::Input::PrevOut { outpoint, .. } => {
|
|
|
|
self.spent_utxos.insert(*outpoint);
|
|
|
|
}
|
|
|
|
transparent::Input::Coinbase { .. } => {}
|
|
|
|
}
|
|
|
|
}
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
fn revert_chain_state_with(&mut self, inputs: &Vec<transparent::Input>) {
|
|
|
|
for consumed_utxo in inputs {
|
|
|
|
match consumed_utxo {
|
|
|
|
transparent::Input::PrevOut { outpoint, .. } => {
|
|
|
|
assert!(
|
|
|
|
self.spent_utxos.remove(outpoint),
|
2021-07-14 05:06:43 -07:00
|
|
|
"spent_utxos must be present if block was added to chain"
|
2020-11-09 10:05:18 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
transparent::Input::Coinbase { .. } => {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UpdateWith<Option<transaction::JoinSplitData<Groth16Proof>>> for Chain {
|
|
|
|
#[instrument(skip(self, joinsplit_data))]
|
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
joinsplit_data: &Option<transaction::JoinSplitData<Groth16Proof>>,
|
2021-06-29 20:52:31 -07:00
|
|
|
) -> Result<(), ValidateContextError> {
|
2020-11-09 10:05:18 -08:00
|
|
|
if let Some(joinsplit_data) = joinsplit_data {
|
2021-07-14 05:06:43 -07:00
|
|
|
check::nullifier::add_to_non_finalized_chain_unique(
|
|
|
|
&mut self.sprout_nullifiers,
|
|
|
|
joinsplit_data.nullifiers(),
|
|
|
|
)?;
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
2021-07-14 05:06:43 -07:00
|
|
|
/// # 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.
|
2020-11-09 10:05:18 -08:00
|
|
|
#[instrument(skip(self, joinsplit_data))]
|
|
|
|
fn revert_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
joinsplit_data: &Option<transaction::JoinSplitData<Groth16Proof>>,
|
|
|
|
) {
|
|
|
|
if let Some(joinsplit_data) = joinsplit_data {
|
2021-07-14 05:06:43 -07:00
|
|
|
check::nullifier::remove_from_non_finalized_chain(
|
|
|
|
&mut self.sprout_nullifiers,
|
|
|
|
joinsplit_data.nullifiers(),
|
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-31 14:34:25 -07:00
|
|
|
impl<AnchorV> UpdateWith<Option<sapling::ShieldedData<AnchorV>>> for Chain
|
|
|
|
where
|
|
|
|
AnchorV: sapling::AnchorVariant + Clone,
|
|
|
|
{
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
#[instrument(skip(self, sapling_shielded_data))]
|
2021-04-27 06:37:53 -07:00
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
sapling_shielded_data: &Option<sapling::ShieldedData<AnchorV>>,
|
2021-06-29 20:52:31 -07:00
|
|
|
) -> Result<(), ValidateContextError> {
|
2021-04-27 06:37:53 -07:00
|
|
|
if let Some(sapling_shielded_data) = sapling_shielded_data {
|
2021-07-29 06:37:18 -07:00
|
|
|
for cm_u in sapling_shielded_data.note_commitments() {
|
|
|
|
self.sapling_note_commitment_tree.append(*cm_u)?;
|
|
|
|
}
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
check::nullifier::add_to_non_finalized_chain_unique(
|
|
|
|
&mut self.sapling_nullifiers,
|
|
|
|
sapling_shielded_data.nullifiers(),
|
|
|
|
)?;
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
/// # 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.
|
|
|
|
#[instrument(skip(self, sapling_shielded_data))]
|
2021-04-27 06:37:53 -07:00
|
|
|
fn revert_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
sapling_shielded_data: &Option<sapling::ShieldedData<AnchorV>>,
|
|
|
|
) {
|
|
|
|
if let Some(sapling_shielded_data) = sapling_shielded_data {
|
2021-07-29 06:37:18 -07:00
|
|
|
// Note commitments are not removed from the tree here because we
|
|
|
|
// don't support that operation yet. Instead, we recreate the tree
|
|
|
|
// from the finalized tip in NonFinalizedState.
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
check::nullifier::remove_from_non_finalized_chain(
|
|
|
|
&mut self.sapling_nullifiers,
|
|
|
|
sapling_shielded_data.nullifiers(),
|
|
|
|
);
|
2020-11-09 10:05:18 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-01 00:53:13 -07:00
|
|
|
impl UpdateWith<Option<orchard::ShieldedData>> for Chain {
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
#[instrument(skip(self, orchard_shielded_data))]
|
2021-06-29 20:52:31 -07:00
|
|
|
fn update_chain_state_with(
|
|
|
|
&mut self,
|
|
|
|
orchard_shielded_data: &Option<orchard::ShieldedData>,
|
|
|
|
) -> Result<(), ValidateContextError> {
|
2021-06-01 00:53:13 -07:00
|
|
|
if let Some(orchard_shielded_data) = orchard_shielded_data {
|
2021-07-29 06:37:18 -07:00
|
|
|
for cm_x in orchard_shielded_data.note_commitments() {
|
|
|
|
self.orchard_note_commitment_tree.append(*cm_x)?;
|
|
|
|
}
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
check::nullifier::add_to_non_finalized_chain_unique(
|
|
|
|
&mut self.orchard_nullifiers,
|
|
|
|
orchard_shielded_data.nullifiers(),
|
|
|
|
)?;
|
2021-06-01 00:53:13 -07:00
|
|
|
}
|
2021-06-29 20:52:31 -07:00
|
|
|
Ok(())
|
2021-06-01 00:53:13 -07:00
|
|
|
}
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
/// # 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.
|
|
|
|
#[instrument(skip(self, orchard_shielded_data))]
|
2021-06-01 00:53:13 -07:00
|
|
|
fn revert_chain_state_with(&mut self, orchard_shielded_data: &Option<orchard::ShieldedData>) {
|
|
|
|
if let Some(orchard_shielded_data) = orchard_shielded_data {
|
2021-07-29 06:37:18 -07:00
|
|
|
// Note commitments are not removed from the tree here because we
|
|
|
|
// don't support that operation yet. Instead, we recreate the tree
|
|
|
|
// from the finalized tip in NonFinalizedState.
|
|
|
|
|
Reject duplicate Sapling and Orchard nullifiers (#2497)
* Add sapling and orchard duplicate nullifier errors
* Reject duplicate finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is already in the finalized state.
* Reject duplicate non-finalized sapling and orchard nullifiers
Reject duplicate sapling and orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block, or
* an earlier block in the non-finalized chain.
* Refactor sprout nullifier tests to remove common code
* Add sapling nullifier tests
Test that the state rejects duplicate sapling nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Add orchard nullifier tests
Test that the state rejects duplicate orchard nullifiers in a new block,
when the block is added to a non-finalized chain,
and the duplicate nullifier is in:
* the same shielded data,
* the same transaction,
* the same block,
* an earlier block in the non-finalized chain, or
* the finalized state.
* Check for specific nullifiers in the state in tests
* Replace slices with vectors in arguments
* Remove redundant code and variables
* Simplify sapling TransferData tests
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
* Remove an extra :
* Remove redundant vec!
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>
2021-07-19 17:39:05 -07:00
|
|
|
check::nullifier::remove_from_non_finalized_chain(
|
|
|
|
&mut self.orchard_nullifiers,
|
|
|
|
orchard_shielded_data.nullifiers(),
|
|
|
|
);
|
2021-06-01 00:53:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-09 10:05:18 -08:00
|
|
|
impl Ord for Chain {
|
2021-07-14 15:23:54 -07:00
|
|
|
/// 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 [`Block`]s 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
|
|
|
|
///
|
|
|
|
/// # 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.
|
2020-11-09 10:05:18 -08:00
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
|
|
if self.partial_cumulative_work != other.partial_cumulative_work {
|
|
|
|
self.partial_cumulative_work
|
|
|
|
.cmp(&other.partial_cumulative_work)
|
|
|
|
} else {
|
|
|
|
let self_hash = self
|
|
|
|
.blocks
|
|
|
|
.values()
|
|
|
|
.last()
|
|
|
|
.expect("always at least 1 element")
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
.hash;
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
let other_hash = other
|
|
|
|
.blocks
|
|
|
|
.values()
|
|
|
|
.last()
|
|
|
|
.expect("always at least 1 element")
|
state: introduce PreparedBlock, FinalizedBlock
This change introduces two new types:
- `PreparedBlock`, representing a block which has undergone semantic
validation and has been prepared for contextual validation;
- `FinalizedBlock`, representing a block which is ready to be finalized
immediately;
and changes the `Request::CommitBlock`,`Request::CommitFinalizedBlock`
variants to use these types instead of their previous fields.
This change solves the problem of passing data between semantic
validation and contextual validation, and cleans up the state code by
allowing it to pass around a bundle of data. Previously, the state code
just passed around an `Arc<Block>`, which forced it to needlessly
recompute block hashes and other data, and was incompatible with the
already-known but not-yet-implemented data transfer requirements, namely
passing in the Sprout and Sapling anchors computed during contextual
validation.
This commit propagates the `PreparedBlock` and `FinalizedBlock` types
through the state code but only uses their data opportunistically, e.g.,
changing .hash() computations to use the precomputed hash. In the
future, these structures can be extended to pass data through the
verification pipeline for reuse as appropriate. For instance, these
changes allow the sprout and sapling anchors to be propagated through
the state.
2020-11-21 01:16:14 -08:00
|
|
|
.hash;
|
2020-11-09 10:05:18 -08:00
|
|
|
|
|
|
|
// This comparison is a tie-breaker within the local node, so it does not need to
|
|
|
|
// be consistent with the ordering on `ExpandedDifficulty` and `block::Hash`.
|
|
|
|
match self_hash.0.cmp(&other_hash.0) {
|
|
|
|
Ordering::Equal => unreachable!("Chain tip block hashes are always unique"),
|
|
|
|
ordering => ordering,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-07-14 15:23:54 -07:00
|
|
|
|
|
|
|
impl PartialOrd for Chain {
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialEq for Chain {
|
|
|
|
/// Chain equality for the [`NonFinalizedState`]'s `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 eq(&self, other: &Self) -> bool {
|
|
|
|
self.partial_cmp(other) == Some(Ordering::Equal)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Eq for Chain {}
|