Merge of #8421

zebra-chain/src/block.rs

@@ -25,6 +25,7 @@ mod header;
 mod height;
 mod serialize;
 
+pub mod genesis;
 pub mod merkle;
 
 #[cfg(any(test, feature = "proptest-impl"))]

zebra-chain/src/block/genesis.rs

@@ -0,0 +1,19 @@
+//! Regtest genesis block
+
+use std::sync::Arc;
+
+use hex::FromHex;
+
+use crate::{block::Block, serialization::ZcashDeserializeInto};
+
+/// Genesis block for Regtest, copied from zcashd via `getblock 0 0` RPC method
+pub fn regtest_genesis_block() -> Arc<Block> {
+    let regtest_genesis_block_bytes =
+        <Vec<u8>>::from_hex(include_str!("genesis/block-regtest-0-000-000.txt").trim())
+            .expect("Block bytes are in valid hex representation");
+
+    regtest_genesis_block_bytes
+        .zcash_deserialize_into()
+        .map(Arc::new)
+        .expect("hard-coded Regtest genesis block data must deserialize successfully")
+}

zebra-chain/src/block/genesis/block-regtest-0-000-000.txt

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

zebra-chain/src/history_tree.rs

@@ -455,9 +455,15 @@ impl HistoryTree {
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
     ) -> Result<(), HistoryTreeError> {
-        let heartwood_height = NetworkUpgrade::Heartwood
+        let Some(heartwood_height) = NetworkUpgrade::Heartwood.activation_height(network) else {
-            .activation_height(network)
+            assert!(
-            .expect("Heartwood height is known");
+                self.0.is_none(),
+                "history tree must not exist pre-Heartwood"
+            );
+
+            return Ok(());
+        };
+
         match block
             .coinbase_height()
             .expect("must have height")

zebra-chain/src/parameters/network.rs

@@ -189,6 +189,14 @@ impl Network {
         }
     }
 
