ZIP-221: Validate chain history commitments in the non-finalized state

zebra-state/src/error.rs

@@ -74,4 +74,10 @@ pub enum ValidateContextError {
         difficulty_threshold: CompactDifficulty,
         expected_difficulty: CompactDifficulty,
     },
+
+    #[error("block has the wrong history commitment")]
+    #[non_exhaustive]
+    InvalidHistoryCommitment {
+        // TODO: add commitments?
+    },
 }

zebra-state/src/service.rs

@@ -149,9 +149,9 @@ impl StateService {
         let parent_hash = prepared.block.header.previous_block_hash;
 
         if self.disk.finalized_tip_hash() == parent_hash {
-            self.mem.commit_new_chain(prepared);
+            self.mem.commit_new_chain(prepared)?;
         } else {
-            self.mem.commit_block(prepared);
+            self.mem.commit_block(prepared)?;
         }
 
         Ok(())

zebra-state/src/service/check.rs

@@ -4,7 +4,7 @@ use std::borrow::Borrow;
 
 use chrono::Duration;
 use zebra_chain::{
-    block::{self, Block},
+    block::{self, Block, ChainHistoryMmrRootHash},
     parameters::POW_AVERAGING_WINDOW,
     parameters::{Network, NetworkUpgrade},
     work::difficulty::CompactDifficulty,
@@ -86,6 +86,41 @@ where
     Ok(())
 }
 
+#[tracing::instrument(
+    name = "contextual_validation_for_chain",
+    fields(?network),
+    skip(prepared, network)
+)]
+pub(crate) fn block_is_contextually_valid_for_chain(
+    prepared: &PreparedBlock,
+    network: Network,
+    mmr_hash: &ChainHistoryMmrRootHash,
+) -> Result<(), ValidateContextError> {
+    match prepared
+        .block
+        .commitment(network)
+        .expect("should have commitment (TODO: confirm)")
+    {
+        block::Commitment::PreSaplingReserved(_) => todo!("Confirm where this is being checked"),
+        block::Commitment::FinalSaplingRoot(_) => todo!("Confirm where this is being checked"),
+        block::Commitment::ChainHistoryActivationReserved => {
+            todo!("Confirm where this is being checked")
+        }
+        block::Commitment::ChainHistoryRoot(block_mmr_hash) => {
+            if block_mmr_hash == *mmr_hash {
+                Ok(())
+            } else {
+                Err(ValidateContextError::InvalidHistoryCommitment {})
+            }
+        }
+        block::Commitment::ChainHistoryBlockTxAuthCommitment(_) => {
+            // TODO: Get auth_hash from block (ZIP-244), e.g.
+            // let auth_hash = prepared.block.auth_hash();
+            todo!("hash mmr_hash and auth_hash per ZIP-244 and compare")
+        }
+    }
+}
+
 /// Returns `ValidateContextError::OrphanedBlock` if the height of the given
 /// block is less than or equal to the finalized tip height.
 fn block_is_not_orphaned(

zebra-state/src/service/non_finalized_state.rs

@@ -21,10 +21,12 @@ use zebra_chain::{
     transparent,
 };
 
-use crate::{FinalizedBlock, HashOrHeight, PreparedBlock, Utxo};
+use crate::{FinalizedBlock, HashOrHeight, PreparedBlock, Utxo, ValidateContextError};
 
 use self::chain::Chain;
 
+use super::check;
+
 /// The state of the chains in memory, incuding queued blocks.
 #[derive(Default)]
 pub struct NonFinalizedState {
@@ -76,7 +78,7 @@ impl NonFinalizedState {
     }
 
     /// Commit block to the non-finalized state.
-    pub fn commit_block(&mut self, prepared: PreparedBlock) {
+    pub fn commit_block(&mut self, prepared: PreparedBlock) -> Result<(), ValidateContextError> {
         let parent_hash = prepared.block.header.previous_block_hash;
         let (height, hash) = (prepared.height, prepared.hash);
 
@@ -97,19 +99,31 @@ impl NonFinalizedState {
             })
             .expect("commit_block is only called with blocks that are ready to be commited");
 
+        check::block_is_contextually_valid_for_chain(
+            &prepared,
+            self.network,
+            &parent_chain.mmr_hash(),
+        )?;
         parent_chain.push(prepared);
         self.chain_set.insert(parent_chain);
         self.update_metrics_for_committed_block(height, hash);
+        Ok(())
     }
 
     /// Commit block to the non-finalized state as a new chain where its parent
     /// is the finalized tip.
-    pub fn commit_new_chain(&mut self, prepared: PreparedBlock) {
+    pub fn commit_new_chain(
+        &mut self,
+        prepared: PreparedBlock,
+    ) -> Result<(), ValidateContextError> {
+        // TODO: will need to pass the MMR tree of the finalized tip to the newly built chain. How?
         let mut chain = Chain::default();
         let (height, hash) = (prepared.height, prepared.hash);
+        check::block_is_contextually_valid_for_chain(&prepared, self.network, &chain.mmr_hash())?;
         chain.push(prepared);
         self.chain_set.insert(Box::new(chain));
         self.update_metrics_for_committed_block(height, hash);
+        Ok(())
     }
 
     /// Returns the length of the non-finalized portion of the current best chain.

zebra-state/src/service/non_finalized_state/chain.rs

@@ -6,8 +6,13 @@ use std::{
 
 use tracing::{debug_span, instrument, trace};
 use zebra_chain::{
-    block, orchard, primitives::Groth16Proof, sapling, sprout, transaction,
-    transaction::Transaction::*, transparent, work::difficulty::PartialCumulativeWork,
+    block::{self, ChainHistoryMmrRootHash},
+    orchard,
+    primitives::Groth16Proof,
+    sapling, sprout, transaction,
+    transaction::Transaction::*,
+    transparent,
+    work::difficulty::PartialCumulativeWork,
 };
 
 use crate::{PreparedBlock, Utxo};
@@ -27,6 +32,7 @@ pub struct Chain {
     sapling_nullifiers: HashSet<sapling::Nullifier>,
     orchard_nullifiers: HashSet<orchard::Nullifier>,
     partial_cumulative_work: PartialCumulativeWork,
+    // TODO: MMR tree
 }
 
 impl Chain {
@@ -117,6 +123,10 @@ impl Chain {
     pub fn is_empty(&self) -> bool {
         self.blocks.is_empty()
     }
+
+    pub fn mmr_hash(&self) -> ChainHistoryMmrRootHash {
+        todo!("get MMR hash from the MMR tree");
+    }
 }
 
 /// Helper trait to organize inverse operations done on the `Chain` type. Used to
@@ -160,6 +170,8 @@ impl UpdateWith<PreparedBlock> for Chain {
             .expect("work has already been validated");
         self.partial_cumulative_work += block_work;
 
+        // TODO: add block data to MMR tree
+
         // for each transaction in block
         for (transaction_index, (transaction, transaction_hash)) in block
             .transactions
@@ -241,6 +253,10 @@ impl UpdateWith<PreparedBlock> for Chain {
             .expect("work has already been validated");
         self.partial_cumulative_work -= block_work;
 
+        // TODO: remove block data from MMR tree
+        // In order to do that, we need to load some "extra" nodes (blocks) from the
+        // state (see zcash_history and librustzcash). How to do that here?
+
         // for each transaction in block
         for (transaction, transaction_hash) in
             block.transactions.iter().zip(transaction_hashes.iter())