Copy tests from zsa-issued-assets-tests here and fix compilation errors

Author: dmidem

zebra-consensus/src/orchard_zsa/tests.rs

@@ -1,3 +1,7 @@
+// FIXME: Consider moving thesr tests to `zebra-consensus/src/router/tests.rs`, or creating a
+// `zebra-consensus/src/router/tests` directory and placing this module with a name
+// 'orchard_zsa` there.
+
 //! Simulates a full Zebra node’s block‐processing pipeline on a predefined Orchard/ZSA workflow.
 //!
 //! This integration test reads a sequence of serialized regtest blocks (including Orchard burns

zebra-consensus/src/router/tests.rs

@@ -270,3 +270,50 @@ async fn verify_fail_add_block_checkpoint() -> Result<(), Report> {
 
     Ok(())
 }
+
+// FIXME: Remove this test. The more comprehensive `check_orchard_zsa_workflow` in
+// `zebra-consensus/src/orchard_zsa/tests.rs` already verifies everything this test
+// covers (and more).
+#[tokio::test(flavor = "multi_thread")]
+async fn verify_issuance_blocks_test() -> Result<(), Report> {
+    use block::genesis::regtest_genesis_block;
+
+    use zebra_test::vectors::{OrchardWorkflowBlock, ORCHARD_WORKFLOW_BLOCKS_ZSA};
+
+    let _init_guard = zebra_test::init();
+
+    let network = Network::new_regtest(Some(1), None, Some(1));
+    let (block_verifier_router, _state_service) = verifiers_from_network(network.clone()).await;
+
+    let block_verifier_router =
+        TimeoutLayer::new(Duration::from_secs(VERIFY_TIMEOUT_SECONDS)).layer(block_verifier_router);
+
+    let commit_genesis = [(
+        Request::Commit(regtest_genesis_block()),
+        Ok(network.genesis_hash()),
+    )];
+
+    let commit_issuance_blocks =
+        ORCHARD_WORKFLOW_BLOCKS_ZSA
+            .iter()
+            .map(|OrchardWorkflowBlock { bytes, is_valid }| {
+                let block = Arc::new(
+                    Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"),
+                );
+                (
+                    Request::Commit(block.clone()),
+                    if *is_valid {
+                        Ok(block.hash())
+                    } else {
+                        Err(ExpectedTranscriptError::Any)
+                    },
+                )
+            });
+
+    Transcript::from(commit_genesis.into_iter().chain(commit_issuance_blocks))
+        .check(block_verifier_router.clone())
+        .await
+        .unwrap();
+
+    Ok(())
+}

zebra-state/src/service/check/tests.rs

@@ -1,6 +1,7 @@
 //! Tests for state contextual validation checks.
 
 mod anchors;
+mod issuance;
 mod nullifier;
 mod utxo;
 mod vectors;

zebra-state/src/service/check/tests/issuance.rs

@@ -0,0 +1,94 @@
+use std::sync::Arc;
+
+use zebra_chain::{
+    block::{self, genesis::regtest_genesis_block, Block},
+    orchard_zsa::IssuedAssets,
+    parameters::Network,
+    serialization::ZcashDeserialize,
+};
+
+use zebra_test::vectors::{OrchardWorkflowBlock, ORCHARD_WORKFLOW_BLOCKS_ZSA};
+
+use crate::{
+    check::{self, Chain},
+    service::{finalized_state::FinalizedState, write::validate_and_commit_non_finalized},
+    CheckpointVerifiedBlock, Config, NonFinalizedState,
+};
+
+fn valid_issuance_blocks() -> Vec<Arc<Block>> {
+    ORCHARD_WORKFLOW_BLOCKS_ZSA
+        .iter()
+        .map(|OrchardWorkflowBlock { bytes, .. }| {
+            Arc::new(Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"))
+        })
+        .collect()
+}
+
+#[test]
+fn check_burns_and_issuance() {
+    let _init_guard = zebra_test::init();
+
+    let network = Network::new_regtest(Some(1), None, Some(1));
+
+    let mut finalized_state = FinalizedState::new_with_debug(
+        &Config::ephemeral(),
+        &network,
+        true,
+        #[cfg(feature = "elasticsearch")]
+        false,
+        false,
+    );
+
+    let mut non_finalized_state = NonFinalizedState::new(&network);
+
+    let regtest_genesis_block = regtest_genesis_block();
+    let regtest_genesis_hash = regtest_genesis_block.hash();
+
+    finalized_state
+        .commit_finalized_direct(regtest_genesis_block.into(), None, "test")
+        .expect("unexpected invalid genesis block test vector");
+
+    let block = valid_issuance_blocks().first().unwrap().clone();
+    let mut header = Arc::<block::Header>::unwrap_or_clone(block.header.clone());
+    header.previous_block_hash = regtest_genesis_hash;
+    header.commitment_bytes = [0; 32].into();
+    let block = Arc::new(Block {
+        header: Arc::new(header),
+        transactions: block.transactions.clone(),
+    });
+
+    let CheckpointVerifiedBlock(block) = CheckpointVerifiedBlock::new(block, None, None);
+
+    let empty_chain = Chain::new(
+        &network,
+        finalized_state
+            .db
+            .finalized_tip_height()
+            .unwrap_or(block::Height::MIN),
+        finalized_state.db.sprout_tree_for_tip(),
+        finalized_state.db.sapling_tree_for_tip(),
+        finalized_state.db.orchard_tree_for_tip(),
+        finalized_state.db.history_tree(),
+        finalized_state.db.finalized_value_pool(),
+    );
+
+    let block_1_issued_assets = check::issuance::valid_burns_and_issuance(
+        &finalized_state.db,
+        &Arc::new(empty_chain),
+        &block,
+    )
+    .expect("test transactions should be valid");
+
+    validate_and_commit_non_finalized(&finalized_state.db, &mut non_finalized_state, block)
+        .expect("validation should succeed");
+
+    let best_chain = non_finalized_state
+        .best_chain()
+        .expect("should have a non-finalized chain");
+
+    assert_eq!(
+        IssuedAssets::from(best_chain.issued_assets.clone()),
+        block_1_issued_assets,
+        "issued assets for chain should match those of block 1"
+    );
+}