+    /// Returns true if proof-of-work validation should be disabled for this network
+    pub fn disable_pow(&self) -> bool {
+        if let Self::Testnet(params) = self {
+            params.disable_pow()
+        } else {
+            false
+        }
+    }
     /// Returns the [`NetworkKind`] for this network.
     pub fn kind(&self) -> NetworkKind {
         match self {

zebra-chain/src/parameters/network/testnet.rs

@@ -4,7 +4,7 @@ use std::{collections::BTreeMap, fmt};
 use zcash_primitives::constants as zp_constants;
 
 use crate::{
-    block::Height,
+    block::{self, Height},
     parameters::{
         network_upgrade::TESTNET_ACTIVATION_HEIGHTS, Network, NetworkUpgrade,
         NETWORK_UPGRADES_IN_ORDER,
@@ -27,6 +27,14 @@ pub const MAX_NETWORK_NAME_LENGTH: usize = 30;
 /// Maximum length for a configured human-readable prefix.
 pub const MAX_HRP_LENGTH: usize = 30;
 
+/// The block hash of the Regtest genesis block, `zcash-cli -regtest getblockhash 0`
+const REGTEST_GENESIS_HASH: &str =
+    "029f11d80ef9765602235e1bc9727e3eb6ba20839319f761fee920d63401e327";
+
+/// The block hash of the Testnet genesis block, `zcash-cli -testnet getblockhash 0`
+const TESTNET_GENESIS_HASH: &str =
+    "05a60a92d99d85997cce3b87616c089f6124d7342af37106edc76126334a2c38";
+
 /// Configurable activation heights for Regtest and configured Testnets.
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "PascalCase")]
@@ -53,6 +61,8 @@ pub struct ConfiguredActivationHeights {
 pub struct ParametersBuilder {
     /// The name of this network to be used by the `Display` trait impl.
     network_name: String,
+    /// The genesis block hash
+    genesis_hash: block::Hash,
     /// The network upgrade activation heights for this network, see [`Parameters::activation_heights`] for more details.
     activation_heights: BTreeMap<Height, NetworkUpgrade>,
     /// Sapling extended spending key human-readable prefix for this network
@@ -61,9 +71,12 @@ pub struct ParametersBuilder {
     hrp_sapling_extended_full_viewing_key: String,
     /// Sapling payment address human-readable prefix for this network
     hrp_sapling_payment_address: String,
+    /// A flag for disabling proof-of-work checks when Zebra is validating blocks
+    disable_pow: bool,
 }
 
 impl Default for ParametersBuilder {
+    /// Creates a [`ParametersBuilder`] with all of the default Testnet parameters except `network_name`.
     fn default() -> Self {
         Self {
             network_name: "UnknownTestnet".to_string(),
@@ -77,6 +90,10 @@ impl Default for ParametersBuilder {
                 zp_constants::testnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY.to_string(),
             hrp_sapling_payment_address: zp_constants::testnet::HRP_SAPLING_PAYMENT_ADDRESS
                 .to_string(),
+            genesis_hash: TESTNET_GENESIS_HASH
+                .parse()
+                .expect("hard-coded hash parses"),
+            disable_pow: false,
         }
     }
 }
@@ -144,6 +161,15 @@ impl ParametersBuilder {
         self
     }
 
+    /// Parses the hex-encoded block hash and sets it as the genesis hash in the [`Parameters`] being built.
+    pub fn with_genesis_hash(mut self, genesis_hash: impl fmt::Display) -> Self {
+        self.genesis_hash = genesis_hash
+            .to_string()
+            .parse()
+            .expect("configured genesis hash must parse");
+        self
+    }
+
     /// Checks that the provided network upgrade activation heights are in the correct order, then
     /// sets them as the new network upgrade activation heights.
     pub fn with_activation_heights(
@@ -208,21 +234,31 @@ impl ParametersBuilder {
         self
     }
 
+    /// Sets the `disable_pow` flag to be used in the [`Parameters`] being built.
+    pub fn with_disable_pow(mut self, disable_pow: bool) -> Self {
+        self.disable_pow = disable_pow;
+        self
+    }
+
     /// Converts the builder to a [`Parameters`] struct
     pub fn finish(self) -> Parameters {
         let Self {
             network_name,
+            genesis_hash,
             activation_heights,
             hrp_sapling_extended_spending_key,
             hrp_sapling_extended_full_viewing_key,
             hrp_sapling_payment_address,
+            disable_pow,
         } = self;
         Parameters {
             network_name,
+            genesis_hash,
             activation_heights,
             hrp_sapling_extended_spending_key,
             hrp_sapling_extended_full_viewing_key,
             hrp_sapling_payment_address,
+            disable_pow,
         }
     }
 
@@ -237,6 +273,8 @@ impl ParametersBuilder {
 pub struct Parameters {
     /// The name of this network to be used by the `Display` trait impl.
     network_name: String,
+    /// The genesis block hash
+    genesis_hash: block::Hash,
     /// The network upgrade activation heights for this network.
     ///
     /// Note: This value is ignored by `Network::activation_list()` when `zebra-chain` is
@@ -249,6 +287,8 @@ pub struct Parameters {
     hrp_sapling_extended_full_viewing_key: String,
     /// Sapling payment address human-readable prefix for this network
     hrp_sapling_payment_address: String,
+    /// A flag for disabling proof-of-work checks when Zebra is validating blocks
+    disable_pow: bool,
 }
 
 impl Default for Parameters {
@@ -274,6 +314,8 @@ impl Parameters {
         Self {
             network_name: "Regtest".to_string(),
             ..Self::build()
+                .with_genesis_hash(REGTEST_GENESIS_HASH)
+                .with_disable_pow(true)
                 .with_sapling_hrps(
                     zp_constants::regtest::HRP_SAPLING_EXTENDED_SPENDING_KEY,
                     zp_constants::regtest::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY,
@@ -295,16 +337,21 @@ impl Parameters {
     pub fn is_regtest(&self) -> bool {
         let Self {
             network_name,
+            genesis_hash,
+            // Activation heights are configurable on Regtest
+            activation_heights: _,
             hrp_sapling_extended_spending_key,
             hrp_sapling_extended_full_viewing_key,
             hrp_sapling_payment_address,
-            ..
+            disable_pow,
         } = Self::new_regtest(ConfiguredActivationHeights::default());
 
         self.network_name == network_name
+            && self.genesis_hash == genesis_hash
             && self.hrp_sapling_extended_spending_key == hrp_sapling_extended_spending_key
             && self.hrp_sapling_extended_full_viewing_key == hrp_sapling_extended_full_viewing_key
             && self.hrp_sapling_payment_address == hrp_sapling_payment_address
+            && self.disable_pow == disable_pow
     }
 
     /// Returns the network name
@@ -312,6 +359,11 @@ impl Parameters {
         &self.network_name
     }
 
+    /// Returns the genesis hash
+    pub fn genesis_hash(&self) -> block::Hash {
+        self.genesis_hash
+    }
+
     /// Returns the network upgrade activation heights
     pub fn activation_heights(&self) -> &BTreeMap<Height, NetworkUpgrade> {
         &self.activation_heights
@@ -331,4 +383,9 @@ impl Parameters {
     pub fn hrp_sapling_payment_address(&self) -> &str {
         &self.hrp_sapling_payment_address
     }
+
+    /// Returns true if proof-of-work validation should be disabled for this network
+    pub fn disable_pow(&self) -> bool {
+        self.disable_pow
+    }
 }

zebra-chain/src/work/arbitrary.rs

@@ -10,7 +10,7 @@ impl Arbitrary for equihash::Solution {
             .prop_map(|v| {
                 let mut bytes = [0; equihash::SOLUTION_SIZE];
                 bytes.copy_from_slice(v.as_slice());
-                Self(bytes)
+                Self::Common(bytes)
             })
             .boxed()
     }

zebra-chain/src/work/equihash.rs

@@ -29,16 +29,26 @@ pub struct SolverCancelled;
 /// The size of an Equihash solution in bytes (always 1344).
 pub(crate) const SOLUTION_SIZE: usize = 1344;
 
+/// The size of an Equihash solution in bytes on Regtest (always 36).
+pub(crate) const REGTEST_SOLUTION_SIZE: usize = 36;
+
 /// Equihash Solution in compressed format.
 ///
-/// A wrapper around [u8; 1344] because Rust doesn't implement common
+/// A wrapper around `[u8; n]` where `n` is the solution size because
-/// traits like `Debug`, `Clone`, etc for collections like array
+/// Rust doesn't implement common traits like `Debug`, `Clone`, etc.
-/// beyond lengths 0 to 32.
+/// for collections like arrays beyond lengths 0 to 32.
 ///
-/// The size of an Equihash solution in bytes is always 1344 so the
+/// The size of an Equihash solution in bytes is always 1344 on Mainnet and Testnet, and
-/// length of this type is fixed.
+/// is always 36 on Regtest so the length of this type is fixed.
 #[derive(Deserialize, Serialize)]
-pub struct Solution(#[serde(with = "BigArray")] pub [u8; SOLUTION_SIZE]);
+// It's okay to use the extra space on Regtest
+#[allow(clippy::large_enum_variant)]
+pub enum Solution {
+    /// Equihash solution on Mainnet or Testnet
+    Common(#[serde(with = "BigArray")] [u8; SOLUTION_SIZE]),
+    /// Equihash solution on Regtest
+    Regtest(#[serde(with = "BigArray")] [u8; REGTEST_SOLUTION_SIZE]),
+}
 
 impl Solution {
     /// The length of the portion of the header used as input when verifying
@@ -48,15 +58,24 @@ impl Solution {
     /// to the verification function.
     pub const INPUT_LENGTH: usize = 4 + 32 * 3 + 4 * 2;
 
+    /// Returns the inner value of the [`Solution`] as a byte slice.
+    fn value(&self) -> &[u8] {
+        match self {
+            Solution::Common(solution) => solution.as_slice(),
+            Solution::Regtest(solution) => solution.as_slice(),
+        }
+    }
+
     /// Returns `Ok(())` if `EquihashSolution` is valid for `header`
     #[allow(clippy::unwrap_in_result)]
     pub fn check(&self, header: &Header) -> Result<(), Error> {
-        let n = 200;
-        let k = 9;
         let nonce = &header.nonce;
-        let solution = &self.0;
+        let (solution, n, k) = match self {
-        let mut input = Vec::new();
+            Solution::Common(solution) => (solution.as_slice(), 200, 9),
+            Solution::Regtest(solution) => (solution.as_slice(), 48, 5),
+        };
 
+        let mut input = Vec::new();
         header
             .zcash_serialize(&mut input)
             .expect("serialization into a vec can't fail");
@@ -73,23 +92,29 @@ impl Solution {
     /// Returns a [`Solution`] containing the bytes from `solution`.
     /// Returns an error if `solution` is the wrong length.
     pub fn from_bytes(solution: &[u8]) -> Result<Self, SerializationError> {
-        if solution.len() != SOLUTION_SIZE {
+        match solution.len() {
-            return Err(SerializationError::Parse(
+            // Won't panic, because we just checked the length.
+            SOLUTION_SIZE => {
+                let mut bytes = [0; SOLUTION_SIZE];
+                bytes.copy_from_slice(solution);
+                Ok(Self::Common(bytes))
+            }
+            REGTEST_SOLUTION_SIZE => {
+                let mut bytes = [0; REGTEST_SOLUTION_SIZE];
+                bytes.copy_from_slice(solution);
+                Ok(Self::Regtest(bytes))
+            }
+            _unexpected_len => Err(SerializationError::Parse(
                 "incorrect equihash solution size",
-            ));
+            )),
         }
-
-        let mut bytes = [0; SOLUTION_SIZE];
-        // Won't panic, because we just checked the length.
-        bytes.copy_from_slice(solution);
-
-        Ok(Self(bytes))
     }
 
     /// Returns a [`Solution`] of `[0; SOLUTION_SIZE]` to be used in block proposals.
     #[cfg(feature = "getblocktemplate-rpcs")]
     pub fn for_proposal() -> Self {
-        Self([0; SOLUTION_SIZE])
+        // TODO: Accept network as an argument, and if it's Regtest, return the shorter null solution.
+        Self::Common([0; SOLUTION_SIZE])
     }
 
     /// Mines and returns one or more [`Solution`]s based on a template `header`.
@@ -126,14 +151,14 @@ impl Solution {
 
 impl PartialEq<Solution> for Solution {
     fn eq(&self, other: &Solution) -> bool {
-        self.0.as_ref() == other.0.as_ref()
+        self.value() == other.value()
     }
 }
 
 impl fmt::Debug for Solution {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("EquihashSolution")
-            .field(&hex::encode(&self.0[..]))
+            .field(&hex::encode(self.value()))
             .finish()
     }
 }
@@ -153,13 +178,13 @@ impl Eq for Solution {}
 #[cfg(any(test, feature = "proptest-impl"))]
 impl Default for Solution {
     fn default() -> Self {
-        Self([0; SOLUTION_SIZE])
+        Self::Common([0; SOLUTION_SIZE])
     }
 }
 
 impl ZcashSerialize for Solution {
     fn zcash_serialize<W: io::Write>(&self, writer: W) -> Result<(), io::Error> {
-        zcash_serialize_bytes(&self.0.to_vec(), writer)
+        zcash_serialize_bytes(&self.value().to_vec(), writer)
     }
 }
 

zebra-consensus/src/block.rs

@@ -176,16 +176,18 @@ where
                 Err(BlockError::MaxHeight(height, hash, block::Height::MAX))?;
             }
 
-            // > The block data MUST be validated and checked against the server's usual
+            if !network.disable_pow() {
-            // > acceptance rules (excluding the check for a valid proof-of-work).
+                // > The block data MUST be validated and checked against the server's usual
-            // <https://en.bitcoin.it/wiki/BIP_0023#Block_Proposal>
+                // > acceptance rules (excluding the check for a valid proof-of-work).
-            if request.is_proposal() {
+                // <https://en.bitcoin.it/wiki/BIP_0023#Block_Proposal>
-                check::difficulty_threshold_is_valid(&block.header, &network, &height, &hash)?;
+                if request.is_proposal() {
-            } else {
+                    check::difficulty_threshold_is_valid(&block.header, &network, &height, &hash)?;
-                // Do the difficulty checks first, to raise the threshold for
+                } else {
-                // attacks that use any other fields.
+                    // Do the difficulty checks first, to raise the threshold for
-                check::difficulty_is_valid(&block.header, &network, &height, &hash)?;
+                    // attacks that use any other fields.
-                check::equihash_solution_is_valid(&block.header)?;
+                    check::difficulty_is_valid(&block.header, &network, &height, &hash)?;
+                    check::equihash_solution_is_valid(&block.header)?;
+                }
             }
 
             // Next, check the Merkle root validity, to ensure that

zebra-consensus/src/checkpoint.rs

@@ -595,8 +595,10 @@ where
             .ok_or(VerifyCheckpointError::CoinbaseHeight { hash })?;
         self.check_height(height)?;
 
-        crate::block::check::difficulty_is_valid(&block.header, &self.network, &height, &hash)?;
+        if !self.network.disable_pow() {
-        crate::block::check::equihash_solution_is_valid(&block.header)?;
+            crate::block::check::difficulty_is_valid(&block.header, &self.network, &height, &hash)?;
+            crate::block::check::equihash_solution_is_valid(&block.header)?;
+        }
 
         // don't do precalculation until the block passes basic difficulty checks
         let block = CheckpointVerifiedBlock::with_hash(block, hash);

zebra-consensus/src/checkpoint/list.rs

@@ -55,41 +55,60 @@ impl ParameterCheckpoint for Network {
     fn genesis_hash(&self) -> zebra_chain::block::Hash {
         match self {
             // zcash-cli getblockhash 0
-            Network::Mainnet => "00040fe8ec8471911baa1db1266ea15dd06b4a8a5c453883c000b031973dce08",
+            Network::Mainnet => "00040fe8ec8471911baa1db1266ea15dd06b4a8a5c453883c000b031973dce08"
-            // zcash-cli -testnet getblockhash 0
+                .parse()
-            // TODO: Add a `genesis_hash` field to `testnet::Parameters` and return it here (#8366)
+                .expect("hard-coded hash parses"),
-            Network::Testnet(_params) => {
+            // See `zebra_chain::parameters::network::testnet` for more details.
-                "05a60a92d99d85997cce3b87616c089f6124d7342af37106edc76126334a2c38"
+            Network::Testnet(params) => params.genesis_hash(),
-            }
         }
-        .parse()
-        .expect("hard-coded hash parses")
     }
 
     fn checkpoint_list(&self) -> CheckpointList {
-        // parse calls CheckpointList::from_list
+        let (checkpoints_for_network, should_fallback_to_genesis_hash_as_checkpoint) = match self {
-        // TODO:
+            Network::Mainnet => (MAINNET_CHECKPOINTS, false),
-        // - Add a `genesis_hash` field to `testnet::Parameters` and return it here (#8366)
+            Network::Testnet(params) if params.is_default_testnet() => (TESTNET_CHECKPOINTS, false),
-        // - Try to disable checkpoints entirely for regtest and custom testnets
+            Network::Testnet(_params) => (TESTNET_CHECKPOINTS, true),
-        let checkpoint_list: CheckpointList = match self {
-            Network::Mainnet => MAINNET_CHECKPOINTS
-                .parse()
-                .expect("Hard-coded Mainnet checkpoint list parses and validates"),
-            Network::Testnet(_params) => TESTNET_CHECKPOINTS
-                .parse()
-                .expect("Hard-coded Testnet checkpoint list parses and validates"),
         };
 
-        match checkpoint_list.hash(block::Height(0)) {
+        // Check that the list starts with the correct genesis block and parses checkpoint list.
-            Some(hash) if hash == self.genesis_hash() => checkpoint_list,
+        let first_checkpoint_height = checkpoints_for_network
-            Some(_) => {
+            .lines()
-                panic!("The hard-coded genesis checkpoint does not match the network genesis hash")
+            .next()
+            .map(checkpoint_height_and_hash);
+
+        match first_checkpoint_height {
+            // parse calls CheckpointList::from_list
+            Some(Ok((block::Height(0), hash))) if hash == self.genesis_hash() => {
+                checkpoints_for_network
+                    .parse()
+                    .expect("hard-coded checkpoint list parses and validates")
             }
-            None => unreachable!("Parser should have checked for a missing genesis checkpoint"),
+            _ if should_fallback_to_genesis_hash_as_checkpoint => {
+                CheckpointList::from_list([(block::Height(0), self.genesis_hash())])
+                    .expect("hard-coded checkpoint list parses and validates")
+            }
+            Some(Ok((block::Height(0), _))) => {
+                panic!("the genesis checkpoint does not match the {self} genesis hash")
+            }
+            Some(Ok(_)) => panic!("checkpoints must start at the genesis block height 0"),
+            Some(Err(err)) => panic!("{err}"),
+            None => panic!(
+                "there must be at least one checkpoint on default networks, for the genesis block"
+            ),
         }
     }
 }
 
+/// Parses a checkpoint to a [`block::Height`] and [`block::Hash`].
+fn checkpoint_height_and_hash(checkpoint: &str) -> Result<(block::Height, block::Hash), BoxError> {
+    let fields = checkpoint.split(' ').collect::<Vec<_>>();
+    if let [height, hash] = fields[..] {
+        Ok((height.parse()?, hash.parse()?))
+    } else {
+        Err(format!("Invalid checkpoint format: expected 2 space-separated fields but found {}: '{checkpoint}'", fields.len()).into())
+    }
+}
+
 /// A list of block height and hash checkpoints.
 ///
 /// Checkpoints should be chosen to avoid forks or chain reorganizations,
@@ -115,12 +134,7 @@ impl FromStr for CheckpointList {
         let mut checkpoint_list: Vec<(block::Height, block::Hash)> = Vec::new();
 
         for checkpoint in s.lines() {
-            let fields = checkpoint.split(' ').collect::<Vec<_>>();
+            checkpoint_list.push(checkpoint_height_and_hash(checkpoint)?);
-            if let [height, hash] = fields[..] {
-                checkpoint_list.push((height.parse()?, hash.parse()?));
-            } else {
-                Err(format!("Invalid checkpoint format: expected 2 space-separated fields but found {}: '{checkpoint}'", fields.len()))?;
-            };
         }
 
         CheckpointList::from_list(checkpoint_list)
@@ -146,17 +160,9 @@ impl CheckpointList {
         let checkpoints: BTreeMap<block::Height, block::Hash> =
             original_checkpoints.into_iter().collect();
 
-        // Check that the list starts with the correct genesis block
+        // Check that the list starts with _some_ genesis block
         match checkpoints.iter().next() {
-            // TODO: If required (we may not need checkpoints at all in Regtest or custom testnets):
+            Some((block::Height(0), _hash)) => {}
-            //       move this check to `<Network as ParameterCheckpoint>::checkpoint_list(&network)` method above (#8366),
-            //       See <https://github.com/ZcashFoundation/zebra/pull/7924#discussion_r1385865347>
-            Some((block::Height(0), hash))
-                if (hash == &Network::Mainnet.genesis_hash()
-                    || hash == &Network::new_default_testnet().genesis_hash()) => {}
-            Some((block::Height(0), _)) => {
-                Err("the genesis checkpoint does not match the Mainnet or Testnet genesis hash")?
-            }
             Some(_) => Err("checkpoints must start at the genesis block height 0")?,
             None => Err("there must be at least one checkpoint, for the genesis block")?,
         };

zebra-consensus/src/checkpoint/list/tests.rs

@@ -237,6 +237,7 @@ fn checkpoint_list_load_hard_coded() -> Result<(), BoxError> {
 
     let _ = Mainnet.checkpoint_list();
     let _ = Network::new_default_testnet().checkpoint_list();
+    let _ = Network::new_regtest(Default::default()).checkpoint_list();
 
     Ok(())
 }

zebrad/tests/acceptance.rs

@@ -161,10 +161,12 @@ use color_eyre::{
 use semver::Version;
 use serde_json::Value;
 
+use tower::ServiceExt;
 use zebra_chain::{
-    block::{self, Height},
+    block::{self, genesis::regtest_genesis_block, Height},
     parameters::Network::{self, *},
 };
+use zebra_consensus::ParameterCheckpoint;
 use zebra_network::constants::PORT_IN_USE_ERROR;
 use zebra_node_services::rpc_client::RpcRequestClient;
 use zebra_state::{constants::LOCK_FILE_ERROR, state_database_format_version_in_code};
@@ -3099,3 +3101,29 @@ fn scan_start_where_left() -> Result<()> {
 async fn scan_task_commands() -> Result<()> {
     common::shielded_scan::scan_task_commands::run().await
 }
+
+/// Checks that the Regtest genesis block can be validated.
+#[tokio::test]
+async fn validate_regtest_genesis_block() {
+    let _init_guard = zebra_test::init();
+
+    let network = Network::new_regtest(Default::default());
+    let state = zebra_state::init_test(&network);
+    let (
+        block_verifier_router,
+        _transaction_verifier,
+        _parameter_download_task_handle,
+        _max_checkpoint_height,
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &network, state).await;
+
+    let genesis_hash = block_verifier_router
+        .oneshot(zebra_consensus::Request::Commit(regtest_genesis_block()))
+        .await
+        .expect("should validate Regtest genesis block");
+
+    assert_eq!(
+        genesis_hash,
+        network.genesis_hash(),
+        "validated block hash should match network genesis hash"
+    )
+}