diff --git a/zebra-chain/src/block/tests/vectors.rs b/zebra-chain/src/block/tests/vectors.rs index 1cbf17f8c..afd86d21a 100644 --- a/zebra-chain/src/block/tests/vectors.rs +++ b/zebra-chain/src/block/tests/vectors.rs @@ -208,16 +208,7 @@ fn block_test_vectors_height_testnet() { /// Test that the block test vector indexes match the heights in the block data, /// and that each post-sapling block has a corresponding final sapling root. fn block_test_vectors_height(network: Network) { - let (block_iter, sapling_roots) = match network { - Mainnet => ( - zebra_test::vectors::MAINNET_BLOCKS.iter(), - zebra_test::vectors::MAINNET_FINAL_SAPLING_ROOTS.clone(), - ), - Testnet => ( - zebra_test::vectors::TESTNET_BLOCKS.iter(), - zebra_test::vectors::TESTNET_FINAL_SAPLING_ROOTS.clone(), - ), - }; + let (block_iter, sapling_roots) = network.block_sapling_roots_iter(); for (&height, block) in block_iter { let block = block @@ -262,16 +253,7 @@ fn block_commitment_testnet() { /// /// TODO: add chain history test vectors? fn block_commitment(network: Network) { - let (block_iter, sapling_roots) = match network { - Mainnet => ( - zebra_test::vectors::MAINNET_BLOCKS.iter(), - zebra_test::vectors::MAINNET_FINAL_SAPLING_ROOTS.clone(), - ), - Testnet => ( - zebra_test::vectors::TESTNET_BLOCKS.iter(), - zebra_test::vectors::TESTNET_FINAL_SAPLING_ROOTS.clone(), - ), - }; + let (block_iter, sapling_roots) = network.block_sapling_roots_iter(); for (height, block) in block_iter { let block = block diff --git a/zebra-chain/src/history_tree/tests/vectors.rs b/zebra-chain/src/history_tree/tests/vectors.rs index ef9295204..6d63d4391 100644 --- a/zebra-chain/src/history_tree/tests/vectors.rs +++ b/zebra-chain/src/history_tree/tests/vectors.rs @@ -13,9 +13,6 @@ use crate::{ use color_eyre::eyre; use eyre::Result; -use zebra_test::vectors::{ - MAINNET_BLOCKS, MAINNET_FINAL_SAPLING_ROOTS, TESTNET_BLOCKS, TESTNET_FINAL_SAPLING_ROOTS, -}; /// Test the history tree using the activation block of a network upgrade /// and its next block. @@ -36,10 +33,8 @@ fn push_and_prune_for_network_upgrade( network: Network, network_upgrade: NetworkUpgrade, ) -> Result<()> { - let (blocks, sapling_roots) = match network { - Network::Mainnet => (&*MAINNET_BLOCKS, &*MAINNET_FINAL_SAPLING_ROOTS), - Network::Testnet => (&*TESTNET_BLOCKS, &*TESTNET_FINAL_SAPLING_ROOTS), - }; + let (blocks, sapling_roots) = network.block_sapling_roots_map(); + let height = network_upgrade.activation_height(network).unwrap().0; // Load first block (activation block of the given network upgrade) @@ -120,10 +115,8 @@ fn upgrade() -> Result<()> { } fn upgrade_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) -> Result<()> { - let (blocks, sapling_roots) = match network { - Network::Mainnet => (&*MAINNET_BLOCKS, &*MAINNET_FINAL_SAPLING_ROOTS), - Network::Testnet => (&*TESTNET_BLOCKS, &*TESTNET_FINAL_SAPLING_ROOTS), - }; + let (blocks, sapling_roots) = network.block_sapling_roots_map(); + let height = network_upgrade.activation_height(network).unwrap().0; // Load previous block (the block before the activation block of the given network upgrade) diff --git a/zebra-chain/src/lib.rs b/zebra-chain/src/lib.rs index 2182e1ba1..4faaeab70 100644 --- a/zebra-chain/src/lib.rs +++ b/zebra-chain/src/lib.rs @@ -43,6 +43,9 @@ pub mod work; #[cfg(any(test, feature = "proptest-impl"))] pub use block::LedgerState; +#[cfg(any(test, feature = "proptest-impl"))] +pub mod tests; + /// Error type alias to make working with generic errors easier. /// /// Note: the 'static lifetime bound means that the *type* cannot have any diff --git a/zebra-chain/src/primitives/zcash_history/tests/vectors.rs b/zebra-chain/src/primitives/zcash_history/tests/vectors.rs index b2b5a0c1b..4d986ed78 100644 --- a/zebra-chain/src/primitives/zcash_history/tests/vectors.rs +++ b/zebra-chain/src/primitives/zcash_history/tests/vectors.rs @@ -6,9 +6,6 @@ use crate::{ use crate::primitives::zcash_history::*; use color_eyre::eyre; use eyre::Result; -use zebra_test::vectors::{ - MAINNET_BLOCKS, MAINNET_FINAL_SAPLING_ROOTS, TESTNET_BLOCKS, TESTNET_FINAL_SAPLING_ROOTS, -}; /// Test the MMR tree using the activation block of a network upgrade /// and its next block. @@ -22,10 +19,8 @@ fn tree() -> Result<()> { } fn tree_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) -> Result<()> { - let (blocks, sapling_roots) = match network { - Network::Mainnet => (&*MAINNET_BLOCKS, &*MAINNET_FINAL_SAPLING_ROOTS), - Network::Testnet => (&*TESTNET_BLOCKS, &*TESTNET_FINAL_SAPLING_ROOTS), - }; + let (blocks, sapling_roots) = network.block_sapling_roots_map(); + let height = network_upgrade.activation_height(network).unwrap().0; // Load Block 0 (activation block of the given network upgrade) diff --git a/zebra-chain/src/sapling/tests/tree.rs b/zebra-chain/src/sapling/tests/tree.rs index 666544b73..7ea22c4ce 100644 --- a/zebra-chain/src/sapling/tests/tree.rs +++ b/zebra-chain/src/sapling/tests/tree.rs @@ -9,9 +9,6 @@ use crate::parameters::NetworkUpgrade; use crate::sapling::{self, tree::*}; use crate::serialization::ZcashDeserializeInto; use crate::{parameters::Network, sapling::tests::test_vectors}; -use zebra_test::vectors::{ - MAINNET_BLOCKS, MAINNET_FINAL_SAPLING_ROOTS, TESTNET_BLOCKS, TESTNET_FINAL_SAPLING_ROOTS, -}; #[test] fn empty_roots() { @@ -60,10 +57,8 @@ fn incremental_roots_with_blocks() -> Result<()> { } fn incremental_roots_with_blocks_for_network(network: Network) -> Result<()> { - let (blocks, sapling_roots) = match network { - Network::Mainnet => (&*MAINNET_BLOCKS, &*MAINNET_FINAL_SAPLING_ROOTS), - Network::Testnet => (&*TESTNET_BLOCKS, &*TESTNET_FINAL_SAPLING_ROOTS), - }; + let (blocks, sapling_roots) = network.block_sapling_roots_map(); + let height = NetworkUpgrade::Sapling .activation_height(network) .unwrap() diff --git a/zebra-chain/src/sprout/tests/tree.rs b/zebra-chain/src/sprout/tests/tree.rs index 0f2482600..61185a5dc 100644 --- a/zebra-chain/src/sprout/tests/tree.rs +++ b/zebra-chain/src/sprout/tests/tree.rs @@ -6,8 +6,6 @@ use color_eyre::eyre; use eyre::Result; use hex::FromHex; -use zebra_test::vectors; - use crate::{ block::Block, parameters::{Network, NetworkUpgrade}, @@ -88,25 +86,8 @@ fn incremental_roots_with_blocks() -> Result<()> { } fn incremental_roots_with_blocks_for_network(network: Network) -> Result<()> { - // The mainnet block height at which the first JoinSplit occurred. - const MAINNET_FIRST_JOINSPLIT_HEIGHT: u32 = 396; - - // The testnet block height at which the first JoinSplit occurred. - const TESTNET_FIRST_JOINSPLIT_HEIGHT: u32 = 2259; - // Load the test data. - let (blocks, sprout_roots, next_height) = match network { - Network::Mainnet => ( - &*vectors::MAINNET_BLOCKS, - &*vectors::MAINNET_FINAL_SPROUT_ROOTS, - MAINNET_FIRST_JOINSPLIT_HEIGHT, - ), - Network::Testnet => ( - &*vectors::TESTNET_BLOCKS, - &*vectors::TESTNET_FINAL_SPROUT_ROOTS, - TESTNET_FIRST_JOINSPLIT_HEIGHT, - ), - }; + let (blocks, sprout_roots, next_height) = network.block_sprout_roots_height(); // Load the Genesis height. let genesis_height = NetworkUpgrade::Genesis diff --git a/zebra-chain/src/tests.rs b/zebra-chain/src/tests.rs new file mode 100644 index 000000000..7cfa4a959 --- /dev/null +++ b/zebra-chain/src/tests.rs @@ -0,0 +1,4 @@ +//!Chain functionality for fetching test vectors. +//! + +mod vectors; diff --git a/zebra-chain/src/tests/vectors.rs b/zebra-chain/src/tests/vectors.rs new file mode 100644 index 000000000..0e60f6e99 --- /dev/null +++ b/zebra-chain/src/tests/vectors.rs @@ -0,0 +1,154 @@ +//! Network methods for fetching blockchain vectors. +//! + +use std::collections::BTreeMap; + +use crate::{block::Block, parameters::Network, serialization::ZcashDeserializeInto}; + +use zebra_test::vectors::{ + BLOCK_MAINNET_1046400_BYTES, BLOCK_MAINNET_653599_BYTES, BLOCK_MAINNET_982681_BYTES, + BLOCK_TESTNET_1116000_BYTES, BLOCK_TESTNET_583999_BYTES, BLOCK_TESTNET_925483_BYTES, + CONTINUOUS_MAINNET_BLOCKS, CONTINUOUS_TESTNET_BLOCKS, MAINNET_BLOCKS, + MAINNET_FINAL_SAPLING_ROOTS, MAINNET_FINAL_SPROUT_ROOTS, + SAPLING_FINAL_ROOT_MAINNET_1046400_BYTES, SAPLING_FINAL_ROOT_TESTNET_1116000_BYTES, + TESTNET_BLOCKS, TESTNET_FINAL_SAPLING_ROOTS, TESTNET_FINAL_SPROUT_ROOTS, +}; + +/// Network methods for fetching blockchain vectors. +impl Network { + /// Returns true if network is of type Mainnet. + pub fn is_mainnet(&self) -> bool { + matches!(self, Network::Mainnet) + } + + /// Returns iterator over blocks. + pub fn block_iter(&self) -> std::collections::btree_map::Iter<'static, u32, &'static [u8]> { + if self.is_mainnet() { + MAINNET_BLOCKS.iter() + } else { + TESTNET_BLOCKS.iter() + } + } + + /// + pub fn block_map(&self) -> BTreeMap { + if self.is_mainnet() { + zebra_test::vectors::MAINNET_BLOCKS.clone() + } else { + zebra_test::vectors::TESTNET_BLOCKS.clone() + } + } + + /// Returns genesis block for chain. + pub fn gen_block(&self) -> std::option::Option<&&[u8]> { + if self.is_mainnet() { + MAINNET_BLOCKS.get(&0) + } else { + TESTNET_BLOCKS.get(&0) + } + } + + /// Returns block bytes + pub fn test_block(&self, main_height: u32, test_height: u32) -> Option { + match (self.is_mainnet(), main_height, test_height) { + (true, 653_599, _) => BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into().ok(), + (true, 982_681, _) => BLOCK_MAINNET_982681_BYTES.zcash_deserialize_into().ok(), + (false, _, 583_999) => BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into().ok(), + (false, _, 925_483) => BLOCK_TESTNET_925483_BYTES.zcash_deserialize_into().ok(), + _ => None, + } + } + + /// Returns iterator over blockchain. + pub fn blockchain_iter(&self) -> std::collections::btree_map::Iter<'_, u32, &[u8]> { + if self.is_mainnet() { + CONTINUOUS_MAINNET_BLOCKS.iter() + } else { + CONTINUOUS_TESTNET_BLOCKS.iter() + } + } + + /// Returns BTreemap of blockchain. + pub fn blockchain_map(&self) -> &BTreeMap { + if self.is_mainnet() { + &CONTINUOUS_MAINNET_BLOCKS + } else { + &CONTINUOUS_TESTNET_BLOCKS + } + } + + /// Returns iterator over blocks and sapling roots. + pub fn block_sapling_roots_iter( + &self, + ) -> ( + std::collections::btree_map::Iter<'_, u32, &[u8]>, + std::collections::BTreeMap, + ) { + if self.is_mainnet() { + (MAINNET_BLOCKS.iter(), MAINNET_FINAL_SAPLING_ROOTS.clone()) + } else { + (TESTNET_BLOCKS.iter(), TESTNET_FINAL_SAPLING_ROOTS.clone()) + } + } + + /// Returns BTreemap of blocks and sapling roots. + pub fn block_sapling_roots_map( + &self, + ) -> ( + &std::collections::BTreeMap, + &std::collections::BTreeMap, + ) { + if self.is_mainnet() { + (&*MAINNET_BLOCKS, &*MAINNET_FINAL_SAPLING_ROOTS) + } else { + (&*TESTNET_BLOCKS, &*TESTNET_FINAL_SAPLING_ROOTS) + } + } + + /// Returns block and sapling root bytes + pub fn test_block_sapling_roots( + &self, + main_height: u32, + test_height: u32, + ) -> Option<(&[u8], [u8; 32])> { + match (self.is_mainnet(), main_height, test_height) { + (true, 1_046_400, _) => Some(( + &BLOCK_MAINNET_1046400_BYTES[..], + *SAPLING_FINAL_ROOT_MAINNET_1046400_BYTES, + )), + (false, _, 1_116_000) => Some(( + &BLOCK_TESTNET_1116000_BYTES[..], + *SAPLING_FINAL_ROOT_TESTNET_1116000_BYTES, + )), + _ => None, + } + } + + /// Returns BTreemap of blocks and sprout roots, and last split height. + pub fn block_sprout_roots_height( + &self, + ) -> ( + &std::collections::BTreeMap, + &std::collections::BTreeMap, + u32, + ) { + // The mainnet block height at which the first JoinSplit occurred. + const MAINNET_FIRST_JOINSPLIT_HEIGHT: u32 = 396; + + // The testnet block height at which the first JoinSplit occurred. + const TESTNET_FIRST_JOINSPLIT_HEIGHT: u32 = 2259; + if self.is_mainnet() { + ( + &*MAINNET_BLOCKS, + &*MAINNET_FINAL_SPROUT_ROOTS, + MAINNET_FIRST_JOINSPLIT_HEIGHT, + ) + } else { + ( + &*TESTNET_BLOCKS, + &*TESTNET_FINAL_SPROUT_ROOTS, + TESTNET_FIRST_JOINSPLIT_HEIGHT, + ) + } + } +} diff --git a/zebra-chain/src/transaction/arbitrary.rs b/zebra-chain/src/transaction/arbitrary.rs index 704a0d23c..df914c208 100644 --- a/zebra-chain/src/transaction/arbitrary.rs +++ b/zebra-chain/src/transaction/arbitrary.rs @@ -995,10 +995,7 @@ fn sapling_spend_v4_to_fake_v5( pub fn test_transactions( network: Network, ) -> impl DoubleEndedIterator)> { - let blocks = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let blocks = network.block_iter(); transactions_from_blocks(blocks) } diff --git a/zebra-chain/src/transaction/tests/vectors.rs b/zebra-chain/src/transaction/tests/vectors.rs index 297c9bc78..cfac4898b 100644 --- a/zebra-chain/src/transaction/tests/vectors.rs +++ b/zebra-chain/src/transaction/tests/vectors.rs @@ -349,10 +349,7 @@ fn fake_v5_round_trip() { } fn fake_v5_round_trip_for_network(network: Network) { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let overwinter_activation_height = NetworkUpgrade::Overwinter .activation_height(network) @@ -500,10 +497,7 @@ fn fake_v5_librustzcash_round_trip() { } fn fake_v5_librustzcash_round_trip_for_network(network: Network) { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let overwinter_activation_height = NetworkUpgrade::Overwinter .activation_height(network) @@ -943,10 +937,7 @@ fn binding_signatures() { } fn binding_signatures_for_network(network: Network) { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (height, bytes) in block_iter { let upgrade = NetworkUpgrade::current(network, Height(*height)); diff --git a/zebra-chain/src/transparent/tests/vectors.rs b/zebra-chain/src/transparent/tests/vectors.rs index f1c8cd889..b0a43e665 100644 --- a/zebra-chain/src/transparent/tests/vectors.rs +++ b/zebra-chain/src/transparent/tests/vectors.rs @@ -92,10 +92,7 @@ fn get_transparent_output_address_with_blocks() { /// Test that the block test vector indexes match the heights in the block data, /// and that each post-sapling block has a corresponding final sapling root. fn get_transparent_output_address_with_blocks_for_network(network: Network) { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let mut valid_addresses = 0; diff --git a/zebra-chain/src/work/difficulty/tests/vectors.rs b/zebra-chain/src/work/difficulty/tests/vectors.rs index d198fd32c..e8b190221 100644 --- a/zebra-chain/src/work/difficulty/tests/vectors.rs +++ b/zebra-chain/src/work/difficulty/tests/vectors.rs @@ -273,10 +273,7 @@ fn block_difficulty() -> Result<(), Report> { fn block_difficulty_for_network(network: Network) -> Result<(), Report> { let _init_guard = zebra_test::init(); - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let diff_zero = ExpandedDifficulty(U256::zero()); let diff_one = ExpandedDifficulty(U256::one()); @@ -362,10 +359,7 @@ fn genesis_block_difficulty() -> Result<(), Report> { fn genesis_block_difficulty_for_network(network: Network) -> Result<(), Report> { let _init_guard = zebra_test::init(); - let block = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.get(&0), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.get(&0), - }; + let block = network.gen_block(); let block = block.expect("test vectors contain the genesis block"); let block = Block::zcash_deserialize(&block[..]).expect("block test vector should deserialize"); diff --git a/zebra-consensus/src/block/tests.rs b/zebra-consensus/src/block/tests.rs index 2eed87601..f074cf736 100644 --- a/zebra-consensus/src/block/tests.rs +++ b/zebra-consensus/src/block/tests.rs @@ -189,10 +189,7 @@ fn difficulty_is_valid_for_historical_blocks() -> Result<(), Report> { } fn difficulty_is_valid_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (&height, block) in block_iter { let block = block @@ -296,10 +293,7 @@ fn subsidy_is_valid_for_historical_blocks() -> Result<(), Report> { } fn subsidy_is_valid_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (&height, block) in block_iter { let block = block @@ -401,10 +395,7 @@ fn funding_stream_validation() -> Result<(), Report> { } fn funding_stream_validation_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let canopy_activation_height = NetworkUpgrade::Canopy .activation_height(network) @@ -479,10 +470,7 @@ fn miner_fees_validation_success() -> Result<(), Report> { } fn miner_fees_validation_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (&height, block) in block_iter { if Height(height) > SLOW_START_SHIFT { @@ -568,10 +556,7 @@ fn merkle_root_is_valid() -> Result<(), Report> { } fn merkle_root_is_valid_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (_height, block) in block_iter { let block = block @@ -592,10 +577,7 @@ fn merkle_root_is_valid_for_network(network: Network) -> Result<(), Report> { } fn merkle_root_fake_v5_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (height, block) in block_iter { let mut block = block @@ -707,10 +689,7 @@ fn transaction_expiration_height_validation() -> Result<(), Report> { } fn transaction_expiration_height_for_network(network: Network) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); for (&height, block) in block_iter { let block = Block::zcash_deserialize(&block[..]).expect("block should deserialize"); diff --git a/zebra-consensus/src/checkpoint/tests.rs b/zebra-consensus/src/checkpoint/tests.rs index 9fb29048c..e4be1c2b6 100644 --- a/zebra-consensus/src/checkpoint/tests.rs +++ b/zebra-consensus/src/checkpoint/tests.rs @@ -233,10 +233,8 @@ async fn continuous_blockchain( let _init_guard = zebra_test::init(); // A continuous blockchain - let blockchain = match network { - Mainnet => zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS.iter(), - Testnet => zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS.iter(), - }; + let blockchain = network.blockchain_iter(); + let blockchain: Vec<_> = blockchain .map(|(height, b)| { let block = Arc::::zcash_deserialize(*b).unwrap(); diff --git a/zebra-consensus/src/transaction/tests.rs b/zebra-consensus/src/transaction/tests.rs index 9b0e6aaae..c5e25be64 100644 --- a/zebra-consensus/src/transaction/tests.rs +++ b/zebra-consensus/src/transaction/tests.rs @@ -909,11 +909,7 @@ fn v5_transaction_is_accepted_after_nu5_activation_for_network(network: Network) let nu5_activation_height = nu5 .activation_height(network) .expect("NU5 activation height is specified"); - - let blocks = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let blocks = network.block_iter(); let state_service = service_fn(|_| async { unreachable!("Service should not be called") }); let verifier = Verifier::new(network, state_service); @@ -2772,10 +2768,7 @@ fn coinbase_outputs_are_decryptable_for_historical_blocks() -> Result<(), Report fn coinbase_outputs_are_decryptable_for_historical_blocks_for_network( network: Network, ) -> Result<(), Report> { - let block_iter = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let block_iter = network.block_iter(); let mut tested_coinbase_txs = 0; let mut tested_non_coinbase_txs = 0; diff --git a/zebra-grpc/src/tests/vectors.rs b/zebra-grpc/src/tests/vectors.rs index 41959a3bd..f84bcec29 100644 --- a/zebra-grpc/src/tests/vectors.rs +++ b/zebra-grpc/src/tests/vectors.rs @@ -81,19 +81,16 @@ async fn test_mocked_getresults_for_network( .1 .by_height .len(); - match network { - Network::Mainnet => { - assert_eq!( - transaction_heights, 3, - "there should be 3 transaction heights" - ); - } - Network::Testnet => { - assert_eq!( - transaction_heights, 1, - "there should be 1 transaction height" - ); - } + if network.is_mainnet() { + assert_eq!( + transaction_heights, 3, + "there should be 3 transaction heights" + ); + } else { + assert_eq!( + transaction_heights, 1, + "there should be 1 transaction height" + ); } // create request, fake empty results and get response @@ -150,13 +147,10 @@ async fn test_mocked_clear_results_for_network( .1 .by_height .len(); - match network { - Network::Mainnet => { - assert_eq!(transaction_heights, 3); - } - Network::Testnet => { - assert_eq!(transaction_heights, 1); - } + if network.is_mainnet() { + assert_eq!(transaction_heights, 3); + } else { + assert_eq!(transaction_heights, 1) } // create request, fake results and get response @@ -210,13 +204,10 @@ async fn test_mocked_delete_keys_for_network( .1 .by_height .len(); - match network { - Network::Mainnet => { - assert_eq!(transaction_heights, 3); - } - Network::Testnet => { - assert_eq!(transaction_heights, 1); - } + if network.is_mainnet() { + assert_eq!(transaction_heights, 3); + } else { + assert_eq!(transaction_heights, 1); } let delete_keys_response = @@ -282,9 +273,10 @@ async fn add_fake_populated_results( tokio::spawn(async move { let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string(); let mut fake_results = BTreeMap::new(); - let heights = match network { - Network::Mainnet => vec![Height::MIN, Height(1), Height::MAX], - Network::Testnet => vec![Height::MIN], + let heights = if network.is_mainnet() { + vec![Height::MIN, Height(1), Height::MAX] + } else { + vec![Height::MIN] }; for fake_result_height in heights { fake_results.insert( diff --git a/zebra-rpc/src/methods/tests/snapshot.rs b/zebra-rpc/src/methods/tests/snapshot.rs index 2a8e9149f..6d775f132 100644 --- a/zebra-rpc/src/methods/tests/snapshot.rs +++ b/zebra-rpc/src/methods/tests/snapshot.rs @@ -44,10 +44,7 @@ async fn test_rpc_response_data() { async fn test_rpc_response_data_for_network(network: Network) { // Create a continuous chain of mainnet and testnet blocks from genesis - let block_data = match network { - Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - }; + let block_data = network.blockchain_map(); let blocks: Vec> = block_data .iter() diff --git a/zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs b/zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs index e4e6dceaf..c7299565a 100644 --- a/zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs +++ b/zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs @@ -413,9 +413,10 @@ pub async fn test_responses( snapshot_rpc_submit_block_invalid(submit_block, &settings); // `validateaddress` - let founder_address = match network { - Network::Mainnet => "t3fqvkzrrNaMcamkQMwAyHRjfDdM2xQvDTR", - Network::Testnet => "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi", + let founder_address = if network.is_mainnet() { + "t3fqvkzrrNaMcamkQMwAyHRjfDdM2xQvDTR" + } else { + "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi" }; let validate_address = get_block_template_rpc @@ -431,9 +432,10 @@ pub async fn test_responses( snapshot_rpc_validateaddress("invalid", validate_address, &settings); // `z_validateaddress` - let founder_address = match network { - Network::Mainnet => "t3fqvkzrrNaMcamkQMwAyHRjfDdM2xQvDTR", - Network::Testnet => "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi", + let founder_address = if network.is_mainnet() { + "t3fqvkzrrNaMcamkQMwAyHRjfDdM2xQvDTR" + } else { + "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi" }; let z_validate_address = get_block_template_rpc diff --git a/zebra-rpc/src/methods/tests/utils.rs b/zebra-rpc/src/methods/tests/utils.rs index 797d712a6..bb5c728cf 100644 --- a/zebra-rpc/src/methods/tests/utils.rs +++ b/zebra-rpc/src/methods/tests/utils.rs @@ -9,20 +9,9 @@ use zebra_chain::{ serialization::ZcashDeserialize, }; -use zebra_test::vectors; - /// Create a history tree with one single block for a network by using Zebra test vectors. pub fn fake_history_tree(network: Network) -> Arc { - let (block, sapling_root) = match network { - Network::Mainnet => ( - &vectors::BLOCK_MAINNET_1046400_BYTES[..], - *vectors::SAPLING_FINAL_ROOT_MAINNET_1046400_BYTES, - ), - Network::Testnet => ( - &vectors::BLOCK_TESTNET_1116000_BYTES[..], - *vectors::SAPLING_FINAL_ROOT_TESTNET_1116000_BYTES, - ), - }; + let (block, sapling_root) = network.test_block_sapling_roots(1046400, 1116000).unwrap(); let block = Arc::::zcash_deserialize(block).expect("block should deserialize"); let first_sapling_root = Root::try_from(sapling_root).unwrap(); diff --git a/zebra-rpc/src/methods/tests/vectors.rs b/zebra-rpc/src/methods/tests/vectors.rs index 105dd50a3..0a9dcb9e1 100644 --- a/zebra-rpc/src/methods/tests/vectors.rs +++ b/zebra-rpc/src/methods/tests/vectors.rs @@ -655,14 +655,11 @@ async fn rpc_getaddresstxids_response() { let _init_guard = zebra_test::init(); for network in [Mainnet, Testnet] { - let blocks: Vec> = match network { - Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - } - .iter() - .map(|(_height, block_bytes)| block_bytes.zcash_deserialize_into().unwrap()) - .collect(); - + let blocks: Vec> = network + .blockchain_map() + .iter() + .map(|(_height, block_bytes)| block_bytes.zcash_deserialize_into().unwrap()) + .collect(); // The first few blocks after genesis send funds to the same founders reward address, // in one output per coinbase transaction. // diff --git a/zebra-scan/src/storage/db/tests.rs b/zebra-scan/src/storage/db/tests.rs index f34650ab2..b6b207403 100644 --- a/zebra-scan/src/storage/db/tests.rs +++ b/zebra-scan/src/storage/db/tests.rs @@ -4,7 +4,7 @@ use std::{collections::BTreeMap, sync::Arc}; use zebra_chain::{ block::{Block, Height}, - parameters::Network::{self, *}, + parameters::Network::{self}, serialization::ZcashDeserializeInto, transaction, }; @@ -45,10 +45,7 @@ pub fn add_fake_results( height: Height, add_progress_marker: bool, ) { - let blocks = match network { - Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - }; + let blocks = network.blockchain_map(); let block: Arc = blocks .get(&height.0) diff --git a/zebra-state/src/service/finalized_state/disk_format/tests/snapshot.rs b/zebra-state/src/service/finalized_state/disk_format/tests/snapshot.rs index 5866b08dd..80224954c 100644 --- a/zebra-state/src/service/finalized_state/disk_format/tests/snapshot.rs +++ b/zebra-state/src/service/finalized_state/disk_format/tests/snapshot.rs @@ -89,10 +89,7 @@ fn test_raw_rocksdb_column_families_with_network(network: Network) { // Snapshot raw database data for: // - mainnet and testnet // - genesis, block 1, and block 2 - let blocks = match network { - Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - }; + let blocks = network.blockchain_map(); // We limit the number of blocks, because the serialized data is a few kilobytes per block. for height in 0..=2 { diff --git a/zebra-state/src/service/finalized_state/zebra_db/block/tests/snapshot.rs b/zebra-state/src/service/finalized_state/zebra_db/block/tests/snapshot.rs index 6fc96f8df..54b17c846 100644 --- a/zebra-state/src/service/finalized_state/zebra_db/block/tests/snapshot.rs +++ b/zebra-state/src/service/finalized_state/zebra_db/block/tests/snapshot.rs @@ -181,10 +181,7 @@ fn test_block_and_transaction_data_with_network(network: Network) { // Snapshot block and transaction database data for: // - mainnet and testnet // - genesis, block 1, and block 2 - let blocks = match network { - Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - }; + let blocks = network.blockchain_map(); // We limit the number of blocks, because the serialized data is a few kilobytes per block. // diff --git a/zebra-state/src/service/non_finalized_state/tests/vectors.rs b/zebra-state/src/service/non_finalized_state/tests/vectors.rs index eae0235ea..a869a01ea 100644 --- a/zebra-state/src/service/non_finalized_state/tests/vectors.rs +++ b/zebra-state/src/service/non_finalized_state/tests/vectors.rs @@ -141,17 +141,10 @@ fn best_chain_wins() -> Result<()> { } fn best_chain_wins_for_network(network: Network) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let block2 = block1.make_fake_child().set_work(10); let child = block1.make_fake_child().set_work(1); @@ -186,17 +179,10 @@ fn finalize_pops_from_best_chain() -> Result<()> { } fn finalize_pops_from_best_chain_for_network(network: Network) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let block2 = block1.make_fake_child().set_work(10); let child = block1.make_fake_child().set_work(1); @@ -242,17 +228,10 @@ fn commit_block_extending_best_chain_doesnt_drop_worst_chains() -> Result<()> { fn commit_block_extending_best_chain_doesnt_drop_worst_chains_for_network( network: Network, ) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let block2 = block1.make_fake_child().set_work(10); let child1 = block1.make_fake_child().set_work(1); @@ -293,17 +272,10 @@ fn shorter_chain_can_be_best_chain() -> Result<()> { } fn shorter_chain_can_be_best_chain_for_network(network: Network) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let long_chain_block1 = block1.make_fake_child().set_work(1); let long_chain_block2 = long_chain_block1.make_fake_child().set_work(1); @@ -343,17 +315,10 @@ fn longer_chain_with_more_work_wins() -> Result<()> { } fn longer_chain_with_more_work_wins_for_network(network: Network) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let long_chain_block1 = block1.make_fake_child().set_work(1); let long_chain_block2 = long_chain_block1.make_fake_child().set_work(1); @@ -396,17 +361,10 @@ fn equal_length_goes_to_more_work() -> Result<()> { Ok(()) } fn equal_length_goes_to_more_work_for_network(network: Network) -> Result<()> { - let block1: Arc = match network { - // Since the brand new FinalizedState below will pass a None history tree - // to the NonFinalizedState, we must use pre-Heartwood blocks since - // they won't trigger the history tree update in the NonFinalizedState. - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_653599_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_583999_BYTES.zcash_deserialize_into()? - } - }; + // Since the brand new FinalizedState below will pass a None history tree + // to the NonFinalizedState, we must use pre-Heartwood blocks since + // they won't trigger the history tree update in the NonFinalizedState. + let block1: Arc = Arc::new(network.test_block(653599, 583999).unwrap()); let less_work_child = block1.make_fake_child().set_work(1); let more_work_child = block1.make_fake_child().set_work(3); @@ -447,10 +405,8 @@ fn history_tree_is_updated_for_network_upgrade( network: Network, network_upgrade: NetworkUpgrade, ) -> Result<()> { - let blocks = match network { - Network::Mainnet => &*zebra_test::vectors::MAINNET_BLOCKS, - Network::Testnet => &*zebra_test::vectors::TESTNET_BLOCKS, - }; + let blocks = network.block_map(); + let height = network_upgrade.activation_height(network).unwrap().0; let prev_block = Arc::new( @@ -548,10 +504,7 @@ fn commitment_is_validated() { } fn commitment_is_validated_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) { - let blocks = match network { - Network::Mainnet => &*zebra_test::vectors::MAINNET_BLOCKS, - Network::Testnet => &*zebra_test::vectors::TESTNET_BLOCKS, - }; + let blocks = network.block_map(); let height = network_upgrade.activation_height(network).unwrap().0; let prev_block = Arc::new( diff --git a/zebra-state/src/service/tests.rs b/zebra-state/src/service/tests.rs index 0321e1bb9..7acd02406 100644 --- a/zebra-state/src/service/tests.rs +++ b/zebra-state/src/service/tests.rs @@ -562,10 +562,7 @@ fn continuous_empty_blocks_from_test_vectors() -> impl Strategy< any::() .prop_flat_map(|network| { // Select the test vector based on the network - let raw_blocks = match network { - Network::Mainnet => &*zebra_test::vectors::CONTINUOUS_MAINNET_BLOCKS, - Network::Testnet => &*zebra_test::vectors::CONTINUOUS_TESTNET_BLOCKS, - }; + let raw_blocks = network.blockchain_map(); // Transform the test vector's block bytes into a vector of `SemanticallyVerifiedBlock`s. let blocks: Vec<_> = raw_blocks diff --git a/zebra-state/tests/basic.rs b/zebra-state/tests/basic.rs index 638ab0f1a..a96b176dc 100644 --- a/zebra-state/tests/basic.rs +++ b/zebra-state/tests/basic.rs @@ -73,10 +73,13 @@ async fn check_transcripts(network: Network) -> Result<(), Report> { let mainnet_transcript = &[&COMMIT_FINALIZED_BLOCK_MAINNET]; let testnet_transcript = &[&COMMIT_FINALIZED_BLOCK_TESTNET]; - for transcript_data in match network { - Network::Mainnet => mainnet_transcript, - Network::Testnet => testnet_transcript, - } { + let net_data = if network.is_mainnet() { + mainnet_transcript + } else { + testnet_transcript + }; + + for transcript_data in net_data { // We're not verifying UTXOs here. let (service, _, _, _) = zebra_state::init(Config::ephemeral(), network, Height::MAX, 0); let transcript = Transcript::from(transcript_data.iter().cloned()); diff --git a/zebrad/src/components/mempool/storage/tests.rs b/zebrad/src/components/mempool/storage/tests.rs index cad844108..3a6c84b85 100644 --- a/zebrad/src/components/mempool/storage/tests.rs +++ b/zebrad/src/components/mempool/storage/tests.rs @@ -17,10 +17,7 @@ pub fn unmined_transactions_in_blocks( block_height_range: impl RangeBounds, network: Network, ) -> impl DoubleEndedIterator { - let blocks = match network { - Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(), - Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(), - }; + let blocks = network.block_iter(); // Deserialize the blocks that are selected based on the specified `block_height_range`. let selected_blocks = blocks diff --git a/zebrad/src/components/mempool/storage/tests/vectors.rs b/zebrad/src/components/mempool/storage/tests/vectors.rs index 358275749..89d626cef 100644 --- a/zebrad/src/components/mempool/storage/tests/vectors.rs +++ b/zebrad/src/components/mempool/storage/tests/vectors.rs @@ -8,7 +8,6 @@ use zebra_chain::{ amount::Amount, block::{Block, Height}, parameters::Network, - serialization::ZcashDeserializeInto, transaction::{UnminedTxId, VerifiedUnminedTx}, }; @@ -252,14 +251,7 @@ fn mempool_expired_basic_for_network(network: Network) -> Result<()> { ..Default::default() }); - let block: Block = match network { - Network::Mainnet => { - zebra_test::vectors::BLOCK_MAINNET_982681_BYTES.zcash_deserialize_into()? - } - Network::Testnet => { - zebra_test::vectors::BLOCK_TESTNET_925483_BYTES.zcash_deserialize_into()? - } - }; + let block: Block = network.test_block(982681, 925483).unwrap(); // Get a test transaction let tx = &*(block.transactions[1]).clone();