zebra-test: refactor orchard_zsa_workflow_blocks.rs to use a u8 static ref for bytes OrchardWorkflowBlock instead of a vec, matching the approach used in block.rs there

Author: dmidem

zebra-consensus/src/orchard_zsa/tests.rs

@@ -31,7 +31,7 @@ use orchard::{
 };
 
 use zebra_chain::{
-    block::{genesis::regtest_genesis_block, Block, Hash},
+    block::{Block, Hash},
     parameters::{testnet::ConfiguredActivationHeights, Network},
     serialization::ZcashDeserialize,
 };
@@ -179,30 +179,24 @@ fn build_asset_records<'a, I: IntoIterator<Item = &'a TranscriptItem>>(
 fn create_transcript_data<'a, I: IntoIterator<Item = &'a OrchardWorkflowBlock>>(
     serialized_blocks: I,
 ) -> impl Iterator<Item = TranscriptItem> + use<'a, I> {
-    let workflow_blocks =
-        serialized_blocks
-            .into_iter()
-            .map(|OrchardWorkflowBlock { bytes, is_valid }| {
-                (
-                    Arc::new(
-                        Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"),
-                    ),
-                    *is_valid,
-                )
-            });
-
-    std::iter::once((regtest_genesis_block(), true))
-        .chain(workflow_blocks)
-        .map(|(block, is_valid)| {
+    serialized_blocks.into_iter().map(
+        |OrchardWorkflowBlock {
+             height: _,
+             bytes,
+             is_valid,
+         }| {
+            let block =
+                Arc::new(Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"));
             (
                 Request::Commit(block.clone()),
-                if is_valid {
+                if *is_valid {
                     Ok(block.hash())
                 } else {
                     Err(ExpectedTranscriptError::Any)
                 },
             )
-        })
+        },
+    )
 }
 
 /// Queries the state service for the asset state of the given asset.

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use zebra_chain::{
-    block::{self, genesis::regtest_genesis_block, Block},
+    block::{self, Block},
     orchard_zsa::{AssetBase, IssuedAssetChanges},
     parameters::Network,
     serialization::ZcashDeserialize,
@@ -15,15 +15,6 @@ use crate::{
     CheckpointVerifiedBlock, Config, NonFinalizedState,
 };
 
-fn valid_issuance_blocks() -> Vec<Arc<Block>> {
-    ORCHARD_ZSA_WORKFLOW_BLOCKS
-        .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();
@@ -41,23 +32,26 @@ fn check_burns_and_issuance() {
 
     let mut non_finalized_state = NonFinalizedState::new(&network);
 
-    let regtest_genesis_block = regtest_genesis_block();
-    let regtest_genesis_hash = regtest_genesis_block.hash();
+    let mut block_iter =
+        ORCHARD_ZSA_WORKFLOW_BLOCKS
+            .iter()
+            .map(|OrchardWorkflowBlock { bytes, .. }| {
+                Arc::new(Block::zcash_deserialize(&bytes[..]).expect("block should deserialize"))
+            });
+
+    let genesis_block = block_iter.next().expect("genesis block must exist").clone();
 
     finalized_state
-        .commit_finalized_direct(regtest_genesis_block.into(), None, "test")
+        .commit_finalized_direct(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 block_1 = {
+        let mut block = (*block_iter.next().expect("block 1 must exist")).clone();
+        Arc::make_mut(&mut block.header).commitment_bytes = [0; 32].into();
+        Arc::new(block)
+    };
 
-    let CheckpointVerifiedBlock(block) = CheckpointVerifiedBlock::new(block, None, None);
+    let CheckpointVerifiedBlock(block_1) = CheckpointVerifiedBlock::new(block_1, None, None);
 
     let empty_chain = Chain::new(
         &network,
@@ -73,7 +67,7 @@ fn check_burns_and_issuance() {
     );
 
     let block_1_issued_assets = IssuedAssetChanges::validate_and_get_changes(
-        &block.block.transactions,
+        &block_1.block.transactions,
         None,
         |asset_base: &AssetBase| {
             read::asset_state(
@@ -85,7 +79,7 @@ fn check_burns_and_issuance() {
     )
     .expect("test transactions should be valid");
 
-    validate_and_commit_non_finalized(&finalized_state.db, &mut non_finalized_state, block)
+    validate_and_commit_non_finalized(&finalized_state.db, &mut non_finalized_state, block_1)
         .expect("validation should succeed");
 
     let best_chain = non_finalized_state

zebra-test/src/vectors/orchard-zsa-workflow-block-0-genesis.txt

@@ -0,0 +1 @@
+040000000000000000000000000000000000000000000000000000000000000000000000db4d7a85b768123f1dff1d4c4cece70083b2d27e117b4ac2e31d087988a5eac40000000000000000000000000000000000000000000000000000000000000000dae5494d0f0f0f2009000000000000000000000000000000000000000000000000000000000000002401936b7db1eb4ac39f151b8704642d0a8bda13ec547d54cd5e43ba142fc6d8877cab07b30101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff071f0104455a6361736830623963346565663862376363343137656535303031653335303039383462366665613335363833613763616331343161303433633432303634383335643334ffffffff010000000000000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000

zebra-test/src/vectors/orchard_zsa_workflow_blocks.rs

@@ -7,48 +7,79 @@ use lazy_static::lazy_static;
 
 /// Represents a serialized block and its validity status.
 pub struct OrchardWorkflowBlock {
+    /// Block height.
+    pub height: u32,
     /// Serialized byte data of the block.
-    pub bytes: Vec<u8>,
+    pub bytes: &'static [u8],
     /// Indicates whether the block is valid.
     pub is_valid: bool,
 }
 
 fn decode_bytes(hex: &str) -> Vec<u8> {
-    <Vec<u8>>::from_hex((hex).trim()).expect("Block bytes are in valid hex representation")
+    <Vec<u8>>::from_hex(hex.trim()).expect("Block bytes are in valid hex representation")
 }
 
 lazy_static! {
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_0_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-0-genesis.txt"));
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_1_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-1.txt"));
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_2_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-2.txt"));
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_3_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-3.txt"));
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_4_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-4.txt"));
+    pub static ref ORCHARD_ZSA_WORKFLOW_BLOCK_5_BYTES: Vec<u8> =
+        decode_bytes(include_str!("orchard-zsa-workflow-block-5.txt"));
+
     /// Test blocks for a Zcash Shielded Assets (ZSA) workflow.
-    /// The sequence demonstrates issuing, transferring and burning a custom
-    /// asset, then finalising the issuance and attempting an extra issue.
+    /// The sequence demonstrates issuing, transferring, and burning a custom
+    /// asset, then finalizing the issuance and attempting an extra issue.
+    ///
+    /// Block 0 is the Regtest genesis block, copied from
+    /// `zebra-chain/src/block/genesis/block-regtest-0-000-000.txt`.
+    /// The remaining workflow blocks were generated using `zcash_tx_tool`
     pub static ref ORCHARD_ZSA_WORKFLOW_BLOCKS: Vec<OrchardWorkflowBlock> = vec![
+        // Genesis
+        OrchardWorkflowBlock {
+            height: 0,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_0_BYTES.as_slice(),
+            is_valid: true
+        },
+
         // Issue: 1000
         OrchardWorkflowBlock {
-            bytes: decode_bytes(include_str!("orchard-zsa-workflow-block-1.txt")),
+            height: 1,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_1_BYTES.as_slice(),
             is_valid: true
         },
 
         // Transfer
         OrchardWorkflowBlock {
-            bytes: decode_bytes(include_str!("orchard-zsa-workflow-block-2.txt")),
+            height: 2,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_2_BYTES.as_slice(),
             is_valid: true
         },
 
         // Burn: 7, Burn: 2
         OrchardWorkflowBlock {
-            bytes: decode_bytes(include_str!("orchard-zsa-workflow-block-3.txt")),
+            height: 3,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_3_BYTES.as_slice(),
             is_valid: true
         },
 
         // Issue: finalize
         OrchardWorkflowBlock {
-            bytes: decode_bytes(include_str!("orchard-zsa-workflow-block-4.txt")),
+            height: 4,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_4_BYTES.as_slice(),
             is_valid: true
         },
 
         // Try to issue: 2000
         OrchardWorkflowBlock {
-            bytes: decode_bytes(include_str!("orchard-zsa-workflow-block-5.txt")),
+            height: 5,
+            bytes: ORCHARD_ZSA_WORKFLOW_BLOCK_5_BYTES.as_slice(),
             is_valid: false
         },
     ];