diff --git a/zebra-chain/src/block.rs b/zebra-chain/src/block.rs
index cee913dd5a4..8b45b5ea55b 100644
--- a/zebra-chain/src/block.rs
+++ b/zebra-chain/src/block.rs
@@ -98,7 +98,7 @@ impl Block {
     ///
     /// Returns an error if this block does not have a block height,
     /// or if the commitment value is structurally invalid.
-    pub fn commitment(&self, network: Network) -> Result<Commitment, CommitmentError> {
+    pub fn commitment(&self, network: &Network) -> Result<Commitment, CommitmentError> {
         match self.coinbase_height() {
             None => Err(CommitmentError::MissingBlockHeight {
                 block_hash: self.hash(),
@@ -121,7 +121,7 @@ impl Block {
     #[allow(clippy::unwrap_in_result)]
     pub fn check_transaction_network_upgrade_consistency(
         &self,
-        network: Network,
+        network: &Network,
     ) -> Result<(), error::BlockError> {
         let block_nu =
             NetworkUpgrade::current(network, self.coinbase_height().expect("a valid height"));
diff --git a/zebra-chain/src/block/arbitrary.rs b/zebra-chain/src/block/arbitrary.rs
index 4db23bfd26d..973ad110f5d 100644
--- a/zebra-chain/src/block/arbitrary.rs
+++ b/zebra-chain/src/block/arbitrary.rs
@@ -69,7 +69,7 @@ impl Arbitrary for Height {
     type Strategy = BoxedStrategy<Self>;
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 /// The configuration data for proptest when generating arbitrary chains
 pub struct LedgerState {
@@ -245,7 +245,7 @@ impl LedgerState {
         if let Some(network_upgrade_override) = self.network_upgrade_override {
             network_upgrade_override
         } else {
-            NetworkUpgrade::current(self.network, self.height)
+            NetworkUpgrade::current(&self.network, self.height)
         }
     }
 
@@ -268,9 +268,9 @@ impl Default for LedgerState {
         let default_network = Network::default();
         let default_override = LedgerStateOverride::default();
 
-        let most_recent_nu = NetworkUpgrade::current(default_network, Height::MAX);
+        let most_recent_nu = NetworkUpgrade::current(&default_network, Height::MAX);
         let most_recent_activation_height =
-            most_recent_nu.activation_height(default_network).unwrap();
+            most_recent_nu.activation_height(&default_network).unwrap();
 
         LedgerState {
             height: most_recent_activation_height,
@@ -290,7 +290,7 @@ impl Default for LedgerStateOverride {
         let default_network = Network::default();
 
         // TODO: dynamically select any future network upgrade (#1974)
-        let nu5_activation_height = Nu5.activation_height(default_network);
+        let nu5_activation_height = Nu5.activation_height(&default_network);
         let nu5_override = if nu5_activation_height.is_some() {
             None
         } else {
@@ -348,12 +348,14 @@ impl Arbitrary for Block {
     type Parameters = LedgerState;
 
     fn arbitrary_with(ledger_state: Self::Parameters) -> Self::Strategy {
-        let transactions_strategy =
+        let transactions_strategy = {
+            let ledger_state = ledger_state.clone();
             // Generate a random number transactions. A coinbase tx is always generated, so if
             // `transaction_count` is zero, the block will contain only the coinbase tx.
             (0..MAX_ARBITRARY_ITEMS).prop_flat_map(move |transaction_count| {
-                Transaction::vec_strategy(ledger_state, transaction_count)
-            });
+                Transaction::vec_strategy(ledger_state.clone(), transaction_count)
+            })
+        };
 
         // TODO: if needed, fixup:
         // - history and authorizing data commitments
@@ -411,7 +413,7 @@ impl Block {
 
         // generate block strategies with the correct heights
         for _ in 0..count {
-            vec.push((Just(current.height), Block::arbitrary_with(current)));
+            vec.push((Just(current.height), Block::arbitrary_with(current.clone())));
             current.height.0 += 1;
         }
 
@@ -473,9 +475,9 @@ impl Block {
                 if generate_valid_commitments {
                     let current_height = block.coinbase_height().unwrap();
                     let heartwood_height = NetworkUpgrade::Heartwood
-                        .activation_height(current.network)
+                        .activation_height(&current.network)
                         .unwrap();
-                    let nu5_height = NetworkUpgrade::Nu5.activation_height(current.network);
+                    let nu5_height = NetworkUpgrade::Nu5.activation_height(&current.network);
 
                     match current_height.cmp(&heartwood_height) {
                         std::cmp::Ordering::Less => {
@@ -520,16 +522,16 @@ impl Block {
                     if let Some(history_tree) = history_tree.as_mut() {
                         history_tree
                             .push(
-                                current.network,
+                                &current.network,
                                 Arc::new(block.clone()),
-                                sapling_tree.root(),
-                                orchard_tree.root(),
+                                &sapling_tree.root(),
+                                &orchard_tree.root(),
                             )
                             .unwrap();
                     } else {
                         history_tree = Some(
                             HistoryTree::from_block(
-                                current.network,
+                                &current.network,
                                 Arc::new(block.clone()),
                                 &sapling_tree.root(),
                                 &orchard_tree.root(),
@@ -703,10 +705,10 @@ impl Arbitrary for Commitment {
     fn arbitrary_with(_args: ()) -> Self::Strategy {
         (any::<[u8; 32]>(), any::<Network>(), any::<Height>())
             .prop_map(|(commitment_bytes, network, block_height)| {
-                if block_height == Heartwood.activation_height(network).unwrap() {
+                if block_height == Heartwood.activation_height(&network).unwrap() {
                     Commitment::ChainHistoryActivationReserved
                 } else {
-                    Commitment::from_bytes(commitment_bytes, network, block_height)
+                    Commitment::from_bytes(commitment_bytes, &network, block_height)
                         .expect("unexpected failure in from_bytes parsing")
                 }
             })
diff --git a/zebra-chain/src/block/commitment.rs b/zebra-chain/src/block/commitment.rs
index 3d2591d4563..3c88972b630 100644
--- a/zebra-chain/src/block/commitment.rs
+++ b/zebra-chain/src/block/commitment.rs
@@ -103,7 +103,7 @@ impl Commitment {
     // TODO: rename as from_bytes_in_serialized_order()
     pub(super) fn from_bytes(
         bytes: [u8; 32],
-        network: Network,
+        network: &Network,
         height: block::Height,
     ) -> Result<Commitment, CommitmentError> {
         use Commitment::*;
diff --git a/zebra-chain/src/block/tests/prop.rs b/zebra-chain/src/block/tests/prop.rs
index b4446c0ee88..5f642e63db0 100644
--- a/zebra-chain/src/block/tests/prop.rs
+++ b/zebra-chain/src/block/tests/prop.rs
@@ -81,7 +81,7 @@ proptest! {
 
         // just skip the test if the bytes don't parse, because there's nothing
         // to compare with
-        if let Ok(commitment) = Commitment::from_bytes(bytes, network, block_height) {
+        if let Ok(commitment) = Commitment::from_bytes(bytes, &network, block_height) {
             let other_bytes = commitment.to_bytes();
 
             prop_assert_eq![bytes, other_bytes];
@@ -104,7 +104,7 @@ proptest! {
         let bytes = block.zcash_serialize_to_vec()?;
 
         // Check the block commitment
-        let commitment = block.commitment(network);
+        let commitment = block.commitment(&network);
         if let Ok(commitment) = commitment {
             let commitment_bytes = commitment.to_bytes();
             prop_assert_eq![block.header.commitment_bytes.0, commitment_bytes];
diff --git a/zebra-chain/src/block/tests/vectors.rs b/zebra-chain/src/block/tests/vectors.rs
index afd86d21a79..8aa81dbd3cb 100644
--- a/zebra-chain/src/block/tests/vectors.rs
+++ b/zebra-chain/src/block/tests/vectors.rs
@@ -222,7 +222,7 @@ fn block_test_vectors_height(network: Network) {
 
         if height
             >= Sapling
-                .activation_height(network)
+                .activation_height(&network)
                 .expect("sapling activation height is set")
                 .0
         {
@@ -260,7 +260,7 @@ fn block_commitment(network: Network) {
             .zcash_deserialize_into::<Block>()
             .expect("block is structurally valid");
 
-        let commitment = block.commitment(network).unwrap_or_else(|_| {
+        let commitment = block.commitment(&network).unwrap_or_else(|_| {
             panic!("unexpected structurally invalid block commitment at {network} {height}")
         });
 
diff --git a/zebra-chain/src/chain_tip.rs b/zebra-chain/src/chain_tip.rs
index e2d55a7dab6..c19c556e7ef 100644
--- a/zebra-chain/src/chain_tip.rs
+++ b/zebra-chain/src/chain_tip.rs
@@ -84,7 +84,7 @@ pub trait ChainTip {
     /// and the height of the best tip.
     fn estimate_network_chain_tip_height(
         &self,
-        network: Network,
+        network: &Network,
         now: DateTime<Utc>,
     ) -> Option<block::Height> {
         let (current_height, current_block_time) = self.best_tip_height_and_block_time()?;
@@ -110,7 +110,7 @@ pub trait ChainTip {
     /// Returns `None` if the state is empty.
     fn estimate_distance_to_network_chain_tip(
         &self,
-        network: Network,
+        network: &Network,
     ) -> Option<(block::HeightDiff, block::Height)> {
         let (current_height, current_block_time) = self.best_tip_height_and_block_time()?;
 
diff --git a/zebra-chain/src/chain_tip/mock.rs b/zebra-chain/src/chain_tip/mock.rs
index 980af365673..46ca5e89e5e 100644
--- a/zebra-chain/src/chain_tip/mock.rs
+++ b/zebra-chain/src/chain_tip/mock.rs
@@ -111,7 +111,7 @@ impl ChainTip for MockChainTip {
 
     fn estimate_distance_to_network_chain_tip(
         &self,
-        _network: Network,
+        _network: &Network,
     ) -> Option<(block::HeightDiff, block::Height)> {
         self.estimated_distance_to_network_chain_tip
             .borrow()
diff --git a/zebra-chain/src/chain_tip/network_chain_tip_height_estimator.rs b/zebra-chain/src/chain_tip/network_chain_tip_height_estimator.rs
index 1c5e1cf08c5..1382983e9af 100644
--- a/zebra-chain/src/chain_tip/network_chain_tip_height_estimator.rs
+++ b/zebra-chain/src/chain_tip/network_chain_tip_height_estimator.rs
@@ -43,7 +43,7 @@ impl NetworkChainTipHeightEstimator {
     pub fn new(
         current_block_time: DateTime<Utc>,
         current_height: block::Height,
-        network: Network,
+        network: &Network,
     ) -> Self {
         let mut target_spacings = NetworkUpgrade::target_spacings(network);
         let (_genesis_height, initial_target_spacing) =
diff --git a/zebra-chain/src/chain_tip/tests/prop.rs b/zebra-chain/src/chain_tip/tests/prop.rs
index 1cbc7a5375d..3b5fff99fd9 100644
--- a/zebra-chain/src/chain_tip/tests/prop.rs
+++ b/zebra-chain/src/chain_tip/tests/prop.rs
@@ -24,7 +24,7 @@ proptest! {
     ) {
         let (chain_tip, mock_chain_tip_sender) = MockChainTip::new();
         let blossom_activation_height = NetworkUpgrade::Blossom
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Blossom activation height is missing");
 
         block_heights.sort();
@@ -50,13 +50,13 @@ proptest! {
 
         let time_displacement = calculate_time_displacement(
             time_displacement_factor,
-            NetworkUpgrade::current(network, network_height),
+            NetworkUpgrade::current(&network, network_height),
         );
 
         let mock_local_time = current_block_time + estimated_time_difference + time_displacement;
 
         assert_eq!(
-            chain_tip.estimate_network_chain_tip_height(network, mock_local_time),
+            chain_tip.estimate_network_chain_tip_height(&network, mock_local_time),
             Some(network_height)
         );
     }
diff --git a/zebra-chain/src/history_tree.rs b/zebra-chain/src/history_tree.rs
index 696369587c0..8666ba49e0a 100644
--- a/zebra-chain/src/history_tree.rs
+++ b/zebra-chain/src/history_tree.rs
@@ -78,7 +78,7 @@ impl NonEmptyHistoryTree {
     /// The parameters must come from the values of [`NonEmptyHistoryTree::size`],
     /// [`NonEmptyHistoryTree::peaks`] and [`NonEmptyHistoryTree::current_height`] of a HistoryTree.
     pub fn from_cache(
-        network: Network,
+        network: &Network,
         size: u32,
         peaks: BTreeMap<u32, Entry>,
         current_height: Height,
@@ -114,7 +114,7 @@ impl NonEmptyHistoryTree {
             }
         };
         Ok(Self {
-            network,
+            network: network.clone(),
             network_upgrade,
             inner,
             size,
@@ -130,7 +130,7 @@ impl NonEmptyHistoryTree {
     ///  (ignored for pre-Orchard blocks).
     #[allow(clippy::unwrap_in_result)]
     pub fn from_block(
-        network: Network,
+        network: &Network,
         block: Arc<Block>,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
@@ -169,7 +169,7 @@ impl NonEmptyHistoryTree {
         let mut peaks = BTreeMap::new();
         peaks.insert(0u32, entry);
         Ok(NonEmptyHistoryTree {
-            network,
+            network: network.clone(),
             network_upgrade,
             inner: tree,
             size: 1,
@@ -208,11 +208,11 @@ impl NonEmptyHistoryTree {
             self.current_height
         );
 
-        let network_upgrade = NetworkUpgrade::current(self.network, height);
+        let network_upgrade = NetworkUpgrade::current(&self.network, height);
         if network_upgrade != self.network_upgrade {
             // This is the activation block of a network upgrade.
             // Create a new tree.
-            let new_tree = Self::from_block(self.network, block, sapling_root, orchard_root)?;
+            let new_tree = Self::from_block(&self.network, block, sapling_root, orchard_root)?;
             // Replaces self with the new tree
             *self = new_tree;
             assert_eq!(self.network_upgrade, network_upgrade);
@@ -328,7 +328,7 @@ impl NonEmptyHistoryTree {
         self.inner = match self.inner {
             InnerHistoryTree::PreOrchard(_) => {
                 InnerHistoryTree::PreOrchard(Tree::<PreOrchard>::new_from_cache(
-                    self.network,
+                    &self.network,
                     self.network_upgrade,
                     self.size,
                     &self.peaks,
@@ -337,7 +337,7 @@ impl NonEmptyHistoryTree {
             }
             InnerHistoryTree::OrchardOnward(_) => {
                 InnerHistoryTree::OrchardOnward(Tree::<OrchardOnward>::new_from_cache(
-                    self.network,
+                    &self.network,
                     self.network_upgrade,
                     self.size,
                     &self.peaks,
@@ -373,7 +373,7 @@ impl NonEmptyHistoryTree {
 
     /// Return the network where this tree is used.
     pub fn network(&self) -> Network {
-        self.network
+        self.network.clone()
     }
 }
 
@@ -382,7 +382,7 @@ impl Clone for NonEmptyHistoryTree {
         let tree = match self.inner {
             InnerHistoryTree::PreOrchard(_) => InnerHistoryTree::PreOrchard(
                 Tree::<PreOrchard>::new_from_cache(
-                    self.network,
+                    &self.network,
                     self.network_upgrade,
                     self.size,
                     &self.peaks,
@@ -392,7 +392,7 @@ impl Clone for NonEmptyHistoryTree {
             ),
             InnerHistoryTree::OrchardOnward(_) => InnerHistoryTree::OrchardOnward(
                 Tree::<OrchardOnward>::new_from_cache(
-                    self.network,
+                    &self.network,
                     self.network_upgrade,
                     self.size,
                     &self.peaks,
@@ -402,7 +402,7 @@ impl Clone for NonEmptyHistoryTree {
             ),
         };
         NonEmptyHistoryTree {
-            network: self.network,
+            network: self.network.clone(),
             network_upgrade: self.network_upgrade,
             inner: tree,
             size: self.size,
@@ -423,7 +423,7 @@ impl HistoryTree {
     /// If the block is pre-Heartwood, it returns an empty history tree.
     #[allow(clippy::unwrap_in_result)]
     pub fn from_block(
-        network: Network,
+        network: &Network,
         block: Arc<Block>,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
@@ -450,10 +450,10 @@ impl HistoryTree {
     #[allow(clippy::unwrap_in_result)]
     pub fn push(
         &mut self,
-        network: Network,
+        network: &Network,
         block: Arc<Block>,
-        sapling_root: sapling::tree::Root,
-        orchard_root: orchard::tree::Root,
+        sapling_root: &sapling::tree::Root,
+        orchard_root: &orchard::tree::Root,
     ) -> Result<(), HistoryTreeError> {
         let heartwood_height = NetworkUpgrade::Heartwood
             .activation_height(network)
@@ -472,9 +472,9 @@ impl HistoryTree {
             std::cmp::Ordering::Equal => {
                 let tree = Some(NonEmptyHistoryTree::from_block(
                     network,
-                    block.clone(),
-                    &sapling_root,
-                    &orchard_root,
+                    block,
+                    sapling_root,
+                    orchard_root,
                 )?);
                 // Replace the current object with the new tree
                 *self = HistoryTree(tree);
@@ -483,7 +483,7 @@ impl HistoryTree {
                 self.0
                     .as_mut()
                     .expect("history tree must exist Heartwood-onward")
-                    .push(block.clone(), &sapling_root, &orchard_root)?;
+                    .push(block.clone(), sapling_root, orchard_root)?;
             }
         };
         Ok(())
diff --git a/zebra-chain/src/history_tree/tests/vectors.rs b/zebra-chain/src/history_tree/tests/vectors.rs
index 6d63d439163..9ddb32bd049 100644
--- a/zebra-chain/src/history_tree/tests/vectors.rs
+++ b/zebra-chain/src/history_tree/tests/vectors.rs
@@ -35,7 +35,7 @@ fn push_and_prune_for_network_upgrade(
 ) -> Result<()> {
     let (blocks, sapling_roots) = network.block_sapling_roots_map();
 
-    let height = network_upgrade.activation_height(network).unwrap().0;
+    let height = network_upgrade.activation_height(&network).unwrap().0;
 
     // Load first block (activation block of the given network upgrade)
     let first_block = Arc::new(
@@ -47,7 +47,7 @@ fn push_and_prune_for_network_upgrade(
     );
 
     // Check its commitment
-    let first_commitment = first_block.commitment(network)?;
+    let first_commitment = first_block.commitment(&network)?;
     if network_upgrade == NetworkUpgrade::Heartwood {
         // Heartwood is the only upgrade that has a reserved value.
         // (For other upgrades we could compare with the expected commitment,
@@ -59,7 +59,7 @@ fn push_and_prune_for_network_upgrade(
     let first_sapling_root =
         sapling::tree::Root::try_from(**sapling_roots.get(&height).expect("test vector exists"))?;
     let mut tree = NonEmptyHistoryTree::from_block(
-        network,
+        &network,
         first_block,
         &first_sapling_root,
         &Default::default(),
@@ -82,7 +82,7 @@ fn push_and_prune_for_network_upgrade(
     );
 
     // Check its commitment
-    let second_commitment = second_block.commitment(network)?;
+    let second_commitment = second_block.commitment(&network)?;
     assert_eq!(second_commitment, Commitment::ChainHistoryRoot(first_root));
 
     // Append second block to history tree
@@ -117,7 +117,7 @@ fn upgrade() -> Result<()> {
 fn upgrade_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) -> Result<()> {
     let (blocks, sapling_roots) = network.block_sapling_roots_map();
 
-    let height = network_upgrade.activation_height(network).unwrap().0;
+    let height = network_upgrade.activation_height(&network).unwrap().0;
 
     // Load previous block (the block before the activation block of the given network upgrade)
     let block_prev = Arc::new(
@@ -134,7 +134,7 @@ fn upgrade_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade
     let sapling_root_prev =
         sapling::tree::Root::try_from(**sapling_roots.get(&height).expect("test vector exists"))?;
     let mut tree = NonEmptyHistoryTree::from_block(
-        network,
+        &network,
         block_prev,
         &sapling_root_prev,
         &Default::default(),
diff --git a/zebra-chain/src/parameters/network.rs b/zebra-chain/src/parameters/network.rs
index 634a44a19b9..3ba5a090234 100644
--- a/zebra-chain/src/parameters/network.rs
+++ b/zebra-chain/src/parameters/network.rs
@@ -52,7 +52,7 @@ mod tests;
 const ZIP_212_GRACE_PERIOD_DURATION: HeightDiff = 32_256;
 
 /// An enum describing the possible network choices.
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, Serialize, Deserialize)]
 #[cfg_attr(any(test, feature = "proptest-impl"), derive(Arbitrary))]
 pub enum Network {
     /// The production mainnet.
@@ -68,13 +68,13 @@ impl Network {
     /// Returns the human-readable prefix for Base58Check-encoded transparent
     /// pay-to-public-key-hash payment addresses for the network.
     pub fn b58_pubkey_address_prefix(&self) -> [u8; 2] {
-        <ZcashPrimitivesNetwork>::from(*self).b58_pubkey_address_prefix()
+        <ZcashPrimitivesNetwork>::from(self).b58_pubkey_address_prefix()
     }
 
     /// Returns the human-readable prefix for Base58Check-encoded transparent pay-to-script-hash
     /// payment addresses for the network.
     pub fn b58_script_address_prefix(&self) -> [u8; 2] {
-        <ZcashPrimitivesNetwork>::from(*self).b58_script_address_prefix()
+        <ZcashPrimitivesNetwork>::from(self).b58_script_address_prefix()
     }
     /// Returns true if the maximum block time rule is active for `network` and `height`.
     ///
@@ -84,7 +84,7 @@ impl Network {
     /// Returns false otherwise.
     ///
     /// Part of the consensus rules at <https://zips.z.cash/protocol/protocol.pdf#blockheader>
-    pub fn is_max_block_time_enforced(self, height: block::Height) -> bool {
+    pub fn is_max_block_time_enforced(&self, height: block::Height) -> bool {
         match self {
             Network::Mainnet => true,
             Network::Testnet => height >= super::TESTNET_MAX_TIME_START_HEIGHT,
@@ -92,8 +92,8 @@ impl Network {
     }
 }
 
-impl From<Network> for &'static str {
-    fn from(network: Network) -> &'static str {
+impl From<&Network> for &'static str {
+    fn from(network: &Network) -> &'static str {
         match network {
             Network::Mainnet => "Mainnet",
             Network::Testnet => "Testnet",
@@ -101,12 +101,6 @@ impl From<Network> for &'static str {
     }
 }
 
-impl From<&Network> for &'static str {
-    fn from(network: &Network) -> &'static str {
-        (*network).into()
-    }
-}
-
 impl fmt::Display for Network {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.into())
@@ -139,7 +133,7 @@ impl Network {
         // See the `ZIP_212_GRACE_PERIOD_DURATION` documentation for more information.
 
         let canopy_activation = Canopy
-            .activation_height(*self)
+            .activation_height(self)
             .expect("Canopy activation height must be present for both networks");
 
         (canopy_activation + ZIP_212_GRACE_PERIOD_DURATION)
@@ -166,7 +160,7 @@ impl Network {
     }
 
     /// Returns the Sapling activation height for this network.
-    pub fn sapling_activation_height(self) -> Height {
+    pub fn sapling_activation_height(&self) -> Height {
         super::NetworkUpgrade::Sapling
             .activation_height(self)
             .expect("Sapling activation height needs to be set")
diff --git a/zebra-chain/src/parameters/network/tests/prop.rs b/zebra-chain/src/parameters/network/tests/prop.rs
index 8fd495d1c19..cab04496d7f 100644
--- a/zebra-chain/src/parameters/network/tests/prop.rs
+++ b/zebra-chain/src/parameters/network/tests/prop.rs
@@ -18,7 +18,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         let canopy_activation = NetworkUpgrade::Canopy
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Canopy activation height is set");
 
         let grace_period_end_height = (canopy_activation + ZIP_212_GRACE_PERIOD_DURATION)
diff --git a/zebra-chain/src/parameters/network_upgrade.rs b/zebra-chain/src/parameters/network_upgrade.rs
index 38529babde8..4d88e96bd77 100644
--- a/zebra-chain/src/parameters/network_upgrade.rs
+++ b/zebra-chain/src/parameters/network_upgrade.rs
@@ -280,7 +280,7 @@ impl Network {
 }
 impl NetworkUpgrade {
     /// Returns the current network upgrade for `network` and `height`.
-    pub fn current(network: Network, height: block::Height) -> NetworkUpgrade {
+    pub fn current(network: &Network, height: block::Height) -> NetworkUpgrade {
         network
             .activation_list()
             .range(..=height)
@@ -293,7 +293,7 @@ impl NetworkUpgrade {
     ///
     /// Returns None if the next upgrade has not been implemented in Zebra
     /// yet.
-    pub fn next(network: Network, height: block::Height) -> Option<NetworkUpgrade> {
+    pub fn next(network: &Network, height: block::Height) -> Option<NetworkUpgrade> {
         network
             .activation_list()
             .range((Excluded(height), Unbounded))
@@ -305,7 +305,7 @@ impl NetworkUpgrade {
     ///
     /// Returns None if this network upgrade is a future upgrade, and its
     /// activation height has not been set yet.
-    pub fn activation_height(&self, network: Network) -> Option<block::Height> {
+    pub fn activation_height(&self, network: &Network) -> Option<block::Height> {
         network
             .activation_list()
             .iter()
@@ -319,7 +319,7 @@ impl NetworkUpgrade {
     ///
     /// Use [`NetworkUpgrade::activation_height`] to get the specific network
     /// upgrade.
-    pub fn is_activation_height(network: Network, height: block::Height) -> bool {
+    pub fn is_activation_height(network: &Network, height: block::Height) -> bool {
         network.activation_list().contains_key(&height)
     }
 
@@ -358,12 +358,14 @@ impl NetworkUpgrade {
     /// Returns the target block spacing for `network` and `height`.
     ///
     /// See [`NetworkUpgrade::target_spacing`] for details.
-    pub fn target_spacing_for_height(network: Network, height: block::Height) -> Duration {
+    pub fn target_spacing_for_height(network: &Network, height: block::Height) -> Duration {
         NetworkUpgrade::current(network, height).target_spacing()
     }
 
     /// Returns all the target block spacings for `network` and the heights where they start.
-    pub fn target_spacings(network: Network) -> impl Iterator<Item = (block::Height, Duration)> {
+    pub fn target_spacings(
+        network: &Network,
+    ) -> impl Iterator<Item = (block::Height, Duration)> + '_ {
         [
             (NetworkUpgrade::Genesis, PRE_BLOSSOM_POW_TARGET_SPACING),
             (
@@ -388,7 +390,7 @@ impl NetworkUpgrade {
     ///
     /// Based on <https://zips.z.cash/zip-0208#minimum-difficulty-blocks-on-the-test-network>
     pub fn minimum_difficulty_spacing_for_height(
-        network: Network,
+        network: &Network,
         height: block::Height,
     ) -> Option<Duration> {
         match (network, height) {
@@ -417,7 +419,7 @@ impl NetworkUpgrade {
     /// check for the time gap. This function implements the correct "greater than"
     /// check.
     pub fn is_testnet_min_difficulty_block(
-        network: Network,
+        network: &Network,
         block_height: block::Height,
         block_time: DateTime<Utc>,
         previous_block_time: DateTime<Utc>,
@@ -443,7 +445,7 @@ impl NetworkUpgrade {
     ///
     /// See [`NetworkUpgrade::averaging_window_timespan`] for details.
     pub fn averaging_window_timespan_for_height(
-        network: Network,
+        network: &Network,
         height: block::Height,
     ) -> Duration {
         NetworkUpgrade::current(network, height).averaging_window_timespan()
@@ -472,7 +474,7 @@ impl ConsensusBranchId {
     /// Returns the current consensus branch id for `network` and `height`.
     ///
     /// Returns None if the network has no branch id at this height.
-    pub fn current(network: Network, height: block::Height) -> Option<ConsensusBranchId> {
+    pub fn current(network: &Network, height: block::Height) -> Option<ConsensusBranchId> {
         NetworkUpgrade::current(network, height).branch_id()
     }
 }
diff --git a/zebra-chain/src/parameters/tests.rs b/zebra-chain/src/parameters/tests.rs
index ac4e4ca6918..715ceb68242 100644
--- a/zebra-chain/src/parameters/tests.rs
+++ b/zebra-chain/src/parameters/tests.rs
@@ -49,15 +49,15 @@ fn activation_extremes(network: Network) {
         network.activation_list().get(&block::Height(0)),
         Some(&Genesis)
     );
-    assert_eq!(Genesis.activation_height(network), Some(block::Height(0)));
+    assert_eq!(Genesis.activation_height(&network), Some(block::Height(0)));
     assert!(NetworkUpgrade::is_activation_height(
-        network,
+        &network,
         block::Height(0)
     ));
 
-    assert_eq!(NetworkUpgrade::current(network, block::Height(0)), Genesis);
+    assert_eq!(NetworkUpgrade::current(&network, block::Height(0)), Genesis);
     assert_eq!(
-        NetworkUpgrade::next(network, block::Height(0)),
+        NetworkUpgrade::next(&network, block::Height(0)),
         Some(BeforeOverwinter)
     );
 
@@ -66,25 +66,25 @@ fn activation_extremes(network: Network) {
         Some(&BeforeOverwinter)
     );
     assert_eq!(
-        BeforeOverwinter.activation_height(network),
+        BeforeOverwinter.activation_height(&network),
         Some(block::Height(1))
     );
     assert!(NetworkUpgrade::is_activation_height(
-        network,
+        &network,
         block::Height(1)
     ));
 
     assert_eq!(
-        NetworkUpgrade::current(network, block::Height(1)),
+        NetworkUpgrade::current(&network, block::Height(1)),
         BeforeOverwinter
     );
     assert_eq!(
-        NetworkUpgrade::next(network, block::Height(1)),
+        NetworkUpgrade::next(&network, block::Height(1)),
         Some(Overwinter)
     );
 
     assert!(!NetworkUpgrade::is_activation_height(
-        network,
+        &network,
         block::Height(2)
     ));
 
@@ -95,15 +95,15 @@ fn activation_extremes(network: Network) {
         Some(&Genesis)
     );
     assert!(!NetworkUpgrade::is_activation_height(
-        network,
+        &network,
         block::Height::MAX
     ));
 
     assert_ne!(
-        NetworkUpgrade::current(network, block::Height::MAX),
+        NetworkUpgrade::current(&network, block::Height::MAX),
         Genesis
     );
-    assert_eq!(NetworkUpgrade::next(network, block::Height::MAX), None);
+    assert_eq!(NetworkUpgrade::next(&network, block::Height::MAX), None);
 }
 
 #[test]
@@ -126,28 +126,31 @@ fn activation_consistent(network: Network) {
 
     for &network_upgrade in network_upgrades {
         let height = network_upgrade
-            .activation_height(network)
+            .activation_height(&network)
             .expect("activations must have a height");
-        assert!(NetworkUpgrade::is_activation_height(network, height));
+        assert!(NetworkUpgrade::is_activation_height(&network, height));
 
         if height > block::Height(0) {
             // Genesis is immediately followed by BeforeOverwinter,
             // but the other network upgrades have multiple blocks between them
             assert!(!NetworkUpgrade::is_activation_height(
-                network,
+                &network,
                 (height + 1).unwrap()
             ));
         }
 
-        assert_eq!(NetworkUpgrade::current(network, height), network_upgrade);
+        assert_eq!(NetworkUpgrade::current(&network, height), network_upgrade);
         // Network upgrades don't repeat
-        assert_ne!(NetworkUpgrade::next(network, height), Some(network_upgrade));
         assert_ne!(
-            NetworkUpgrade::next(network, block::Height(height.0 + 1)),
+            NetworkUpgrade::next(&network, height),
             Some(network_upgrade)
         );
         assert_ne!(
-            NetworkUpgrade::next(network, block::Height::MAX),
+            NetworkUpgrade::next(&network, block::Height(height.0 + 1)),
+            Some(network_upgrade)
+        );
+        assert_ne!(
+            NetworkUpgrade::next(&network, block::Height::MAX),
             Some(network_upgrade)
         );
     }
@@ -186,7 +189,7 @@ fn branch_id_extremes(network: Network) {
         NetworkUpgrade::branch_id_list().get(&BeforeOverwinter),
         None
     );
-    assert_eq!(ConsensusBranchId::current(network, block::Height(0)), None);
+    assert_eq!(ConsensusBranchId::current(&network, block::Height(0)), None);
     assert_eq!(
         NetworkUpgrade::branch_id_list().get(&Overwinter).cloned(),
         Overwinter.branch_id()
@@ -195,11 +198,12 @@ fn branch_id_extremes(network: Network) {
     // We assume that the last upgrade we know about continues forever
     // (even if we suspect that won't be true)
     assert_ne!(
-        NetworkUpgrade::branch_id_list().get(&NetworkUpgrade::current(network, block::Height::MAX)),
+        NetworkUpgrade::branch_id_list()
+            .get(&NetworkUpgrade::current(&network, block::Height::MAX)),
         None
     );
     assert_ne!(
-        ConsensusBranchId::current(network, block::Height::MAX),
+        ConsensusBranchId::current(&network, block::Height::MAX),
         None
     );
 }
@@ -222,12 +226,12 @@ fn branch_id_consistent(network: Network) {
     let network_upgrades: HashSet<&NetworkUpgrade> = branch_id_list.keys().collect();
 
     for &network_upgrade in network_upgrades {
-        let height = network_upgrade.activation_height(network);
+        let height = network_upgrade.activation_height(&network);
 
         // Skip network upgrades that don't have activation heights yet
         if let Some(height) = height {
             assert_eq!(
-                ConsensusBranchId::current(network, height),
+                ConsensusBranchId::current(&network, height),
                 network_upgrade.branch_id()
             );
         }
diff --git a/zebra-chain/src/primitives/address.rs b/zebra-chain/src/primitives/address.rs
index be0b8587d09..553e523b780 100644
--- a/zebra-chain/src/primitives/address.rs
+++ b/zebra-chain/src/primitives/address.rs
@@ -53,8 +53,8 @@ impl TryFrom<zcash_address::Network> for Network {
     }
 }
 
-impl From<Network> for zcash_address::Network {
-    fn from(network: Network) -> Self {
+impl From<&Network> for zcash_address::Network {
+    fn from(network: &Network) -> Self {
         match network {
             Network::Mainnet => zcash_address::Network::Main,
             Network::Testnet => zcash_address::Network::Test,
@@ -71,7 +71,7 @@ impl zcash_address::TryFromAddress for Address {
         data: [u8; 20],
     ) -> Result<Self, zcash_address::ConversionError<Self::Error>> {
         Ok(Self::Transparent(transparent::Address::from_pub_key_hash(
-            network.try_into()?,
+            &network.try_into()?,
             data,
         )))
     }
@@ -81,7 +81,7 @@ impl zcash_address::TryFromAddress for Address {
         data: [u8; 20],
     ) -> Result<Self, zcash_address::ConversionError<Self::Error>> {
         Ok(Self::Transparent(transparent::Address::from_script_hash(
-            network.try_into()?,
+            &network.try_into()?,
             data,
         )))
     }
@@ -100,7 +100,7 @@ impl zcash_address::TryFromAddress for Address {
         network: zcash_address::Network,
         unified_address: zcash_address::unified::Address,
     ) -> Result<Self, zcash_address::ConversionError<Self::Error>> {
-        let network = network.try_into()?;
+        let network = &network.try_into()?;
         let mut orchard = None;
         let mut sapling = None;
         let mut transparent = None;
@@ -144,7 +144,7 @@ impl zcash_address::TryFromAddress for Address {
         }
 
         Ok(Self::Unified {
-            network,
+            network: network.clone(),
             unified_address,
             orchard,
             sapling,
@@ -158,7 +158,7 @@ impl Address {
     pub fn network(&self) -> Network {
         match &self {
             Self::Transparent(address) => address.network(),
-            Self::Sapling { network, .. } | Self::Unified { network, .. } => *network,
+            Self::Sapling { network, .. } | Self::Unified { network, .. } => network.clone(),
         }
     }
 
@@ -185,7 +185,7 @@ impl Address {
             Self::Transparent(address) => Some(address.to_string()),
             Self::Sapling { address, network } => {
                 let data = address.to_bytes();
-                let address = ZcashAddress::from_sapling((*network).into(), data);
+                let address = ZcashAddress::from_sapling(network.into(), data);
                 Some(address.encode())
             }
             Self::Unified { .. } => None,
diff --git a/zebra-chain/src/primitives/viewing_key.rs b/zebra-chain/src/primitives/viewing_key.rs
index 3a34d534dc6..e59498b72d3 100644
--- a/zebra-chain/src/primitives/viewing_key.rs
+++ b/zebra-chain/src/primitives/viewing_key.rs
@@ -25,19 +25,19 @@ impl ViewingKey {
     /// Accepts an encoded Sapling viewing key to decode
     ///
     /// Returns a [`ViewingKey`] if successful, or None otherwise
-    fn parse_sapling(sapling_key: &str, network: Network) -> Option<Self> {
+    fn parse_sapling(sapling_key: &str, network: &Network) -> Option<Self> {
         SaplingViewingKey::parse(sapling_key, network).map(Self::Sapling)
     }
 
     /// Accepts an encoded Orchard viewing key to decode
     ///
     /// Returns a [`ViewingKey`] if successful, or None otherwise
-    fn parse_orchard(sapling_key: &str, network: Network) -> Option<Self> {
+    fn parse_orchard(sapling_key: &str, network: &Network) -> Option<Self> {
         OrchardViewingKey::parse(sapling_key, network).map(Self::Orchard)
     }
 
     /// Parses an encoded viewing key and returns it as a [`ViewingKey`] type.
-    pub fn parse(key: &str, network: Network) -> Option<Self> {
+    pub fn parse(key: &str, network: &Network) -> Option<Self> {
         Self::parse_sapling(key, network).or_else(|| Self::parse_orchard(key, network))
     }
 }
diff --git a/zebra-chain/src/primitives/viewing_key/orchard.rs b/zebra-chain/src/primitives/viewing_key/orchard.rs
index ddb0664be2a..140331a496e 100644
--- a/zebra-chain/src/primitives/viewing_key/orchard.rs
+++ b/zebra-chain/src/primitives/viewing_key/orchard.rs
@@ -10,7 +10,7 @@ impl OrchardViewingKey {
     /// Accepts an encoded Orchard viewing key to decode
     ///
     /// Returns a [`OrchardViewingKey`] if successful, or None otherwise
-    pub fn parse(_key: &str, _network: Network) -> Option<Self> {
+    pub fn parse(_key: &str, _network: &Network) -> Option<Self> {
         // TODO: parse Orchard viewing keys
         None
     }
diff --git a/zebra-chain/src/primitives/viewing_key/sapling.rs b/zebra-chain/src/primitives/viewing_key/sapling.rs
index 0b699706c81..e8d423a7fc0 100644
--- a/zebra-chain/src/primitives/viewing_key/sapling.rs
+++ b/zebra-chain/src/primitives/viewing_key/sapling.rs
@@ -26,7 +26,7 @@ impl SaplingViewingKey {
     /// Accepts an encoded Sapling extended full viewing key to decode
     ///
     /// Returns a [`SaplingViewingKey::Dfvk`] if successful, or None otherwise
-    fn parse_extended_full_viewing_key(sapling_key: &str, network: Network) -> Option<Self> {
+    fn parse_extended_full_viewing_key(sapling_key: &str, network: &Network) -> Option<Self> {
         decode_extended_full_viewing_key(network.sapling_efvk_hrp(), sapling_key)
             // this should fail often, so a debug-level log is okay
             .map_err(|err| debug!(?err, "could not decode Sapling extended full viewing key"))
@@ -38,7 +38,10 @@ impl SaplingViewingKey {
     /// Accepts an encoded Sapling diversifiable full viewing key to decode
     ///
     /// Returns a [`SaplingViewingKey::Dfvk`] if successful, or None otherwise
-    fn parse_diversifiable_full_viewing_key(_sapling_key: &str, _network: Network) -> Option<Self> {
+    fn parse_diversifiable_full_viewing_key(
+        _sapling_key: &str,
+        _network: &Network,
+    ) -> Option<Self> {
         // TODO: Parse Sapling diversifiable full viewing key
         None
     }
@@ -46,7 +49,7 @@ impl SaplingViewingKey {
     /// Accepts an encoded Sapling full viewing key to decode
     ///
     /// Returns a [`SaplingViewingKey::Fvk`] if successful, or None otherwise
-    fn parse_full_viewing_key(_sapling_key: &str, _network: Network) -> Option<Self> {
+    fn parse_full_viewing_key(_sapling_key: &str, _network: &Network) -> Option<Self> {
         // TODO: Parse Sapling full viewing key
         None
     }
@@ -54,7 +57,7 @@ impl SaplingViewingKey {
     /// Accepts an encoded Sapling incoming viewing key to decode
     ///
     /// Returns a [`SaplingViewingKey::Ivk`] if successful, or None otherwise
-    fn parse_incoming_viewing_key(_sapling_key: &str, _network: Network) -> Option<Self> {
+    fn parse_incoming_viewing_key(_sapling_key: &str, _network: &Network) -> Option<Self> {
         // TODO: Parse Sapling incoming viewing key
         None
     }
@@ -62,7 +65,7 @@ impl SaplingViewingKey {
     /// Accepts an encoded Sapling viewing key to decode
     ///
     /// Returns a [`SaplingViewingKey`] if successful, or None otherwise
-    pub(super) fn parse(key: &str, network: Network) -> Option<Self> {
+    pub(super) fn parse(key: &str, network: &Network) -> Option<Self> {
         // TODO: Try types with prefixes first if some don't have prefixes?
         Self::parse_extended_full_viewing_key(key, network)
             .or_else(|| Self::parse_diversifiable_full_viewing_key(key, network))
diff --git a/zebra-chain/src/primitives/viewing_key/tests.rs b/zebra-chain/src/primitives/viewing_key/tests.rs
index 0b86c143131..a073f484e34 100644
--- a/zebra-chain/src/primitives/viewing_key/tests.rs
+++ b/zebra-chain/src/primitives/viewing_key/tests.rs
@@ -10,6 +10,6 @@ pub const ZECPAGES_SAPLING_VIEWING_KEY: &str = "zxviews1q0duytgcqqqqpqre26wkl45g
 fn parses_sapling_efvk_correctly() {
     let _init_guard = zebra_test::init();
 
-    ViewingKey::parse(ZECPAGES_SAPLING_VIEWING_KEY, Network::Mainnet)
+    ViewingKey::parse(ZECPAGES_SAPLING_VIEWING_KEY, &Network::Mainnet)
         .expect("should parse hard-coded viewing key successfully");
 }
diff --git a/zebra-chain/src/primitives/zcash_history.rs b/zebra-chain/src/primitives/zcash_history.rs
index 82cd4ff1109..8642343da5f 100644
--- a/zebra-chain/src/primitives/zcash_history.rs
+++ b/zebra-chain/src/primitives/zcash_history.rs
@@ -23,7 +23,7 @@ pub trait Version: zcash_history::Version {
     /// Convert a Block into the NodeData for this version.
     fn block_to_history_node(
         block: Arc<Block>,
-        network: Network,
+        network: &Network,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
     ) -> Self::NodeData;
@@ -75,7 +75,7 @@ impl Entry {
     ///  (ignored for V1 trees).
     fn new_leaf<V: Version>(
         block: Arc<Block>,
-        network: Network,
+        network: &Network,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
     ) -> Self {
@@ -106,7 +106,7 @@ impl<V: Version> Tree<V> {
     /// Will panic if `peaks` is empty.
     #[allow(clippy::unwrap_in_result)]
     pub fn new_from_cache(
-        network: Network,
+        network: &Network,
         network_upgrade: NetworkUpgrade,
         length: u32,
         peaks: &BTreeMap<u32, Entry>,
@@ -127,7 +127,7 @@ impl<V: Version> Tree<V> {
         }
         let inner = zcash_history::Tree::new(length, peaks_vec, extra_vec);
         Ok(Tree {
-            network,
+            network: network.clone(),
             network_upgrade,
             inner,
         })
@@ -140,7 +140,7 @@ impl<V: Version> Tree<V> {
     ///  (ignored for V1 trees).
     #[allow(clippy::unwrap_in_result)]
     pub fn new_from_block(
-        network: Network,
+        network: &Network,
         block: Arc<Block>,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
@@ -182,7 +182,7 @@ impl<V: Version> Tree<V> {
         let height = block
             .coinbase_height()
             .expect("block must have coinbase height during contextual verification");
-        let network_upgrade = NetworkUpgrade::current(self.network, height);
+        let network_upgrade = NetworkUpgrade::current(&self.network, height);
 
         assert!(
             network_upgrade == self.network_upgrade,
@@ -191,7 +191,7 @@ impl<V: Version> Tree<V> {
             self.network_upgrade
         );
 
-        let node_data = V::block_to_history_node(block, self.network, sapling_root, orchard_root);
+        let node_data = V::block_to_history_node(block, &self.network, sapling_root, orchard_root);
         let appended = self.inner.append_leaf(node_data)?;
 
         let mut new_nodes = Vec::new();
@@ -233,7 +233,7 @@ impl Version for zcash_history::V1 {
     /// `orchard_root` is ignored.
     fn block_to_history_node(
         block: Arc<Block>,
-        network: Network,
+        network: &Network,
         sapling_root: &sapling::tree::Root,
         _orchard_root: &orchard::tree::Root,
     ) -> Self::NodeData {
@@ -300,7 +300,7 @@ impl Version for V2 {
     /// `orchard_root` is the root of the Orchard note commitment tree of the block.
     fn block_to_history_node(
         block: Arc<Block>,
-        network: Network,
+        network: &Network,
         sapling_root: &sapling::tree::Root,
         orchard_root: &orchard::tree::Root,
     ) -> Self::NodeData {
diff --git a/zebra-chain/src/primitives/zcash_history/tests/vectors.rs b/zebra-chain/src/primitives/zcash_history/tests/vectors.rs
index 4d986ed78ba..b5ead10982f 100644
--- a/zebra-chain/src/primitives/zcash_history/tests/vectors.rs
+++ b/zebra-chain/src/primitives/zcash_history/tests/vectors.rs
@@ -11,14 +11,14 @@ use eyre::Result;
 /// and its next block.
 #[test]
 fn tree() -> Result<()> {
-    tree_for_network_upgrade(Network::Mainnet, NetworkUpgrade::Heartwood)?;
-    tree_for_network_upgrade(Network::Testnet, NetworkUpgrade::Heartwood)?;
-    tree_for_network_upgrade(Network::Mainnet, NetworkUpgrade::Canopy)?;
-    tree_for_network_upgrade(Network::Testnet, NetworkUpgrade::Canopy)?;
+    tree_for_network_upgrade(&Network::Mainnet, NetworkUpgrade::Heartwood)?;
+    tree_for_network_upgrade(&Network::Testnet, NetworkUpgrade::Heartwood)?;
+    tree_for_network_upgrade(&Network::Mainnet, NetworkUpgrade::Canopy)?;
+    tree_for_network_upgrade(&Network::Testnet, NetworkUpgrade::Canopy)?;
     Ok(())
 }
 
-fn tree_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) -> Result<()> {
+fn tree_for_network_upgrade(network: &Network, network_upgrade: NetworkUpgrade) -> Result<()> {
     let (blocks, sapling_roots) = network.block_sapling_roots_map();
 
     let height = network_upgrade.activation_height(network).unwrap().0;
diff --git a/zebra-chain/src/primitives/zcash_note_encryption.rs b/zebra-chain/src/primitives/zcash_note_encryption.rs
index 0760c9f3750..0870dac5680 100644
--- a/zebra-chain/src/primitives/zcash_note_encryption.rs
+++ b/zebra-chain/src/primitives/zcash_note_encryption.rs
@@ -15,7 +15,7 @@ use crate::{
 ///
 /// If passed a network/height without matching consensus branch ID (pre-Overwinter),
 /// since `librustzcash` won't be able to parse it.
-pub fn decrypts_successfully(transaction: &Transaction, network: Network, height: Height) -> bool {
+pub fn decrypts_successfully(transaction: &Transaction, network: &Network, height: Height) -> bool {
     let network_upgrade = NetworkUpgrade::current(network, height);
     let alt_tx = convert_tx_to_librustzcash(transaction, network_upgrade)
         .expect("zcash_primitives and Zebra transaction formats must be compatible");
diff --git a/zebra-chain/src/primitives/zcash_primitives.rs b/zebra-chain/src/primitives/zcash_primitives.rs
index a9fbd9f4b95..c4e439184e2 100644
--- a/zebra-chain/src/primitives/zcash_primitives.rs
+++ b/zebra-chain/src/primitives/zcash_primitives.rs
@@ -319,7 +319,7 @@ pub(crate) fn auth_digest(trans: &Transaction) -> AuthDigest {
 /// Returns None if the address type is not valid or unrecognized.
 pub(crate) fn transparent_output_address(
     output: &transparent::Output,
-    network: Network,
+    network: &Network,
 ) -> Option<transparent::Address> {
     let tx_out = zp_tx::components::TxOut::try_from(output)
         .expect("zcash_primitives and Zebra transparent output formats must be compatible");
@@ -337,8 +337,8 @@ pub(crate) fn transparent_output_address(
     }
 }
 
-impl From<Network> for zcash_primitives::consensus::Network {
-    fn from(network: Network) -> Self {
+impl From<&Network> for zcash_primitives::consensus::Network {
+    fn from(network: &Network) -> Self {
         match network {
             Network::Mainnet => zcash_primitives::consensus::Network::MainNetwork,
             Network::Testnet => zcash_primitives::consensus::Network::TestNetwork,
diff --git a/zebra-chain/src/sapling/tests/tree.rs b/zebra-chain/src/sapling/tests/tree.rs
index 7ea22c4ce74..17ee640f00b 100644
--- a/zebra-chain/src/sapling/tests/tree.rs
+++ b/zebra-chain/src/sapling/tests/tree.rs
@@ -60,7 +60,7 @@ fn incremental_roots_with_blocks_for_network(network: Network) -> Result<()> {
     let (blocks, sapling_roots) = network.block_sapling_roots_map();
 
     let height = NetworkUpgrade::Sapling
-        .activation_height(network)
+        .activation_height(&network)
         .unwrap()
         .0;
 
diff --git a/zebra-chain/src/sprout/tests/tree.rs b/zebra-chain/src/sprout/tests/tree.rs
index 61185a5dcfb..f71c8c6a3f2 100644
--- a/zebra-chain/src/sprout/tests/tree.rs
+++ b/zebra-chain/src/sprout/tests/tree.rs
@@ -91,7 +91,7 @@ fn incremental_roots_with_blocks_for_network(network: Network) -> Result<()> {
 
     // Load the Genesis height.
     let genesis_height = NetworkUpgrade::Genesis
-        .activation_height(network)
+        .activation_height(&network)
         .unwrap()
         .0;
 
diff --git a/zebra-chain/src/transaction/arbitrary.rs b/zebra-chain/src/transaction/arbitrary.rs
index df914c208e9..f459af7f477 100644
--- a/zebra-chain/src/transaction/arbitrary.rs
+++ b/zebra-chain/src/transaction/arbitrary.rs
@@ -46,7 +46,7 @@ impl Transaction {
     /// Generate a proptest strategy for V1 Transactions
     pub fn v1_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self> {
         (
-            transparent::Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS),
+            transparent::Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS),
             vec(any::<transparent::Output>(), 0..MAX_ARBITRARY_ITEMS),
             any::<LockTime>(),
         )
@@ -61,7 +61,7 @@ impl Transaction {
     /// Generate a proptest strategy for V2 Transactions
     pub fn v2_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self> {
         (
-            transparent::Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS),
+            transparent::Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS),
             vec(any::<transparent::Output>(), 0..MAX_ARBITRARY_ITEMS),
             any::<LockTime>(),
             option::of(any::<JoinSplitData<Bctv14Proof>>()),
@@ -80,7 +80,7 @@ impl Transaction {
     /// Generate a proptest strategy for V3 Transactions
     pub fn v3_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self> {
         (
-            transparent::Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS),
+            transparent::Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS),
             vec(any::<transparent::Output>(), 0..MAX_ARBITRARY_ITEMS),
             any::<LockTime>(),
             any::<block::Height>(),
@@ -101,7 +101,7 @@ impl Transaction {
     /// Generate a proptest strategy for V4 Transactions
     pub fn v4_strategy(ledger_state: LedgerState) -> BoxedStrategy<Self> {
         (
-            transparent::Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS),
+            transparent::Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS),
             vec(any::<transparent::Output>(), 0..MAX_ARBITRARY_ITEMS),
             any::<LockTime>(),
             any::<block::Height>(),
@@ -146,7 +146,7 @@ impl Transaction {
             NetworkUpgrade::branch_id_strategy(),
             any::<LockTime>(),
             any::<block::Height>(),
-            transparent::Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS),
+            transparent::Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS),
             vec(any::<transparent::Output>(), 0..MAX_ARBITRARY_ITEMS),
             option::of(any::<sapling::ShieldedData<sapling::SharedAnchor>>()),
             option::of(any::<orchard::ShieldedData>()),
@@ -196,7 +196,7 @@ impl Transaction {
         len: usize,
     ) -> BoxedStrategy<Vec<Arc<Self>>> {
         // TODO: fixup coinbase miner subsidy
-        let coinbase = Transaction::arbitrary_with(ledger_state).prop_map(Arc::new);
+        let coinbase = Transaction::arbitrary_with(ledger_state.clone()).prop_map(Arc::new);
         ledger_state.has_coinbase = false;
         let remainder = vec(
             Transaction::arbitrary_with(ledger_state).prop_map(Arc::new),
@@ -787,7 +787,7 @@ impl Arbitrary for Transaction {
                 Self::v4_strategy(ledger_state)
             }
             NetworkUpgrade::Nu5 => prop_oneof![
-                Self::v4_strategy(ledger_state),
+                Self::v4_strategy(ledger_state.clone()),
                 Self::v5_strategy(ledger_state)
             ]
             .boxed(),
@@ -859,7 +859,7 @@ impl Arbitrary for VerifiedUnminedTx {
 /// converting sapling shielded data from v4 to v5 if possible.
 pub fn transaction_to_fake_v5(
     trans: &Transaction,
-    network: Network,
+    network: &Network,
     height: block::Height,
 ) -> Transaction {
     use Transaction::*;
@@ -993,7 +993,7 @@ fn sapling_spend_v4_to_fake_v5(
 
 /// Iterate over V4 transactions in the block test vectors for the specified `network`.
 pub fn test_transactions(
-    network: Network,
+    network: &Network,
 ) -> impl DoubleEndedIterator<Item = (block::Height, Arc<Transaction>)> {
     let blocks = network.block_iter();
 
@@ -1005,7 +1005,7 @@ pub fn test_transactions(
 /// These transactions are converted from non-V5 transactions that exist in the provided network
 /// blocks.
 pub fn fake_v5_transactions_for_network<'b>(
-    network: Network,
+    network: &'b Network,
     blocks: impl DoubleEndedIterator<Item = (&'b u32, &'b &'static [u8])> + 'b,
 ) -> impl DoubleEndedIterator<Item = Transaction> + 'b {
     transactions_from_blocks(blocks)
diff --git a/zebra-chain/src/transaction/builder.rs b/zebra-chain/src/transaction/builder.rs
index ab1eca500a9..37397353aab 100644
--- a/zebra-chain/src/transaction/builder.rs
+++ b/zebra-chain/src/transaction/builder.rs
@@ -12,7 +12,7 @@ impl Transaction {
     /// Returns a new version 5 coinbase transaction for `network` and `height`,
     /// which contains the specified `outputs`.
     pub fn new_v5_coinbase(
-        network: Network,
+        network: &Network,
         height: Height,
         outputs: impl IntoIterator<Item = (Amount<NonNegative>, transparent::Script)>,
         extra_coinbase_data: Vec<u8>,
@@ -109,7 +109,7 @@ impl Transaction {
     /// If `like_zcashd` is true, try to match the coinbase transactions generated by `zcashd`
     /// in the `getblocktemplate` RPC.
     pub fn new_v4_coinbase(
-        _network: Network,
+        _network: &Network,
         height: Height,
         outputs: impl IntoIterator<Item = (Amount<NonNegative>, transparent::Script)>,
         like_zcashd: bool,
diff --git a/zebra-chain/src/transaction/tests/prop.rs b/zebra-chain/src/transaction/tests/prop.rs
index 1a655adf545..09a9dbeac7e 100644
--- a/zebra-chain/src/transaction/tests/prop.rs
+++ b/zebra-chain/src/transaction/tests/prop.rs
@@ -150,13 +150,13 @@ fn transaction_valid_network_upgrade_strategy() -> Result<()> {
     // Update with new transaction versions as needed
     let strategy = LedgerState::coinbase_strategy(None, 5, true).prop_flat_map(|ledger_state| {
         (
-            Just(ledger_state.network),
+            Just(ledger_state.network.clone()),
             Block::arbitrary_with(ledger_state),
         )
     });
 
     proptest!(|((network, block) in strategy)| {
-        block.check_transaction_network_upgrade_consistency(network)?;
+        block.check_transaction_network_upgrade_consistency(&network)?;
     });
 
     Ok(())
diff --git a/zebra-chain/src/transaction/tests/vectors.rs b/zebra-chain/src/transaction/tests/vectors.rs
index cfac4898b25..129565a6ce9 100644
--- a/zebra-chain/src/transaction/tests/vectors.rs
+++ b/zebra-chain/src/transaction/tests/vectors.rs
@@ -352,7 +352,7 @@ fn fake_v5_round_trip_for_network(network: Network) {
     let block_iter = network.block_iter();
 
     let overwinter_activation_height = NetworkUpgrade::Overwinter
-        .activation_height(network)
+        .activation_height(&network)
         .expect("a valid height")
         .0;
 
@@ -380,7 +380,7 @@ fn fake_v5_round_trip_for_network(network: Network) {
             .transactions
             .iter()
             .map(AsRef::as_ref)
-            .map(|t| arbitrary::transaction_to_fake_v5(t, network, Height(*height)))
+            .map(|t| arbitrary::transaction_to_fake_v5(t, &network, Height(*height)))
             .map(Into::into)
             .collect();
 
@@ -500,12 +500,12 @@ fn fake_v5_librustzcash_round_trip_for_network(network: Network) {
     let block_iter = network.block_iter();
 
     let overwinter_activation_height = NetworkUpgrade::Overwinter
-        .activation_height(network)
+        .activation_height(&network)
         .expect("a valid height")
         .0;
 
     let nu5_activation_height = NetworkUpgrade::Nu5
-        .activation_height(network)
+        .activation_height(&network)
         .unwrap_or(Height::MAX_EXPIRY_HEIGHT)
         .0;
 
@@ -525,7 +525,7 @@ fn fake_v5_librustzcash_round_trip_for_network(network: Network) {
             .transactions
             .iter()
             .map(AsRef::as_ref)
-            .map(|t| arbitrary::transaction_to_fake_v5(t, network, Height(*height)))
+            .map(|t| arbitrary::transaction_to_fake_v5(t, &network, Height(*height)))
             .map(Into::into)
             .collect();
 
@@ -940,7 +940,7 @@ fn binding_signatures_for_network(network: Network) {
     let block_iter = network.block_iter();
 
     for (height, bytes) in block_iter {
-        let upgrade = NetworkUpgrade::current(network, Height(*height));
+        let upgrade = NetworkUpgrade::current(&network, Height(*height));
 
         let block = bytes
             .zcash_deserialize_into::<Block>()
diff --git a/zebra-chain/src/transparent.rs b/zebra-chain/src/transparent.rs
index 7982468288c..55f45beb92d 100644
--- a/zebra-chain/src/transparent.rs
+++ b/zebra-chain/src/transparent.rs
@@ -426,7 +426,7 @@ impl Output {
     /// Return the destination address from a transparent output.
     ///
     /// Returns None if the address type is not valid or unrecognized.
-    pub fn address(&self, network: Network) -> Option<Address> {
+    pub fn address(&self, network: &Network) -> Option<Address> {
         zcash_primitives::transparent_output_address(self, network)
     }
 }
diff --git a/zebra-chain/src/transparent/address.rs b/zebra-chain/src/transparent/address.rs
index 5fb203baf35..0c7ab62deed 100644
--- a/zebra-chain/src/transparent/address.rs
+++ b/zebra-chain/src/transparent/address.rs
@@ -27,7 +27,7 @@ use proptest::prelude::*;
 ///
 /// <https://zips.z.cash/protocol/protocol.pdf#transparentaddrencoding>
 #[derive(
-    Copy, Clone, Eq, PartialEq, Hash, serde_with::SerializeDisplay, serde_with::DeserializeFromStr,
+    Clone, Eq, PartialEq, Hash, serde_with::SerializeDisplay, serde_with::DeserializeFromStr,
 )]
 #[cfg_attr(
     any(test, feature = "proptest-impl"),
@@ -183,26 +183,26 @@ impl ToAddressWithNetwork for PublicKey {
 
 impl Address {
     /// Create an address for the given public key hash and network.
-    pub fn from_pub_key_hash(network: Network, pub_key_hash: [u8; 20]) -> Self {
+    pub fn from_pub_key_hash(network: &Network, pub_key_hash: [u8; 20]) -> Self {
         Self::PayToPublicKeyHash {
-            network,
+            network: network.clone(),
             pub_key_hash,
         }
     }
 
     /// Create an address for the given script hash and network.
-    pub fn from_script_hash(network: Network, script_hash: [u8; 20]) -> Self {
+    pub fn from_script_hash(network: &Network, script_hash: [u8; 20]) -> Self {
         Self::PayToScriptHash {
-            network,
+            network: network.clone(),
             script_hash,
         }
     }
 
     /// Returns the network for this address.
     pub fn network(&self) -> Network {
-        match *self {
-            Address::PayToScriptHash { network, .. } => network,
-            Address::PayToPublicKeyHash { network, .. } => network,
+        match self {
+            Address::PayToScriptHash { network, .. } => network.clone(),
+            Address::PayToPublicKeyHash { network, .. } => network.clone(),
         }
     }
 
diff --git a/zebra-chain/src/transparent/arbitrary.rs b/zebra-chain/src/transparent/arbitrary.rs
index 02c2d50cbd5..f7678bdc808 100644
--- a/zebra-chain/src/transparent/arbitrary.rs
+++ b/zebra-chain/src/transparent/arbitrary.rs
@@ -6,7 +6,7 @@ use super::{CoinbaseData, Input, OutPoint, Script, GENESIS_COINBASE_DATA};
 
 impl Input {
     /// Construct a strategy for creating valid-ish vecs of Inputs.
-    pub fn vec_strategy(ledger_state: LedgerState, max_size: usize) -> BoxedStrategy<Vec<Self>> {
+    pub fn vec_strategy(ledger_state: &LedgerState, max_size: usize) -> BoxedStrategy<Vec<Self>> {
         if ledger_state.has_coinbase {
             Self::arbitrary_with(Some(ledger_state.height))
                 .prop_map(|input| vec![input])
diff --git a/zebra-chain/src/transparent/tests/prop.rs b/zebra-chain/src/transparent/tests/prop.rs
index db677295c28..5d3f586d298 100644
--- a/zebra-chain/src/transparent/tests/prop.rs
+++ b/zebra-chain/src/transparent/tests/prop.rs
@@ -31,7 +31,7 @@ fn input_coinbase_vecs_only_have_coinbase_input() -> Result<()> {
     let _init_guard = zebra_test::init();
 
     let strategy = LedgerState::coinbase_strategy(None, None, false)
-        .prop_flat_map(|ledger_state| Input::vec_strategy(ledger_state, MAX_ARBITRARY_ITEMS));
+        .prop_flat_map(|ledger_state| Input::vec_strategy(&ledger_state, MAX_ARBITRARY_ITEMS));
 
     proptest!(|(inputs in strategy.prop_map(SummaryDebug))| {
         let len = inputs.len();
diff --git a/zebra-chain/src/transparent/tests/vectors.rs b/zebra-chain/src/transparent/tests/vectors.rs
index b0a43e665eb..d3ceae41309 100644
--- a/zebra-chain/src/transparent/tests/vectors.rs
+++ b/zebra-chain/src/transparent/tests/vectors.rs
@@ -64,17 +64,17 @@ fn get_transparent_output_address() -> Result<()> {
     // for the prefixes.
 
     // Script hash 1b8a9bda4b62cd0d0582b55455d0778c86f8628f
-    let addr = transparent_output_address(&transaction.outputs()[0], Network::Mainnet)
+    let addr = transparent_output_address(&transaction.outputs()[0], &Network::Mainnet)
         .expect("should return address");
     assert_eq!(addr.to_string(), "t3M5FDmPfWNRG3HRLddbicsuSCvKuk9hxzZ");
-    let addr = transparent_output_address(&transaction.outputs()[0], Network::Testnet)
+    let addr = transparent_output_address(&transaction.outputs()[0], &Network::Testnet)
         .expect("should return address");
     assert_eq!(addr.to_string(), "t294SGSVoNq2daz15ZNbmAW65KQZ5e3nN5G");
     // Public key hash e4ff5512ffafe9287992a1cd177ca6e408e03003
-    let addr = transparent_output_address(&transaction.outputs()[1], Network::Mainnet)
+    let addr = transparent_output_address(&transaction.outputs()[1], &Network::Mainnet)
         .expect("should return address");
     assert_eq!(addr.to_string(), "t1ekRwsd4LaSsd6NXgsx66q2HxQWTLCF44y");
-    let addr = transparent_output_address(&transaction.outputs()[1], Network::Testnet)
+    let addr = transparent_output_address(&transaction.outputs()[1], &Network::Testnet)
         .expect("should return address");
     assert_eq!(addr.to_string(), "tmWbBGi7TjExNmLZyMcFpxVh3ZPbGrpbX3H");
 
@@ -103,7 +103,7 @@ fn get_transparent_output_address_with_blocks_for_network(network: Network) {
 
         for (idx, tx) in block.transactions.iter().enumerate() {
             for output in tx.outputs() {
-                let addr = output.address(network);
+                let addr = output.address(&network);
                 if addr.is_none() && idx == 0 && output.lock_script.as_raw_bytes()[0] == 0x21 {
                     // There are a bunch of coinbase transactions with pay-to-pubkey scripts
                     // which we don't support; skip them
diff --git a/zebra-chain/src/work/difficulty/tests/vectors.rs b/zebra-chain/src/work/difficulty/tests/vectors.rs
index e18b1541737..9f9c0354458 100644
--- a/zebra-chain/src/work/difficulty/tests/vectors.rs
+++ b/zebra-chain/src/work/difficulty/tests/vectors.rs
@@ -454,7 +454,7 @@ fn check_testnet_minimum_difficulty_block(height: block::Height) -> Result<(), R
         // threshold, as documented in ZIP-205 and ZIP-208:
         // https://zips.z.cash/zip-0205#change-to-difficulty-adjustment-on-testnet
         // https://zips.z.cash/zip-0208#minimum-difficulty-blocks-on-testnet
-        match NetworkUpgrade::minimum_difficulty_spacing_for_height(Network::Testnet, height) {
+        match NetworkUpgrade::minimum_difficulty_spacing_for_height(&Network::Testnet, height) {
             None => Err(eyre!("the minimum difficulty rule is not active"))?,
             Some(spacing) if (time_gap <= spacing) => Err(eyre!(
                 "minimum difficulty block times must be more than 6 target spacing intervals apart"
diff --git a/zebra-consensus/src/block.rs b/zebra-consensus/src/block.rs
index 970cf4118aa..82304a27896 100644
--- a/zebra-consensus/src/block.rs
+++ b/zebra-consensus/src/block.rs
@@ -108,9 +108,9 @@ where
     V::Future: Send + 'static,
 {
     /// Creates a new SemanticBlockVerifier
-    pub fn new(network: Network, state_service: S, transaction_verifier: V) -> Self {
+    pub fn new(network: &Network, state_service: S, transaction_verifier: V) -> Self {
         Self {
-            network,
+            network: network.clone(),
             state_service,
             transaction_verifier,
         }
@@ -139,7 +139,7 @@ where
     fn call(&mut self, request: Request) -> Self::Future {
         let mut state_service = self.state_service.clone();
         let mut transaction_verifier = self.transaction_verifier.clone();
-        let network = self.network;
+        let network = self.network.clone();
 
         let block = request.block();
 
@@ -180,11 +180,11 @@ where
             // > acceptance rules (excluding the check for a valid proof-of-work).
             // <https://en.bitcoin.it/wiki/BIP_0023#Block_Proposal>
             if request.is_proposal() {
-                check::difficulty_threshold_is_valid(&block.header, network, &height, &hash)?;
+                check::difficulty_threshold_is_valid(&block.header, &network, &height, &hash)?;
             } else {
                 // Do the difficulty checks first, to raise the threshold for
                 // attacks that use any other fields.
-                check::difficulty_is_valid(&block.header, network, &height, &hash)?;
+                check::difficulty_is_valid(&block.header, &network, &height, &hash)?;
                 check::equihash_solution_is_valid(&block.header)?;
             }
 
@@ -195,7 +195,7 @@ where
             let transaction_hashes: Arc<[_]> =
                 block.transactions.iter().map(|t| t.hash()).collect();
 
-            check::merkle_root_validity(network, &block, &transaction_hashes)?;
+            check::merkle_root_validity(&network, &block, &transaction_hashes)?;
 
             // Since errors cause an early exit, try to do the
             // quick checks first.
@@ -205,12 +205,12 @@ where
             check::time_is_valid_at(&block.header, now, &height, &hash)
                 .map_err(VerifyBlockError::Time)?;
             let coinbase_tx = check::coinbase_is_first(&block)?;
-            check::subsidy_is_valid(&block, network)?;
+            check::subsidy_is_valid(&block, &network)?;
 
             // Now do the slower checks
 
             // Check compatibility with ZIP-212 shielded Sapling and Orchard coinbase output decryption
-            tx::check::coinbase_outputs_are_decryptable(&coinbase_tx, network, height)?;
+            tx::check::coinbase_outputs_are_decryptable(&coinbase_tx, &network, height)?;
 
             // Send transactions to the transaction verifier to be checked
             let mut async_checks = FuturesUnordered::new();
@@ -277,7 +277,7 @@ where
                     hash,
                     source: amount_error,
                 })?;
-            check::miner_fees_are_valid(&block, network, block_miner_fees)?;
+            check::miner_fees_are_valid(&block, &network, block_miner_fees)?;
 
             // Finally, submit the block for contextual verification.
             let new_outputs = Arc::into_inner(known_utxos)
diff --git a/zebra-consensus/src/block/check.rs b/zebra-consensus/src/block/check.rs
index 319fa5004c5..797df65c5b9 100644
--- a/zebra-consensus/src/block/check.rs
+++ b/zebra-consensus/src/block/check.rs
@@ -67,7 +67,7 @@ pub fn coinbase_is_first(block: &Block) -> Result<Arc<transaction::Transaction>,
 /// If the header difficulty threshold is invalid, returns an error containing `height` and `hash`.
 pub fn difficulty_threshold_is_valid(
     header: &Header,
-    network: Network,
+    network: &Network,
     height: &Height,
     hash: &Hash,
 ) -> Result<ExpandedDifficulty, BlockError> {
@@ -86,7 +86,7 @@ pub fn difficulty_threshold_is_valid(
             *height,
             *hash,
             difficulty_threshold,
-            network,
+            network.clone(),
             network.target_difficulty_limit(),
         ))?;
     }
@@ -102,7 +102,7 @@ pub fn difficulty_threshold_is_valid(
 /// If the block is invalid, returns an error containing `height` and `hash`.
 pub fn difficulty_is_valid(
     header: &Header,
-    network: Network,
+    network: &Network,
     height: &Height,
     hash: &Hash,
 ) -> Result<(), BlockError> {
@@ -123,7 +123,7 @@ pub fn difficulty_is_valid(
             *height,
             *hash,
             difficulty_threshold,
-            network,
+            network.clone(),
         ))?;
     }
 
@@ -143,7 +143,7 @@ pub fn equihash_solution_is_valid(header: &Header) -> Result<(), equihash::Error
 /// Returns `Ok(())` if the block subsidy in `block` is valid for `network`
 ///
 /// [3.9]: https://zips.z.cash/protocol/protocol.pdf#subsidyconcepts
-pub fn subsidy_is_valid(block: &Block, network: Network) -> Result<(), BlockError> {
+pub fn subsidy_is_valid(block: &Block, network: &Network) -> Result<(), BlockError> {
     let height = block.coinbase_height().ok_or(SubsidyError::NoCoinbase)?;
     let coinbase = block.transactions.first().ok_or(SubsidyError::NoCoinbase)?;
 
@@ -189,7 +189,7 @@ pub fn subsidy_is_valid(block: &Block, network: Network) -> Result<(), BlockErro
                 subsidy::funding_streams::funding_stream_address(height, network, receiver);
 
             let has_expected_output =
-                subsidy::funding_streams::filter_outputs_by_address(coinbase, address)
+                subsidy::funding_streams::filter_outputs_by_address(coinbase, &address)
                     .iter()
                     .map(zebra_chain::transparent::Output::value)
                     .any(|value| value == expected_amount);
@@ -210,7 +210,7 @@ pub fn subsidy_is_valid(block: &Block, network: Network) -> Result<(), BlockErro
 /// [7.1.2]: https://zips.z.cash/protocol/protocol.pdf#txnconsensus
 pub fn miner_fees_are_valid(
     block: &Block,
-    network: Network,
+    network: &Network,
     block_miner_fees: Amount<NonNegative>,
 ) -> Result<(), BlockError> {
     let height = block.coinbase_height().ok_or(SubsidyError::NoCoinbase)?;
@@ -289,7 +289,7 @@ pub fn time_is_valid_at(
 /// [7.1]: https://zips.z.cash/protocol/nu5.pdf#txnencodingandconsensus
 /// [7.6]: https://zips.z.cash/protocol/nu5.pdf#blockheader
 pub fn merkle_root_validity(
-    network: Network,
+    network: &Network,
     block: &Block,
     transaction_hashes: &[transaction::Hash],
 ) -> Result<(), BlockError> {
diff --git a/zebra-consensus/src/block/subsidy/funding_streams.rs b/zebra-consensus/src/block/subsidy/funding_streams.rs
index 22cfec72998..39382e7a26a 100644
--- a/zebra-consensus/src/block/subsidy/funding_streams.rs
+++ b/zebra-consensus/src/block/subsidy/funding_streams.rs
@@ -23,13 +23,13 @@ mod tests;
 /// [7.8]: https://zips.z.cash/protocol/protocol.pdf#subsidies
 pub fn funding_stream_values(
     height: Height,
-    network: Network,
+    network: &Network,
 ) -> Result<HashMap<FundingStreamReceiver, Amount<NonNegative>>, Error> {
     let canopy_height = Canopy.activation_height(network).unwrap();
     let mut results = HashMap::new();
 
     if height >= canopy_height {
-        let range = FUNDING_STREAM_HEIGHT_RANGES.get(&network).unwrap();
+        let range = FUNDING_STREAM_HEIGHT_RANGES.get(network).unwrap();
         if range.contains(&height) {
             let block_subsidy = block_subsidy(height, network)?;
             for (&receiver, &numerator) in FUNDING_STREAM_RECEIVER_NUMERATORS.iter() {
@@ -52,7 +52,7 @@ pub fn funding_stream_values(
 /// as described in [protocol specification §7.10][7.10]
 ///
 /// [7.10]: https://zips.z.cash/protocol/protocol.pdf#fundingstreams
-fn funding_stream_address_period(height: Height, network: Network) -> u32 {
+fn funding_stream_address_period(height: Height, network: &Network) -> u32 {
     // Spec equation: `address_period = floor((height - (height_for_halving(1) - post_blossom_halving_interval))/funding_stream_address_change_interval)`,
     // <https://zips.z.cash/protocol/protocol.pdf#fundingstreams>
     //
@@ -76,14 +76,14 @@ fn funding_stream_address_period(height: Height, network: Network) -> u32 {
 /// as described in [protocol specification §7.10][7.10]
 ///
 /// [7.10]: https://zips.z.cash/protocol/protocol.pdf#fundingstreams
-fn funding_stream_address_index(height: Height, network: Network) -> usize {
+fn funding_stream_address_index(height: Height, network: &Network) -> usize {
     let num_addresses = network.num_funding_streams();
 
     let index = 1u32
         .checked_add(funding_stream_address_period(height, network))
         .expect("no overflow should happen in this sum")
         .checked_sub(funding_stream_address_period(
-            FUNDING_STREAM_HEIGHT_RANGES.get(&network).unwrap().start,
+            FUNDING_STREAM_HEIGHT_RANGES.get(network).unwrap().start,
             network,
         ))
         .expect("no overflow should happen in this sub") as usize;
@@ -100,12 +100,12 @@ fn funding_stream_address_index(height: Height, network: Network) -> usize {
 /// only use transparent addresses,
 pub fn funding_stream_address(
     height: Height,
-    network: Network,
+    network: &Network,
     receiver: FundingStreamReceiver,
 ) -> transparent::Address {
     let index = funding_stream_address_index(height, network);
     let address = &FUNDING_STREAM_ADDRESSES
-        .get(&network)
+        .get(network)
         .expect("there is always another hash map as value for a given valid network")
         .get(&receiver)
         .expect("in the inner hash map there is always a vector of strings with addresses")[index];
@@ -127,7 +127,7 @@ pub fn funding_stream_recipient_info(
 /// as the given lock_script as described in [protocol specification §7.10][7.10]
 ///
 /// [7.10]: https://zips.z.cash/protocol/protocol.pdf#fundingstreams
-pub fn check_script_form(lock_script: &Script, address: transparent::Address) -> bool {
+pub fn check_script_form(lock_script: &Script, address: &transparent::Address) -> bool {
     assert!(
         address.is_script_hash(),
         "incorrect funding stream address constant: {address} \
@@ -141,7 +141,7 @@ pub fn check_script_form(lock_script: &Script, address: transparent::Address) ->
 }
 
 /// Returns a new funding stream coinbase output lock script, which pays to the P2SH `address`.
-pub fn new_coinbase_script(address: transparent::Address) -> Script {
+pub fn new_coinbase_script(address: &transparent::Address) -> Script {
     assert!(
         address.is_script_hash(),
         "incorrect coinbase script address: {address} \
@@ -158,7 +158,7 @@ pub fn new_coinbase_script(address: transparent::Address) -> Script {
 /// Returns a list of outputs in `transaction`, which have a script address equal to `address`.
 pub fn filter_outputs_by_address(
     transaction: &Transaction,
-    address: transparent::Address,
+    address: &transparent::Address,
 ) -> Vec<transparent::Output> {
     transaction
         .outputs()
diff --git a/zebra-consensus/src/block/subsidy/funding_streams/tests.rs b/zebra-consensus/src/block/subsidy/funding_streams/tests.rs
index cddf66d6d4d..763fa172736 100644
--- a/zebra-consensus/src/block/subsidy/funding_streams/tests.rs
+++ b/zebra-consensus/src/block/subsidy/funding_streams/tests.rs
@@ -8,7 +8,7 @@ use super::*;
 #[test]
 fn test_funding_stream_values() -> Result<(), Report> {
     let _init_guard = zebra_test::init();
-    let network = Network::Mainnet;
+    let network = &Network::Mainnet;
 
     // funding streams not active
     let canopy_height_minus1 = Canopy.activation_height(network).unwrap() - 1;
@@ -44,7 +44,7 @@ fn test_funding_stream_values() -> Result<(), Report> {
     );
 
     // funding stream period is ending
-    let range = FUNDING_STREAM_HEIGHT_RANGES.get(&network).unwrap();
+    let range = FUNDING_STREAM_HEIGHT_RANGES.get(network).unwrap();
     let end = range.end;
     let last = end - 1;
 
@@ -74,7 +74,7 @@ fn test_funding_stream_addresses() -> Result<(), Report> {
                 );
 
                 // Asserts if address is not a P2SH address.
-                let _script = new_coinbase_script(address);
+                let _script = new_coinbase_script(&address);
             }
         }
     }
diff --git a/zebra-consensus/src/block/subsidy/general.rs b/zebra-consensus/src/block/subsidy/general.rs
index c906541e010..37ba1cfe95a 100644
--- a/zebra-consensus/src/block/subsidy/general.rs
+++ b/zebra-consensus/src/block/subsidy/general.rs
@@ -20,7 +20,7 @@ use crate::{funding_stream_values, parameters::subsidy::*};
 /// [7.8]: https://zips.z.cash/protocol/protocol.pdf#subsidies
 ///
 /// Returns `None` if the divisor would overflow a `u64`.
-pub fn halving_divisor(height: Height, network: Network) -> Option<u64> {
+pub fn halving_divisor(height: Height, network: &Network) -> Option<u64> {
     let blossom_height = Blossom
         .activation_height(network)
         .expect("blossom activation height should be available");
@@ -64,7 +64,7 @@ pub fn halving_divisor(height: Height, network: Network) -> Option<u64> {
 /// `BlockSubsidy(height)` as described in [protocol specification §7.8][7.8]
 ///
 /// [7.8]: https://zips.z.cash/protocol/protocol.pdf#subsidies
-pub fn block_subsidy(height: Height, network: Network) -> Result<Amount<NonNegative>, Error> {
+pub fn block_subsidy(height: Height, network: &Network) -> Result<Amount<NonNegative>, Error> {
     let blossom_height = Blossom
         .activation_height(network)
         .expect("blossom activation height should be available");
@@ -97,7 +97,7 @@ pub fn block_subsidy(height: Height, network: Network) -> Result<Amount<NonNegat
 /// `MinerSubsidy(height)` as described in [protocol specification §7.8][7.8]
 ///
 /// [7.8]: https://zips.z.cash/protocol/protocol.pdf#subsidies
-pub fn miner_subsidy(height: Height, network: Network) -> Result<Amount<NonNegative>, Error> {
+pub fn miner_subsidy(height: Height, network: &Network) -> Result<Amount<NonNegative>, Error> {
     let total_funding_stream_amount: Result<Amount<NonNegative>, _> =
         funding_stream_values(height, network)?.values().sum();
 
@@ -123,13 +123,13 @@ mod test {
     fn halving_test() -> Result<(), Report> {
         let _init_guard = zebra_test::init();
 
-        halving_for_network(Network::Mainnet)?;
-        halving_for_network(Network::Testnet)?;
+        halving_for_network(&Network::Mainnet)?;
+        halving_for_network(&Network::Testnet)?;
 
         Ok(())
     }
 
-    fn halving_for_network(network: Network) -> Result<(), Report> {
+    fn halving_for_network(network: &Network) -> Result<(), Report> {
         let blossom_height = Blossom.activation_height(network).unwrap();
         let first_halving_height = network.height_for_first_halving();
 
@@ -249,13 +249,13 @@ mod test {
     fn block_subsidy_test() -> Result<(), Report> {
         let _init_guard = zebra_test::init();
 
-        block_subsidy_for_network(Network::Mainnet)?;
-        block_subsidy_for_network(Network::Testnet)?;
+        block_subsidy_for_network(&Network::Mainnet)?;
+        block_subsidy_for_network(&Network::Testnet)?;
 
         Ok(())
     }
 
-    fn block_subsidy_for_network(network: Network) -> Result<(), Report> {
+    fn block_subsidy_for_network(network: &Network) -> Result<(), Report> {
         let blossom_height = Blossom.activation_height(network).unwrap();
         let first_halving_height = network.height_for_first_halving();
 
diff --git a/zebra-consensus/src/block/tests.rs b/zebra-consensus/src/block/tests.rs
index d727378933f..44e577b1cfa 100644
--- a/zebra-consensus/src/block/tests.rs
+++ b/zebra-consensus/src/block/tests.rs
@@ -139,12 +139,12 @@ async fn check_transcripts() -> Result<(), Report> {
     let _init_guard = zebra_test::init();
 
     let network = Network::Mainnet;
-    let state_service = zebra_state::init_test(network);
+    let state_service = zebra_state::init_test(&network);
 
-    let transaction = transaction::Verifier::new(network, state_service.clone());
+    let transaction = transaction::Verifier::new(&network, state_service.clone());
     let transaction = Buffer::new(BoxService::new(transaction), 1);
     let block_verifier = Buffer::new(
-        SemanticBlockVerifier::new(network, state_service.clone(), transaction),
+        SemanticBlockVerifier::new(&network, state_service.clone(), transaction),
         1,
     );
 
@@ -196,7 +196,7 @@ fn difficulty_is_valid_for_network(network: Network) -> Result<(), Report> {
             .zcash_deserialize_into::<Block>()
             .expect("block is structurally valid");
 
-        check::difficulty_is_valid(&block.header, network, &Height(height), &block.hash())
+        check::difficulty_is_valid(&block.header, &network, &Height(height), &block.hash())
             .expect("the difficulty from a historical block should be valid");
     }
 
@@ -220,7 +220,7 @@ fn difficulty_validation_failure() -> Result<(), Report> {
 
     // Validate the block
     let result =
-        check::difficulty_is_valid(&block.header, Network::Mainnet, &height, &hash).unwrap_err();
+        check::difficulty_is_valid(&block.header, &Network::Mainnet, &height, &hash).unwrap_err();
     let expected = BlockError::InvalidDifficulty(height, hash);
     assert_eq!(expected, result);
 
@@ -235,7 +235,7 @@ fn difficulty_validation_failure() -> Result<(), Report> {
 
     // Validate the block as if it is a mainnet block
     let result =
-        check::difficulty_is_valid(&block.header, Network::Mainnet, &height, &hash).unwrap_err();
+        check::difficulty_is_valid(&block.header, &Network::Mainnet, &height, &hash).unwrap_err();
     let expected = BlockError::TargetDifficultyLimit(
         height,
         hash,
@@ -255,7 +255,7 @@ fn difficulty_validation_failure() -> Result<(), Report> {
     let difficulty_threshold = block.header.difficulty_threshold.to_expanded().unwrap();
 
     // Validate the block
-    let result = check::difficulty_is_valid(&block.header, Network::Mainnet, &height, &bad_hash)
+    let result = check::difficulty_is_valid(&block.header, &Network::Mainnet, &height, &bad_hash)
         .unwrap_err();
     let expected =
         BlockError::DifficultyFilter(height, bad_hash, difficulty_threshold, Network::Mainnet);
@@ -301,12 +301,13 @@ fn subsidy_is_valid_for_network(network: Network) -> Result<(), Report> {
             .expect("block is structurally valid");
 
         let canopy_activation_height = NetworkUpgrade::Canopy
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Canopy activation height is known");
 
         // TODO: first halving, second halving, third halving, and very large halvings
         if block::Height(height) >= canopy_activation_height {
-            check::subsidy_is_valid(&block, network).expect("subsidies should pass for this block");
+            check::subsidy_is_valid(&block, &network)
+                .expect("subsidies should pass for this block");
         }
     }
 
@@ -334,7 +335,7 @@ fn coinbase_validation_failure() -> Result<(), Report> {
     assert_eq!(expected, result);
 
     // Validate the block using subsidy_is_valid
-    let result = check::subsidy_is_valid(&block, network).unwrap_err();
+    let result = check::subsidy_is_valid(&block, &network).unwrap_err();
     let expected = BlockError::Transaction(TransactionError::Subsidy(SubsidyError::NoCoinbase));
     assert_eq!(expected, result);
 
@@ -353,7 +354,7 @@ fn coinbase_validation_failure() -> Result<(), Report> {
     assert_eq!(expected, result);
 
     // Validate the block using subsidy_is_valid
-    let result = check::subsidy_is_valid(&block, network).unwrap_err();
+    let result = check::subsidy_is_valid(&block, &network).unwrap_err();
     let expected = BlockError::Transaction(TransactionError::Subsidy(SubsidyError::NoCoinbase));
     assert_eq!(expected, result);
 
@@ -378,7 +379,7 @@ fn coinbase_validation_failure() -> Result<(), Report> {
     assert_eq!(expected, result);
 
     // Validate the block using subsidy_is_valid, which does not detect this error
-    check::subsidy_is_valid(&block, network)
+    check::subsidy_is_valid(&block, &network)
         .expect("subsidy does not check for extra coinbase transactions");
 
     Ok(())
@@ -398,7 +399,7 @@ fn funding_stream_validation_for_network(network: Network) -> Result<(), Report>
     let block_iter = network.block_iter();
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is known");
 
     for (&height, block) in block_iter {
@@ -406,7 +407,7 @@ fn funding_stream_validation_for_network(network: Network) -> Result<(), Report>
             let block = Block::zcash_deserialize(&block[..]).expect("block should deserialize");
 
             // Validate
-            let result = check::subsidy_is_valid(&block, network);
+            let result = check::subsidy_is_valid(&block, &network);
             assert!(result.is_ok());
         }
     }
@@ -450,7 +451,7 @@ fn funding_stream_validation_failure() -> Result<(), Report> {
     };
 
     // Validate it
-    let result = check::subsidy_is_valid(&block, network);
+    let result = check::subsidy_is_valid(&block, &network);
     let expected = Err(BlockError::Transaction(TransactionError::Subsidy(
         SubsidyError::FundingStreamNotFound,
     )));
@@ -480,7 +481,7 @@ fn miner_fees_validation_for_network(network: Network) -> Result<(), Report> {
             let miner_fees = Amount::try_from(MAX_MONEY / 2).unwrap();
 
             // Validate
-            let result = check::miner_fees_are_valid(&block, network, miner_fees);
+            let result = check::miner_fees_are_valid(&block, &network, miner_fees);
             assert!(result.is_ok());
         }
     }
@@ -501,7 +502,7 @@ fn miner_fees_validation_failure() -> Result<(), Report> {
     let miner_fees = Amount::zero();
 
     // Validate
-    let result = check::miner_fees_are_valid(&block, network, miner_fees);
+    let result = check::miner_fees_are_valid(&block, &network, miner_fees);
 
     let expected = Err(BlockError::Transaction(TransactionError::Subsidy(
         SubsidyError::InvalidMinerFees,
@@ -569,7 +570,7 @@ fn merkle_root_is_valid_for_network(network: Network) -> Result<(), Report> {
             .map(|tx| tx.hash())
             .collect::<Vec<_>>();
 
-        check::merkle_root_validity(network, &block, &transaction_hashes)
+        check::merkle_root_validity(&network, &block, &transaction_hashes)
             .expect("merkle root should be valid for this block");
     }
 
@@ -587,7 +588,7 @@ fn merkle_root_fake_v5_for_network(network: Network) -> Result<(), Report> {
         // skip blocks that are before overwinter as they will not have a valid consensus branch id
         if *height
             < NetworkUpgrade::Overwinter
-                .activation_height(network)
+                .activation_height(&network)
                 .expect("a valid overwinter activation height")
                 .0
         {
@@ -599,7 +600,7 @@ fn merkle_root_fake_v5_for_network(network: Network) -> Result<(), Report> {
             .transactions
             .iter()
             .map(AsRef::as_ref)
-            .map(|t| transaction_to_fake_v5(t, network, Height(*height)))
+            .map(|t| transaction_to_fake_v5(t, &network, Height(*height)))
             .map(Into::into)
             .collect();
 
@@ -616,7 +617,7 @@ fn merkle_root_fake_v5_for_network(network: Network) -> Result<(), Report> {
         // but we also need to test against zcashd test vectors.
         Arc::make_mut(&mut block.header).merkle_root = transaction_hashes.iter().cloned().collect();
 
-        check::merkle_root_validity(network, &block, &transaction_hashes)
+        check::merkle_root_validity(&network, &block, &transaction_hashes)
             .expect("merkle root should be valid for this block");
     }
 
@@ -682,13 +683,13 @@ fn legacy_sigops_count_for_historic_blocks() {
 fn transaction_expiration_height_validation() -> Result<(), Report> {
     let _init_guard = zebra_test::init();
 
-    transaction_expiration_height_for_network(Network::Mainnet)?;
-    transaction_expiration_height_for_network(Network::Testnet)?;
+    transaction_expiration_height_for_network(&Network::Mainnet)?;
+    transaction_expiration_height_for_network(&Network::Testnet)?;
 
     Ok(())
 }
 
-fn transaction_expiration_height_for_network(network: Network) -> Result<(), Report> {
+fn transaction_expiration_height_for_network(network: &Network) -> Result<(), Report> {
     let block_iter = network.block_iter();
 
     for (&height, block) in block_iter {
diff --git a/zebra-consensus/src/checkpoint.rs b/zebra-consensus/src/checkpoint.rs
index e8605c1e3f6..1155f1caac8 100644
--- a/zebra-consensus/src/checkpoint.rs
+++ b/zebra-consensus/src/checkpoint.rs
@@ -203,7 +203,7 @@ where
     /// `tower::Buffer` service.
     #[allow(dead_code)]
     pub fn new(
-        network: Network,
+        network: &Network,
         initial_tip: Option<(block::Height, block::Hash)>,
         state_service: S,
     ) -> Self {
@@ -232,7 +232,7 @@ where
     #[allow(dead_code)]
     pub(crate) fn from_list(
         list: impl IntoIterator<Item = (block::Height, block::Hash)>,
-        network: Network,
+        network: &Network,
         initial_tip: Option<(block::Height, block::Hash)>,
         state_service: S,
     ) -> Result<Self, VerifyCheckpointError> {
@@ -253,7 +253,7 @@ where
     /// hard-coded checkpoint lists. See that function for more details.
     pub(crate) fn from_checkpoint_list(
         checkpoint_list: CheckpointList,
-        network: Network,
+        network: &Network,
         initial_tip: Option<(block::Height, block::Hash)>,
         state_service: S,
     ) -> Self {
@@ -273,7 +273,7 @@ where
 
         let verifier = CheckpointVerifier {
             checkpoint_list,
-            network,
+            network: network.clone(),
             initial_tip_hash,
             state_service,
             queued: BTreeMap::new(),
@@ -595,14 +595,14 @@ where
             .ok_or(VerifyCheckpointError::CoinbaseHeight { hash })?;
         self.check_height(height)?;
 
-        crate::block::check::difficulty_is_valid(&block.header, self.network, &height, &hash)?;
+        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);
 
         crate::block::check::merkle_root_validity(
-            self.network,
+            &self.network,
             &block.block,
             &block.transaction_hashes,
         )?;
diff --git a/zebra-consensus/src/checkpoint/tests.rs b/zebra-consensus/src/checkpoint/tests.rs
index e4be1c2b6b7..b2493540f5d 100644
--- a/zebra-consensus/src/checkpoint/tests.rs
+++ b/zebra-consensus/src/checkpoint/tests.rs
@@ -45,9 +45,9 @@ async fn single_item_checkpoint_list() -> Result<(), Report> {
             .cloned()
             .collect();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     let mut checkpoint_verifier =
-        CheckpointVerifier::from_list(genesis_checkpoint_list, Mainnet, None, state_service)
+        CheckpointVerifier::from_list(genesis_checkpoint_list, &Mainnet, None, state_service)
             .map_err(|e| eyre!(e))?;
 
     assert_eq!(
@@ -124,9 +124,9 @@ async fn multi_item_checkpoint_list() -> Result<(), Report> {
         .map(|(_block, height, hash)| (*height, *hash))
         .collect();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     let mut checkpoint_verifier =
-        CheckpointVerifier::from_list(checkpoint_list, Mainnet, None, state_service)
+        CheckpointVerifier::from_list(checkpoint_list, &Mainnet, None, state_service)
             .map_err(|e| eyre!(e))?;
 
     assert_eq!(
@@ -268,10 +268,10 @@ async fn continuous_blockchain(
         let initial_tip = restart_height.map(|block::Height(height)| {
             (blockchain[height as usize].1, blockchain[height as usize].2)
         });
-        let state_service = zebra_state::init_test(Mainnet);
+        let state_service = zebra_state::init_test(&Mainnet);
         let mut checkpoint_verifier = CheckpointVerifier::from_list(
             checkpoint_list,
-            network,
+            &network,
             initial_tip,
             state_service.clone(),
         )
@@ -437,9 +437,9 @@ async fn block_higher_than_max_checkpoint_fail() -> Result<(), Report> {
             .cloned()
             .collect();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     let mut checkpoint_verifier =
-        CheckpointVerifier::from_list(genesis_checkpoint_list, Mainnet, None, state_service)
+        CheckpointVerifier::from_list(genesis_checkpoint_list, &Mainnet, None, state_service)
             .map_err(|e| eyre!(e))?;
 
     assert_eq!(
@@ -511,9 +511,9 @@ async fn wrong_checkpoint_hash_fail() -> Result<(), Report> {
             .cloned()
             .collect();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     let mut checkpoint_verifier =
-        CheckpointVerifier::from_list(genesis_checkpoint_list, Mainnet, None, state_service)
+        CheckpointVerifier::from_list(genesis_checkpoint_list, &Mainnet, None, state_service)
             .map_err(|e| eyre!(e))?;
 
     assert_eq!(
@@ -684,9 +684,9 @@ async fn checkpoint_drop_cancel() -> Result<(), Report> {
         .map(|(_block, height, hash)| (*height, *hash))
         .collect();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     let mut checkpoint_verifier =
-        CheckpointVerifier::from_list(checkpoint_list, Mainnet, None, state_service)
+        CheckpointVerifier::from_list(checkpoint_list, &Mainnet, None, state_service)
             .map_err(|e| eyre!(e))?;
 
     assert_eq!(
@@ -767,9 +767,9 @@ async fn hard_coded_mainnet() -> Result<(), Report> {
         Arc::<Block>::zcash_deserialize(&zebra_test::vectors::BLOCK_MAINNET_GENESIS_BYTES[..])?;
     let hash0 = block0.hash();
 
-    let state_service = zebra_state::init_test(Mainnet);
+    let state_service = zebra_state::init_test(&Mainnet);
     // Use the hard-coded checkpoint list
-    let mut checkpoint_verifier = CheckpointVerifier::new(Network::Mainnet, None, state_service);
+    let mut checkpoint_verifier = CheckpointVerifier::new(&Network::Mainnet, None, state_service);
 
     assert_eq!(
         checkpoint_verifier.previous_checkpoint_height(),
diff --git a/zebra-consensus/src/parameters/subsidy.rs b/zebra-consensus/src/parameters/subsidy.rs
index 1b12a52fca0..8dfd42bd912 100644
--- a/zebra-consensus/src/parameters/subsidy.rs
+++ b/zebra-consensus/src/parameters/subsidy.rs
@@ -224,7 +224,7 @@ impl ParameterSubsidy for Network {
         // <https://zips.z.cash/protocol/protocol.pdf#zip214fundingstreams>
         match self {
             Network::Mainnet => NetworkUpgrade::Canopy
-                .activation_height(*self)
+                .activation_height(self)
                 .expect("canopy activation height should be available"),
             Network::Testnet => FIRST_HALVING_TESTNET,
         }
diff --git a/zebra-consensus/src/router.rs b/zebra-consensus/src/router.rs
index ab99bbd4154..d8587309607 100644
--- a/zebra-consensus/src/router.rs
+++ b/zebra-consensus/src/router.rs
@@ -220,7 +220,7 @@ where
 #[instrument(skip(state_service))]
 pub async fn init<S>(
     config: Config,
-    network: Network,
+    network: &Network,
     mut state_service: S,
 ) -> (
     Buffer<BoxService<Request, block::Hash, RouterError>, Request>,
@@ -240,8 +240,14 @@ where
 
     // Make sure the state contains the known best chain checkpoints, in a separate thread.
 
-    let checkpoint_state_service = state_service.clone();
-    let checkpoint_sync = config.checkpoint_sync;
+    let (checkpoint_state_service, checkpoint_sync, network_clone) = {
+        let checkpoint_state_service = state_service.clone();
+        let checkpoint_sync = config.checkpoint_sync;
+        let network_clone = network.clone();
+
+        (checkpoint_state_service, checkpoint_sync, network_clone)
+    };
+
     let state_checkpoint_verify_handle = tokio::task::spawn(
         // TODO: move this into an async function?
         async move {
@@ -263,7 +269,7 @@ where
             // > activation block hashes given in § 3.12 ‘Mainnet and Testnet’ on p. 20.
             //
             // <https://zips.z.cash/protocol/protocol.pdf#blockchain>
-            let full_checkpoints = network.checkpoint_list();
+            let full_checkpoints = network_clone.checkpoint_list();
             let mut already_warned = false;
 
             for (height, checkpoint_hash) in full_checkpoints.iter() {
@@ -360,7 +366,7 @@ where
 
 /// Parses the checkpoint list for `network` and `config`.
 /// Returns the checkpoint list and maximum checkpoint height.
-pub fn init_checkpoint_list(config: Config, network: Network) -> (CheckpointList, Height) {
+pub fn init_checkpoint_list(config: Config, network: &Network) -> (CheckpointList, Height) {
     // TODO: Zebra parses the checkpoint list three times at startup.
     //       Instead, cache the checkpoint list for each `network`.
     let list = network.checkpoint_list();
diff --git a/zebra-consensus/src/router/tests.rs b/zebra-consensus/src/router/tests.rs
index c438a79f8f2..6fe88361fd5 100644
--- a/zebra-consensus/src/router/tests.rs
+++ b/zebra-consensus/src/router/tests.rs
@@ -65,13 +65,13 @@ async fn verifiers_from_network(
         + Clone
         + 'static,
 ) {
-    let state_service = zs::init_test(network);
+    let state_service = zs::init_test(&network);
     let (
         block_verifier_router,
         _transaction_verifier,
         _groth16_download_handle,
         _max_checkpoint_height,
-    ) = crate::router::init(Config::default(), network, state_service.clone()).await;
+    ) = crate::router::init(Config::default(), &network, state_service.clone()).await;
 
     // We can drop the download task handle here, because:
     // - if the download task fails, the tests will panic, and
@@ -172,7 +172,7 @@ async fn verify_checkpoint(config: Config) -> Result<(), Report> {
         _transaction_verifier,
         _groth16_download_handle,
         _max_checkpoint_height,
-    ) = super::init(config.clone(), network, zs::init_test(network)).await;
+    ) = super::init(config.clone(), &network, zs::init_test(&network)).await;
 
     // Add a timeout layer
     let block_verifier_router =
diff --git a/zebra-consensus/src/transaction.rs b/zebra-consensus/src/transaction.rs
index 90c549a3b00..076f47ce799 100644
--- a/zebra-consensus/src/transaction.rs
+++ b/zebra-consensus/src/transaction.rs
@@ -73,9 +73,9 @@ where
     ZS::Future: Send + 'static,
 {
     /// Create a new transaction verifier.
-    pub fn new(network: Network, state: ZS) -> Self {
+    pub fn new(network: &Network, state: ZS) -> Self {
         Self {
-            network,
+            network: network.clone(),
             state: Timeout::new(state, UTXO_LOOKUP_TIMEOUT),
             script_verifier: script::Verifier,
         }
@@ -218,7 +218,7 @@ impl Request {
     /// The network upgrade to consider for the verification.
     ///
     /// This is based on the block height from the request, and the supplied `network`.
-    pub fn upgrade(&self, network: Network) -> NetworkUpgrade {
+    pub fn upgrade(&self, network: &Network) -> NetworkUpgrade {
         NetworkUpgrade::current(network, self.height())
     }
 
@@ -294,7 +294,7 @@ where
     // TODO: break up each chunk into its own method
     fn call(&mut self, req: Request) -> Self::Future {
         let script_verifier = self.script_verifier;
-        let network = self.network;
+        let network = self.network.clone();
         let state = self.state.clone();
 
         let tx = req.transaction();
@@ -321,7 +321,7 @@ where
 
             // Validate `nExpiryHeight` consensus rules
             if tx.is_coinbase() {
-                check::coinbase_expiry_height(&req.height(), &tx, network)?;
+                check::coinbase_expiry_height(&req.height(), &tx, &network)?;
             } else {
                 check::non_coinbase_expiry_height(&req.height(), &tx)?;
             }
@@ -335,7 +335,7 @@ where
 
             // [Canopy onward]: `vpub_old` MUST be zero.
             // https://zips.z.cash/protocol/protocol.pdf#joinsplitdesc
-            check::disabled_add_to_sprout_pool(&tx, req.height(), network)?;
+            check::disabled_add_to_sprout_pool(&tx, req.height(), &network)?;
 
             check::spend_conflicts(&tx)?;
 
@@ -396,7 +396,7 @@ where
                     ..
                 } => Self::verify_v4_transaction(
                     &req,
-                    network,
+                    &network,
                     script_verifier,
                     cached_ffi_transaction.clone(),
                     joinsplit_data,
@@ -408,7 +408,7 @@ where
                     ..
                 } => Self::verify_v5_transaction(
                     &req,
-                    network,
+                    &network,
                     script_verifier,
                     cached_ffi_transaction.clone(),
                     sapling_shielded_data,
@@ -616,7 +616,7 @@ where
     /// - the `sapling_shielded_data` in the transaction
     fn verify_v4_transaction(
         request: &Request,
-        network: Network,
+        network: &Network,
         script_verifier: script::Verifier,
         cached_ffi_transaction: Arc<CachedFfiTransaction>,
         joinsplit_data: &Option<transaction::JoinSplitData<Groth16Proof>>,
@@ -708,7 +708,7 @@ where
     /// - the orchard shielded data of the transaction, if any
     fn verify_v5_transaction(
         request: &Request,
-        network: Network,
+        network: &Network,
         script_verifier: script::Verifier,
         cached_ffi_transaction: Arc<CachedFfiTransaction>,
         sapling_shielded_data: &Option<sapling::ShieldedData<sapling::SharedAnchor>>,
@@ -782,7 +782,7 @@ where
     /// Returns script verification responses via the `utxo_sender`.
     fn verify_transparent_inputs_and_outputs(
         request: &Request,
-        network: Network,
+        network: &Network,
         script_verifier: script::Verifier,
         cached_ffi_transaction: Arc<CachedFfiTransaction>,
     ) -> Result<AsyncChecks, TransactionError> {
diff --git a/zebra-consensus/src/transaction/check.rs b/zebra-consensus/src/transaction/check.rs
index bfb8df37fd5..432f3d2f641 100644
--- a/zebra-consensus/src/transaction/check.rs
+++ b/zebra-consensus/src/transaction/check.rs
@@ -212,7 +212,7 @@ pub fn joinsplit_has_vpub_zero(tx: &Transaction) -> Result<(), TransactionError>
 pub fn disabled_add_to_sprout_pool(
     tx: &Transaction,
     height: Height,
-    network: Network,
+    network: &Network,
 ) -> Result<(), TransactionError> {
     let canopy_activation_height = NetworkUpgrade::Canopy
         .activation_height(network)
@@ -325,7 +325,7 @@ where
 /// <https://github.com/ZcashFoundation/zebra/issues/3027>
 pub fn coinbase_outputs_are_decryptable(
     transaction: &Transaction,
-    network: Network,
+    network: &Network,
     height: Height,
 ) -> Result<(), TransactionError> {
     // The consensus rule only applies to Heartwood onward.
@@ -352,7 +352,7 @@ pub fn coinbase_outputs_are_decryptable(
 pub fn coinbase_expiry_height(
     block_height: &Height,
     coinbase: &Transaction,
-    network: Network,
+    network: &Network,
 ) -> Result<(), TransactionError> {
     let expiry_height = coinbase.expiry_height();
 
diff --git a/zebra-consensus/src/transaction/tests.rs b/zebra-consensus/src/transaction/tests.rs
index c5e25be64fa..758c13fa9e4 100644
--- a/zebra-consensus/src/transaction/tests.rs
+++ b/zebra-consensus/src/transaction/tests.rs
@@ -48,7 +48,7 @@ fn v5_fake_transactions() -> Result<(), Report> {
     ];
 
     for (network, blocks) in networks {
-        for transaction in fake_v5_transactions_for_network(network, blocks) {
+        for transaction in fake_v5_transactions_for_network(&network, blocks) {
             match check::has_inputs_and_outputs(&transaction) {
                 Ok(()) => (),
                 Err(TransactionError::NoInputs) | Err(TransactionError::NoOutputs) => (),
@@ -67,7 +67,7 @@ fn v5_fake_transactions() -> Result<(), Report> {
 fn fake_v5_transaction_with_orchard_actions_has_inputs_and_outputs() {
     // Find a transaction with no inputs or outputs to use as base
     let mut transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -121,7 +121,7 @@ fn fake_v5_transaction_with_orchard_actions_has_inputs_and_outputs() {
 fn fake_v5_transaction_with_orchard_actions_has_flags() {
     // Find a transaction with no inputs or outputs to use as base
     let mut transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -164,7 +164,7 @@ fn fake_v5_transaction_with_orchard_actions_has_flags() {
 #[test]
 fn v5_transaction_with_no_inputs_fails_validation() {
     let transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -186,7 +186,7 @@ fn v5_transaction_with_no_inputs_fails_validation() {
 #[tokio::test]
 async fn mempool_request_with_missing_input_is_rejected() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let (height, tx) = transactions_from_blocks(zebra_test::vectors::MAINNET_BLOCKS.iter())
         .find(|(_, tx)| !(tx.is_coinbase() || tx.inputs().is_empty()))
@@ -235,10 +235,10 @@ async fn mempool_request_with_missing_input_is_rejected() {
 #[tokio::test]
 async fn mempool_request_with_present_input_is_accepted() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -302,10 +302,10 @@ async fn mempool_request_with_present_input_is_accepted() {
 #[tokio::test]
 async fn mempool_request_with_invalid_lock_time_is_rejected() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -381,10 +381,10 @@ async fn mempool_request_with_invalid_lock_time_is_rejected() {
 #[tokio::test]
 async fn mempool_request_with_unlocked_lock_time_is_accepted() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -448,10 +448,10 @@ async fn mempool_request_with_unlocked_lock_time_is_accepted() {
 #[tokio::test]
 async fn mempool_request_with_lock_time_max_sequence_number_is_accepted() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (mut input, output, known_utxos) = mock_transparent_transfer(
@@ -518,10 +518,10 @@ async fn mempool_request_with_lock_time_max_sequence_number_is_accepted() {
 #[tokio::test]
 async fn mempool_request_with_past_lock_time_is_accepted() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -597,10 +597,10 @@ async fn mempool_request_with_immature_spend_is_rejected() {
     let _init_guard = zebra_test::init();
 
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -700,10 +700,10 @@ async fn state_error_converted_correctly() {
     use zebra_state::DuplicateNullifierError;
 
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -798,7 +798,7 @@ async fn state_error_converted_correctly() {
 #[test]
 fn v5_transaction_with_no_outputs_fails_validation() {
     let transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -821,7 +821,7 @@ fn v5_transaction_with_no_outputs_fails_validation() {
 #[test]
 fn v5_coinbase_transaction_without_enable_spends_flag_passes_validation() {
     let mut transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -836,7 +836,7 @@ fn v5_coinbase_transaction_without_enable_spends_flag_passes_validation() {
 #[test]
 fn v5_coinbase_transaction_with_enable_spends_flag_fails_validation() {
     let mut transaction = fake_v5_transactions_for_network(
-        Network::Mainnet,
+        &Network::Mainnet,
         zebra_test::vectors::MAINNET_BLOCKS.iter(),
     )
     .rev()
@@ -865,9 +865,9 @@ async fn v5_transaction_is_rejected_before_nu5_activation() {
 
     for (network, blocks) in networks {
         let state_service = service_fn(|_| async { unreachable!("Service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
-        let transaction = fake_v5_transactions_for_network(network, blocks)
+        let transaction = fake_v5_transactions_for_network(&network, blocks)
             .next_back()
             .expect("At least one fake V5 transaction in the test vectors");
 
@@ -876,7 +876,7 @@ async fn v5_transaction_is_rejected_before_nu5_activation() {
                 transaction: Arc::new(transaction),
                 known_utxos: Arc::new(HashMap::new()),
                 height: canopy
-                    .activation_height(network)
+                    .activation_height(&network)
                     .expect("Canopy activation height is specified"),
                 time: DateTime::<Utc>::MAX_UTC,
             })
@@ -907,14 +907,14 @@ fn v5_transaction_is_accepted_after_nu5_activation_for_network(network: Network)
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let nu5 = NetworkUpgrade::Nu5;
         let nu5_activation_height = nu5
-            .activation_height(network)
+            .activation_height(&network)
             .expect("NU5 activation height is specified");
         let blocks = network.block_iter();
 
         let state_service = service_fn(|_| async { unreachable!("Service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
-        let mut transaction = fake_v5_transactions_for_network(network, blocks)
+        let mut transaction = fake_v5_transactions_for_network(&network, blocks)
             .next_back()
             .expect("At least one fake V5 transaction in the test vectors");
         if transaction
@@ -953,7 +953,7 @@ async fn v4_transaction_with_transparent_transfer_is_accepted() {
     let network = Network::Mainnet;
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is specified");
 
     let transaction_block_height =
@@ -984,7 +984,7 @@ async fn v4_transaction_with_transparent_transfer_is_accepted() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1007,10 +1007,10 @@ async fn v4_transaction_with_transparent_transfer_is_accepted() {
 async fn v4_transaction_with_last_valid_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     let block_height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
     let fund_height = (block_height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -1054,10 +1054,10 @@ async fn v4_transaction_with_last_valid_expiry_height() {
 async fn v4_coinbase_transaction_with_low_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     let block_height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
 
     let (input, output) = mock_coinbase_transparent_output(block_height);
@@ -1095,10 +1095,10 @@ async fn v4_coinbase_transaction_with_low_expiry_height() {
 async fn v4_transaction_with_too_low_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     let block_height = NetworkUpgrade::Canopy
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Canopy activation height is specified");
 
     let fund_height = (block_height - 1).expect("fake source fund block height is too small");
@@ -1147,7 +1147,7 @@ async fn v4_transaction_with_too_low_expiry_height() {
 async fn v4_transaction_with_exceeding_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     let block_height = block::Height::MAX;
 
@@ -1198,14 +1198,14 @@ async fn v4_transaction_with_exceeding_expiry_height() {
 async fn v4_coinbase_transaction_with_exceeding_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     // Use an arbitrary pre-NU5 block height.
     // It can't be NU5-onward because the expiry height limit is not enforced
     // for coinbase transactions (it needs to match the block height instead),
     // which is what is used in this test.
     let block_height = (NetworkUpgrade::Nu5
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("NU5 height must be set")
         - 1)
     .expect("will not underflow");
@@ -1251,7 +1251,7 @@ async fn v4_coinbase_transaction_is_accepted() {
     let network = Network::Mainnet;
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is specified");
 
     let transaction_block_height =
@@ -1274,7 +1274,7 @@ async fn v4_coinbase_transaction_is_accepted() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1300,7 +1300,7 @@ async fn v4_transaction_with_transparent_transfer_is_rejected_by_the_script() {
     let network = Network::Mainnet;
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is specified");
 
     let transaction_block_height =
@@ -1329,7 +1329,7 @@ async fn v4_transaction_with_transparent_transfer_is_rejected_by_the_script() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1355,7 +1355,7 @@ async fn v4_transaction_with_conflicting_transparent_spend_is_rejected() {
     let network = Network::Mainnet;
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is specified");
 
     let transaction_block_height =
@@ -1384,7 +1384,7 @@ async fn v4_transaction_with_conflicting_transparent_spend_is_rejected() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1414,7 +1414,7 @@ fn v4_transaction_with_conflicting_sprout_nullifier_inside_joinsplit_is_rejected
         let network_upgrade = NetworkUpgrade::Canopy;
 
         let canopy_activation_height = NetworkUpgrade::Canopy
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Canopy activation height is specified");
 
         let transaction_block_height =
@@ -1450,7 +1450,7 @@ fn v4_transaction_with_conflicting_sprout_nullifier_inside_joinsplit_is_rejected
 
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         let result = verifier
             .oneshot(Request::Block {
@@ -1479,7 +1479,7 @@ fn v4_transaction_with_conflicting_sprout_nullifier_across_joinsplits_is_rejecte
         let network_upgrade = NetworkUpgrade::Canopy;
 
         let canopy_activation_height = NetworkUpgrade::Canopy
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Canopy activation height is specified");
 
         let transaction_block_height =
@@ -1521,7 +1521,7 @@ fn v4_transaction_with_conflicting_sprout_nullifier_across_joinsplits_is_rejecte
 
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         let result = verifier
             .oneshot(Request::Block {
@@ -1548,7 +1548,7 @@ async fn v5_transaction_with_transparent_transfer_is_accepted() {
     let network_upgrade = NetworkUpgrade::Nu5;
 
     let nu5_activation_height = network_upgrade
-        .activation_height(network)
+        .activation_height(&network)
         .expect("NU5 activation height is specified");
 
     let transaction_block_height =
@@ -1580,7 +1580,7 @@ async fn v5_transaction_with_transparent_transfer_is_accepted() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1603,10 +1603,10 @@ async fn v5_transaction_with_transparent_transfer_is_accepted() {
 async fn v5_transaction_with_last_valid_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Testnet, state_service);
+    let verifier = Verifier::new(&Network::Testnet, state_service);
 
     let block_height = NetworkUpgrade::Nu5
-        .activation_height(Network::Testnet)
+        .activation_height(&Network::Testnet)
         .expect("Nu5 activation height for testnet is specified");
     let fund_height = (block_height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -1648,10 +1648,10 @@ async fn v5_transaction_with_last_valid_expiry_height() {
 async fn v5_coinbase_transaction_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Testnet, state_service);
+    let verifier = Verifier::new(&Network::Testnet, state_service);
 
     let block_height = NetworkUpgrade::Nu5
-        .activation_height(Network::Testnet)
+        .activation_height(&Network::Testnet)
         .expect("Nu5 activation height for testnet is specified");
 
     let (input, output) = mock_coinbase_transparent_output(block_height);
@@ -1763,10 +1763,10 @@ async fn v5_coinbase_transaction_expiry_height() {
 async fn v5_transaction_with_too_low_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Testnet, state_service);
+    let verifier = Verifier::new(&Network::Testnet, state_service);
 
     let block_height = NetworkUpgrade::Nu5
-        .activation_height(Network::Testnet)
+        .activation_height(&Network::Testnet)
         .expect("Nu5 activation height for testnet is specified");
     let fund_height = (block_height - 1).expect("fake source fund block height is too small");
     let (input, output, known_utxos) = mock_transparent_transfer(
@@ -1815,7 +1815,7 @@ async fn v5_transaction_with_too_low_expiry_height() {
 async fn v5_transaction_with_exceeding_expiry_height() {
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(Network::Mainnet, state_service);
+    let verifier = Verifier::new(&Network::Mainnet, state_service);
 
     let block_height = block::Height::MAX;
 
@@ -1868,7 +1868,7 @@ async fn v5_coinbase_transaction_is_accepted() {
     let network_upgrade = NetworkUpgrade::Nu5;
 
     let nu5_activation_height = network_upgrade
-        .activation_height(network)
+        .activation_height(&network)
         .expect("NU5 activation height is specified");
 
     let transaction_block_height =
@@ -1893,7 +1893,7 @@ async fn v5_coinbase_transaction_is_accepted() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1920,7 +1920,7 @@ async fn v5_transaction_with_transparent_transfer_is_rejected_by_the_script() {
     let network_upgrade = NetworkUpgrade::Nu5;
 
     let nu5_activation_height = network_upgrade
-        .activation_height(network)
+        .activation_height(&network)
         .expect("NU5 activation height is specified");
 
     let transaction_block_height =
@@ -1950,7 +1950,7 @@ async fn v5_transaction_with_transparent_transfer_is_rejected_by_the_script() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -1977,7 +1977,7 @@ async fn v5_transaction_with_conflicting_transparent_spend_is_rejected() {
     let network_upgrade = NetworkUpgrade::Nu5;
 
     let canopy_activation_height = NetworkUpgrade::Canopy
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Canopy activation height is specified");
 
     let transaction_block_height =
@@ -2007,7 +2007,7 @@ async fn v5_transaction_with_conflicting_transparent_spend_is_rejected() {
 
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     let result = verifier
         .oneshot(Request::Block {
@@ -2037,7 +2037,7 @@ fn v4_with_signed_sprout_transfer_is_accepted() {
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let network = Network::Mainnet;
 
-        let (height, transaction) = test_transactions(network)
+        let (height, transaction) = test_transactions(&network)
             .rev()
             .filter(|(_, transaction)| {
                 !transaction.is_coinbase() && transaction.inputs().is_empty()
@@ -2050,7 +2050,7 @@ fn v4_with_signed_sprout_transfer_is_accepted() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2109,7 +2109,7 @@ async fn v4_with_joinsplit_is_rejected_for_modification(
 ) {
     let network = Network::Mainnet;
 
-    let (height, mut transaction) = test_transactions(network)
+    let (height, mut transaction) = test_transactions(&network)
         .rev()
         .filter(|(_, transaction)| !transaction.is_coinbase() && transaction.inputs().is_empty())
         .find(|(_, transaction)| transaction.sprout_groth16_joinsplits().next().is_some())
@@ -2130,7 +2130,7 @@ async fn v4_with_joinsplit_is_rejected_for_modification(
     // Initialize the verifier
     let state_service =
         service_fn(|_| async { unreachable!("State service should not be called.") });
-    let verifier = Verifier::new(network, state_service);
+    let verifier = Verifier::new(&network, state_service);
 
     // Test the transaction verifier.
     //
@@ -2168,7 +2168,7 @@ fn v4_with_sapling_spends() {
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let network = Network::Mainnet;
 
-        let (height, transaction) = test_transactions(network)
+        let (height, transaction) = test_transactions(&network)
             .rev()
             .filter(|(_, transaction)| {
                 !transaction.is_coinbase() && transaction.inputs().is_empty()
@@ -2181,7 +2181,7 @@ fn v4_with_sapling_spends() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2208,7 +2208,7 @@ fn v4_with_duplicate_sapling_spends() {
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let network = Network::Mainnet;
 
-        let (height, mut transaction) = test_transactions(network)
+        let (height, mut transaction) = test_transactions(&network)
             .rev()
             .filter(|(_, transaction)| {
                 !transaction.is_coinbase() && transaction.inputs().is_empty()
@@ -2224,7 +2224,7 @@ fn v4_with_duplicate_sapling_spends() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2253,7 +2253,7 @@ fn v4_with_sapling_outputs_and_no_spends() {
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let network = Network::Mainnet;
 
-        let (height, transaction) = test_transactions(network)
+        let (height, transaction) = test_transactions(&network)
             .rev()
             .filter(|(_, transaction)| {
                 !transaction.is_coinbase() && transaction.inputs().is_empty()
@@ -2269,7 +2269,7 @@ fn v4_with_sapling_outputs_and_no_spends() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2297,10 +2297,10 @@ fn v5_with_sapling_spends() {
     let _init_guard = zebra_test::init();
     zebra_test::MULTI_THREADED_RUNTIME.block_on(async {
         let network = Network::Mainnet;
-        let nu5_activation = NetworkUpgrade::Nu5.activation_height(network);
+        let nu5_activation = NetworkUpgrade::Nu5.activation_height(&network);
 
         let transaction =
-            fake_v5_transactions_for_network(network, zebra_test::vectors::MAINNET_BLOCKS.iter())
+            fake_v5_transactions_for_network(&network, zebra_test::vectors::MAINNET_BLOCKS.iter())
                 .rev()
                 .filter(|transaction| {
                     !transaction.is_coinbase()
@@ -2318,7 +2318,7 @@ fn v5_with_sapling_spends() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2346,7 +2346,7 @@ fn v5_with_duplicate_sapling_spends() {
         let network = Network::Mainnet;
 
         let mut transaction =
-            fake_v5_transactions_for_network(network, zebra_test::vectors::MAINNET_BLOCKS.iter())
+            fake_v5_transactions_for_network(&network, zebra_test::vectors::MAINNET_BLOCKS.iter())
                 .rev()
                 .filter(|transaction| !transaction.is_coinbase() && transaction.inputs().is_empty())
                 .find(|transaction| transaction.sapling_spends_per_anchor().next().is_some())
@@ -2362,7 +2362,7 @@ fn v5_with_duplicate_sapling_spends() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2393,7 +2393,7 @@ fn v5_with_duplicate_orchard_action() {
 
         // Find a transaction with no inputs or outputs to use as base
         let mut transaction =
-            fake_v5_transactions_for_network(network, zebra_test::vectors::MAINNET_BLOCKS.iter())
+            fake_v5_transactions_for_network(&network, zebra_test::vectors::MAINNET_BLOCKS.iter())
                 .rev()
                 .find(|transaction| {
                     transaction.inputs().is_empty()
@@ -2425,7 +2425,7 @@ fn v5_with_duplicate_orchard_action() {
         // Initialize the verifier
         let state_service =
             service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = Verifier::new(network, state_service);
+        let verifier = Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         let result = verifier
@@ -2710,21 +2710,21 @@ fn add_to_sprout_pool_after_nu() {
 
     // create a block height at canopy activation.
     let network = Network::Mainnet;
-    let block_height = NetworkUpgrade::Canopy.activation_height(network).unwrap();
+    let block_height = NetworkUpgrade::Canopy.activation_height(&network).unwrap();
 
     // create a zero amount.
     let zero = Amount::<NonNegative>::try_from(0).expect("an amount of 0 is always valid");
 
     // the coinbase transaction should pass the check.
     assert_eq!(
-        check::disabled_add_to_sprout_pool(&block.transactions[0], block_height, network),
+        check::disabled_add_to_sprout_pool(&block.transactions[0], block_height, &network),
         Ok(())
     );
 
     // the 2nd transaction has no joinsplits, should pass the check.
     assert_eq!(block.transactions[1].joinsplit_count(), 0);
     assert_eq!(
-        check::disabled_add_to_sprout_pool(&block.transactions[1], block_height, network),
+        check::disabled_add_to_sprout_pool(&block.transactions[1], block_height, &network),
         Ok(())
     );
 
@@ -2737,7 +2737,7 @@ fn add_to_sprout_pool_after_nu() {
     assert!(vpub_old > zero);
 
     assert_eq!(
-        check::disabled_add_to_sprout_pool(&block.transactions[3], block_height, network),
+        check::disabled_add_to_sprout_pool(&block.transactions[3], block_height, &network),
         Err(TransactionError::DisabledAddToSproutPool)
     );
 
@@ -2750,7 +2750,7 @@ fn add_to_sprout_pool_after_nu() {
     assert_eq!(vpub_old, zero);
 
     assert_eq!(
-        check::disabled_add_to_sprout_pool(&block.transactions[7], block_height, network),
+        check::disabled_add_to_sprout_pool(&block.transactions[7], block_height, &network),
         Ok(())
     );
 }
@@ -2780,7 +2780,7 @@ fn coinbase_outputs_are_decryptable_for_historical_blocks_for_network(
         let height = Height(*height);
         let heartwood_onward = height
             >= NetworkUpgrade::Heartwood
-                .activation_height(network)
+                .activation_height(&network)
                 .unwrap();
         let coinbase_tx = block
             .transactions
@@ -2796,7 +2796,7 @@ fn coinbase_outputs_are_decryptable_for_historical_blocks_for_network(
             // and there are relevant outputs.
             tested_coinbase_txs += 1;
         }
-        check::coinbase_outputs_are_decryptable(coinbase_tx, network, height)
+        check::coinbase_outputs_are_decryptable(coinbase_tx, &network, height)
             .expect("coinbase outputs must be decryptable with an all-zero key");
 
         // For remaining transactions, check if existing outputs are NOT decryptable
@@ -2805,11 +2805,11 @@ fn coinbase_outputs_are_decryptable_for_historical_blocks_for_network(
             let has_outputs = tx.sapling_outputs().count() > 0 || tx.orchard_actions().count() > 0;
             if has_outputs && heartwood_onward {
                 tested_non_coinbase_txs += 1;
-                check::coinbase_outputs_are_decryptable(tx, network, height).expect_err(
+                check::coinbase_outputs_are_decryptable(tx, &network, height).expect_err(
                     "decrypting a non-coinbase output with an all-zero key should fail",
                 );
             } else {
-                check::coinbase_outputs_are_decryptable(tx, network, height)
+                check::coinbase_outputs_are_decryptable(tx, &network, height)
                     .expect("a transaction without outputs, or pre-Heartwood, must be considered 'decryptable'");
             }
         }
@@ -2849,7 +2849,7 @@ fn coinbase_outputs_are_decryptable_for_fake_v5_blocks() {
     for v in zebra_test::vectors::ORCHARD_NOTE_ENCRYPTION_ZERO_VECTOR.iter() {
         // Find a transaction with no inputs or outputs to use as base
         let mut transaction =
-            fake_v5_transactions_for_network(network, zebra_test::vectors::TESTNET_BLOCKS.iter())
+            fake_v5_transactions_for_network(&network, zebra_test::vectors::TESTNET_BLOCKS.iter())
                 .rev()
                 .find(|transaction| {
                     transaction.inputs().is_empty()
@@ -2874,8 +2874,8 @@ fn coinbase_outputs_are_decryptable_for_fake_v5_blocks() {
         assert_eq!(
             check::coinbase_outputs_are_decryptable(
                 &transaction,
-                network,
-                NetworkUpgrade::Nu5.activation_height(network).unwrap(),
+                &network,
+                NetworkUpgrade::Nu5.activation_height(&network).unwrap(),
             ),
             Ok(())
         );
@@ -2891,7 +2891,7 @@ fn shielded_outputs_are_not_decryptable_for_fake_v5_blocks() {
     for v in zebra_test::vectors::ORCHARD_NOTE_ENCRYPTION_VECTOR.iter() {
         // Find a transaction with no inputs or outputs to use as base
         let mut transaction =
-            fake_v5_transactions_for_network(network, zebra_test::vectors::TESTNET_BLOCKS.iter())
+            fake_v5_transactions_for_network(&network, zebra_test::vectors::TESTNET_BLOCKS.iter())
                 .rev()
                 .find(|transaction| {
                     transaction.inputs().is_empty()
@@ -2916,8 +2916,8 @@ fn shielded_outputs_are_not_decryptable_for_fake_v5_blocks() {
         assert_eq!(
             check::coinbase_outputs_are_decryptable(
                 &transaction,
-                network,
-                NetworkUpgrade::Nu5.activation_height(network).unwrap(),
+                &network,
+                NetworkUpgrade::Nu5.activation_height(&network).unwrap(),
             ),
             Err(TransactionError::CoinbaseOutputsNotDecryptable)
         );
@@ -2927,10 +2927,10 @@ fn shielded_outputs_are_not_decryptable_for_fake_v5_blocks() {
 #[tokio::test]
 async fn mempool_zip317_error() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Nu5
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Nu5 activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
 
@@ -2999,10 +2999,10 @@ async fn mempool_zip317_error() {
 #[tokio::test]
 async fn mempool_zip317_ok() {
     let mut state: MockService<_, _, _, _> = MockService::build().for_prop_tests();
-    let verifier = Verifier::new(Network::Mainnet, state.clone());
+    let verifier = Verifier::new(&Network::Mainnet, state.clone());
 
     let height = NetworkUpgrade::Nu5
-        .activation_height(Network::Mainnet)
+        .activation_height(&Network::Mainnet)
         .expect("Nu5 activation height is specified");
     let fund_height = (height - 1).expect("fake source fund block height is too small");
 
diff --git a/zebra-consensus/src/transaction/tests/prop.rs b/zebra-consensus/src/transaction/tests/prop.rs
index a2c22377464..e5e79005953 100644
--- a/zebra-consensus/src/transaction/tests/prop.rs
+++ b/zebra-consensus/src/transaction/tests/prop.rs
@@ -36,7 +36,7 @@ proptest! {
         let zero_lock_time = LockTime::Height(block::Height(0));
 
         let (transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -67,7 +67,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         let (mut transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -105,7 +105,7 @@ proptest! {
         let lock_time = LockTime::Height(unlock_height);
 
         let (transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -138,7 +138,7 @@ proptest! {
         };
 
         let (transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -172,7 +172,7 @@ proptest! {
         let lock_time = LockTime::Height(unlock_height);
 
         let (transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -213,7 +213,7 @@ proptest! {
         };
 
         let (transaction, known_utxos) = mock_transparent_transaction(
-            network,
+            &network,
             block_height,
             relative_source_fund_heights,
             transaction_version,
@@ -244,14 +244,14 @@ proptest! {
 fn sapling_onwards_strategy() -> impl Strategy<Value = (Network, block::Height)> {
     any::<Network>().prop_flat_map(|network| {
         let start_height_value = NetworkUpgrade::Sapling
-            .activation_height(network)
+            .activation_height(&network)
             .expect("Sapling to have an activation height")
             .0;
 
         let end_height_value = block::Height::MAX_EXPIRY_HEIGHT.0;
 
         (start_height_value..=end_height_value)
-            .prop_map(move |height_value| (network, block::Height(height_value)))
+            .prop_map(move |height_value| (network.clone(), block::Height(height_value)))
     })
 }
 
@@ -281,7 +281,7 @@ fn sapling_onwards_strategy() -> impl Strategy<Value = (Network, block::Height)>
 /// - if any item of `relative_source_heights` is not in the range `0.0..1.0` (see
 /// [`scale_block_height`] for details)
 fn mock_transparent_transaction(
-    network: Network,
+    network: &Network,
     block_height: block::Height,
     relative_source_heights: Vec<f64>,
     transaction_version: u8,
@@ -330,7 +330,7 @@ fn mock_transparent_transaction(
 /// The `transaction_version` might be reduced if it is not supported by the network upgrade active
 /// at the `block_height` of the specified `network`.
 fn sanitize_transaction_version(
-    network: Network,
+    network: &Network,
     transaction_version: u8,
     block_height: block::Height,
 ) -> (u8, NetworkUpgrade) {
@@ -450,7 +450,7 @@ fn validate(
         // Initialize the verifier
         let state_service =
             tower::service_fn(|_| async { unreachable!("State service should not be called") });
-        let verifier = transaction::Verifier::new(network, state_service);
+        let verifier = transaction::Verifier::new(&network, state_service);
 
         // Test the transaction verifier
         verifier
diff --git a/zebra-grpc/src/tests/vectors.rs b/zebra-grpc/src/tests/vectors.rs
index f84bcec299c..b34a8ec8bac 100644
--- a/zebra-grpc/src/tests/vectors.rs
+++ b/zebra-grpc/src/tests/vectors.rs
@@ -37,11 +37,11 @@ async fn test_grpc_methods_mocked() {
     test_delete_keys_errors(client.clone()).await;
 
     for network in Network::iter() {
-        test_mocked_getinfo_for_network(&client, &mock_scan_service, network).await;
-        test_mocked_getresults_for_network(&client, &mock_scan_service, network).await;
-        test_mocked_register_keys_for_network(&client, &mock_scan_service, network).await;
-        test_mocked_clear_results_for_network(&client, &mock_scan_service, network).await;
-        test_mocked_delete_keys_for_network(&client, &mock_scan_service, network).await;
+        test_mocked_getinfo_for_network(&client, &mock_scan_service, &network).await;
+        test_mocked_getresults_for_network(&client, &mock_scan_service, &network).await;
+        test_mocked_register_keys_for_network(&client, &mock_scan_service, &network).await;
+        test_mocked_clear_results_for_network(&client, &mock_scan_service, &network).await;
+        test_mocked_delete_keys_for_network(&client, &mock_scan_service, &network).await;
     }
 }
 
@@ -49,7 +49,7 @@ async fn test_grpc_methods_mocked() {
 async fn test_mocked_getinfo_for_network(
     client: &ScannerClient<Channel>,
     mock_scan_service: &MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     // create request, fake results and get response
     let get_info_response = call_get_info(client.clone(), mock_scan_service.clone(), network).await;
@@ -66,7 +66,7 @@ async fn test_mocked_getinfo_for_network(
 async fn test_mocked_getresults_for_network(
     client: &ScannerClient<Channel>,
     mock_scan_service: &MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     // create request, fake populated results and get response
     let get_results_response =
@@ -114,7 +114,7 @@ async fn test_mocked_getresults_for_network(
 async fn test_mocked_register_keys_for_network(
     client: &ScannerClient<Channel>,
     mock_scan_service: &MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     // create request, fake return value and get response
     let register_keys_response =
@@ -132,7 +132,7 @@ async fn test_mocked_register_keys_for_network(
 async fn test_mocked_clear_results_for_network(
     client: &ScannerClient<Channel>,
     mock_scan_service: &MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     // create request, fake results and get response
     let get_results_response =
@@ -181,7 +181,7 @@ async fn test_mocked_clear_results_for_network(
 async fn test_mocked_delete_keys_for_network(
     client: &ScannerClient<Channel>,
     mock_scan_service: &MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     // create request, fake results and get response
     let register_keys_response =
@@ -267,9 +267,10 @@ async fn start_server_and_get_client(
 /// Add fake populated results to the mock scan service
 async fn add_fake_populated_results(
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) {
     let mut mock_scan_service = mock_scan_service.clone();
+    let network = network.clone();
     tokio::spawn(async move {
         let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
         let mut fake_results = BTreeMap::new();
@@ -298,7 +299,7 @@ async fn add_fake_populated_results(
 /// Add fake empty results to the mock scan service
 async fn add_fake_empty_results(
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    _network: Network,
+    _network: &Network,
 ) {
     let mut mock_scan_service = mock_scan_service.clone();
     tokio::spawn(async move {
@@ -318,7 +319,7 @@ async fn add_fake_empty_results(
 async fn call_get_results(
     client: ScannerClient<Channel>,
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
     empty_results: bool,
 ) -> tonic::Response<GetResultsResponse> {
     let get_results_response_fut = {
@@ -380,7 +381,7 @@ async fn test_get_results_errors(mut client: ScannerClient<Channel>) {
 async fn call_get_info(
     client: ScannerClient<Channel>,
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    network: Network,
+    network: &Network,
 ) -> tonic::Response<InfoReply> {
     let get_info_response_fut = {
         let mut client = client.clone();
@@ -389,6 +390,7 @@ async fn call_get_info(
     };
 
     let mut mock_scan_service = mock_scan_service.clone();
+    let network = network.clone();
     tokio::spawn(async move {
         mock_scan_service
             .expect_request_that(|req| matches!(req, ScanRequest::Info))
@@ -408,7 +410,7 @@ async fn call_get_info(
 async fn call_register_keys(
     client: ScannerClient<Channel>,
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    _network: Network,
+    _network: &Network,
 ) -> tonic::Response<RegisterKeysResponse> {
     let key_with_height = KeyWithHeight {
         key: ZECPAGES_SAPLING_VIEWING_KEY.to_string(),
@@ -472,7 +474,7 @@ async fn test_register_keys_errors(client: ScannerClient<Channel>) {
 async fn call_clear_results(
     client: ScannerClient<Channel>,
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    _network: Network,
+    _network: &Network,
 ) -> tonic::Response<Empty> {
     let clear_results_response_fut = {
         let mut client = client.clone();
@@ -525,7 +527,7 @@ async fn test_clear_results_errors(client: ScannerClient<Channel>) {
 async fn call_delete_keys(
     client: ScannerClient<Channel>,
     mock_scan_service: MockService<ScanRequest, ScanResponse, PanicAssertion>,
-    _network: Network,
+    _network: &Network,
 ) -> tonic::Response<Empty> {
     let delete_keys_response_fut = {
         let mut client = client.clone();
diff --git a/zebra-network/src/address_book.rs b/zebra-network/src/address_book.rs
index 2f2142b6e0e..f19cdcbc819 100644
--- a/zebra-network/src/address_book.rs
+++ b/zebra-network/src/address_book.rs
@@ -138,7 +138,7 @@ impl AddressBook {
     /// Uses the supplied [`tracing::Span`] for address book operations.
     pub fn new(
         local_listener: SocketAddr,
-        network: Network,
+        network: &Network,
         max_connections_per_ip: usize,
         span: Span,
     ) -> AddressBook {
@@ -157,7 +157,7 @@ impl AddressBook {
         let mut new_book = AddressBook {
             by_addr: OrderedMap::new(|meta_addr| Reverse(*meta_addr)),
             local_listener: canonical_socket_addr(local_listener),
-            network,
+            network: network.clone(),
             addr_limit: constants::MAX_ADDRS_IN_ADDRESS_BOOK,
             span,
             address_metrics_tx,
@@ -183,7 +183,7 @@ impl AddressBook {
     #[cfg(any(test, feature = "proptest-impl"))]
     pub fn new_with_addrs(
         local_listener: SocketAddr,
-        network: Network,
+        network: &Network,
         max_connections_per_ip: usize,
         addr_limit: usize,
         span: Span,
@@ -293,7 +293,7 @@ impl AddressBook {
         // Then sanitize and shuffle
         let mut peers: Vec<MetaAddr> = peers
             .descending_values()
-            .filter_map(|meta_addr| meta_addr.sanitize(self.network))
+            .filter_map(|meta_addr| meta_addr.sanitize(&self.network))
             // # Security
             //
             // Remove peers that:
@@ -431,7 +431,7 @@ impl AddressBook {
         if let Some(updated) = updated {
             // Ignore invalid outbound addresses.
             // (Inbound connections can be monitored via Zebra's metrics.)
-            if !updated.address_is_valid_for_outbound(self.network) {
+            if !updated.address_is_valid_for_outbound(&self.network) {
                 return None;
             }
 
@@ -440,7 +440,7 @@ impl AddressBook {
             //
             // Otherwise, if we got the info directly from the peer,
             // store it in the address book, so we know not to reconnect.
-            if !updated.last_known_info_is_valid_for_outbound(self.network)
+            if !updated.last_known_info_is_valid_for_outbound(&self.network)
                 && updated.last_connection_state.is_never_attempted()
             {
                 return None;
@@ -598,7 +598,7 @@ impl AddressBook {
         self.by_addr
             .descending_values()
             .filter(move |peer| {
-                peer.is_ready_for_connection_attempt(instant_now, chrono_now, self.network)
+                peer.is_ready_for_connection_attempt(instant_now, chrono_now, &self.network)
                     && self.is_ready_for_connection_attempt_with_ip(&peer.addr.ip(), chrono_now)
             })
             .cloned()
@@ -630,7 +630,7 @@ impl AddressBook {
         self.by_addr
             .descending_values()
             .filter(move |peer| {
-                !peer.is_ready_for_connection_attempt(instant_now, chrono_now, self.network)
+                !peer.is_ready_for_connection_attempt(instant_now, chrono_now, &self.network)
             })
             .cloned()
     }
@@ -800,7 +800,7 @@ impl Clone for AddressBook {
         AddressBook {
             by_addr: self.by_addr.clone(),
             local_listener: self.local_listener,
-            network: self.network,
+            network: self.network.clone(),
             addr_limit: self.addr_limit,
             span: self.span.clone(),
             address_metrics_tx,
diff --git a/zebra-network/src/address_book/tests/prop.rs b/zebra-network/src/address_book/tests/prop.rs
index 75ad6635a36..e65b54045cd 100644
--- a/zebra-network/src/address_book/tests/prop.rs
+++ b/zebra-network/src/address_book/tests/prop.rs
@@ -32,7 +32,7 @@ proptest! {
 
         let address_book = AddressBook::new_with_addrs(
             local_listener,
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             MAX_ADDRS_IN_ADDRESS_BOOK,
             Span::none(),
@@ -71,7 +71,7 @@ proptest! {
 
         let address_book = AddressBook::new_with_addrs(
             local_listener,
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             MAX_ADDRS_IN_ADDRESS_BOOK,
             Span::none(),
@@ -110,7 +110,7 @@ proptest! {
 
         let mut address_book = AddressBook::new_with_addrs(
             local_listener,
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             addr_limit,
             Span::none(),
@@ -133,7 +133,7 @@ proptest! {
 
         let mut address_book = AddressBook::new_with_addrs(
             local_listener,
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             addr_limit,
             Span::none(),
diff --git a/zebra-network/src/address_book/tests/vectors.rs b/zebra-network/src/address_book/tests/vectors.rs
index 16a9544429c..8a262b51001 100644
--- a/zebra-network/src/address_book/tests/vectors.rs
+++ b/zebra-network/src/address_book/tests/vectors.rs
@@ -22,7 +22,7 @@ use crate::{
 fn address_book_empty() {
     let address_book = AddressBook::new(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         Span::current(),
     );
@@ -54,7 +54,7 @@ fn address_book_peer_order() {
     let addrs = vec![meta_addr1, meta_addr2];
     let address_book = AddressBook::new_with_addrs(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         MAX_ADDRS_IN_ADDRESS_BOOK,
         Span::current(),
@@ -71,7 +71,7 @@ fn address_book_peer_order() {
     let addrs = vec![meta_addr2, meta_addr1];
     let address_book = AddressBook::new_with_addrs(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         MAX_ADDRS_IN_ADDRESS_BOOK,
         Span::current(),
@@ -91,7 +91,7 @@ fn address_book_peer_order() {
     let addrs = vec![meta_addr1, meta_addr2];
     let address_book = AddressBook::new_with_addrs(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         MAX_ADDRS_IN_ADDRESS_BOOK,
         Span::current(),
@@ -108,7 +108,7 @@ fn address_book_peer_order() {
     let addrs = vec![meta_addr2, meta_addr1];
     let address_book = AddressBook::new_with_addrs(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         MAX_ADDRS_IN_ADDRESS_BOOK,
         Span::current(),
@@ -163,7 +163,7 @@ fn test_reconnection_peers_skips_recently_updated_ip<
     let addrs = vec![meta_addr1, meta_addr2];
     let address_book = AddressBook::new_with_addrs(
         "0.0.0.0:0".parse().unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         MAX_ADDRS_IN_ADDRESS_BOOK,
         Span::current(),
diff --git a/zebra-network/src/address_book_updater.rs b/zebra-network/src/address_book_updater.rs
index 2feeb49e8e0..fc3e8f93258 100644
--- a/zebra-network/src/address_book_updater.rs
+++ b/zebra-network/src/address_book_updater.rs
@@ -56,7 +56,7 @@ impl AddressBookUpdater {
 
         let address_book = AddressBook::new(
             local_listener,
-            config.network,
+            &config.network,
             config.max_connections_per_ip,
             span!(Level::TRACE, "address book"),
         );
diff --git a/zebra-network/src/config.rs b/zebra-network/src/config.rs
index 2c7a9b416ff..da989f99093 100644
--- a/zebra-network/src/config.rs
+++ b/zebra-network/src/config.rs
@@ -381,7 +381,7 @@ impl Config {
 
     /// Returns the addresses in the peer list cache file, if available.
     pub async fn load_peer_cache(&self) -> io::Result<HashSet<PeerSocketAddr>> {
-        let Some(peer_cache_file) = self.cache_dir.peer_cache_file_path(self.network) else {
+        let Some(peer_cache_file) = self.cache_dir.peer_cache_file_path(&self.network) else {
             return Ok(HashSet::new());
         };
 
@@ -457,7 +457,7 @@ impl Config {
     /// Atomic writes avoid corrupting the cache if Zebra panics or crashes, or if multiple Zebra
     /// instances try to read and write the same cache file.
     pub async fn update_peer_cache(&self, peer_list: HashSet<PeerSocketAddr>) -> io::Result<()> {
-        let Some(peer_cache_file) = self.cache_dir.peer_cache_file_path(self.network) else {
+        let Some(peer_cache_file) = self.cache_dir.peer_cache_file_path(&self.network) else {
             return Ok(());
         };
 
diff --git a/zebra-network/src/config/cache_dir.rs b/zebra-network/src/config/cache_dir.rs
index 112ebe704ec..99b75f9f4e1 100644
--- a/zebra-network/src/config/cache_dir.rs
+++ b/zebra-network/src/config/cache_dir.rs
@@ -45,7 +45,7 @@ impl CacheDir {
     }
 
     /// Returns the peer cache file path for `network`, if enabled.
-    pub fn peer_cache_file_path(&self, network: Network) -> Option<PathBuf> {
+    pub fn peer_cache_file_path(&self, network: &Network) -> Option<PathBuf> {
         Some(
             self.cache_dir()?
                 .join("network")
diff --git a/zebra-network/src/constants.rs b/zebra-network/src/constants.rs
index 12fabbff51a..7d7543d843d 100644
--- a/zebra-network/src/constants.rs
+++ b/zebra-network/src/constants.rs
@@ -395,8 +395,8 @@ lazy_static! {
     pub static ref INITIAL_MIN_NETWORK_PROTOCOL_VERSION: HashMap<Network, Version> = {
         let mut hash_map = HashMap::new();
 
-        hash_map.insert(Mainnet, Version::min_specified_for_upgrade(Mainnet, Nu5));
-        hash_map.insert(Testnet, Version::min_specified_for_upgrade(Testnet, Nu5));
+        hash_map.insert(Mainnet, Version::min_specified_for_upgrade(&Mainnet, Nu5));
+        hash_map.insert(Testnet, Version::min_specified_for_upgrade(&Testnet, Nu5));
 
         hash_map
     };
diff --git a/zebra-network/src/isolated.rs b/zebra-network/src/isolated.rs
index 403b5102042..62b3eee7a93 100644
--- a/zebra-network/src/isolated.rs
+++ b/zebra-network/src/isolated.rs
@@ -47,7 +47,7 @@ mod tests;
 ///
 /// - `user_agent`: a valid BIP14 user-agent, e.g., the empty string.
 pub fn connect_isolated<PeerTransport>(
-    network: Network,
+    network: &Network,
     data_stream: PeerTransport,
     user_agent: String,
 ) -> impl Future<Output = Result<Client, BoxError>>
@@ -74,7 +74,7 @@ where
 /// This function can make the isolated connection send different responses to peers,
 /// which makes it stand out from other isolated connections from other peers.
 pub fn connect_isolated_with_inbound<PeerTransport, InboundService>(
-    network: Network,
+    network: &Network,
     data_stream: PeerTransport,
     user_agent: String,
     inbound_service: InboundService,
@@ -86,7 +86,7 @@ where
     InboundService::Future: Send,
 {
     let config = Config {
-        network,
+        network: network.clone(),
         ..Config::default()
     };
 
@@ -125,7 +125,7 @@ where
 ///
 /// Prefer `connect_isolated_tor` if available.
 pub fn connect_isolated_tcp_direct(
-    network: Network,
+    network: &Network,
     addr: impl Into<PeerSocketAddr>,
     user_agent: String,
 ) -> impl Future<Output = Result<Client, BoxError>> {
@@ -145,7 +145,7 @@ pub fn connect_isolated_tcp_direct(
 /// This function can make the isolated connection send different responses to peers,
 /// which makes it stand out from other isolated connections from other peers.
 pub fn connect_isolated_tcp_direct_with_inbound<InboundService>(
-    network: Network,
+    network: &Network,
     addr: impl Into<PeerSocketAddr>,
     user_agent: String,
     inbound_service: InboundService,
@@ -156,10 +156,11 @@ where
     InboundService::Future: Send,
 {
     let addr = addr.into();
+    let network = network.clone();
 
     tokio::net::TcpStream::connect(*addr)
         .err_into()
         .and_then(move |tcp_stream| {
-            connect_isolated_with_inbound(network, tcp_stream, user_agent, inbound_service)
+            connect_isolated_with_inbound(&network, tcp_stream, user_agent, inbound_service)
         })
 }
diff --git a/zebra-network/src/isolated/tests/vectors.rs b/zebra-network/src/isolated/tests/vectors.rs
index aa13b65e91e..94f75fe57c0 100644
--- a/zebra-network/src/isolated/tests/vectors.rs
+++ b/zebra-network/src/isolated/tests/vectors.rs
@@ -40,15 +40,17 @@ async fn connect_isolated_sends_anonymised_version_message_tcp_net(network: Netw
     // Connection errors are detected using the JoinHandle.
     // (They might also make the test hang.)
     let mut outbound_join_handle = tokio::spawn(connect_isolated_tcp_direct(
-        network,
+        &network,
         listen_addr,
         "".to_string(),
     ));
 
     let (inbound_conn, _) = listener.accept().await.unwrap();
 
-    let mut inbound_stream =
-        Framed::new(inbound_conn, Codec::builder().for_network(network).finish());
+    let mut inbound_stream = Framed::new(
+        inbound_conn,
+        Codec::builder().for_network(&network).finish(),
+    );
 
     check_version_message(network, &mut inbound_stream).await;
 
@@ -90,11 +92,11 @@ async fn connect_isolated_sends_anonymised_version_message_mem_net(network: Netw
     let (inbound_stream, outbound_stream) = tokio::io::duplex(1024);
 
     let mut outbound_join_handle =
-        tokio::spawn(connect_isolated(network, outbound_stream, "".to_string()));
+        tokio::spawn(connect_isolated(&network, outbound_stream, "".to_string()));
 
     let mut inbound_stream = Framed::new(
         inbound_stream,
-        Codec::builder().for_network(network).finish(),
+        Codec::builder().for_network(&network).finish(),
     );
 
     check_version_message(network, &mut inbound_stream).await;
diff --git a/zebra-network/src/meta_addr.rs b/zebra-network/src/meta_addr.rs
index 507620f29a0..8c0336f4a5a 100644
--- a/zebra-network/src/meta_addr.rs
+++ b/zebra-network/src/meta_addr.rs
@@ -559,7 +559,7 @@ impl MetaAddr {
         &self,
         instant_now: Instant,
         chrono_now: chrono::DateTime<Utc>,
-        network: Network,
+        network: &Network,
     ) -> bool {
         self.last_known_info_is_valid_for_outbound(network)
             && !self.was_recently_updated(instant_now, chrono_now)
@@ -571,8 +571,8 @@ impl MetaAddr {
     ///
     /// Since the addresses in the address book are unique, this check can be
     /// used to permanently reject entire [`MetaAddr`]s.
-    pub fn address_is_valid_for_outbound(&self, network: Network) -> bool {
-        address_is_valid_for_outbound_connections(self.addr, network).is_ok()
+    pub fn address_is_valid_for_outbound(&self, network: &Network) -> bool {
+        address_is_valid_for_outbound_connections(self.addr, network.clone()).is_ok()
     }
 
     /// Is the last known information for this peer valid for outbound
@@ -582,7 +582,7 @@ impl MetaAddr {
     /// only be used to:
     /// - reject `NeverAttempted...` [`MetaAddrChange`]s, and
     /// - temporarily stop outbound connections to a [`MetaAddr`].
-    pub fn last_known_info_is_valid_for_outbound(&self, network: Network) -> bool {
+    pub fn last_known_info_is_valid_for_outbound(&self, network: &Network) -> bool {
         let is_node = match self.services {
             Some(services) => services.contains(PeerServices::NODE_NETWORK),
             None => true,
@@ -627,7 +627,7 @@ impl MetaAddr {
     ///
     /// Returns `None` if this `MetaAddr` should not be sent to remote peers.
     #[allow(clippy::unwrap_in_result)]
-    pub fn sanitize(&self, network: Network) -> Option<MetaAddr> {
+    pub fn sanitize(&self, network: &Network) -> Option<MetaAddr> {
         if !self.last_known_info_is_valid_for_outbound(network) {
             return None;
         }
diff --git a/zebra-network/src/meta_addr/arbitrary.rs b/zebra-network/src/meta_addr/arbitrary.rs
index 985b36693ea..3f314f36770 100644
--- a/zebra-network/src/meta_addr/arbitrary.rs
+++ b/zebra-network/src/meta_addr/arbitrary.rs
@@ -106,7 +106,7 @@ impl MetaAddrChange {
                 |(addr, services, local_now)| {
                     let addr = MetaAddr::new_gossiped_meta_addr(addr, services, local_now);
 
-                    if addr.last_known_info_is_valid_for_outbound(Mainnet) {
+                    if addr.last_known_info_is_valid_for_outbound(&Mainnet) {
                         Some(addr.addr.port())
                     } else {
                         None
diff --git a/zebra-network/src/meta_addr/tests/prop.rs b/zebra-network/src/meta_addr/tests/prop.rs
index dfd497b3d22..fc3859d7146 100644
--- a/zebra-network/src/meta_addr/tests/prop.rs
+++ b/zebra-network/src/meta_addr/tests/prop.rs
@@ -42,9 +42,9 @@ proptest! {
     fn sanitize_avoids_leaks(addr in MetaAddr::arbitrary()) {
         let _init_guard = zebra_test::init();
 
-        if let Some(sanitized) = addr.sanitize(Mainnet) {
+        if let Some(sanitized) = addr.sanitize(&Mainnet) {
             // check that all sanitized addresses are valid for outbound
-            prop_assert!(addr.last_known_info_is_valid_for_outbound(Mainnet));
+            prop_assert!(addr.last_known_info_is_valid_for_outbound(&Mainnet));
             // also check the address, port, and services individually
             prop_assert!(!addr.addr.ip().is_unspecified());
             prop_assert_ne!(addr.addr.port(), 0);
@@ -117,7 +117,7 @@ proptest! {
         let mut attempt_count: usize = 0;
 
         for change in changes {
-            while addr.is_ready_for_connection_attempt(instant_now, chrono_now, Mainnet) {
+            while addr.is_ready_for_connection_attempt(instant_now, chrono_now, &Mainnet) {
                 // Simulate an attempt
                 addr = if let Some(addr) = MetaAddr::new_reconnect(addr.addr)
                     .apply_to_meta_addr(addr, instant_now, chrono_now) {
@@ -158,7 +158,7 @@ proptest! {
 
         let address_book = AddressBook::new_with_addrs(
             local_listener,
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             MAX_ADDRS_IN_ADDRESS_BOOK,
             Span::none(),
@@ -176,7 +176,7 @@ proptest! {
         // regardless of where they have come from
         prop_assert_eq!(
             book_sanitized_local_listener.cloned(),
-            expected_local_listener.sanitize(Mainnet),
+            expected_local_listener.sanitize(&Mainnet),
             "address book: {:?}, sanitized_addrs: {:?}, canonical_local_listener: {:?}",
             address_book,
             sanitized_addrs,
@@ -217,7 +217,7 @@ proptest! {
             // Check address book update - return value
             let mut address_book = AddressBook::new_with_addrs(
                 local_listener,
-                Mainnet,
+                &Mainnet,
                 DEFAULT_MAX_CONNS_PER_IP,
                 1,
                 Span::none(),
@@ -229,8 +229,8 @@ proptest! {
             let book_contents: Vec<MetaAddr> = address_book.peers().collect();
 
             // Ignore the same addresses that the address book ignores
-            let expected_result = if !expected_result.address_is_valid_for_outbound(Mainnet)
-                || ( !expected_result.last_known_info_is_valid_for_outbound(Mainnet)
+            let expected_result = if !expected_result.address_is_valid_for_outbound(&Mainnet)
+                || ( !expected_result.last_known_info_is_valid_for_outbound(&Mainnet)
                       && expected_result.last_connection_state.is_never_attempted())
             {
                None
@@ -323,7 +323,7 @@ proptest! {
 
         // Only put valid addresses in the address book.
         // This means some tests will start with an empty address book.
-        let addrs = if addr.last_known_info_is_valid_for_outbound(Mainnet) {
+        let addrs = if addr.last_known_info_is_valid_for_outbound(&Mainnet) {
             Some(addr)
         } else {
             None
@@ -331,7 +331,7 @@ proptest! {
 
         let address_book = Arc::new(std::sync::Mutex::new(AddressBook::new_with_addrs(
             SocketAddr::from_str("0.0.0.0:0").unwrap(),
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             MAX_ADDRS_IN_ADDRESS_BOOK,
             Span::none(),
@@ -371,7 +371,7 @@ proptest! {
                         LIVE_PEER_INTERVALS,
                         overall_test_time,
                         peer_change_interval,
-                        addr.last_known_info_is_valid_for_outbound(Mainnet),
+                        addr.last_known_info_is_valid_for_outbound(&Mainnet),
                     );
                 }
 
@@ -438,7 +438,7 @@ proptest! {
                     let addr = addrs.entry(addr.addr).or_insert(*addr);
                     let change = changes.get(change_index);
 
-                    while addr.is_ready_for_connection_attempt(instant_now, chrono_now, Mainnet) {
+                    while addr.is_ready_for_connection_attempt(instant_now, chrono_now, &Mainnet) {
                         // Simulate an attempt
                         *addr = if let Some(addr) = MetaAddr::new_reconnect(addr.addr)
                             .apply_to_meta_addr(*addr, instant_now, chrono_now) {
diff --git a/zebra-network/src/meta_addr/tests/vectors.rs b/zebra-network/src/meta_addr/tests/vectors.rs
index d5a81bfd996..c4775362ade 100644
--- a/zebra-network/src/meta_addr/tests/vectors.rs
+++ b/zebra-network/src/meta_addr/tests/vectors.rs
@@ -48,10 +48,10 @@ fn sanitize_extremes() {
         last_connection_state: Default::default(),
     };
 
-    if let Some(min_sanitized) = min_time_entry.sanitize(Mainnet) {
+    if let Some(min_sanitized) = min_time_entry.sanitize(&Mainnet) {
         check::sanitize_avoids_leaks(&min_time_entry, &min_sanitized);
     }
-    if let Some(max_sanitized) = max_time_entry.sanitize(Mainnet) {
+    if let Some(max_sanitized) = max_time_entry.sanitize(&Mainnet) {
         check::sanitize_avoids_leaks(&max_time_entry, &max_sanitized);
     }
 }
diff --git a/zebra-network/src/peer/handshake.rs b/zebra-network/src/peer/handshake.rs
index 161c25f0ac5..963b49086b2 100644
--- a/zebra-network/src/peer/handshake.rs
+++ b/zebra-network/src/peer/handshake.rs
@@ -515,8 +515,8 @@ where
         let user_agent = self.user_agent.unwrap_or_default();
         let our_services = self.our_services.unwrap_or_else(PeerServices::empty);
         let relay = self.relay.unwrap_or(false);
-        let network = config.network;
-        let minimum_peer_version = MinimumPeerVersion::new(self.latest_chain_tip, network);
+        let network = config.network.clone();
+        let minimum_peer_version = MinimumPeerVersion::new(self.latest_chain_tip, &network);
 
         Ok(Handshake {
             config,
@@ -898,7 +898,7 @@ where
             let mut peer_conn = Framed::new(
                 data_stream,
                 Codec::builder()
-                    .for_network(config.network)
+                    .for_network(&config.network)
                     .with_metrics_addr_label(connected_addr.get_transient_addr_label())
                     .finish(),
             );
diff --git a/zebra-network/src/peer/minimum_peer_version.rs b/zebra-network/src/peer/minimum_peer_version.rs
index 97846a64c03..ff0e5cd87ba 100644
--- a/zebra-network/src/peer/minimum_peer_version.rs
+++ b/zebra-network/src/peer/minimum_peer_version.rs
@@ -35,9 +35,9 @@ where
 {
     /// Create a new [`MinimumPeerVersion`] to track the minimum supported peer protocol version
     /// for the current `chain_tip` on the `network`.
-    pub fn new(chain_tip: C, network: Network) -> Self {
+    pub fn new(chain_tip: C, network: &Network) -> Self {
         MinimumPeerVersion {
-            network,
+            network: network.clone(),
             chain_tip,
             current_minimum: Version::min_remote_for_height(network, None),
             has_changed: true,
@@ -72,7 +72,7 @@ where
     /// has changed.
     fn update(&mut self) {
         let height = self.chain_tip.best_tip_height();
-        let new_minimum = Version::min_remote_for_height(self.network, height);
+        let new_minimum = Version::min_remote_for_height(&self.network, height);
 
         if self.current_minimum != new_minimum {
             self.current_minimum = new_minimum;
@@ -99,7 +99,7 @@ where
 {
     fn clone(&self) -> Self {
         MinimumPeerVersion {
-            network: self.network,
+            network: self.network.clone(),
             chain_tip: self.chain_tip.clone(),
             current_minimum: self.current_minimum,
             has_changed: true,
diff --git a/zebra-network/src/peer/minimum_peer_version/tests.rs b/zebra-network/src/peer/minimum_peer_version/tests.rs
index 57f6fed5b55..861eb66a4ab 100644
--- a/zebra-network/src/peer/minimum_peer_version/tests.rs
+++ b/zebra-network/src/peer/minimum_peer_version/tests.rs
@@ -13,7 +13,7 @@ use super::MinimumPeerVersion;
 mod prop;
 
 impl MinimumPeerVersion<MockChainTip> {
-    pub fn with_mock_chain_tip(network: Network) -> (Self, MockChainTipSender) {
+    pub fn with_mock_chain_tip(network: &Network) -> (Self, MockChainTipSender) {
         let (chain_tip, best_tip) = MockChainTip::new();
         let minimum_peer_version = MinimumPeerVersion::new(chain_tip, network);
 
diff --git a/zebra-network/src/peer/minimum_peer_version/tests/prop.rs b/zebra-network/src/peer/minimum_peer_version/tests/prop.rs
index cab53748da2..c88fd7aa880 100644
--- a/zebra-network/src/peer/minimum_peer_version/tests/prop.rs
+++ b/zebra-network/src/peer/minimum_peer_version/tests/prop.rs
@@ -12,11 +12,11 @@ proptest! {
         block_height in any::<Option<block::Height>>(),
     ) {
         let (mut minimum_peer_version, best_tip) =
-            MinimumPeerVersion::with_mock_chain_tip(network);
+            MinimumPeerVersion::with_mock_chain_tip(&network);
 
         best_tip.send_best_tip_height(block_height);
 
-        let expected_minimum_version = Version::min_remote_for_height(network, block_height);
+        let expected_minimum_version = Version::min_remote_for_height(&network, block_height);
 
         prop_assert_eq!(minimum_peer_version.current(), expected_minimum_version);
     }
@@ -28,12 +28,12 @@ proptest! {
         block_heights in any::<Vec<Option<block::Height>>>(),
     ) {
         let (mut minimum_peer_version, best_tip) =
-            MinimumPeerVersion::with_mock_chain_tip(network);
+            MinimumPeerVersion::with_mock_chain_tip(&network);
 
         for block_height in block_heights {
             best_tip.send_best_tip_height(block_height);
 
-            let expected_minimum_version = Version::min_remote_for_height(network, block_height);
+            let expected_minimum_version = Version::min_remote_for_height(&network, block_height);
 
             prop_assert_eq!(minimum_peer_version.current(), expected_minimum_version);
         }
@@ -46,9 +46,9 @@ proptest! {
         block_height_updates in any::<Vec<Option<Option<block::Height>>>>(),
     ) {
         let (mut minimum_peer_version, best_tip) =
-            MinimumPeerVersion::with_mock_chain_tip(network);
+            MinimumPeerVersion::with_mock_chain_tip(&network);
 
-        let mut current_minimum_version = Version::min_remote_for_height(network, None);
+        let mut current_minimum_version = Version::min_remote_for_height(&network, None);
         let mut expected_minimum_version = Some(current_minimum_version);
 
         prop_assert_eq!(minimum_peer_version.changed(), expected_minimum_version);
@@ -57,7 +57,7 @@ proptest! {
             if let Some(new_block_height) = update {
                 best_tip.send_best_tip_height(new_block_height);
 
-                let new_minimum_version = Version::min_remote_for_height(network, new_block_height);
+                let new_minimum_version = Version::min_remote_for_height(&network, new_block_height);
 
                 expected_minimum_version = if new_minimum_version != current_minimum_version {
                     Some(new_minimum_version)
diff --git a/zebra-network/src/peer_set/candidate_set/tests/prop.rs b/zebra-network/src/peer_set/candidate_set/tests/prop.rs
index d434e9866e2..5c30d5c6602 100644
--- a/zebra-network/src/peer_set/candidate_set/tests/prop.rs
+++ b/zebra-network/src/peer_set/candidate_set/tests/prop.rs
@@ -71,7 +71,7 @@ proptest! {
         });
 
         // Since the address book is empty, there won't be any available peers
-        let address_book = AddressBook::new(SocketAddr::from_str("0.0.0.0:0").unwrap(), Mainnet, DEFAULT_MAX_CONNS_PER_IP, Span::none());
+        let address_book = AddressBook::new(SocketAddr::from_str("0.0.0.0:0").unwrap(), &Mainnet, DEFAULT_MAX_CONNS_PER_IP, Span::none());
 
         let mut candidate_set = CandidateSet::new(Arc::new(std::sync::Mutex::new(address_book)), peer_service);
 
@@ -113,7 +113,7 @@ proptest! {
             unreachable!("Mock peer service is never used");
         });
 
-        let mut address_book = AddressBook::new(SocketAddr::from_str("0.0.0.0:0").unwrap(), Mainnet, DEFAULT_MAX_CONNS_PER_IP, Span::none());
+        let mut address_book = AddressBook::new(SocketAddr::from_str("0.0.0.0:0").unwrap(), &Mainnet, DEFAULT_MAX_CONNS_PER_IP, Span::none());
         address_book.extend(peers);
 
         let mut candidate_set = CandidateSet::new(Arc::new(std::sync::Mutex::new(address_book)), peer_service);
diff --git a/zebra-network/src/peer_set/candidate_set/tests/vectors.rs b/zebra-network/src/peer_set/candidate_set/tests/vectors.rs
index e9811796b8f..14c6a1dbe9d 100644
--- a/zebra-network/src/peer_set/candidate_set/tests/vectors.rs
+++ b/zebra-network/src/peer_set/candidate_set/tests/vectors.rs
@@ -140,7 +140,7 @@ fn candidate_set_updates_are_rate_limited() {
 
     let address_book = AddressBook::new(
         SocketAddr::from_str("0.0.0.0:0").unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         Span::none(),
     );
@@ -186,7 +186,7 @@ fn candidate_set_update_after_update_initial_is_rate_limited() {
 
     let address_book = AddressBook::new(
         SocketAddr::from_str("0.0.0.0:0").unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         Span::none(),
     );
diff --git a/zebra-network/src/peer_set/initialize.rs b/zebra-network/src/peer_set/initialize.rs
index e9ba3d38085..7268b21057c 100644
--- a/zebra-network/src/peer_set/initialize.rs
+++ b/zebra-network/src/peer_set/initialize.rs
@@ -174,7 +174,7 @@ where
         handle_rx,
         inv_receiver,
         address_metrics,
-        MinimumPeerVersion::new(latest_chain_tip, config.network),
+        MinimumPeerVersion::new(latest_chain_tip, &config.network),
         None,
     );
     let peer_set = Buffer::new(BoxService::new(peer_set), constants::PEERSET_BUFFER_SIZE);
@@ -436,7 +436,7 @@ async fn limit_initial_peers(
     // Filter out invalid initial peers, and prioritise valid peers for initial connections.
     // (This treats initial peers the same way we treat gossiped peers.)
     for peer_addr in all_peers {
-        let preference = PeerPreference::new(peer_addr, config.network);
+        let preference = PeerPreference::new(peer_addr, config.network.clone());
 
         match preference {
             Ok(preference) => preferred_peers
@@ -499,7 +499,7 @@ async fn limit_initial_peers(
 pub(crate) async fn open_listener(config: &Config) -> (TcpListener, SocketAddr) {
     // Warn if we're configured using the wrong network port.
     if let Err(wrong_addr) =
-        address_is_valid_for_inbound_listeners(config.listen_addr, config.network)
+        address_is_valid_for_inbound_listeners(config.listen_addr, config.network.clone())
     {
         warn!(
             "We are configured with address {} on {:?}, but it could cause network issues. \
diff --git a/zebra-network/src/peer_set/initialize/tests/vectors.rs b/zebra-network/src/peer_set/initialize/tests/vectors.rs
index 59bafdc771e..54fd25a26a4 100644
--- a/zebra-network/src/peer_set/initialize/tests/vectors.rs
+++ b/zebra-network/src/peer_set/initialize/tests/vectors.rs
@@ -325,7 +325,7 @@ async fn written_peer_cache_can_be_read_manually() {
         assert!(
             !cached_peers.is_empty(),
             "unexpected empty peer cache from manual load: {:?}",
-            config.cache_dir.peer_cache_file_path(config.network)
+            config.cache_dir.peer_cache_file_path(&config.network)
         );
     }
 }
@@ -371,7 +371,7 @@ async fn written_peer_cache_is_automatically_read_on_startup() {
         assert!(
             approximate_cached_peer_count > 0,
             "unexpected empty address book using cache from previous instance: {:?}",
-            config.cache_dir.peer_cache_file_path(config.network)
+            config.cache_dir.peer_cache_file_path(&config.network)
         );
     }
 }
diff --git a/zebra-network/src/peer_set/set/tests.rs b/zebra-network/src/peer_set/set/tests.rs
index e044447e389..b2b19770583 100644
--- a/zebra-network/src/peer_set/set/tests.rs
+++ b/zebra-network/src/peer_set/set/tests.rs
@@ -336,7 +336,7 @@ impl PeerSetGuard {
             .expect("Invalid local listener address");
         let address_book = AddressBook::new(
             local_listener,
-            Network::Mainnet,
+            &Network::Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             Span::none(),
         );
@@ -347,7 +347,7 @@ impl PeerSetGuard {
 
 /// A pair of block height values, where one is before and the other is at or after an arbitrary
 /// network upgrade's activation height.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub struct BlockHeightPairAcrossNetworkUpgrades {
     /// The network for which the block height values represent heights before and after an
     /// upgrade.
@@ -374,7 +374,7 @@ impl Arbitrary for BlockHeightPairAcrossNetworkUpgrades {
                 "missing activation height for network upgrade",
                 |(network, upgrade)| {
                     upgrade
-                        .activation_height(network)
+                        .activation_height(&network)
                         .map(|height| (network, height))
                 },
             )
diff --git a/zebra-network/src/peer_set/set/tests/prop.rs b/zebra-network/src/peer_set/set/tests/prop.rs
index b7301fea214..6f64fcb15c6 100644
--- a/zebra-network/src/peer_set/set/tests/prop.rs
+++ b/zebra-network/src/peer_set/set/tests/prop.rs
@@ -31,7 +31,7 @@ proptest! {
         let (runtime, _init_guard) = zebra_test::init_async();
 
         let (mut minimum_peer_version, best_tip_height) =
-            MinimumPeerVersion::with_mock_chain_tip(network);
+            MinimumPeerVersion::with_mock_chain_tip(&network);
 
         best_tip_height.send_best_tip_height(block_height);
 
@@ -64,7 +64,7 @@ proptest! {
         let (runtime, _init_guard) = zebra_test::init_async();
 
         let (mut minimum_peer_version, best_tip_height) =
-            MinimumPeerVersion::with_mock_chain_tip(block_heights.network);
+            MinimumPeerVersion::with_mock_chain_tip(&block_heights.network);
 
         best_tip_height.send_best_tip_height(block_heights.before_upgrade);
 
@@ -117,7 +117,7 @@ proptest! {
         // Get peers and handles
         let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
         let (minimum_peer_version, _best_tip_height) =
-            MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+            MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
         // Build a peerset
         runtime.block_on(async move {
@@ -193,7 +193,7 @@ proptest! {
         // Get peers and handles
         let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
         let (minimum_peer_version, _best_tip_height) =
-            MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+            MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
         runtime.block_on(async move {
             // Build a peerset
@@ -264,7 +264,7 @@ proptest! {
         // Get peers and handles
         let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
         let (minimum_peer_version, _best_tip_height) =
-            MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+            MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
         runtime.block_on(async move {
             // Build a peerset
diff --git a/zebra-network/src/peer_set/set/tests/vectors.rs b/zebra-network/src/peer_set/set/tests/vectors.rs
index 02ddc25d85e..0a5d3d34eaf 100644
--- a/zebra-network/src/peer_set/set/tests/vectors.rs
+++ b/zebra-network/src/peer_set/set/tests/vectors.rs
@@ -25,7 +25,7 @@ fn peer_set_ready_single_connection() {
     // We are going to use just one peer version in this test
     let peer_versions = PeerVersions {
         peer_versions: vec![Version::min_specified_for_upgrade(
-            Network::Mainnet,
+            &Network::Mainnet,
             NetworkUpgrade::Nu5,
         )],
     };
@@ -37,7 +37,7 @@ fn peer_set_ready_single_connection() {
     // Get peers and client handles of them
     let (discovered_peers, handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // We will just use the first peer handle
     let mut client_handle = handles
@@ -118,7 +118,7 @@ fn peer_set_ready_single_connection() {
 #[test]
 fn peer_set_ready_multiple_connections() {
     // Use three peers with the same version
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: vec![peer_version, peer_version, peer_version],
     };
@@ -136,7 +136,7 @@ fn peer_set_ready_multiple_connections() {
     // Get peers and client handles of them
     let (discovered_peers, handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), 3);
@@ -182,7 +182,7 @@ fn peer_set_rejects_connections_past_per_ip_limit() {
     const NUM_PEER_VERSIONS: usize = crate::constants::DEFAULT_MAX_CONNS_PER_IP + 1;
 
     // Use three peers with the same version
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: [peer_version; NUM_PEER_VERSIONS].into_iter().collect(),
     };
@@ -200,7 +200,7 @@ fn peer_set_rejects_connections_past_per_ip_limit() {
     // Get peers and client handles of them
     let (discovered_peers, handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), NUM_PEER_VERSIONS);
@@ -232,7 +232,7 @@ fn peer_set_route_inv_empty_registry() {
     let test_hash = block::Hash([0; 32]);
 
     // Use two peers with the same version
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: vec![peer_version, peer_version],
     };
@@ -250,7 +250,7 @@ fn peer_set_route_inv_empty_registry() {
     // Get peers and client handles of them
     let (discovered_peers, handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), 2);
@@ -315,7 +315,7 @@ fn peer_set_route_inv_advertised_registry_order(advertised_first: bool) {
     let test_change = InventoryStatus::new_available(test_inv, test_peer);
 
     // Use two peers with the same version
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: vec![peer_version, peer_version],
     };
@@ -333,7 +333,7 @@ fn peer_set_route_inv_advertised_registry_order(advertised_first: bool) {
     // Get peers and client handles of them
     let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), 2);
@@ -423,7 +423,7 @@ fn peer_set_route_inv_missing_registry_order(missing_first: bool) {
     let test_change = InventoryStatus::new_missing(test_inv, test_peer);
 
     // Use two peers with the same version
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: vec![peer_version, peer_version],
     };
@@ -441,7 +441,7 @@ fn peer_set_route_inv_missing_registry_order(missing_first: bool) {
     // Get peers and client handles of them
     let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), 2);
@@ -525,7 +525,7 @@ fn peer_set_route_inv_all_missing_fail() {
     let test_change = InventoryStatus::new_missing(test_inv, test_peer);
 
     // Use one peer
-    let peer_version = Version::min_specified_for_upgrade(Network::Mainnet, NetworkUpgrade::Nu5);
+    let peer_version = Version::min_specified_for_upgrade(&Network::Mainnet, NetworkUpgrade::Nu5);
     let peer_versions = PeerVersions {
         peer_versions: vec![peer_version],
     };
@@ -543,7 +543,7 @@ fn peer_set_route_inv_all_missing_fail() {
     // Get the peer and its client handle
     let (discovered_peers, mut handles) = peer_versions.mock_peer_discovery();
     let (minimum_peer_version, _best_tip_height) =
-        MinimumPeerVersion::with_mock_chain_tip(Network::Mainnet);
+        MinimumPeerVersion::with_mock_chain_tip(&Network::Mainnet);
 
     // Make sure we have the right number of peers
     assert_eq!(handles.len(), 1);
diff --git a/zebra-network/src/protocol/external/codec.rs b/zebra-network/src/protocol/external/codec.rs
index d511b50f7db..a2a267b2338 100644
--- a/zebra-network/src/protocol/external/codec.rs
+++ b/zebra-network/src/protocol/external/codec.rs
@@ -84,8 +84,8 @@ impl Builder {
     }
 
     /// Configure the codec for the given [`Network`].
-    pub fn for_network(mut self, network: Network) -> Self {
-        self.network = network;
+    pub fn for_network(mut self, network: &Network) -> Self {
+        self.network = network.clone();
         self
     }
 
diff --git a/zebra-network/src/protocol/external/tests/preallocate.rs b/zebra-network/src/protocol/external/tests/preallocate.rs
index 1ff30d1285c..e247aa958dd 100644
--- a/zebra-network/src/protocol/external/tests/preallocate.rs
+++ b/zebra-network/src/protocol/external/tests/preallocate.rs
@@ -96,7 +96,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We require sanitization before serialization
-        let addr = addr.sanitize(Mainnet);
+        let addr = addr.sanitize(&Mainnet);
         prop_assume!(addr.is_some());
 
         let addr: AddrV1 = addr.unwrap().into();
@@ -115,7 +115,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We require sanitization before serialization
-        let addr = addr.sanitize(Mainnet);
+        let addr = addr.sanitize(&Mainnet);
         prop_assume!(addr.is_some());
 
         let addr: AddrV1 = addr.unwrap().into();
@@ -153,7 +153,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We require sanitization before serialization
-        let addr = addr.sanitize(Mainnet);
+        let addr = addr.sanitize(&Mainnet);
         prop_assume!(addr.is_some());
 
         let addr: AddrV2 = addr.unwrap().into();
@@ -172,7 +172,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We require sanitization before serialization
-        let addr = addr.sanitize(Mainnet);
+        let addr = addr.sanitize(&Mainnet);
         prop_assume!(addr.is_some());
 
         let addr: AddrV2 = addr.unwrap().into();
diff --git a/zebra-network/src/protocol/external/tests/prop.rs b/zebra-network/src/protocol/external/tests/prop.rs
index 912868fde2e..1ab9a6e6718 100644
--- a/zebra-network/src/protocol/external/tests/prop.rs
+++ b/zebra-network/src/protocol/external/tests/prop.rs
@@ -111,7 +111,7 @@ proptest! {
 
         // We require sanitization before serialization,
         // but we also need the original address for this test
-        let sanitized_addr = addr.sanitize(Mainnet);
+        let sanitized_addr = addr.sanitize(&Mainnet);
         prop_assume!(sanitized_addr.is_some());
         let sanitized_addr = sanitized_addr.unwrap();
 
@@ -184,7 +184,7 @@ proptest! {
 
         // We require sanitization before serialization,
         // but we also need the original address for this test
-        let sanitized_addr = addr.sanitize(Mainnet);
+        let sanitized_addr = addr.sanitize(&Mainnet);
         prop_assume!(sanitized_addr.is_some());
         let sanitized_addr = sanitized_addr.unwrap();
 
diff --git a/zebra-network/src/protocol/external/types.rs b/zebra-network/src/protocol/external/types.rs
index 049ba1fd731..08e2aa38054 100644
--- a/zebra-network/src/protocol/external/types.rs
+++ b/zebra-network/src/protocol/external/types.rs
@@ -54,7 +54,7 @@ impl Version {
     ///
     /// If we are incompatible with our own minimum remote protocol version.
     pub fn min_remote_for_height(
-        network: Network,
+        network: &Network,
         height: impl Into<Option<block::Height>>,
     ) -> Version {
         let height = height.into().unwrap_or(block::Height(0));
@@ -78,9 +78,9 @@ impl Version {
     /// - during the initial block download,
     /// - after Zebra restarts, and
     /// - after Zebra's local network is slow or shut down.
-    fn initial_min_for_network(network: Network) -> Version {
+    fn initial_min_for_network(network: &Network) -> Version {
         *constants::INITIAL_MIN_NETWORK_PROTOCOL_VERSION
-            .get(&network)
+            .get(network)
             .expect("We always have a value for testnet or mainnet")
     }
 
@@ -88,7 +88,7 @@ impl Version {
     /// `height`.
     ///
     /// This is the minimum peer version when Zebra is close to the current tip.
-    fn min_specified_for_height(network: Network, height: block::Height) -> Version {
+    fn min_specified_for_height(network: &Network, height: block::Height) -> Version {
         let network_upgrade = NetworkUpgrade::current(network, height);
         Version::min_specified_for_upgrade(network, network_upgrade)
     }
@@ -96,7 +96,7 @@ impl Version {
     /// Returns the minimum specified network protocol version for `network` and
     /// `network_upgrade`.
     pub(crate) fn min_specified_for_upgrade(
-        network: Network,
+        network: &Network,
         network_upgrade: NetworkUpgrade,
     ) -> Version {
         // TODO: Should we reject earlier protocol versions during our initial
@@ -196,17 +196,17 @@ mod test {
 
     #[test]
     fn version_extremes_mainnet() {
-        version_extremes(Mainnet)
+        version_extremes(&Mainnet)
     }
 
     #[test]
     fn version_extremes_testnet() {
-        version_extremes(Testnet)
+        version_extremes(&Testnet)
     }
 
     /// Test the min_specified_for_upgrade and min_specified_for_height functions for `network` with
     /// extreme values.
-    fn version_extremes(network: Network) {
+    fn version_extremes(network: &Network) {
         let _init_guard = zebra_test::init();
 
         assert_eq!(
@@ -224,17 +224,17 @@ mod test {
 
     #[test]
     fn version_consistent_mainnet() {
-        version_consistent(Mainnet)
+        version_consistent(&Mainnet)
     }
 
     #[test]
     fn version_consistent_testnet() {
-        version_consistent(Testnet)
+        version_consistent(&Testnet)
     }
 
     /// Check that the min_specified_for_upgrade and min_specified_for_height functions
     /// are consistent for `network`.
-    fn version_consistent(network: Network) {
+    fn version_consistent(network: &Network) {
         let _init_guard = zebra_test::init();
 
         let highest_network_upgrade = NetworkUpgrade::current(network, block::Height::MAX);
diff --git a/zebra-rpc/src/methods.rs b/zebra-rpc/src/methods.rs
index 40b15bb6d18..152005f5e14 100644
--- a/zebra-rpc/src/methods.rs
+++ b/zebra-rpc/src/methods.rs
@@ -437,7 +437,7 @@ where
         let rpc_impl = RpcImpl {
             build_version,
             user_agent,
-            network,
+            network: network.clone(),
             debug_force_finished_sync,
             debug_like_zcashd,
             mempool: mempool.clone(),
@@ -491,7 +491,7 @@ where
     // TODO: use a generic error constructor (#5548)
     #[allow(clippy::unwrap_in_result)]
     fn get_blockchain_info(&self) -> Result<GetBlockChainInfo> {
-        let network = self.network;
+        let network = &self.network;
 
         // `chain` field
         let chain = self.network.bip70_network_name();
@@ -1113,7 +1113,6 @@ where
                 })?;
 
             // Fetch the block referenced by [`hash_or_height`] from the state.
-
             // TODO: If this RPC is called a lot, just get the block header,
             // rather than the whole block.
             let block_request = zebra_state::ReadRequest::Block(hash_or_height);
diff --git a/zebra-rpc/src/methods/get_block_template_rpcs.rs b/zebra-rpc/src/methods/get_block_template_rpcs.rs
index c1f679fa85b..9dba00aa062 100644
--- a/zebra-rpc/src/methods/get_block_template_rpcs.rs
+++ b/zebra-rpc/src/methods/get_block_template_rpcs.rs
@@ -438,7 +438,7 @@ where
     /// If the `mining_config` is invalid.
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        network: Network,
+        network: &Network,
         mining_config: crate::config::mining::Config,
         mempool: Mempool,
         state: State,
@@ -448,10 +448,10 @@ where
         address_book: AddressBook,
     ) -> Self {
         // Prevent loss of miner funds due to an unsupported or incorrect address type.
-        if let Some(miner_address) = mining_config.miner_address {
+        if let Some(miner_address) = mining_config.miner_address.clone() {
             assert_eq!(
                 miner_address.network(),
-                network,
+                network.clone(),
                 "incorrect miner address config: {miner_address} \
                          network.network {network} and miner address network {} must match",
                 miner_address.network(),
@@ -486,7 +486,7 @@ where
         );
 
         Self {
-            network,
+            network: network.clone(),
             miner_address: mining_config.miner_address,
             extra_coinbase_data,
             debug_like_zcashd,
@@ -576,8 +576,8 @@ where
         parameters: Option<get_block_template::JsonParameters>,
     ) -> BoxFuture<Result<get_block_template::Response>> {
         // Clone Configs
-        let network = self.network;
-        let miner_address = self.miner_address;
+        let network = self.network.clone();
+        let miner_address = self.miner_address.clone();
         let debug_like_zcashd = self.debug_like_zcashd;
         let extra_coinbase_data = self.extra_coinbase_data.clone();
 
@@ -626,7 +626,7 @@ where
                 //
                 // Optional TODO:
                 // - add `async changed()` method to ChainSyncStatus (like `ChainTip`)
-                check_synced_to_tip(network, latest_chain_tip.clone(), sync_status.clone())?;
+                check_synced_to_tip(&network, latest_chain_tip.clone(), sync_status.clone())?;
 
                 // TODO: return an error if we have no peers, like `zcashd` does,
                 //       and add a developer config that mines regardless of how many peers we have.
@@ -861,9 +861,9 @@ where
 
             // Randomly select some mempool transactions.
             let mempool_txs = zip317::select_mempool_transactions(
-                network,
+                &network,
                 next_block_height,
-                miner_address,
+                &miner_address,
                 mempool_txs,
                 debug_like_zcashd,
                 extra_coinbase_data.clone(),
@@ -881,8 +881,8 @@ where
             // - After this point, the template only depends on the previously fetched data.
 
             let response = GetBlockTemplate::new(
-                network,
-                miner_address,
+                &network,
+                &miner_address,
                 &chain_tip_and_local_time,
                 server_long_poll_id,
                 mempool_txs,
@@ -988,7 +988,7 @@ where
     }
 
     fn get_mining_info(&self) -> BoxFuture<Result<get_mining_info::Response>> {
-        let network = self.network;
+        let network = self.network.clone();
         let solution_rate_fut = self.get_network_sol_ps(None, None);
         async move {
             Ok(get_mining_info::Response::new(
@@ -1062,7 +1062,7 @@ where
         &self,
         raw_address: String,
     ) -> BoxFuture<Result<validate_address::Response>> {
-        let network = self.network;
+        let network = self.network.clone();
 
         async move {
             let Ok(address) = raw_address
@@ -1107,7 +1107,7 @@ where
         &self,
         raw_address: String,
     ) -> BoxFuture<Result<types::z_validate_address::Response>> {
-        let network = self.network;
+        let network = self.network.clone();
 
         async move {
             let Ok(address) = raw_address
@@ -1148,7 +1148,7 @@ where
 
     fn get_block_subsidy(&self, height: Option<u32>) -> BoxFuture<Result<BlockSubsidy>> {
         let latest_chain_tip = self.latest_chain_tip.clone();
-        let network = self.network;
+        let network = self.network.clone();
 
         async move {
             let height = if let Some(height) = height {
@@ -1167,7 +1167,7 @@ where
                 });
             }
 
-            let miner = miner_subsidy(height, network).map_err(|error| Error {
+            let miner = miner_subsidy(height, &network).map_err(|error| Error {
                 code: ErrorCode::ServerError(0),
                 message: error.to_string(),
                 data: None,
@@ -1176,7 +1176,7 @@ where
             let founders = Amount::zero();
 
             let funding_streams =
-                funding_stream_values(height, network).map_err(|error| Error {
+                funding_stream_values(height, &network).map_err(|error| Error {
                     code: ErrorCode::ServerError(0),
                     message: error.to_string(),
                     data: None,
@@ -1184,7 +1184,7 @@ where
             let mut funding_streams: Vec<_> = funding_streams
                 .iter()
                 .map(|(receiver, value)| {
-                    let address = funding_stream_address(height, network, *receiver);
+                    let address = funding_stream_address(height, &network, *receiver);
                     (*receiver, FundingStream::new(*receiver, *value, address))
                 })
                 .collect();
@@ -1208,7 +1208,7 @@ where
     }
 
     fn get_difficulty(&self) -> BoxFuture<Result<f64>> {
-        let network = self.network;
+        let network = self.network.clone();
         let mut state = self.state.clone();
 
         async move {
diff --git a/zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs b/zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs
index 0efda4db1c3..beb8539de09 100644
--- a/zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs
+++ b/zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs
@@ -113,7 +113,7 @@ where
     Tip: ChainTip + Clone + Send + Sync + 'static,
     SyncStatus: ChainSyncStatus + Clone + Send + Sync + 'static,
 {
-    check_synced_to_tip(network, latest_chain_tip, sync_status)?;
+    check_synced_to_tip(&network, latest_chain_tip, sync_status)?;
 
     let block: Block = match block_proposal_bytes.zcash_deserialize_into() {
         Ok(block) => block,
@@ -158,7 +158,7 @@ where
 /// Returns an error if Zebra is not synced to the consensus chain tip.
 /// This error might be incorrect if the local clock is skewed.
 pub fn check_synced_to_tip<Tip, SyncStatus>(
-    network: Network,
+    network: &Network,
     latest_chain_tip: Tip,
     sync_status: SyncStatus,
 ) -> Result<()>
@@ -283,9 +283,9 @@ where
 /// If `like_zcashd` is true, try to match the coinbase transactions generated by `zcashd`
 /// in the `getblocktemplate` RPC.
 pub fn generate_coinbase_and_roots(
-    network: Network,
+    network: &Network,
     height: Height,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     mempool_txs: &[VerifiedUnminedTx],
     history_tree: Arc<zebra_chain::history_tree::HistoryTree>,
     like_zcashd: bool,
@@ -319,9 +319,9 @@ pub fn generate_coinbase_and_roots(
 /// If `like_zcashd` is true, try to match the coinbase transactions generated by `zcashd`
 /// in the `getblocktemplate` RPC.
 pub fn generate_coinbase_transaction(
-    network: Network,
+    network: &Network,
     height: Height,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     miner_fee: Amount<NonNegative>,
     like_zcashd: bool,
     extra_coinbase_data: Vec<u8>,
@@ -355,9 +355,9 @@ pub fn calculate_miner_fee(mempool_txs: &[VerifiedUnminedTx]) -> Amount<NonNegat
 /// If `like_zcashd` is true, try to match the coinbase transactions generated by `zcashd`
 /// in the `getblocktemplate` RPC.
 pub fn standard_coinbase_outputs(
-    network: Network,
+    network: &Network,
     height: Height,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     miner_fee: Amount<NonNegative>,
     like_zcashd: bool,
 ) -> Vec<(Amount<NonNegative>, transparent::Script)> {
@@ -393,7 +393,7 @@ pub fn standard_coinbase_outputs(
 /// in the `getblocktemplate` RPC.
 fn combine_coinbase_outputs(
     funding_streams: HashMap<FundingStreamReceiver, (Amount<NonNegative>, transparent::Address)>,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     miner_reward: Amount<NonNegative>,
     like_zcashd: bool,
 ) -> Vec<(Amount<NonNegative>, transparent::Script)> {
@@ -402,7 +402,7 @@ fn combine_coinbase_outputs(
         .into_iter()
         .map(|(_receiver, (amount, address))| (amount, address))
         .collect();
-    coinbase_outputs.push((miner_reward, miner_address));
+    coinbase_outputs.push((miner_reward, miner_address.clone()));
 
     let mut coinbase_outputs: Vec<(Amount<NonNegative>, transparent::Script)> = coinbase_outputs
         .iter()
diff --git a/zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template.rs b/zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template.rs
index 92ab9d00593..d7c31e11a81 100644
--- a/zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template.rs
+++ b/zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template.rs
@@ -223,8 +223,8 @@ impl GetBlockTemplate {
     /// in the `getblocktemplate` RPC.
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        network: Network,
-        miner_address: transparent::Address,
+        network: &Network,
+        miner_address: &transparent::Address,
         chain_tip_and_local_time: &GetBlockTemplateChainInfo,
         long_poll_id: LongPollId,
         mempool_txs: Vec<VerifiedUnminedTx>,
diff --git a/zebra-rpc/src/methods/get_block_template_rpcs/zip317.rs b/zebra-rpc/src/methods/get_block_template_rpcs/zip317.rs
index 3737f339ef0..4a6cf92c0d3 100644
--- a/zebra-rpc/src/methods/get_block_template_rpcs/zip317.rs
+++ b/zebra-rpc/src/methods/get_block_template_rpcs/zip317.rs
@@ -37,9 +37,9 @@ use crate::methods::get_block_template_rpcs::{
 ///
 /// [ZIP-317]: https://zips.z.cash/zip-0317#block-production
 pub async fn select_mempool_transactions(
-    network: Network,
+    network: &Network,
     next_block_height: Height,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     mempool_txs: Vec<VerifiedUnminedTx>,
     like_zcashd: bool,
     extra_coinbase_data: Vec<u8>,
@@ -115,9 +115,9 @@ pub async fn select_mempool_transactions(
 /// If `like_zcashd` is true, try to match the coinbase transactions generated by `zcashd`
 /// in the `getblocktemplate` RPC.
 pub fn fake_coinbase_transaction(
-    network: Network,
+    network: &Network,
     height: Height,
-    miner_address: transparent::Address,
+    miner_address: &transparent::Address,
     like_zcashd: bool,
     extra_coinbase_data: Vec<u8>,
 ) -> TransactionTemplate<NegativeOrZero> {
diff --git a/zebra-rpc/src/methods/tests/prop.rs b/zebra-rpc/src/methods/tests/prop.rs
index c6c4fa69693..38c3c6b0895 100644
--- a/zebra-rpc/src/methods/tests/prop.rs
+++ b/zebra-rpc/src/methods/tests/prop.rs
@@ -596,7 +596,7 @@ proptest! {
         let (rpc, rpc_tx_queue_task_handle) = RpcImpl::new(
             "RPC test",
             "RPC test",
-            network,
+            network.clone(),
             false,
             true,
             mempool.clone(),
@@ -615,13 +615,13 @@ proptest! {
 
                 prop_assert_eq!(
                     info.consensus.chain_tip.0,
-                    NetworkUpgrade::current(network, block_height)
+                    NetworkUpgrade::current(&network, block_height)
                         .branch_id()
                         .unwrap()
                 );
                 prop_assert_eq!(
                     info.consensus.next_block.0,
-                    NetworkUpgrade::current(network, (block_height + 1).unwrap())
+                    NetworkUpgrade::current(&network, (block_height + 1).unwrap())
                         .branch_id()
                         .unwrap()
                 );
diff --git a/zebra-rpc/src/methods/tests/snapshot.rs b/zebra-rpc/src/methods/tests/snapshot.rs
index 6d775f13255..94e12cc806f 100644
--- a/zebra-rpc/src/methods/tests/snapshot.rs
+++ b/zebra-rpc/src/methods/tests/snapshot.rs
@@ -35,14 +35,14 @@ async fn test_rpc_response_data() {
     let _init_guard = zebra_test::init();
 
     tokio::join!(
-        test_rpc_response_data_for_network(Mainnet),
-        test_rpc_response_data_for_network(Testnet),
-        test_mocked_rpc_response_data_for_network(Mainnet),
-        test_mocked_rpc_response_data_for_network(Testnet),
+        test_rpc_response_data_for_network(&Mainnet),
+        test_rpc_response_data_for_network(&Testnet),
+        test_mocked_rpc_response_data_for_network(&Mainnet),
+        test_mocked_rpc_response_data_for_network(&Testnet),
     );
 }
 
-async fn test_rpc_response_data_for_network(network: Network) {
+async fn test_rpc_response_data_for_network(network: &Network) {
     // Create a continuous chain of mainnet and testnet blocks from genesis
     let block_data = network.blockchain_map();
 
@@ -77,7 +77,7 @@ async fn test_rpc_response_data_for_network(network: Network) {
     let (rpc, _rpc_tx_queue_task_handle) = RpcImpl::new(
         "RPC test",
         "/Zebra:RPC test/",
-        network,
+        network.clone(),
         false,
         true,
         Buffer::new(mempool.clone(), 1),
@@ -320,7 +320,7 @@ async fn test_rpc_response_data_for_network(network: Network) {
     snapshot_rpc_getaddressutxos(get_address_utxos, &settings);
 }
 
-async fn test_mocked_rpc_response_data_for_network(network: Network) {
+async fn test_mocked_rpc_response_data_for_network(network: &Network) {
     // Prepare the test harness.
 
     let mut settings = insta::Settings::clone_current();
@@ -333,7 +333,7 @@ async fn test_mocked_rpc_response_data_for_network(network: Network) {
     let (rpc, _) = RpcImpl::new(
         "RPC test",
         "/Zebra:RPC test/",
-        network,
+        network.clone(),
         false,
         true,
         mempool,
@@ -542,7 +542,7 @@ fn snapshot_rpc_getaddressutxos(utxos: Vec<GetAddressUtxos>, settings: &insta::S
 }
 
 /// Utility function to convert a `Network` to a lowercase string.
-fn network_string(network: Network) -> String {
+fn network_string(network: &Network) -> String {
     let mut net_suffix = network.to_string();
     net_suffix.make_ascii_lowercase();
     net_suffix
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 e93571baed9..3c2da657341 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
@@ -51,7 +51,7 @@ use crate::methods::{
 };
 
 pub async fn test_responses<State, ReadState>(
-    network: Network,
+    network: &Network,
     mempool: MockService<
         mempool::Request,
         mempool::Response,
diff --git a/zebra-rpc/src/methods/tests/utils.rs b/zebra-rpc/src/methods/tests/utils.rs
index bb5c728cf0b..9bc54f79d39 100644
--- a/zebra-rpc/src/methods/tests/utils.rs
+++ b/zebra-rpc/src/methods/tests/utils.rs
@@ -10,14 +10,14 @@ use zebra_chain::{
 };
 
 /// Create a history tree with one single block for a network by using Zebra test vectors.
-pub fn fake_history_tree(network: Network) -> Arc<HistoryTree> {
+pub fn fake_history_tree(network: &Network) -> Arc<HistoryTree> {
     let (block, sapling_root) = network.test_block_sapling_roots(1046400, 1116000).unwrap();
 
     let block = Arc::<Block>::zcash_deserialize(block).expect("block should deserialize");
     let first_sapling_root = Root::try_from(sapling_root).unwrap();
 
     let history_tree = NonEmptyHistoryTree::from_block(
-        Network::Mainnet,
+        &Network::Mainnet,
         block,
         &first_sapling_root,
         &Default::default(),
diff --git a/zebra-rpc/src/methods/tests/vectors.rs b/zebra-rpc/src/methods/tests/vectors.rs
index 03aa5b12c66..28ca7b198ff 100644
--- a/zebra-rpc/src/methods/tests/vectors.rs
+++ b/zebra-rpc/src/methods/tests/vectors.rs
@@ -70,7 +70,7 @@ async fn rpc_getblock() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     // Init RPC
     let (rpc, rpc_tx_queue_task_handle) = RpcImpl::new(
@@ -343,7 +343,7 @@ async fn rpc_getbestblockhash() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service, the tip will be in `NUMBER_OF_BLOCKS`.
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     // Init RPC
     let (rpc, rpc_tx_queue_task_handle) = RpcImpl::new(
@@ -386,7 +386,7 @@ async fn rpc_getrawtransaction() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service
     let (_state, read_state, _latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     let (latest_chain_tip, latest_chain_tip_sender) = MockChainTip::new();
     latest_chain_tip_sender.send_best_tip_height(Height(10));
@@ -557,7 +557,7 @@ async fn rpc_getaddresstxids_invalid_arguments() {
 
     // Create a populated state service
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     let (rpc, rpc_tx_queue_task_handle) = RpcImpl::new(
         "RPC test",
@@ -669,12 +669,12 @@ async fn rpc_getaddresstxids_response() {
 
         // Get the address.
         let address = first_block_first_transaction.outputs()[1]
-            .address(network)
+            .address(&network)
             .unwrap();
 
         // Create a populated state service
         let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-            zebra_state::populated_state(blocks.to_owned(), network).await;
+            zebra_state::populated_state(blocks.to_owned(), &network).await;
 
         if network == Mainnet {
             // Exhaustively test possible block ranges for mainnet.
@@ -683,7 +683,7 @@ async fn rpc_getaddresstxids_response() {
             for start in 1..=10 {
                 for end in start..=10 {
                     rpc_getaddresstxids_response_with(
-                        network,
+                        &network,
                         start..=end,
                         &address,
                         &read_state,
@@ -695,7 +695,7 @@ async fn rpc_getaddresstxids_response() {
         } else {
             // Just test the full range for testnet.
             rpc_getaddresstxids_response_with(
-                network,
+                &network,
                 1..=10,
                 &address,
                 &read_state,
@@ -707,7 +707,7 @@ async fn rpc_getaddresstxids_response() {
 }
 
 async fn rpc_getaddresstxids_response_with(
-    network: Network,
+    network: &Network,
     range: RangeInclusive<u32>,
     address: &transparent::Address,
     read_state: &ReadStateService,
@@ -718,7 +718,7 @@ async fn rpc_getaddresstxids_response_with(
     let (rpc, rpc_tx_queue_task_handle) = RpcImpl::new(
         "RPC test",
         "RPC test",
-        network,
+        network.clone(),
         false,
         true,
         Buffer::new(mempool.clone(), 1),
@@ -808,13 +808,13 @@ async fn rpc_getaddressutxos_response() {
     let first_block_first_transaction = &blocks[1].transactions[0];
     // get the address, this is always `t3Vz22vK5z2LcKEdg16Yv4FFneEL1zg9ojd`
     let address = &first_block_first_transaction.outputs()[1]
-        .address(Mainnet)
+        .address(&Mainnet)
         .unwrap();
 
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     let rpc = RpcImpl::new(
         "RPC test",
@@ -864,19 +864,19 @@ async fn rpc_getblockcount() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service, the tip will be in `NUMBER_OF_BLOCKS`.
     let (state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     let (
         block_verifier_router,
         _transaction_verifier,
         _parameter_download_task_handle,
         _max_checkpoint_height,
-    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), Mainnet, state.clone())
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &Mainnet, state.clone())
         .await;
 
     // Init RPC
     let get_block_template_rpc = GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         Buffer::new(mempool.clone(), 1),
         read_state,
@@ -909,19 +909,19 @@ async fn rpc_getblockcount_empty_state() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create an empty state
     let (state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::init_test_services(Mainnet);
+        zebra_state::init_test_services(&Mainnet);
 
     let (
         block_verifier_router,
         _transaction_verifier,
         _parameter_download_task_handle,
         _max_checkpoint_height,
-    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), Mainnet, state.clone())
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &Mainnet, state.clone())
         .await;
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         Buffer::new(mempool.clone(), 1),
         read_state,
@@ -956,14 +956,14 @@ async fn rpc_getpeerinfo() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create an empty state
     let (state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::init_test_services(Mainnet);
+        zebra_state::init_test_services(&Mainnet);
 
     let (
         block_verifier_router,
         _transaction_verifier,
         _parameter_download_task_handle,
         _max_checkpoint_height,
-    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), network, state.clone())
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &network, state.clone())
         .await;
 
     let mock_peer_address = zebra_network::types::MetaAddr::new_initial_peer(
@@ -982,7 +982,7 @@ async fn rpc_getpeerinfo() {
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        network,
+        &network,
         Default::default(),
         Buffer::new(mempool.clone(), 1),
         read_state,
@@ -1026,19 +1026,19 @@ async fn rpc_getblockhash() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service
     let (state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     let (
         block_verifier_router,
         _transaction_verifier,
         _parameter_download_task_handle,
         _max_checkpoint_height,
-    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), Mainnet, state.clone())
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &Mainnet, state.clone())
         .await;
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         Buffer::new(mempool.clone(), 1),
         read_state,
@@ -1090,11 +1090,11 @@ async fn rpc_getmininginfo() {
 
     // Create a populated state service
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         MockService::build().for_unit_tests(),
         read_state,
@@ -1126,11 +1126,11 @@ async fn rpc_getnetworksolps() {
 
     // Create a populated state service
     let (_state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), Mainnet).await;
+        zebra_state::populated_state(blocks.clone(), &Mainnet).await;
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         MockService::build().for_unit_tests(),
         read_state,
@@ -1224,8 +1224,10 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
     mock_sync_status.set_is_close_to_tip(true);
 
     let miner_address = match use_p2pkh {
-        false => Some(transparent::Address::from_script_hash(Mainnet, [0x7e; 20])),
-        true => Some(transparent::Address::from_pub_key_hash(Mainnet, [0x7e; 20])),
+        false => Some(transparent::Address::from_script_hash(&Mainnet, [0x7e; 20])),
+        true => Some(transparent::Address::from_pub_key_hash(
+            &Mainnet, [0x7e; 20],
+        )),
     };
 
     #[allow(clippy::unnecessary_struct_initialization)]
@@ -1238,7 +1240,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
     };
 
     // nu5 block height
-    let fake_tip_height = NetworkUpgrade::Nu5.activation_height(Mainnet).unwrap();
+    let fake_tip_height = NetworkUpgrade::Nu5.activation_height(&Mainnet).unwrap();
     // nu5 block hash
     let fake_tip_hash =
         Hash::from_hex("0000000000d723156d9b65ffcf4984da7a19675ed7e2f06d9e5d5188af087bf8").unwrap();
@@ -1257,7 +1259,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
 
     // Init RPC
     let get_block_template_rpc = GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         mining_config,
         Buffer::new(mempool.clone(), 1),
         read_state.clone(),
@@ -1282,7 +1284,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
                     cur_time: fake_cur_time,
                     min_time: fake_min_time,
                     max_time: fake_max_time,
-                    history_tree: fake_history_tree(Mainnet),
+                    history_tree: fake_history_tree(&Mainnet),
                 }));
         }
     };
@@ -1508,7 +1510,7 @@ async fn rpc_submitblock_errors() {
     let mut mempool: MockService<_, _, _, BoxError> = MockService::build().for_unit_tests();
     // Create a populated state service
     let (state, read_state, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks, Mainnet).await;
+        zebra_state::populated_state(blocks, &Mainnet).await;
 
     // Init RPCs
     let (
@@ -1516,12 +1518,12 @@ async fn rpc_submitblock_errors() {
         _transaction_verifier,
         _parameter_download_task_handle,
         _max_checkpoint_height,
-    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), Mainnet, state.clone())
+    ) = zebra_consensus::router::init(zebra_consensus::Config::default(), &Mainnet, state.clone())
         .await;
 
     // Init RPC
     let get_block_template_rpc = GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         Buffer::new(mempool.clone(), 1),
         read_state,
@@ -1573,7 +1575,7 @@ async fn rpc_validateaddress() {
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         MockService::build().for_unit_tests(),
         MockService::build().for_unit_tests(),
@@ -1618,7 +1620,7 @@ async fn rpc_z_validateaddress() {
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         MockService::build().for_unit_tests(),
         MockService::build().for_unit_tests(),
@@ -1687,7 +1689,7 @@ async fn rpc_getdifficulty() {
     };
 
     // nu5 block height
-    let fake_tip_height = NetworkUpgrade::Nu5.activation_height(Mainnet).unwrap();
+    let fake_tip_height = NetworkUpgrade::Nu5.activation_height(&Mainnet).unwrap();
     // nu5 block hash
     let fake_tip_hash =
         Hash::from_hex("0000000000d723156d9b65ffcf4984da7a19675ed7e2f06d9e5d5188af087bf8").unwrap();
@@ -1705,7 +1707,7 @@ async fn rpc_getdifficulty() {
 
     // Init RPC
     let get_block_template_rpc = GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         mining_config,
         Buffer::new(mempool.clone(), 1),
         read_state.clone(),
@@ -1730,7 +1732,7 @@ async fn rpc_getdifficulty() {
                 cur_time: fake_cur_time,
                 min_time: fake_min_time,
                 max_time: fake_max_time,
-                history_tree: fake_history_tree(Mainnet),
+                history_tree: fake_history_tree(&Mainnet),
             }));
     };
 
@@ -1756,7 +1758,7 @@ async fn rpc_getdifficulty() {
                 cur_time: fake_cur_time,
                 min_time: fake_min_time,
                 max_time: fake_max_time,
-                history_tree: fake_history_tree(Mainnet),
+                history_tree: fake_history_tree(&Mainnet),
             }));
     };
 
@@ -1779,7 +1781,7 @@ async fn rpc_getdifficulty() {
                 cur_time: fake_cur_time,
                 min_time: fake_min_time,
                 max_time: fake_max_time,
-                history_tree: fake_history_tree(Mainnet),
+                history_tree: fake_history_tree(&Mainnet),
             }));
     };
 
@@ -1802,7 +1804,7 @@ async fn rpc_getdifficulty() {
                 cur_time: fake_cur_time,
                 min_time: fake_min_time,
                 max_time: fake_max_time,
-                history_tree: fake_history_tree(Mainnet),
+                history_tree: fake_history_tree(&Mainnet),
             }));
     };
 
@@ -1826,7 +1828,7 @@ async fn rpc_z_listunifiedreceivers() {
 
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-        Mainnet,
+        &Mainnet,
         Default::default(),
         MockService::build().for_unit_tests(),
         MockService::build().for_unit_tests(),
diff --git a/zebra-rpc/src/queue.rs b/zebra-rpc/src/queue.rs
index 97662ec7be3..fa60a360886 100644
--- a/zebra-rpc/src/queue.rs
+++ b/zebra-rpc/src/queue.rs
@@ -157,7 +157,7 @@ impl Runner {
             };
 
             // get spacing between blocks
-            let spacing = NetworkUpgrade::target_spacing_for_height(network, tip_height);
+            let spacing = NetworkUpgrade::target_spacing_for_height(&network, tip_height);
 
             // sleep until the next block
             tokio::time::sleep(spacing.to_std().expect("should never be less than zero")).await;
diff --git a/zebra-rpc/src/server.rs b/zebra-rpc/src/server.rs
index c8e13a9a62f..c16ddd2a732 100644
--- a/zebra-rpc/src/server.rs
+++ b/zebra-rpc/src/server.rs
@@ -154,7 +154,7 @@ impl RpcServer {
             {
                 // Initialize the getblocktemplate rpc method handler
                 let get_block_template_rpc_impl = GetBlockTemplateRpcImpl::new(
-                    network,
+                    &network,
                     mining_config.clone(),
                     mempool.clone(),
                     state.clone(),
@@ -171,7 +171,7 @@ impl RpcServer {
             let (rpc_impl, rpc_tx_queue_task_handle) = RpcImpl::new(
                 build_version.clone(),
                 user_agent,
-                network,
+                network.clone(),
                 config.debug_force_finished_sync,
                 #[cfg(feature = "getblocktemplate-rpcs")]
                 mining_config.debug_like_zcashd,
diff --git a/zebra-scan/src/bin/rpc_server.rs b/zebra-scan/src/bin/rpc_server.rs
index 1463df3f8f0..e5efdbc1c0d 100644
--- a/zebra-scan/src/bin/rpc_server.rs
+++ b/zebra-scan/src/bin/rpc_server.rs
@@ -10,7 +10,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (config, network) = Default::default();
 
     let (scan_service, _cmd_receiver) =
-        ScanService::new_with_mock_scanner(Storage::new(&config, network, false));
+        ScanService::new_with_mock_scanner(Storage::new(&config, &network, false));
     let scan_service = ServiceBuilder::new().buffer(10).service(scan_service);
 
     // Start the gRPC server.
diff --git a/zebra-scan/src/init.rs b/zebra-scan/src/init.rs
index 15ab2a9a9ea..b0bfb6ad50f 100644
--- a/zebra-scan/src/init.rs
+++ b/zebra-scan/src/init.rs
@@ -29,7 +29,7 @@ pub async fn init_with_server(
     let scan_service = ServiceBuilder::new()
         .buffer(10)
         .timeout(SCAN_SERVICE_TIMEOUT)
-        .service(ScanService::new(&config, network, state, chain_tip_change).await);
+        .service(ScanService::new(&config, &network, state, chain_tip_change).await);
 
     // TODO: move this to zebra-grpc init() function and include addr
     info!(?listen_addr, "starting scan gRPC server");
@@ -58,7 +58,7 @@ pub fn spawn_init(
         tokio::spawn(
             async move {
                 let storage =
-                    tokio::task::spawn_blocking(move || Storage::new(&config, network, false))
+                    tokio::task::spawn_blocking(move || Storage::new(&config, &network, false))
                         .wait_for_panics()
                         .await;
                 let (_cmd_sender, cmd_receiver) = tokio::sync::mpsc::channel(1);
diff --git a/zebra-scan/src/service.rs b/zebra-scan/src/service.rs
index 0b9758b9124..200160ab3ae 100644
--- a/zebra-scan/src/service.rs
+++ b/zebra-scan/src/service.rs
@@ -41,12 +41,13 @@ impl ScanService {
     /// Create a new [`ScanService`].
     pub async fn new(
         config: &Config,
-        network: Network,
+        network: &Network,
         state: scan::State,
         chain_tip_change: ChainTipChange,
     ) -> Self {
         let config = config.clone();
-        let storage = tokio::task::spawn_blocking(move || Storage::new(&config, network, false))
+        let network = network.clone();
+        let storage = tokio::task::spawn_blocking(move || Storage::new(&config, &network, false))
             .wait_for_panics()
             .await;
 
diff --git a/zebra-scan/src/service/scan_task/commands.rs b/zebra-scan/src/service/scan_task/commands.rs
index 2e7964bf7c1..e718d742c5b 100644
--- a/zebra-scan/src/service/scan_task/commands.rs
+++ b/zebra-scan/src/service/scan_task/commands.rs
@@ -61,7 +61,7 @@ impl ScanTask {
             SaplingScanningKey,
             (Vec<DiversifiableFullViewingKey>, Vec<SaplingIvk>),
         >,
-        network: Network,
+        network: &Network,
     ) -> Result<
         (
             HashMap<
diff --git a/zebra-scan/src/service/scan_task/scan.rs b/zebra-scan/src/service/scan_task/scan.rs
index 898183fe135..b1207ff09ec 100644
--- a/zebra-scan/src/service/scan_task/scan.rs
+++ b/zebra-scan/src/service/scan_task/scan.rs
@@ -111,7 +111,7 @@ pub async fn start(
     > = key_heights
         .keys()
         .map(|key| {
-            let parsed_keys = sapling_key_to_scan_block_keys(key, network)?;
+            let parsed_keys = sapling_key_to_scan_block_keys(key, &network)?;
             Ok::<_, Report>((key.clone(), parsed_keys))
         })
         .try_collect()?;
@@ -143,7 +143,7 @@ pub async fn start(
         let was_parsed_keys_empty = parsed_keys.is_empty();
 
         let (new_keys, new_result_senders, new_result_receivers) =
-            ScanTask::process_messages(&mut cmd_receiver, &mut parsed_keys, network)?;
+            ScanTask::process_messages(&mut cmd_receiver, &mut parsed_keys, &network)?;
 
         subscribed_keys.extend(new_result_senders);
         // Drop any results senders that are closed from subscribed_keys
@@ -311,6 +311,7 @@ pub async fn scan_height_and_store_results(
         let sapling_key = sapling_key.clone();
         let block = block.clone();
         let mut storage = storage.clone();
+        let network = network.clone();
 
         // We use a dummy size of the Sapling note commitment tree.
         //
@@ -326,9 +327,9 @@ pub async fn scan_height_and_store_results(
 
         tokio::task::spawn_blocking(move || {
             let dfvk_res =
-                scan_block(network, &block, sapling_tree_size, &dfvks).map_err(|e| eyre!(e))?;
+                scan_block(&network, &block, sapling_tree_size, &dfvks).map_err(|e| eyre!(e))?;
             let ivk_res =
-                scan_block(network, &block, sapling_tree_size, &ivks).map_err(|e| eyre!(e))?;
+                scan_block(&network, &block, sapling_tree_size, &ivks).map_err(|e| eyre!(e))?;
 
             let dfvk_res = scanned_block_to_db_result(dfvk_res);
             let ivk_res = scanned_block_to_db_result(ivk_res);
@@ -375,7 +376,7 @@ pub async fn scan_height_and_store_results(
 /// - Pass the real `sapling_tree_size` parameter from the state.
 /// - Add other prior block metadata.
 pub fn scan_block<K: ScanningKey>(
-    network: Network,
+    network: &Network,
     block: &Block,
     sapling_tree_size: u32,
     scanning_keys: &[K],
@@ -419,7 +420,7 @@ pub fn scan_block<K: ScanningKey>(
 // TODO: use `ViewingKey::parse` from zebra-chain instead
 pub fn sapling_key_to_scan_block_keys(
     key: &SaplingScanningKey,
-    network: Network,
+    network: &Network,
 ) -> Result<(Vec<DiversifiableFullViewingKey>, Vec<SaplingIvk>), Report> {
     let efvk =
         decode_extended_full_viewing_key(network.sapling_efvk_hrp(), key).map_err(|e| eyre!(e))?;
diff --git a/zebra-scan/src/service/scan_task/tests/vectors.rs b/zebra-scan/src/service/scan_task/tests/vectors.rs
index fca8b9a5b3e..f406927ef93 100644
--- a/zebra-scan/src/service/scan_task/tests/vectors.rs
+++ b/zebra-scan/src/service/scan_task/tests/vectors.rs
@@ -17,7 +17,7 @@ use crate::{service::ScanTask, tests::mock_sapling_scanning_keys};
 async fn scan_task_processes_messages_correctly() -> Result<(), Report> {
     let (mut mock_scan_task, mut cmd_receiver) = ScanTask::mock();
     let mut parsed_keys = HashMap::new();
-    let network = Default::default();
+    let network = &Default::default();
 
     // Send some keys to be registered
     let num_keys = 10;
diff --git a/zebra-scan/src/service/tests.rs b/zebra-scan/src/service/tests.rs
index fa5bd530af9..fdc8e465d81 100644
--- a/zebra-scan/src/service/tests.rs
+++ b/zebra-scan/src/service/tests.rs
@@ -23,7 +23,7 @@ use crate::{
 /// Tests that keys are deleted correctly
 #[tokio::test]
 pub async fn scan_service_deletes_keys_correctly() -> Result<()> {
-    let mut db = new_test_storage(Network::Mainnet);
+    let mut db = new_test_storage(&Network::Mainnet);
 
     let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
 
@@ -86,7 +86,7 @@ pub async fn scan_service_deletes_keys_correctly() -> Result<()> {
 /// Tests that keys are deleted correctly
 #[tokio::test]
 pub async fn scan_service_subscribes_to_results_correctly() -> Result<()> {
-    let db = new_test_storage(Network::Mainnet);
+    let db = new_test_storage(&Network::Mainnet);
 
     let (mut scan_service, mut cmd_receiver) = ScanService::new_with_mock_scanner(db);
 
@@ -133,7 +133,7 @@ pub async fn scan_service_subscribes_to_results_correctly() -> Result<()> {
 /// Tests that results are cleared are deleted correctly
 #[tokio::test]
 pub async fn scan_service_clears_results_correctly() -> Result<()> {
-    let mut db = new_test_storage(Network::Mainnet);
+    let mut db = new_test_storage(&Network::Mainnet);
 
     let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
 
@@ -188,7 +188,7 @@ pub async fn scan_service_clears_results_correctly() -> Result<()> {
 /// Tests that results for key are returned correctly
 #[tokio::test]
 pub async fn scan_service_get_results_for_key_correctly() -> Result<()> {
-    let mut db = new_test_storage(Network::Mainnet);
+    let mut db = new_test_storage(&Network::Mainnet);
 
     let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
 
@@ -265,13 +265,13 @@ pub async fn scan_service_get_results_for_key_correctly() -> Result<()> {
 #[tokio::test]
 pub async fn scan_service_registers_keys_correctly() -> Result<()> {
     for network in Network::iter() {
-        scan_service_registers_keys_correctly_for(network).await?;
+        scan_service_registers_keys_correctly_for(&network).await?;
     }
 
     Ok(())
 }
 
-async fn scan_service_registers_keys_correctly_for(network: Network) -> Result<()> {
+async fn scan_service_registers_keys_correctly_for(network: &Network) -> Result<()> {
     // Mock the state.
     let (state, _, _, chain_tip_change) = zebra_state::populated_state(vec![], network).await;
 
@@ -357,7 +357,7 @@ async fn scan_service_registers_keys_correctly_for(network: Network) -> Result<(
 /// Test that the scan service with a timeout layer returns timeout errors after expected timeout
 #[tokio::test]
 async fn scan_service_timeout() -> Result<()> {
-    let db = new_test_storage(Network::Mainnet);
+    let db = new_test_storage(&Network::Mainnet);
 
     let (scan_service, _cmd_receiver) = ScanService::new_with_mock_scanner(db);
     let mut scan_service = ServiceBuilder::new()
diff --git a/zebra-scan/src/storage.rs b/zebra-scan/src/storage.rs
index 2372957014e..c633d267794 100644
--- a/zebra-scan/src/storage.rs
+++ b/zebra-scan/src/storage.rs
@@ -52,7 +52,7 @@ impl Storage {
     ///
     /// This method can block while creating or reading database files, so it must be inside
     /// spawn_blocking() in async code.
-    pub fn new(config: &Config, network: Network, read_only: bool) -> Self {
+    pub fn new(config: &Config, network: &Network, read_only: bool) -> Self {
         let mut storage = Self::new_db(config, network, read_only);
 
         for (sapling_key, birthday) in config.sapling_keys_to_scan.iter() {
diff --git a/zebra-scan/src/storage/db.rs b/zebra-scan/src/storage/db.rs
index 784ffb3d70f..206226f59ce 100644
--- a/zebra-scan/src/storage/db.rs
+++ b/zebra-scan/src/storage/db.rs
@@ -48,7 +48,7 @@ impl Storage {
     /// If there is no existing database, creates a new database on disk.
     ///
     /// New keys in `config` are not inserted into the database.
-    pub(crate) fn new_db(config: &Config, network: Network, read_only: bool) -> Self {
+    pub(crate) fn new_db(config: &Config, network: &Network, read_only: bool) -> Self {
         Self::new_with_debug(
             config, network,
             // TODO: make format upgrades work with any database, then change debug_skip_format_upgrades to `false`
@@ -64,7 +64,7 @@ impl Storage {
     /// This method is intended for use in tests.
     pub(crate) fn new_with_debug(
         config: &Config,
-        network: Network,
+        network: &Network,
         debug_skip_format_upgrades: bool,
         read_only: bool,
     ) -> Self {
diff --git a/zebra-scan/src/storage/db/tests.rs b/zebra-scan/src/storage/db/tests.rs
index b6b20740341..11d457dfab2 100644
--- a/zebra-scan/src/storage/db/tests.rs
+++ b/zebra-scan/src/storage/db/tests.rs
@@ -23,7 +23,7 @@ mod snapshot;
 mod vectors;
 
 /// Returns an empty `Storage` suitable for testing.
-pub fn new_test_storage(network: Network) -> Storage {
+pub fn new_test_storage(network: &Network) -> Storage {
     Storage::new(&Config::ephemeral(), network, false)
 }
 
@@ -41,7 +41,7 @@ pub fn add_fake_keys(storage: &mut Storage) {
 /// If it is `false`, adds the transaction hashes from `height`.
 pub fn add_fake_results(
     storage: &mut Storage,
-    network: Network,
+    network: &Network,
     height: Height,
     add_progress_marker: bool,
 ) {
diff --git a/zebra-scan/src/storage/db/tests/snapshot.rs b/zebra-scan/src/storage/db/tests/snapshot.rs
index f3f18e2ef03..81dc1a71170 100644
--- a/zebra-scan/src/storage/db/tests/snapshot.rs
+++ b/zebra-scan/src/storage/db/tests/snapshot.rs
@@ -56,7 +56,7 @@ fn test_database_format_with_network(network: Network) {
     let mut net_suffix = network.to_string();
     net_suffix.make_ascii_lowercase();
 
-    let mut storage = super::new_test_storage(network);
+    let mut storage = super::new_test_storage(&network);
 
     // Snapshot the column family names
     let mut cf_names = storage.db.list_cf().expect("empty database is valid");
@@ -89,8 +89,8 @@ fn test_database_format_with_network(network: Network) {
     //
     // We limit the number of blocks, because we create 2 snapshots per block, one for each network.
     for height in 0..=2 {
-        super::add_fake_results(&mut storage, network, Height(height), true);
-        super::add_fake_results(&mut storage, network, Height(height), false);
+        super::add_fake_results(&mut storage, &network, Height(height), true);
+        super::add_fake_results(&mut storage, &network, Height(height), false);
 
         let mut settings = insta::Settings::clone_current();
         settings.set_snapshot_suffix(format!("{net_suffix}_{height}"));
diff --git a/zebra-scan/src/storage/db/tests/vectors.rs b/zebra-scan/src/storage/db/tests/vectors.rs
index f02165d7111..b04a70747c9 100644
--- a/zebra-scan/src/storage/db/tests/vectors.rs
+++ b/zebra-scan/src/storage/db/tests/vectors.rs
@@ -11,7 +11,7 @@ use crate::{
 /// Tests that keys are deleted correctly
 #[test]
 pub fn deletes_keys_and_results_correctly() {
-    let mut db = new_test_storage(Network::Mainnet);
+    let mut db = new_test_storage(&Network::Mainnet);
 
     let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
 
@@ -69,7 +69,7 @@ pub fn deletes_keys_and_results_correctly() {
 /// Tests that keys are deleted correctly
 #[test]
 pub fn clears_results_correctly() {
-    let mut db = new_test_storage(Network::Mainnet);
+    let mut db = new_test_storage(&Network::Mainnet);
 
     let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
 
diff --git a/zebra-scan/src/tests.rs b/zebra-scan/src/tests.rs
index b3a54c674d8..88cb2dcce92 100644
--- a/zebra-scan/src/tests.rs
+++ b/zebra-scan/src/tests.rs
@@ -60,7 +60,7 @@ pub const FAKE_SAPLING_VIEWING_KEY: &str = "zxviewsfake";
 ///
 /// The keys are seeded only from their index in the returned `Vec`, so repeated calls return same
 /// keys at a particular index.
-pub fn mock_sapling_scanning_keys(num_keys: u8, network: Network) -> Vec<SaplingScanningKey> {
+pub fn mock_sapling_scanning_keys(num_keys: u8, network: &Network) -> Vec<SaplingScanningKey> {
     let mut keys: Vec<SaplingScanningKey> = vec![];
 
     for seed in 0..num_keys {
diff --git a/zebra-scan/src/tests/vectors.rs b/zebra-scan/src/tests/vectors.rs
index 7af0d5dedb3..9fff00c62c0 100644
--- a/zebra-scan/src/tests/vectors.rs
+++ b/zebra-scan/src/tests/vectors.rs
@@ -42,7 +42,7 @@ async fn scanning_from_fake_generated_blocks() -> Result<()> {
 
     assert_eq!(block.transactions.len(), 4);
 
-    let res = scan_block(Network::Mainnet, &block, sapling_tree_size, &[&dfvk]).unwrap();
+    let res = scan_block(&Network::Mainnet, &block, sapling_tree_size, &[&dfvk]).unwrap();
 
     // The response should have one transaction relevant to the key we provided.
     assert_eq!(res.transactions().len(), 1);
@@ -93,7 +93,7 @@ async fn scanning_zecpages_from_populated_zebra_state() -> Result<()> {
 
     // Create a populated state service.
     let (_state_service, read_only_state_service, latest_chain_tip, _chain_tip_change) =
-        zebra_state::populated_state(blocks.clone(), network).await;
+        zebra_state::populated_state(blocks.clone(), &network).await;
 
     let db = read_only_state_service.db();
 
@@ -118,7 +118,7 @@ async fn scanning_zecpages_from_populated_zebra_state() -> Result<()> {
 
         let compact_block = block_to_compact(&block, chain_metadata);
 
-        let res = scan_block(network, &block, sapling_commitment_tree_size, &ivks)
+        let res = scan_block(&network, &block, sapling_commitment_tree_size, &ivks)
             .expect("scanning block for the ZECpages viewing key should work");
 
         transactions_found += res.transactions().len();
@@ -156,7 +156,7 @@ fn scanning_fake_blocks_store_key_and_results() -> Result<()> {
     let key_to_be_stored = encode_extended_full_viewing_key("zxviews", &efvk);
 
     // Create a database
-    let mut storage = new_test_storage(network);
+    let mut storage = new_test_storage(&network);
 
     // Insert the generated key to the database
     storage.add_sapling_key(&key_to_be_stored, None);
@@ -177,7 +177,7 @@ fn scanning_fake_blocks_store_key_and_results() -> Result<()> {
 
     let (block, sapling_tree_size) = fake_block(1u32.into(), nf, &dfvk, 1, true, Some(0));
 
-    let result = scan_block(Network::Mainnet, &block, sapling_tree_size, &[&dfvk]).unwrap();
+    let result = scan_block(&Network::Mainnet, &block, sapling_tree_size, &[&dfvk]).unwrap();
 
     // The response should have one transaction relevant to the key we provided.
     assert_eq!(result.transactions().len(), 1);
diff --git a/zebra-state/src/config.rs b/zebra-state/src/config.rs
index 775b41f4283..869fff66533 100644
--- a/zebra-state/src/config.rs
+++ b/zebra-state/src/config.rs
@@ -131,7 +131,7 @@ impl Config {
         &self,
         db_kind: impl AsRef<str>,
         major_version: u64,
-        network: Network,
+        network: &Network,
     ) -> PathBuf {
         let db_kind = db_kind.as_ref();
         let major_version = format!("v{}", major_version);
@@ -153,7 +153,7 @@ impl Config {
         &self,
         db_kind: impl AsRef<str>,
         major_version: u64,
-        network: Network,
+        network: &Network,
     ) -> PathBuf {
         let mut version_path = self.db_path(db_kind, major_version, network);
 
@@ -200,7 +200,7 @@ impl Default for Config {
 /// and deletes them from the filesystem.
 ///
 /// See `check_and_delete_old_databases()` for details.
-pub fn check_and_delete_old_state_databases(config: &Config, network: Network) -> JoinHandle<()> {
+pub fn check_and_delete_old_state_databases(config: &Config, network: &Network) -> JoinHandle<()> {
     check_and_delete_old_databases(
         config,
         STATE_DATABASE_KIND,
@@ -229,15 +229,16 @@ pub fn check_and_delete_old_databases(
     config: &Config,
     db_kind: impl AsRef<str>,
     major_version: u64,
-    network: Network,
+    network: &Network,
 ) -> JoinHandle<()> {
     let current_span = Span::current();
     let config = config.clone();
     let db_kind = db_kind.as_ref().to_string();
+    let network = network.clone();
 
     spawn_blocking(move || {
         current_span.in_scope(|| {
-            delete_old_databases(config, db_kind, major_version, network);
+            delete_old_databases(config, db_kind, major_version, &network);
             info!("finished old database version cleanup task");
         })
     })
@@ -246,7 +247,7 @@ pub fn check_and_delete_old_databases(
 /// Check if there are old database folders and delete them from the filesystem.
 ///
 /// See [`check_and_delete_old_databases`] for details.
-fn delete_old_databases(config: Config, db_kind: String, major_version: u64, network: Network) {
+fn delete_old_databases(config: Config, db_kind: String, major_version: u64, network: &Network) {
     if config.ephemeral || !config.delete_old_database {
         return;
     }
@@ -371,7 +372,7 @@ fn parse_major_version(dir_name: &str) -> Option<u64> {
 /// Returns the full semantic version of the on-disk state database, based on its config and network.
 pub fn state_database_format_version_on_disk(
     config: &Config,
-    network: Network,
+    network: &Network,
 ) -> Result<Option<Version>, BoxError> {
     database_format_version_on_disk(
         config,
@@ -398,7 +399,7 @@ pub fn database_format_version_on_disk(
     config: &Config,
     db_kind: impl AsRef<str>,
     major_version: u64,
-    network: Network,
+    network: &Network,
 ) -> Result<Option<Version>, BoxError> {
     let version_path = config.version_file_path(&db_kind, major_version, network);
     let db_path = config.db_path(db_kind, major_version, network);
@@ -470,7 +471,7 @@ pub(crate) mod hidden {
     pub fn write_state_database_format_version_to_disk(
         config: &Config,
         changed_version: &Version,
-        network: Network,
+        network: &Network,
     ) -> Result<(), BoxError> {
         write_database_format_version_to_disk(config, STATE_DATABASE_KIND, changed_version, network)
     }
@@ -496,7 +497,7 @@ pub(crate) mod hidden {
         config: &Config,
         db_kind: impl AsRef<str>,
         changed_version: &Version,
-        network: Network,
+        network: &Network,
     ) -> Result<(), BoxError> {
         let version_path = config.version_file_path(db_kind, changed_version.major, network);
 
diff --git a/zebra-state/src/service.rs b/zebra-state/src/service.rs
index 64c1936475f..39f6f5e8da8 100644
--- a/zebra-state/src/service.rs
+++ b/zebra-state/src/service.rs
@@ -310,7 +310,7 @@ impl StateService {
     /// and read-only watch channels for its best chain tip.
     pub fn new(
         config: Config,
-        network: Network,
+        network: &Network,
         max_checkpoint_height: block::Height,
         checkpoint_verify_concurrency_limit: usize,
     ) -> (Self, ReadStateService, LatestChainTip, ChainTipChange) {
@@ -353,7 +353,7 @@ impl StateService {
         let non_finalized_state = NonFinalizedState::new(network);
 
         let (non_finalized_state_sender, non_finalized_state_receiver) =
-            watch::channel(NonFinalizedState::new(finalized_state.network()));
+            watch::channel(NonFinalizedState::new(&finalized_state.network()));
 
         // Security: The number of blocks in these channels is limited by
         //           the syncer and inbound lookahead limits.
@@ -399,7 +399,7 @@ impl StateService {
         let finalized_block_write_last_sent_hash = finalized_state.db.finalized_tip_hash();
 
         let state = Self {
-            network,
+            network: network.clone(),
             full_verifier_utxo_lookahead,
             non_finalized_state_queued_blocks,
             finalized_state_queued_blocks: HashMap::new(),
@@ -430,7 +430,7 @@ impl StateService {
                     &state.read_service.db,
                     tip.1,
                 ),
-                state.network,
+                &state.network,
                 MAX_LEGACY_CHAIN_BLOCKS,
             ) {
                 let legacy_db_path = state.read_service.db.path().to_path_buf();
@@ -1643,7 +1643,7 @@ impl Service<ReadRequest> for ReadStateService {
                         let utxos = state.non_finalized_state_receiver.with_watch_data(
                             |non_finalized_state| {
                                 read::address_utxos(
-                                    state.network,
+                                    &state.network,
                                     non_finalized_state.best_chain(),
                                     &state.db,
                                     addresses,
@@ -1749,7 +1749,7 @@ impl Service<ReadRequest> for ReadStateService {
                             read::difficulty::get_block_template_chain_info(
                                 &latest_non_finalized_state,
                                 &state.db,
-                                state.network,
+                                &state.network,
                             );
 
                         // The work is done in the future.
@@ -1882,7 +1882,7 @@ impl Service<ReadRequest> for ReadStateService {
 /// probably not what you want.
 pub fn init(
     config: Config,
-    network: Network,
+    network: &Network,
     max_checkpoint_height: block::Height,
     checkpoint_verify_concurrency_limit: usize,
 ) -> (
@@ -1912,7 +1912,7 @@ pub fn init(
 /// a read state service, and receivers for state chain tip updates.
 pub fn spawn_init(
     config: Config,
-    network: Network,
+    network: &Network,
     max_checkpoint_height: block::Height,
     checkpoint_verify_concurrency_limit: usize,
 ) -> tokio::task::JoinHandle<(
@@ -1921,10 +1921,11 @@ pub fn spawn_init(
     LatestChainTip,
     ChainTipChange,
 )> {
+    let network = network.clone();
     tokio::task::spawn_blocking(move || {
         init(
             config,
-            network,
+            &network,
             max_checkpoint_height,
             checkpoint_verify_concurrency_limit,
         )
@@ -1935,7 +1936,7 @@ pub fn spawn_init(
 ///
 /// This can be used to create a state service for testing. See also [`init`].
 #[cfg(any(test, feature = "proptest-impl"))]
-pub fn init_test(network: Network) -> Buffer<BoxService<Request, Response, BoxError>, Request> {
+pub fn init_test(network: &Network) -> Buffer<BoxService<Request, Response, BoxError>, Request> {
     // TODO: pass max_checkpoint_height and checkpoint_verify_concurrency limit
     //       if we ever need to test final checkpoint sent UTXO queries
     let (state_service, _, _, _) =
@@ -1950,7 +1951,7 @@ pub fn init_test(network: Network) -> Buffer<BoxService<Request, Response, BoxEr
 /// This can be used to create a state service for testing. See also [`init`].
 #[cfg(any(test, feature = "proptest-impl"))]
 pub fn init_test_services(
-    network: Network,
+    network: &Network,
 ) -> (
     Buffer<BoxService<Request, Response, BoxError>, Request>,
     ReadStateService,
diff --git a/zebra-state/src/service/arbitrary.rs b/zebra-state/src/service/arbitrary.rs
index f6185617c59..08eb42a83ca 100644
--- a/zebra-state/src/service/arbitrary.rs
+++ b/zebra-state/src/service/arbitrary.rs
@@ -51,7 +51,7 @@ impl ValueTree for PreparedChainTree {
         (
             self.chain.clone(),
             self.count.current(),
-            self.network,
+            self.network.clone(),
             self.history_tree.clone(),
         )
     }
@@ -90,10 +90,10 @@ impl PreparedChain {
         // Since the network will be chosen later, we pick the larger
         // between the mainnet and testnet Heartwood activation heights.
         let main_height = NetworkUpgrade::Heartwood
-            .activation_height(Network::Mainnet)
+            .activation_height(&Network::Mainnet)
             .expect("must have height");
         let test_height = NetworkUpgrade::Heartwood
-            .activation_height(Network::Testnet)
+            .activation_height(&Network::Testnet)
             .expect("must have height");
         let height = std::cmp::max(main_height, test_height);
 
@@ -137,7 +137,7 @@ impl Strategy for PreparedChain {
             let (network, blocks) = ledger_strategy
                 .prop_flat_map(|ledger| {
                     (
-                        Just(ledger.network),
+                        Just(ledger.network.clone()),
                         Block::partial_chain_strategy(
                             ledger,
                             MAX_PARTIAL_CHAIN_BLOCKS,
@@ -158,7 +158,7 @@ impl Strategy for PreparedChain {
                 .current();
             // Generate a history tree from the first block
             let history_tree = HistoryTree::from_block(
-                network,
+                &network,
                 blocks[0].block.clone(),
                 // Dummy roots since this is only used for tests
                 &Default::default(),
@@ -193,7 +193,7 @@ impl Strategy for PreparedChain {
 /// - a [`ChainTipChange`] tracker
 pub async fn populated_state(
     blocks: impl IntoIterator<Item = Arc<Block>>,
-    network: Network,
+    network: &Network,
 ) -> (
     Buffer<BoxService<Request, Response, BoxError>, Request>,
     ReadStateService,
diff --git a/zebra-state/src/service/chain_tip.rs b/zebra-state/src/service/chain_tip.rs
index 04d2af863f9..3f3468f4ca6 100644
--- a/zebra-state/src/service/chain_tip.rs
+++ b/zebra-state/src/service/chain_tip.rs
@@ -147,7 +147,7 @@ impl ChainTipSender {
     #[instrument(skip(initial_tip), fields(new_height, new_hash))]
     pub fn new(
         initial_tip: impl Into<Option<ChainTipBlock>>,
-        network: Network,
+        network: &Network,
     ) -> (Self, LatestChainTip, ChainTipChange) {
         let initial_tip = initial_tip.into();
         Self::record_new_tip(&initial_tip);
@@ -575,7 +575,7 @@ impl ChainTipChange {
         // Fork changes can activate or deactivate a network upgrade.
         // So we must perform the same actions for network upgrades and skipped blocks.
         if Some(block.previous_block_hash) != self.last_change_hash
-            || NetworkUpgrade::is_activation_height(self.network, block.height)
+            || NetworkUpgrade::is_activation_height(&self.network, block.height)
         {
             TipAction::reset_with(block)
         } else {
@@ -584,11 +584,11 @@ impl ChainTipChange {
     }
 
     /// Create a new [`ChainTipChange`] from a [`LatestChainTip`] receiver and [`Network`].
-    fn new(latest_chain_tip: LatestChainTip, network: Network) -> Self {
+    fn new(latest_chain_tip: LatestChainTip, network: &Network) -> Self {
         Self {
             latest_chain_tip,
             last_change_hash: None,
-            network,
+            network: network.clone(),
         }
     }
 
@@ -643,7 +643,7 @@ impl Clone for ChainTipChange {
             // clear the previous change hash, so the first action is a reset
             last_change_hash: None,
 
-            network: self.network,
+            network: self.network.clone(),
         }
     }
 }
diff --git a/zebra-state/src/service/chain_tip/tests/prop.rs b/zebra-state/src/service/chain_tip/tests/prop.rs
index 86b7e255310..744bd0be097 100644
--- a/zebra-state/src/service/chain_tip/tests/prop.rs
+++ b/zebra-state/src/service/chain_tip/tests/prop.rs
@@ -38,7 +38,7 @@ proptest! {
         tip_updates in any::<SummaryDebug<Vec<(BlockUpdate, BlockConnection, TipChangeCheck)>>>(),
         network in any::<Network>(),
     ) {
-        let (mut chain_tip_sender, latest_chain_tip, mut chain_tip_change) = ChainTipSender::new(None, network);
+        let (mut chain_tip_sender, latest_chain_tip, mut chain_tip_change) = ChainTipSender::new(None, &network);
 
         let mut latest_finalized_tip = None;
         let mut latest_non_finalized_tip = None;
@@ -132,7 +132,7 @@ proptest! {
                     // some updates don't do anything, so there's no new action
                     None
                 } else if Some(chain_tip.previous_block_hash) != old_last_change_hash
-                    || NetworkUpgrade::is_activation_height(network, chain_tip.height)
+                    || NetworkUpgrade::is_activation_height(&network, chain_tip.height)
                 {
                     Some(TipAction::reset_with(block.0.into()))
                 } else {
diff --git a/zebra-state/src/service/chain_tip/tests/vectors.rs b/zebra-state/src/service/chain_tip/tests/vectors.rs
index 29bb8cc2d05..e27cf37f500 100644
--- a/zebra-state/src/service/chain_tip/tests/vectors.rs
+++ b/zebra-state/src/service/chain_tip/tests/vectors.rs
@@ -12,7 +12,7 @@ use super::super::ChainTipSender;
 #[test]
 fn current_best_tip_is_initially_empty() {
     let (_chain_tip_sender, latest_chain_tip, _chain_tip_change) =
-        ChainTipSender::new(None, Mainnet);
+        ChainTipSender::new(None, &Mainnet);
 
     assert_eq!(latest_chain_tip.best_tip_height(), None);
     assert_eq!(latest_chain_tip.best_tip_hash(), None);
@@ -37,7 +37,7 @@ fn empty_latest_chain_tip_is_empty() {
 #[test]
 fn chain_tip_change_is_initially_not_ready() {
     let (_chain_tip_sender, _latest_chain_tip, mut chain_tip_change) =
-        ChainTipSender::new(None, Mainnet);
+        ChainTipSender::new(None, &Mainnet);
 
     // TODO: use `tokio::task::unconstrained` to avoid spurious waits from tokio's cooperative multitasking
     //       (needs a recent tokio version)
diff --git a/zebra-state/src/service/check.rs b/zebra-state/src/service/check.rs
index 0d3a941f2d0..30144d8d3fe 100644
--- a/zebra-state/src/service/check.rs
+++ b/zebra-state/src/service/check.rs
@@ -53,7 +53,7 @@ pub(crate) use difficulty::AdjustedDifficulty;
 #[tracing::instrument(skip(semantically_verified, finalized_tip_height, relevant_chain))]
 pub(crate) fn block_is_valid_for_recent_chain<C>(
     semantically_verified: &SemanticallyVerifiedBlock,
-    network: Network,
+    network: &Network,
     finalized_tip_height: Option<block::Height>,
     relevant_chain: C,
 ) -> Result<(), ValidateContextError>
@@ -121,7 +121,7 @@ where
 #[tracing::instrument(skip(block, history_tree))]
 pub(crate) fn block_commitment_is_valid_for_chain_history(
     block: Arc<Block>,
-    network: Network,
+    network: &Network,
     history_tree: &HistoryTree,
 ) -> Result<(), ValidateContextError> {
     match block.commitment(network)? {
@@ -260,7 +260,7 @@ fn difficulty_threshold_and_time_are_valid(
     //
     // https://zips.z.cash/protocol/protocol.pdf#blockheader
     let genesis_height = NetworkUpgrade::Genesis
-        .activation_height(network)
+        .activation_height(&network)
         .expect("Zebra always has a genesis height available");
 
     if candidate_time <= median_time_past && candidate_height != genesis_height {
@@ -308,7 +308,7 @@ fn difficulty_threshold_and_time_are_valid(
 pub(crate) fn legacy_chain<I>(
     nu5_activation_height: block::Height,
     ancestors: I,
-    network: Network,
+    network: &Network,
     max_legacy_chain_blocks: usize,
 ) -> Result<(), BoxError>
 where
@@ -384,7 +384,7 @@ pub(crate) fn initial_contextual_validity(
     // Security: check proof of work before any other checks
     check::block_is_valid_for_recent_chain(
         semantically_verified,
-        non_finalized_state.network,
+        &non_finalized_state.network,
         finalized_state.finalized_tip_height(),
         relevant_chain,
     )?;
diff --git a/zebra-state/src/service/check/difficulty.rs b/zebra-state/src/service/check/difficulty.rs
index a5ec6179bcf..3f6cd9e966f 100644
--- a/zebra-state/src/service/check/difficulty.rs
+++ b/zebra-state/src/service/check/difficulty.rs
@@ -91,7 +91,7 @@ impl AdjustedDifficulty {
     /// If the `context` contains fewer than 28 items.
     pub fn new_from_block<C>(
         candidate_block: &Block,
-        network: Network,
+        network: &Network,
         context: C,
     ) -> AdjustedDifficulty
     where
@@ -125,7 +125,7 @@ impl AdjustedDifficulty {
     pub fn new_from_header_time<C>(
         candidate_header_time: DateTime<Utc>,
         previous_block_height: block::Height,
-        network: Network,
+        network: &Network,
         context: C,
     ) -> AdjustedDifficulty
     where
@@ -148,7 +148,7 @@ impl AdjustedDifficulty {
         AdjustedDifficulty {
             candidate_time: candidate_header_time,
             candidate_height,
-            network,
+            network: network.clone(),
             relevant_difficulty_thresholds,
             relevant_times,
         }
@@ -166,7 +166,7 @@ impl AdjustedDifficulty {
 
     /// Returns the configured network.
     pub fn network(&self) -> Network {
-        self.network
+        self.network.clone()
     }
 
     /// Calculate the expected `difficulty_threshold` for a candidate block, based
@@ -178,7 +178,7 @@ impl AdjustedDifficulty {
     /// minimum difficulty adjustment from ZIPs 205 and 208.
     pub fn expected_difficulty_threshold(&self) -> CompactDifficulty {
         if NetworkUpgrade::is_testnet_min_difficulty_block(
-            self.network,
+            &self.network,
             self.candidate_height,
             self.candidate_time,
             self.relevant_times[0],
@@ -204,7 +204,7 @@ impl AdjustedDifficulty {
     /// Testnet minimum difficulty adjustment.)
     fn threshold_bits(&self) -> CompactDifficulty {
         let averaging_window_timespan = NetworkUpgrade::averaging_window_timespan_for_height(
-            self.network,
+            &self.network,
             self.candidate_height,
         );
 
@@ -263,7 +263,7 @@ impl AdjustedDifficulty {
     /// start and end of the timespan times. timespan times `[11..=16]` are ignored.
     fn median_timespan_bounded(&self) -> Duration {
         let averaging_window_timespan = NetworkUpgrade::averaging_window_timespan_for_height(
-            self.network,
+            &self.network,
             self.candidate_height,
         );
         // This value is exact, but we need to truncate its nanoseconds component
diff --git a/zebra-state/src/service/finalized_state.rs b/zebra-state/src/service/finalized_state.rs
index bdcb8db6ebf..41c76e64090 100644
--- a/zebra-state/src/service/finalized_state.rs
+++ b/zebra-state/src/service/finalized_state.rs
@@ -141,7 +141,7 @@ impl FinalizedState {
     /// If there is no existing database, creates a new database on disk.
     pub fn new(
         config: &Config,
-        network: Network,
+        network: &Network,
         #[cfg(feature = "elasticsearch")] elastic_db: Option<elasticsearch::Elasticsearch>,
     ) -> Self {
         Self::new_with_debug(
@@ -160,7 +160,7 @@ impl FinalizedState {
     /// This method is intended for use in tests.
     pub(crate) fn new_with_debug(
         config: &Config,
-        network: Network,
+        network: &Network,
         debug_skip_format_upgrades: bool,
         #[cfg(feature = "elasticsearch")] elastic_db: Option<elasticsearch::Elasticsearch>,
         read_only: bool,
@@ -340,7 +340,7 @@ impl FinalizedState {
                 // thread, if it shows up in profiles
                 check::block_commitment_is_valid_for_chain_history(
                     block.clone(),
-                    self.network(),
+                    &self.network(),
                     &history_tree,
                 )?;
 
@@ -351,7 +351,12 @@ impl FinalizedState {
                 let history_tree_mut = Arc::make_mut(&mut history_tree);
                 let sapling_root = note_commitment_trees.sapling.root();
                 let orchard_root = note_commitment_trees.orchard.root();
-                history_tree_mut.push(self.network(), block.clone(), sapling_root, orchard_root)?;
+                history_tree_mut.push(
+                    &self.network(),
+                    block.clone(),
+                    &sapling_root,
+                    &orchard_root,
+                )?;
                 let treestate = Treestate {
                     note_commitment_trees,
                     history_tree,
@@ -409,7 +414,7 @@ impl FinalizedState {
         let result = self.db.write_block(
             finalized,
             prev_note_commitment_trees,
-            self.network(),
+            &self.network(),
             source,
         );
 
diff --git a/zebra-state/src/service/finalized_state/disk_db.rs b/zebra-state/src/service/finalized_state/disk_db.rs
index 825edbc6657..24ca542f950 100644
--- a/zebra-state/src/service/finalized_state/disk_db.rs
+++ b/zebra-state/src/service/finalized_state/disk_db.rs
@@ -727,7 +727,7 @@ impl DiskDb {
         config: &Config,
         db_kind: impl AsRef<str>,
         format_version_in_code: &Version,
-        network: Network,
+        network: &Network,
         column_families_in_code: impl IntoIterator<Item = String>,
         read_only: bool,
     ) -> DiskDb {
@@ -765,7 +765,7 @@ impl DiskDb {
                 let db = DiskDb {
                     db_kind: db_kind.to_string(),
                     format_version_in_code: format_version_in_code.clone(),
-                    network,
+                    network: network.clone(),
                     ephemeral: config.ephemeral,
                     db: Arc::new(db),
                 };
@@ -803,7 +803,7 @@ impl DiskDb {
 
     /// Returns the configured network for this database.
     pub fn network(&self) -> Network {
-        self.network
+        self.network.clone()
     }
 
     /// Returns the `Path` where the files used by this database are located.
diff --git a/zebra-state/src/service/finalized_state/disk_format/chain.rs b/zebra-state/src/service/finalized_state/disk_format/chain.rs
index 5b45ae2c73a..cf1cbe7dc29 100644
--- a/zebra-state/src/service/finalized_state/disk_format/chain.rs
+++ b/zebra-state/src/service/finalized_state/disk_format/chain.rs
@@ -70,7 +70,7 @@ impl FromDisk for NonEmptyHistoryTree {
                 "deserialization format should match the serialization format used by IntoDisk",
             );
         NonEmptyHistoryTree::from_cache(
-            parts.network,
+            &parts.network,
             parts.size,
             parts.peaks,
             parts.current_height,
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 80224954c4d..4605faf7ddd 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
@@ -64,7 +64,7 @@ fn test_raw_rocksdb_column_families_with_network(network: Network) {
 
     let mut state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
diff --git a/zebra-state/src/service/finalized_state/disk_format/transparent.rs b/zebra-state/src/service/finalized_state/disk_format/transparent.rs
index 46879f39aaf..89620cdae40 100644
--- a/zebra-state/src/service/finalized_state/disk_format/transparent.rs
+++ b/zebra-state/src/service/finalized_state/disk_format/transparent.rs
@@ -535,9 +535,9 @@ impl FromDisk for transparent::Address {
         };
 
         if address_variant % 2 == 0 {
-            transparent::Address::from_pub_key_hash(network, hash_bytes)
+            transparent::Address::from_pub_key_hash(&network, hash_bytes)
         } else {
-            transparent::Address::from_script_hash(network, hash_bytes)
+            transparent::Address::from_script_hash(&network, hash_bytes)
         }
     }
 }
diff --git a/zebra-state/src/service/finalized_state/tests/prop.rs b/zebra-state/src/service/finalized_state/tests/prop.rs
index 69fa9f40c85..d48761795f5 100644
--- a/zebra-state/src/service/finalized_state/tests/prop.rs
+++ b/zebra-state/src/service/finalized_state/tests/prop.rs
@@ -24,7 +24,7 @@ fn blocks_with_v5_transactions() -> Result<()> {
         .and_then(|v| v.parse().ok())
         .unwrap_or(DEFAULT_PARTIAL_CHAIN_PROPTEST_CASES)),
         |((chain, count, network, _history_tree) in PreparedChain::default())| {
-            let mut state = FinalizedState::new(&Config::ephemeral(), network, #[cfg(feature = "elasticsearch")] None);
+            let mut state = FinalizedState::new(&Config::ephemeral(), &network, #[cfg(feature = "elasticsearch")] None);
             let mut height = Height(0);
             // use `count` to minimize test failures, so they are easier to diagnose
             for block in chain.iter().take(count) {
@@ -65,11 +65,11 @@ fn all_upgrades_and_wrong_commitments_with_fake_activation_heights() -> Result<(
         .unwrap_or(DEFAULT_PARTIAL_CHAIN_PROPTEST_CASES)),
         |((chain, _count, network, _history_tree) in PreparedChain::default().with_valid_commitments().no_shrink())| {
 
-            let mut state = FinalizedState::new(&Config::ephemeral(), network, #[cfg(feature = "elasticsearch")] None);
+            let mut state = FinalizedState::new(&Config::ephemeral(), &network, #[cfg(feature = "elasticsearch")] None);
             let mut height = Height(0);
-            let heartwood_height = NetworkUpgrade::Heartwood.activation_height(network).unwrap();
+            let heartwood_height = NetworkUpgrade::Heartwood.activation_height(&network).unwrap();
             let heartwood_height_plus1 = (heartwood_height + 1).unwrap();
-            let nu5_height = NetworkUpgrade::Nu5.activation_height(network).unwrap();
+            let nu5_height = NetworkUpgrade::Nu5.activation_height(&network).unwrap();
             let nu5_height_plus1 = (nu5_height + 1).unwrap();
 
             let mut failure_count = 0;
diff --git a/zebra-state/src/service/finalized_state/zebra_db.rs b/zebra-state/src/service/finalized_state/zebra_db.rs
index 810feff878e..ee324a2cfa5 100644
--- a/zebra-state/src/service/finalized_state/zebra_db.rs
+++ b/zebra-state/src/service/finalized_state/zebra_db.rs
@@ -93,7 +93,7 @@ impl ZebraDb {
         config: &Config,
         db_kind: impl AsRef<str>,
         format_version_in_code: &Version,
-        network: Network,
+        network: &Network,
         debug_skip_format_upgrades: bool,
         column_families_in_code: impl IntoIterator<Item = String>,
         read_only: bool,
@@ -194,7 +194,7 @@ impl ZebraDb {
             self.config(),
             self.db_kind(),
             self.major_version(),
-            self.network(),
+            &self.network(),
         )
     }
 
@@ -209,13 +209,13 @@ impl ZebraDb {
             self.config(),
             self.db_kind(),
             new_version,
-            self.network(),
+            &self.network(),
         )
     }
 
     /// Returns the configured network for this database.
     pub fn network(&self) -> Network {
-        self.db.network()
+        self.db.network().clone()
     }
 
     /// Returns the `Path` where the files used by this database are located.
@@ -271,7 +271,7 @@ impl ZebraDb {
                 &self.config,
                 self.db_kind(),
                 self.major_version(),
-                self.network(),
+                &self.network(),
             )
             .expect("unexpected invalid or unreadable database version file");
 
diff --git a/zebra-state/src/service/finalized_state/zebra_db/block.rs b/zebra-state/src/service/finalized_state/zebra_db/block.rs
index 0a5a7b5faa6..e10fd3b43b4 100644
--- a/zebra-state/src/service/finalized_state/zebra_db/block.rs
+++ b/zebra-state/src/service/finalized_state/zebra_db/block.rs
@@ -294,7 +294,7 @@ impl ZebraDb {
         &mut self,
         finalized: FinalizedBlock,
         prev_note_commitment_trees: Option<NoteCommitmentTrees>,
-        network: Network,
+        network: &Network,
         source: &str,
     ) -> Result<block::Hash, BoxError> {
         let tx_hash_indexes: HashMap<transaction::Hash, usize> = finalized
@@ -376,7 +376,9 @@ impl ZebraDb {
         let address_balances: HashMap<transparent::Address, AddressBalanceLocation> =
             changed_addresses
                 .into_iter()
-                .filter_map(|address| Some((address, self.address_balance_location(&address)?)))
+                .filter_map(|address| {
+                    Some((address.clone(), self.address_balance_location(&address)?))
+                })
                 .collect();
 
         let mut batch = DiskWriteBatch::new();
@@ -440,7 +442,7 @@ impl DiskWriteBatch {
     pub fn prepare_block_batch(
         &mut self,
         zebra_db: &ZebraDb,
-        network: Network,
+        network: &Network,
         finalized: &FinalizedBlock,
         new_outputs_by_out_loc: BTreeMap<OutputLocation, transparent::Utxo>,
         spent_utxos_by_outpoint: HashMap<transparent::OutPoint, transparent::Utxo>,
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 54b17c8465f..f91ea584300 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
@@ -167,7 +167,7 @@ fn test_block_and_transaction_data_with_network(network: Network) {
 
     let mut state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -550,7 +550,7 @@ fn snapshot_transparent_address_data(state: &FinalizedState, height: u32) {
         // The default raw data serialization is very verbose, so we hex-encode the bytes.
         stored_address_balances.push((address.to_string(), stored_address_balance_location));
         stored_address_utxo_locations.push((stored_address_location, stored_utxo_locations));
-        stored_address_utxos.push((address, stored_utxos));
+        stored_address_utxos.push((address.clone(), stored_utxos));
         stored_address_transaction_locations.push((address, stored_transaction_locations));
     }
 
diff --git a/zebra-state/src/service/finalized_state/zebra_db/block/tests/vectors.rs b/zebra-state/src/service/finalized_state/zebra_db/block/tests/vectors.rs
index f0ce0d0f414..136121db333 100644
--- a/zebra-state/src/service/finalized_state/zebra_db/block/tests/vectors.rs
+++ b/zebra-state/src/service/finalized_state/zebra_db/block/tests/vectors.rs
@@ -42,14 +42,14 @@ fn test_block_db_round_trip() {
         .iter()
         .map(|(_height, block)| block.zcash_deserialize_into().unwrap());
 
-    test_block_db_round_trip_with(Mainnet, mainnet_test_cases);
-    test_block_db_round_trip_with(Testnet, testnet_test_cases);
+    test_block_db_round_trip_with(&Mainnet, mainnet_test_cases);
+    test_block_db_round_trip_with(&Testnet, testnet_test_cases);
 
     // It doesn't matter if these blocks are mainnet or testnet,
     // because there is no validation at this level of the database.
     //
     // These blocks have the same height and header hash, so they each need a new state.
-    test_block_db_round_trip_with(Mainnet, iter::once(large_multi_transaction_block()));
+    test_block_db_round_trip_with(&Mainnet, iter::once(large_multi_transaction_block()));
 
     // These blocks are unstable under serialization, so we apply a round-trip first.
     //
@@ -61,7 +61,7 @@ fn test_block_db_round_trip() {
     let block: Block = block_data
         .zcash_deserialize_into()
         .expect("deserialization of valid serialized block never fails");
-    test_block_db_round_trip_with(Mainnet, iter::once(block));
+    test_block_db_round_trip_with(&Mainnet, iter::once(block));
 
     let block = large_single_transaction_block_many_outputs();
     let block_data = block
@@ -70,11 +70,11 @@ fn test_block_db_round_trip() {
     let block: Block = block_data
         .zcash_deserialize_into()
         .expect("deserialization of valid serialized block never fails");
-    test_block_db_round_trip_with(Mainnet, iter::once(block));
+    test_block_db_round_trip_with(&Mainnet, iter::once(block));
 }
 
 fn test_block_db_round_trip_with(
-    network: Network,
+    network: &Network,
     block_test_cases: impl IntoIterator<Item = Block>,
 ) {
     let _init_guard = zebra_test::init();
diff --git a/zebra-state/src/service/finalized_state/zebra_db/transparent.rs b/zebra-state/src/service/finalized_state/zebra_db/transparent.rs
index 7c45911824e..149dcf6a26a 100644
--- a/zebra-state/src/service/finalized_state/zebra_db/transparent.rs
+++ b/zebra-state/src/service/finalized_state/zebra_db/transparent.rs
@@ -343,7 +343,7 @@ impl DiskWriteBatch {
     pub fn prepare_transparent_transaction_batch(
         &mut self,
         db: &DiskDb,
-        network: Network,
+        network: &Network,
         finalized: &FinalizedBlock,
         new_outputs_by_out_loc: &BTreeMap<OutputLocation, transparent::Utxo>,
         spent_utxos_by_outpoint: &HashMap<transparent::OutPoint, transparent::Utxo>,
@@ -400,7 +400,7 @@ impl DiskWriteBatch {
     pub fn prepare_new_transparent_outputs_batch(
         &mut self,
         db: &DiskDb,
-        network: Network,
+        network: &Network,
         new_outputs_by_out_loc: &BTreeMap<OutputLocation, transparent::Utxo>,
         address_balances: &mut HashMap<transparent::Address, AddressBalanceLocation>,
     ) -> Result<(), BoxError> {
@@ -477,7 +477,7 @@ impl DiskWriteBatch {
     pub fn prepare_spent_transparent_outputs_batch(
         &mut self,
         db: &DiskDb,
-        network: Network,
+        network: &Network,
         spent_utxos_by_out_loc: &BTreeMap<OutputLocation, transparent::Utxo>,
         address_balances: &mut HashMap<transparent::Address, AddressBalanceLocation>,
     ) -> Result<(), BoxError> {
@@ -532,7 +532,7 @@ impl DiskWriteBatch {
     pub fn prepare_spending_transparent_tx_ids_batch(
         &mut self,
         db: &DiskDb,
-        network: Network,
+        network: &Network,
         spending_tx_location: TransactionLocation,
         transaction: &Transaction,
         spent_utxos_by_outpoint: &HashMap<transparent::OutPoint, transparent::Utxo>,
diff --git a/zebra-state/src/service/non_finalized_state.rs b/zebra-state/src/service/non_finalized_state.rs
index cc9cfbabdb0..7ca7881f30e 100644
--- a/zebra-state/src/service/non_finalized_state.rs
+++ b/zebra-state/src/service/non_finalized_state.rs
@@ -91,7 +91,7 @@ impl Clone for NonFinalizedState {
     fn clone(&self) -> Self {
         Self {
             chain_set: self.chain_set.clone(),
-            network: self.network,
+            network: self.network.clone(),
 
             #[cfg(feature = "getblocktemplate-rpcs")]
             should_count_metrics: self.should_count_metrics,
@@ -108,10 +108,10 @@ impl Clone for NonFinalizedState {
 
 impl NonFinalizedState {
     /// Returns a new non-finalized state for `network`.
-    pub fn new(network: Network) -> NonFinalizedState {
+    pub fn new(network: &Network) -> NonFinalizedState {
         NonFinalizedState {
             chain_set: Default::default(),
-            network,
+            network: network.clone(),
             #[cfg(feature = "getblocktemplate-rpcs")]
             should_count_metrics: true,
             #[cfg(feature = "progress-bar")]
@@ -281,7 +281,7 @@ impl NonFinalizedState {
         let finalized_tip_height = finalized_tip_height.unwrap_or(zebra_chain::block::Height(0));
 
         let chain = Chain::new(
-            self.network,
+            &self.network,
             finalized_tip_height,
             finalized_state.sprout_tree_for_tip(),
             finalized_state.sapling_tree_for_tip(),
@@ -381,7 +381,7 @@ impl NonFinalizedState {
             scope.spawn_fifo(|_scope| {
                 block_commitment_result = Some(check::block_commitment_is_valid_for_chain_history(
                     block,
-                    network,
+                    &network,
                     &history_tree,
                 ));
             });
diff --git a/zebra-state/src/service/non_finalized_state/chain.rs b/zebra-state/src/service/non_finalized_state/chain.rs
index fc31605871b..07d28707427 100644
--- a/zebra-state/src/service/non_finalized_state/chain.rs
+++ b/zebra-state/src/service/non_finalized_state/chain.rs
@@ -211,7 +211,7 @@ pub struct ChainInner {
 impl Chain {
     /// Create a new Chain with the given finalized tip trees and network.
     pub(crate) fn new(
-        network: Network,
+        network: &Network,
         finalized_tip_height: Height,
         sprout_note_commitment_tree: Arc<sprout::tree::NoteCommitmentTree>,
         sapling_note_commitment_tree: Arc<sapling::tree::NoteCommitmentTree>,
@@ -247,7 +247,7 @@ impl Chain {
         };
 
         let mut chain = Self {
-            network,
+            network: network.clone(),
             inner,
             last_fork_height: None,
         };
@@ -373,7 +373,7 @@ impl Chain {
 
     /// Returns the [`Network`] for this chain.
     pub fn network(&self) -> Network {
-        self.network
+        self.network.clone()
     }
 
     /// Returns the [`ContextuallyVerifiedBlock`] with [`block::Hash`] or
@@ -1270,8 +1270,7 @@ impl Chain {
     ) -> impl Iterator<Item = &TransparentTransfers> {
         addresses
             .iter()
-            .copied()
-            .flat_map(|address| self.partial_transparent_transfers.get(&address))
+            .flat_map(|address| self.partial_transparent_transfers.get(address))
     }
 
     /// Returns the transparent balance change for `addresses` in this non-finalized chain.
@@ -1426,10 +1425,10 @@ impl Chain {
         let history_tree_mut = Arc::make_mut(&mut history_tree);
         history_tree_mut
             .push(
-                self.network,
+                &self.network,
                 contextually_valid.block.clone(),
-                sapling_root,
-                orchard_root,
+                &sapling_root,
+                &orchard_root,
             )
             .map_err(Arc::new)?;
 
@@ -1754,7 +1753,7 @@ impl
             );
 
             // Update the address index with this UTXO
-            if let Some(receiving_address) = created_utxo.utxo.output.address(self.network) {
+            if let Some(receiving_address) = created_utxo.utxo.output.address(&self.network) {
                 let address_transfers = self
                     .partial_transparent_transfers
                     .entry(receiving_address)
@@ -1793,7 +1792,7 @@ impl
             );
 
             // Revert the address index for this UTXO
-            if let Some(receiving_address) = created_utxo.utxo.output.address(self.network) {
+            if let Some(receiving_address) = created_utxo.utxo.output.address(&self.network) {
                 let address_transfers = self
                     .partial_transparent_transfers
                     .get_mut(&receiving_address)
@@ -1857,7 +1856,7 @@ impl
             };
 
             // Index the spent output for the address
-            if let Some(spending_address) = spent_output.utxo.output.address(self.network) {
+            if let Some(spending_address) = spent_output.utxo.output.address(&self.network) {
                 let address_transfers = self
                     .partial_transparent_transfers
                     .entry(spending_address)
@@ -1909,7 +1908,7 @@ impl
             };
 
             // Revert the spent output for the address
-            if let Some(receiving_address) = spent_output.utxo.output.address(self.network) {
+            if let Some(receiving_address) = spent_output.utxo.output.address(&self.network) {
                 let address_transfers = self
                     .partial_transparent_transfers
                     .get_mut(&receiving_address)
diff --git a/zebra-state/src/service/non_finalized_state/tests/prop.rs b/zebra-state/src/service/non_finalized_state/tests/prop.rs
index d40b83137f2..fcd9ba544b3 100644
--- a/zebra-state/src/service/non_finalized_state/tests/prop.rs
+++ b/zebra-state/src/service/non_finalized_state/tests/prop.rs
@@ -47,7 +47,7 @@ fn push_genesis_chain() -> Result<()> {
     |((chain, count, network, empty_tree) in PreparedChain::default())| {
         prop_assert!(empty_tree.is_none());
 
-        let mut only_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), empty_tree, ValueBalance::zero());
+        let mut only_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), empty_tree, ValueBalance::zero());
         // contains the block value pool changes and chain value pool balances for each height
         let mut chain_values = BTreeMap::new();
 
@@ -99,7 +99,7 @@ fn push_history_tree_chain() -> Result<()> {
         let count = std::cmp::min(count, chain.len() - 1);
         let chain = &chain[1..];
 
-        let mut only_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, ValueBalance::zero());
+        let mut only_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, ValueBalance::zero());
 
         for block in chain
             .iter()
@@ -142,7 +142,7 @@ fn forked_equals_pushed_genesis() -> Result<()> {
         // This chain will be used to check if the blocks in the forked chain
         // correspond to the blocks in the original chain before the fork.
         let mut partial_chain = Chain::new(
-            network,
+            &network,
             Height(0),
             Default::default(),
             Default::default(),
@@ -162,7 +162,7 @@ fn forked_equals_pushed_genesis() -> Result<()> {
 
         // This chain will be forked.
         let mut full_chain = Chain::new(
-            network,
+            &network,
             Height(0),
             Default::default(),
             Default::default(),
@@ -250,8 +250,8 @@ fn forked_equals_pushed_history_tree() -> Result<()> {
         // use `fork_at_count` as the fork tip
         let fork_tip_hash = chain[fork_at_count - 1].hash;
 
-        let mut full_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree.clone(), ValueBalance::zero());
-        let mut partial_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, ValueBalance::zero());
+        let mut full_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree.clone(), ValueBalance::zero());
+        let mut partial_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, ValueBalance::zero());
 
         for block in chain
             .iter()
@@ -318,7 +318,7 @@ fn finalized_equals_pushed_genesis() -> Result<()> {
 
         let fake_value_pool = ValueBalance::<NonNegative>::fake_populated_pool();
 
-        let mut full_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), empty_tree, fake_value_pool);
+        let mut full_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), empty_tree, fake_value_pool);
         for block in chain
             .clone()
             .take(finalized_count) {
@@ -326,7 +326,7 @@ fn finalized_equals_pushed_genesis() -> Result<()> {
             }
 
         let mut partial_chain = Chain::new(
-            network,
+            &network,
             full_chain.non_finalized_tip_height(),
             full_chain.sprout_note_commitment_tree_for_tip(),
             full_chain.sapling_note_commitment_tree_for_tip(),
@@ -395,7 +395,7 @@ fn finalized_equals_pushed_history_tree() -> Result<()> {
 
         let fake_value_pool = ValueBalance::<NonNegative>::fake_populated_pool();
 
-        let mut full_chain = Chain::new(network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, fake_value_pool);
+        let mut full_chain = Chain::new(&network, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree, fake_value_pool);
         for block in chain
             .iter()
             .take(finalized_count)
@@ -404,7 +404,7 @@ fn finalized_equals_pushed_history_tree() -> Result<()> {
             }
 
         let mut partial_chain = Chain::new(
-            network,
+            &network,
             Height(finalized_count.try_into().unwrap()),
             full_chain.sprout_note_commitment_tree_for_tip(),
             full_chain.sapling_note_commitment_tree_for_tip(),
@@ -477,8 +477,8 @@ fn rejection_restores_internal_state_genesis() -> Result<()> {
           )
       }
       ))| {
-        let mut state = NonFinalizedState::new(network);
-        let finalized_state = FinalizedState::new(&Config::ephemeral(), network, #[cfg(feature = "elasticsearch")] None);
+        let mut state = NonFinalizedState::new(&network);
+        let finalized_state = FinalizedState::new(&Config::ephemeral(), &network, #[cfg(feature = "elasticsearch")] None);
 
         let fake_value_pool = ValueBalance::<NonNegative>::fake_populated_pool();
         finalized_state.set_finalized_value_pool(fake_value_pool);
@@ -568,23 +568,23 @@ fn different_blocks_different_chains() -> Result<()> {
         let height1 = prev_block1.coinbase_height().unwrap();
         let height2 = prev_block1.coinbase_height().unwrap();
 
-        let finalized_tree1: Arc<HistoryTree> = if height1 >= Heartwood.activation_height(Network::Mainnet).unwrap() {
+        let finalized_tree1: Arc<HistoryTree> = if height1 >= Heartwood.activation_height(&Network::Mainnet).unwrap() {
             Arc::new(
-                NonEmptyHistoryTree::from_block(Network::Mainnet, prev_block1, &Default::default(), &Default::default()).unwrap().into()
+                NonEmptyHistoryTree::from_block(&Network::Mainnet, prev_block1, &Default::default(), &Default::default()).unwrap().into()
             )
         } else {
             Default::default()
         };
-        let finalized_tree2: Arc<HistoryTree> = if height2 >= NetworkUpgrade::Heartwood.activation_height(Network::Mainnet).unwrap() {
+        let finalized_tree2: Arc<HistoryTree> = if height2 >= NetworkUpgrade::Heartwood.activation_height(&Network::Mainnet).unwrap() {
             Arc::new(
-                NonEmptyHistoryTree::from_block(Network::Mainnet, prev_block2, &Default::default(), &Default::default()).unwrap().into()
+                NonEmptyHistoryTree::from_block(&Network::Mainnet, prev_block2, &Default::default(), &Default::default()).unwrap().into()
             )
         } else {
             Default::default()
         };
 
-        let chain1 = Chain::new(Network::Mainnet, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree1, ValueBalance::fake_populated_pool());
-        let chain2 = Chain::new(Network::Mainnet, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree2, ValueBalance::fake_populated_pool());
+        let chain1 = Chain::new(&Network::Mainnet, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree1, ValueBalance::fake_populated_pool());
+        let chain2 = Chain::new(&Network::Mainnet, Height(0), Default::default(), Default::default(), Default::default(), finalized_tree2, ValueBalance::fake_populated_pool());
 
         let block1 = vec1[1].clone().prepare().test_with_zero_spent_utxos();
         let block2 = vec2[1].clone().prepare().test_with_zero_spent_utxos();
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 a869a01ea96..00159e4c9ff 100644
--- a/zebra-state/src/service/non_finalized_state/tests/vectors.rs
+++ b/zebra-state/src/service/non_finalized_state/tests/vectors.rs
@@ -26,7 +26,7 @@ use crate::{
 fn construct_empty() {
     let _init_guard = zebra_test::init();
     let _chain = Chain::new(
-        Network::Mainnet,
+        &Network::Mainnet,
         Height(0),
         Default::default(),
         Default::default(),
@@ -43,7 +43,7 @@ fn construct_single() -> Result<()> {
         zebra_test::vectors::BLOCK_MAINNET_434873_BYTES.zcash_deserialize_into()?;
 
     let mut chain = Chain::new(
-        Network::Mainnet,
+        &Network::Mainnet,
         Height(0),
         Default::default(),
         Default::default(),
@@ -77,7 +77,7 @@ fn construct_many() -> Result<()> {
     }
 
     let mut chain = Chain::new(
-        Network::Mainnet,
+        &Network::Mainnet,
         (initial_height - 1).expect("Initial height should be at least 1."),
         Default::default(),
         Default::default(),
@@ -104,7 +104,7 @@ fn ord_matches_work() -> Result<()> {
     let more_block = less_block.clone().set_work(10);
 
     let mut lesser_chain = Chain::new(
-        Network::Mainnet,
+        &Network::Mainnet,
         Height(0),
         Default::default(),
         Default::default(),
@@ -115,7 +115,7 @@ fn ord_matches_work() -> Result<()> {
     lesser_chain = lesser_chain.push(less_block.prepare().test_with_zero_spent_utxos())?;
 
     let mut bigger_chain = Chain::new(
-        Network::Mainnet,
+        &Network::Mainnet,
         Height(0),
         Default::default(),
         Default::default(),
@@ -151,10 +151,10 @@ fn best_chain_wins_for_network(network: Network) -> Result<()> {
 
     let expected_hash = block2.hash();
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -187,10 +187,10 @@ fn finalize_pops_from_best_chain_for_network(network: Network) -> Result<()> {
     let block2 = block1.make_fake_child().set_work(10);
     let child = block1.make_fake_child().set_work(1);
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -237,10 +237,10 @@ fn commit_block_extending_best_chain_doesnt_drop_worst_chains_for_network(
     let child1 = block1.make_fake_child().set_work(1);
     let child2 = block2.make_fake_child().set_work(1);
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -282,10 +282,10 @@ fn shorter_chain_can_be_best_chain_for_network(network: Network) -> Result<()> {
 
     let short_chain_block = block1.make_fake_child().set_work(3);
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -327,10 +327,10 @@ fn longer_chain_with_more_work_wins_for_network(network: Network) -> Result<()>
 
     let short_chain_block = block1.make_fake_child().set_work(3);
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -370,10 +370,10 @@ fn equal_length_goes_to_more_work_for_network(network: Network) -> Result<()> {
     let more_work_child = block1.make_fake_child().set_work(3);
     let expected_hash = more_work_child.hash();
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -407,7 +407,7 @@ fn history_tree_is_updated_for_network_upgrade(
 ) -> Result<()> {
     let blocks = network.block_map();
 
-    let height = network_upgrade.activation_height(network).unwrap().0;
+    let height = network_upgrade.activation_height(&network).unwrap().0;
 
     let prev_block = Arc::new(
         blocks
@@ -417,10 +417,10 @@ fn history_tree_is_updated_for_network_upgrade(
             .expect("block is structurally valid"),
     );
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -467,7 +467,7 @@ fn history_tree_is_updated_for_network_upgrade(
 
     // To fix the commitment in the next block we must recreate the history tree
     let tree = NonEmptyHistoryTree::from_block(
-        Network::Mainnet,
+        &Network::Mainnet,
         activation_block.clone(),
         &chain.sapling_note_commitment_tree_for_tip().root(),
         &chain.orchard_note_commitment_tree_for_tip().root(),
@@ -505,7 +505,7 @@ fn commitment_is_validated() {
 
 fn commitment_is_validated_for_network_upgrade(network: Network, network_upgrade: NetworkUpgrade) {
     let blocks = network.block_map();
-    let height = network_upgrade.activation_height(network).unwrap().0;
+    let height = network_upgrade.activation_height(&network).unwrap().0;
 
     let prev_block = Arc::new(
         blocks
@@ -515,10 +515,10 @@ fn commitment_is_validated_for_network_upgrade(network: Network, network_upgrade
             .expect("block is structurally valid"),
     );
 
-    let mut state = NonFinalizedState::new(network);
+    let mut state = NonFinalizedState::new(&network);
     let finalized_state = FinalizedState::new(
         &Config::ephemeral(),
-        network,
+        &network,
         #[cfg(feature = "elasticsearch")]
         None,
     );
@@ -549,7 +549,7 @@ fn commitment_is_validated_for_network_upgrade(network: Network, network_upgrade
     // To fix the commitment in the next block we must recreate the history tree
     let chain = state.best_chain().unwrap();
     let tree = NonEmptyHistoryTree::from_block(
-        Network::Mainnet,
+        &Network::Mainnet,
         activation_block.clone(),
         &chain.sapling_note_commitment_tree_for_tip().root(),
         &chain.orchard_note_commitment_tree_for_tip().root(),
diff --git a/zebra-state/src/service/read/address/utxo.rs b/zebra-state/src/service/read/address/utxo.rs
index 30bcad2c555..d045bd4d3eb 100644
--- a/zebra-state/src/service/read/address/utxo.rs
+++ b/zebra-state/src/service/read/address/utxo.rs
@@ -48,14 +48,14 @@ pub struct AddressUtxos {
 impl AddressUtxos {
     /// Creates a new set of address UTXOs.
     pub fn new(
-        network: Network,
+        network: &Network,
         utxos: BTreeMap<OutputLocation, transparent::Output>,
         tx_ids: BTreeMap<TransactionLocation, transaction::Hash>,
     ) -> Self {
         Self {
             utxos,
             tx_ids,
-            network,
+            network: network.clone(),
         }
     }
 
@@ -77,7 +77,7 @@ impl AddressUtxos {
         self.utxos.iter().map(|(out_loc, output)| {
             (
                 output
-                    .address(self.network)
+                    .address(&self.network)
                     .expect("address indexes only contain outputs with addresses"),
                 self.tx_ids
                     .get(&out_loc.transaction_location())
@@ -95,7 +95,7 @@ impl AddressUtxos {
 /// If the addresses do not exist in the non-finalized `chain` or finalized `db`,
 /// returns an empty list.
 pub fn address_utxos<C>(
-    network: Network,
+    network: &Network,
     chain: Option<C>,
     db: &ZebraDb,
     addresses: HashSet<transparent::Address>,
diff --git a/zebra-state/src/service/read/difficulty.rs b/zebra-state/src/service/read/difficulty.rs
index cb9734892b6..16d7c67b73f 100644
--- a/zebra-state/src/service/read/difficulty.rs
+++ b/zebra-state/src/service/read/difficulty.rs
@@ -45,7 +45,7 @@ pub const EXTRA_TIME_TO_MINE_A_BLOCK: u32 = POST_BLOSSOM_POW_TARGET_SPACING * 2;
 pub fn get_block_template_chain_info(
     non_finalized_state: &NonFinalizedState,
     db: &ZebraDb,
-    network: Network,
+    network: &Network,
 ) -> Result<GetBlockTemplateChainInfo, BoxError> {
     let mut best_relevant_chain_and_history_tree_result =
         best_relevant_chain_and_history_tree(non_finalized_state, db);
@@ -209,7 +209,7 @@ fn difficulty_time_and_history_tree(
     relevant_chain: [Arc<Block>; POW_ADJUSTMENT_BLOCK_SPAN],
     tip_height: Height,
     tip_hash: block::Hash,
-    network: Network,
+    network: &Network,
     history_tree: Arc<HistoryTree>,
 ) -> GetBlockTemplateChainInfo {
     let relevant_data: Vec<(CompactDifficulty, DateTime<Utc>)> = relevant_chain
@@ -272,11 +272,11 @@ fn difficulty_time_and_history_tree(
 /// The `relevant_data` has recent block difficulties and times in reverse order from the tip.
 fn adjust_difficulty_and_time_for_testnet(
     result: &mut GetBlockTemplateChainInfo,
-    network: Network,
+    network: &Network,
     previous_block_height: Height,
     relevant_data: Vec<(CompactDifficulty, DateTime<Utc>)>,
 ) {
-    if network == Network::Mainnet {
+    if network == &Network::Mainnet {
         return;
     }
 
diff --git a/zebra-state/src/service/read/tests/vectors.rs b/zebra-state/src/service/read/tests/vectors.rs
index f1f39b6ccc4..61fbdc99f6a 100644
--- a/zebra-state/src/service/read/tests/vectors.rs
+++ b/zebra-state/src/service/read/tests/vectors.rs
@@ -37,7 +37,7 @@ async fn empty_read_state_still_responds_to_requests() -> Result<()> {
     let transcript = Transcript::from(empty_state_test_cases());
 
     let network = Mainnet;
-    let (_state, read_state, _latest_chain_tip, _chain_tip_change) = init_test_services(network);
+    let (_state, read_state, _latest_chain_tip, _chain_tip_change) = init_test_services(&network);
 
     transcript.check(read_state).await?;
 
@@ -56,7 +56,7 @@ async fn populated_read_state_responds_correctly() -> Result<()> {
         .collect();
 
     let (_state, read_state, _latest_chain_tip, _chain_tip_change) =
-        populated_state(blocks.clone(), Mainnet).await;
+        populated_state(blocks.clone(), &Mainnet).await;
 
     let tip_height = Height(blocks.len() as u32 - 1);
 
@@ -372,7 +372,7 @@ fn new_ephemeral_db() -> ZebraDb {
         &Config::ephemeral(),
         STATE_DATABASE_KIND,
         &state_database_format_version_in_code(),
-        Mainnet,
+        &Mainnet,
         true,
         STATE_COLUMN_FAMILIES_IN_CODE
             .iter()
diff --git a/zebra-state/src/service/tests.rs b/zebra-state/src/service/tests.rs
index 7acd02406fa..ca8d195af41 100644
--- a/zebra-state/src/service/tests.rs
+++ b/zebra-state/src/service/tests.rs
@@ -194,7 +194,7 @@ async fn test_populated_state_responds_correctly(
 
 #[tokio::main]
 async fn populate_and_check(blocks: Vec<Arc<Block>>) -> Result<()> {
-    let (state, _, _, _) = populated_state(blocks, Network::Mainnet).await;
+    let (state, _, _, _) = populated_state(blocks, &Network::Mainnet).await;
     test_populated_state_responds_correctly(state).await?;
     Ok(())
 }
@@ -253,7 +253,7 @@ async fn empty_state_still_responds_to_requests() -> Result<()> {
     let transcript = Transcript::from(iter);
 
     let network = Network::Mainnet;
-    let state = init_test(network);
+    let state = init_test(&network);
 
     transcript.check(state).await?;
 
@@ -306,7 +306,7 @@ proptest! {
     fn some_block_less_than_network_upgrade(
         (network, nu_activation_height, chain) in partial_nu5_chain_strategy(4, true, UNDER_LEGACY_CHAIN_LIMIT, NetworkUpgrade::Canopy)
     ) {
-        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), network, TEST_LEGACY_CHAIN_LIMIT)
+        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), &network, TEST_LEGACY_CHAIN_LIMIT)
             .map_err(|error| error.to_string());
 
         prop_assert_eq!(response, Ok(()));
@@ -323,7 +323,7 @@ proptest! {
             .coinbase_height()
             .expect("chain contains valid blocks");
 
-        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), network, TEST_LEGACY_CHAIN_LIMIT)
+        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), &network, TEST_LEGACY_CHAIN_LIMIT)
             .map_err(|error| error.to_string());
 
         prop_assert_eq!(
@@ -355,14 +355,14 @@ proptest! {
         prop_assume!(
             first_checked_block
                 .unwrap()
-                .check_transaction_network_upgrade_consistency(network)
+                .check_transaction_network_upgrade_consistency(&network)
                 .is_err()
         );
 
         let response = crate::service::check::legacy_chain(
             nu_activation_height,
             chain.clone().into_iter().rev(),
-            network,
+            &network,
             TEST_LEGACY_CHAIN_LIMIT,
         ).map_err(|error| error.to_string());
 
@@ -380,7 +380,7 @@ proptest! {
     fn at_least_one_transaction_with_valid_network_upgrade(
         (network, nu_activation_height, chain) in partial_nu5_chain_strategy(5, true, UNDER_LEGACY_CHAIN_LIMIT, NetworkUpgrade::Canopy)
     ) {
-        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), network, TEST_LEGACY_CHAIN_LIMIT)
+        let response = crate::service::check::legacy_chain(nu_activation_height, chain.into_iter().rev(), &network, TEST_LEGACY_CHAIN_LIMIT)
             .map_err(|error| error.to_string());
 
         prop_assert_eq!(response, Ok(()));
@@ -401,7 +401,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We're waiting to verify each block here, so we don't need the maximum checkpoint height.
-        let (mut state_service, _, _, _) = StateService::new(Config::ephemeral(), network, Height::MAX, 0);
+        let (mut state_service, _, _, _) = StateService::new(Config::ephemeral(), &network, Height::MAX, 0);
 
         prop_assert_eq!(state_service.read_service.db.finalized_value_pool(), ValueBalance::zero());
         prop_assert_eq!(
@@ -493,7 +493,7 @@ proptest! {
         let _init_guard = zebra_test::init();
 
         // We're waiting to verify each block here, so we don't need the maximum checkpoint height.
-        let (mut state_service, _read_only_state_service, latest_chain_tip, mut chain_tip_change) = StateService::new(Config::ephemeral(), network, Height::MAX, 0);
+        let (mut state_service, _read_only_state_service, latest_chain_tip, mut chain_tip_change) = StateService::new(Config::ephemeral(), &network, Height::MAX, 0);
 
         prop_assert_eq!(latest_chain_tip.best_tip_height(), None);
         prop_assert_eq!(chain_tip_change.last_tip_change(), None);
diff --git a/zebra-state/src/tests/setup.rs b/zebra-state/src/tests/setup.rs
index c5a900c0507..d407726330e 100644
--- a/zebra-state/src/tests/setup.rs
+++ b/zebra-state/src/tests/setup.rs
@@ -54,7 +54,7 @@ pub(crate) fn partial_nu5_chain_strategy(
         .prop_flat_map(move |(network, random_nu)| {
             // TODO: update this to Nu5 after we have a height #1841
             let mut nu = network_upgrade;
-            let nu_activation = nu.activation_height(network).unwrap();
+            let nu_activation = nu.activation_height(&network).unwrap();
             let height = Height(nu_activation.0 + blocks_after_nu_activation);
 
             // The `network_upgrade_override` will not be enough as when it is `None`,
@@ -77,7 +77,10 @@ pub(crate) fn partial_nu5_chain_strategy(
                     false,
                 )
             })
-            .prop_map(move |partial_chain| (network, nu_activation, partial_chain))
+            .prop_map(move |partial_chain| {
+                let network_clone = network.clone();
+                (network_clone, nu_activation, partial_chain)
+            })
         })
 }
 
@@ -94,14 +97,14 @@ pub(crate) fn new_state_with_mainnet_genesis(
 
     let mut finalized_state = FinalizedState::new_with_debug(
         &config,
-        network,
+        &network,
         // The tests that use this setup function also commit invalid blocks to the state.
         true,
         #[cfg(feature = "elasticsearch")]
         None,
         false,
     );
-    let non_finalized_state = NonFinalizedState::new(network);
+    let non_finalized_state = NonFinalizedState::new(&network);
 
     assert_eq!(
         None,
diff --git a/zebra-state/tests/basic.rs b/zebra-state/tests/basic.rs
index a96b176dc1a..49d3346f08b 100644
--- a/zebra-state/tests/basic.rs
+++ b/zebra-state/tests/basic.rs
@@ -81,7 +81,7 @@ async fn check_transcripts(network: Network) -> Result<(), Report> {
 
     for transcript_data in net_data {
         // We're not verifying UTXOs here.
-        let (service, _, _, _) = zebra_state::init(Config::ephemeral(), network, Height::MAX, 0);
+        let (service, _, _, _) = zebra_state::init(Config::ephemeral(), &network, Height::MAX, 0);
         let transcript = Transcript::from(transcript_data.iter().cloned());
         /// SPANDOC: check the on disk service against the transcript
         transcript.check(service).await?;
diff --git a/zebra-utils/src/bin/scanning-results-reader/main.rs b/zebra-utils/src/bin/scanning-results-reader/main.rs
index b12892b7b9f..cd31f55cf9e 100644
--- a/zebra-utils/src/bin/scanning-results-reader/main.rs
+++ b/zebra-utils/src/bin/scanning-results-reader/main.rs
@@ -42,12 +42,13 @@ use zebra_scan::{storage::Storage, Config};
 #[allow(clippy::print_stdout)]
 pub fn main() {
     let network = zcash_primitives::consensus::Network::MainNetwork;
-    let storage = Storage::new(&Config::default(), network.into(), true);
+    let zebra_network: zebra_chain::parameters::Network = network.into();
+    let storage = Storage::new(&Config::default(), &zebra_network, true);
     // If the first memo is empty, it doesn't get printed. But we never print empty memos anyway.
     let mut prev_memo = "".to_owned();
 
     for (key, _) in storage.sapling_keys_last_heights().iter() {
-        let dfvk = sapling_key_to_scan_block_keys(key, network.into())
+        let dfvk = sapling_key_to_scan_block_keys(key, &zebra_network)
             .expect("Scanning key from the storage should be valid")
             .0
             .into_iter()
diff --git a/zebrad/src/application.rs b/zebrad/src/application.rs
index 96264f2f051..1064f562f65 100644
--- a/zebrad/src/application.rs
+++ b/zebrad/src/application.rs
@@ -263,7 +263,7 @@ impl Application for ZebradApp {
 
         // reads state disk version file, doesn't open RocksDB database
         let disk_db_version =
-            match state_database_format_version_on_disk(&config.state, config.network.network) {
+            match state_database_format_version_on_disk(&config.state, &config.network.network) {
                 Ok(Some(version)) => version.to_string(),
                 // This "version" is specially formatted to match a relaxed version regex in CI
                 Ok(None) => "creating.new.database".to_string(),
@@ -441,7 +441,7 @@ impl Application for ZebradApp {
             tracing_config.flamegraph = None;
         }
         components.push(Box::new(Tracing::new(
-            config.network.network,
+            &config.network.network,
             tracing_config,
             command.cmd().uses_intro(),
         )?));
diff --git a/zebrad/src/commands/copy_state.rs b/zebrad/src/commands/copy_state.rs
index ffe9575ddec..179367ef0c6 100644
--- a/zebrad/src/commands/copy_state.rs
+++ b/zebrad/src/commands/copy_state.rs
@@ -97,7 +97,7 @@ impl CopyStateCmd {
 
         info!(?base_config, "state copy base config");
 
-        self.copy(base_config.network.network, source_config, target_config)
+        self.copy(&base_config.network.network, source_config, target_config)
             .await
             .map_err(|e| eyre!(e))
     }
@@ -106,7 +106,7 @@ impl CopyStateCmd {
     /// then copy from the source to the target state.
     async fn copy(
         &self,
-        network: Network,
+        network: &Network,
         source_config: old_zs::Config,
         target_config: new_zs::Config,
     ) -> Result<(), BoxError> {
diff --git a/zebrad/src/commands/start.rs b/zebrad/src/commands/start.rs
index 0e113e974bd..35c4a5b3602 100644
--- a/zebrad/src/commands/start.rs
+++ b/zebrad/src/commands/start.rs
@@ -116,7 +116,7 @@ impl StartCmd {
         info!("initializing node state");
         let (_, max_checkpoint_height) = zebra_consensus::router::init_checkpoint_list(
             config.consensus.clone(),
-            config.network.network,
+            &config.network.network,
         );
 
         info!("opening database, this may take a few minutes");
@@ -124,7 +124,7 @@ impl StartCmd {
         let (state_service, read_only_state_service, latest_chain_tip, chain_tip_change) =
             zebra_state::spawn_init(
                 config.state.clone(),
-                config.network.network,
+                &config.network.network,
                 max_checkpoint_height,
                 config.sync.checkpoint_verify_concurrency_limit
                     * (VERIFICATION_PIPELINE_SCALING_MULTIPLIER + 1),
@@ -168,7 +168,7 @@ impl StartCmd {
         let (block_verifier_router, tx_verifier, consensus_task_handles, max_checkpoint_height) =
             zebra_consensus::router::init(
                 config.consensus.clone(),
-                config.network.network,
+                &config.network.network,
                 state.clone(),
             )
             .await;
@@ -235,7 +235,7 @@ impl StartCmd {
             sync_status.clone(),
             address_book.clone(),
             latest_chain_tip.clone(),
-            config.network.network,
+            config.network.network.clone(),
         );
 
         // Start concurrent tasks which don't add load to other tasks
@@ -261,13 +261,13 @@ impl StartCmd {
         info!("spawning delete old databases task");
         let mut old_databases_task_handle = zebra_state::check_and_delete_old_state_databases(
             &config.state,
-            config.network.network,
+            &config.network.network,
         );
 
         info!("spawning progress logging task");
         let progress_task_handle = tokio::spawn(
             show_block_chain_progress(
-                config.network.network,
+                config.network.network.clone(),
                 latest_chain_tip.clone(),
                 sync_status.clone(),
             )
@@ -277,7 +277,7 @@ impl StartCmd {
         // Spawn never ending end of support task.
         info!("spawning end of support checking task");
         let end_of_support_task_handle = tokio::spawn(
-            sync::end_of_support::start(config.network.network, latest_chain_tip.clone())
+            sync::end_of_support::start(config.network.network.clone(), latest_chain_tip.clone())
                 .in_current_span(),
         );
 
@@ -306,7 +306,7 @@ impl StartCmd {
             info!("spawning shielded scanner with configured viewing keys");
             zebra_scan::spawn_init(
                 config.shielded_scan.clone(),
-                config.network.network,
+                config.network.network.clone(),
                 state,
                 chain_tip_change,
             )
@@ -324,7 +324,7 @@ impl StartCmd {
         let miner_task_handle = if config.mining.is_internal_miner_enabled() {
             info!("spawning Zcash miner");
             let rpc = zebra_rpc::methods::get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
-                config.network.network,
+                &config.network.network,
                 config.mining.clone(),
                 mempool,
                 read_only_state_service,
diff --git a/zebrad/src/commands/tip_height.rs b/zebrad/src/commands/tip_height.rs
index 8ace683d5ac..29a124007dc 100644
--- a/zebrad/src/commands/tip_height.rs
+++ b/zebrad/src/commands/tip_height.rs
@@ -63,7 +63,7 @@ impl TipHeightCmd {
 
         // UTXO verification isn't used here: we're not updating the state.
         let (_state_service, _read_state_service, latest_chain_tip, _chain_tip_change) =
-            zebra_state::init(config, self.network, Height::MAX, 0);
+            zebra_state::init(config, &self.network, Height::MAX, 0);
 
         latest_chain_tip
     }
diff --git a/zebrad/src/components/inbound/tests/fake_peer_set.rs b/zebrad/src/components/inbound/tests/fake_peer_set.rs
index 44f27bd80e2..c0dacf89743 100644
--- a/zebrad/src/components/inbound/tests/fake_peer_set.rs
+++ b/zebrad/src/components/inbound/tests/fake_peer_set.rs
@@ -771,7 +771,7 @@ async fn caches_getaddr_response() {
         let state_config = StateConfig::ephemeral();
         let address_book = AddressBook::new_with_addrs(
             SocketAddr::from_str("0.0.0.0:0").unwrap(),
-            Mainnet,
+            &Mainnet,
             DEFAULT_MAX_CONNS_PER_IP,
             MAX_ADDRS_IN_ADDRESS_BOOK,
             Span::none(),
@@ -782,7 +782,7 @@ async fn caches_getaddr_response() {
 
         // UTXO verification doesn't matter for these tests.
         let (state, _read_only_state_service, latest_chain_tip, _chain_tip_change) =
-            zebra_state::init(state_config.clone(), network, Height::MAX, 0);
+            zebra_state::init(state_config.clone(), &network, Height::MAX, 0);
 
         let state_service = ServiceBuilder::new().buffer(1).service(state);
 
@@ -792,8 +792,12 @@ async fn caches_getaddr_response() {
             _transaction_verifier,
             _groth16_download_handle,
             _max_checkpoint_height,
-        ) = zebra_consensus::router::init(consensus_config.clone(), network, state_service.clone())
-            .await;
+        ) = zebra_consensus::router::init(
+            consensus_config.clone(),
+            &network,
+            state_service.clone(),
+        )
+        .await;
 
         let peer_set = MockService::build()
             .with_max_request_delay(MAX_PEER_SET_REQUEST_DELAY)
@@ -882,7 +886,7 @@ async fn setup(
     let state_config = StateConfig::ephemeral();
     let address_book = AddressBook::new(
         SocketAddr::from_str("0.0.0.0:0").unwrap(),
-        Mainnet,
+        &Mainnet,
         DEFAULT_MAX_CONNS_PER_IP,
         Span::none(),
     );
@@ -891,13 +895,13 @@ async fn setup(
 
     // UTXO verification doesn't matter for these tests.
     let (state, _read_only_state_service, latest_chain_tip, mut chain_tip_change) =
-        zebra_state::init(state_config.clone(), network, Height::MAX, 0);
+        zebra_state::init(state_config.clone(), &network, Height::MAX, 0);
 
     let mut state_service = ServiceBuilder::new().buffer(1).service(state);
 
     // Download task panics and timeouts are propagated to the tests that use Groth16 verifiers.
     let (block_verifier, _transaction_verifier, _groth16_download_handle, _max_checkpoint_height) =
-        zebra_consensus::router::init(consensus_config.clone(), network, state_service.clone())
+        zebra_consensus::router::init(consensus_config.clone(), &network, state_service.clone())
             .await;
 
     let mut peer_set = MockService::build()
@@ -1053,7 +1057,7 @@ fn add_some_stuff_to_mempool(
     network: Network,
 ) -> Vec<VerifiedUnminedTx> {
     // get the genesis block coinbase transaction from the Zcash blockchain.
-    let genesis_transactions: Vec<_> = unmined_transactions_in_blocks(..=0, network)
+    let genesis_transactions: Vec<_> = unmined_transactions_in_blocks(..=0, &network)
         .take(1)
         .collect();
 
diff --git a/zebrad/src/components/inbound/tests/real_peer_set.rs b/zebrad/src/components/inbound/tests/real_peer_set.rs
index 0913d60274d..e4c0f08659e 100644
--- a/zebrad/src/components/inbound/tests/real_peer_set.rs
+++ b/zebrad/src/components/inbound/tests/real_peer_set.rs
@@ -641,12 +641,12 @@ async fn setup(
     // UTXO verification doesn't matter for these tests.
     let state_config = StateConfig::ephemeral();
     let (state_service, _read_only_state_service, latest_chain_tip, chain_tip_change) =
-        zebra_state::init(state_config, network, Height::MAX, 0);
+        zebra_state::init(state_config, &network, Height::MAX, 0);
     let state_service = ServiceBuilder::new().buffer(10).service(state_service);
 
     // Network
     let network_config = NetworkConfig {
-        network,
+        network: network.clone(),
         listen_addr: config_listen_addr,
 
         // Stop Zebra making outbound connections
@@ -746,7 +746,7 @@ async fn setup(
 
     // Open a fake peer connection to the inbound listener, using the isolated connection API
     let connected_peer_service = connect_isolated_tcp_direct_with_inbound(
-        network,
+        &network,
         listen_addr,
         user_agent,
         response_inbound_service,
diff --git a/zebrad/src/components/mempool/crawler.rs b/zebrad/src/components/mempool/crawler.rs
index 6d1129e2b30..ce958e9b465 100644
--- a/zebrad/src/components/mempool/crawler.rs
+++ b/zebrad/src/components/mempool/crawler.rs
@@ -30,7 +30,7 @@
 //! # let peer_set_service = MockService::build().for_unit_tests();
 //! # let mempool_service = MockService::build().for_unit_tests();
 //! # let (sync_status, _) = SyncStatus::new();
-//! # let (_, _, chain_tip_change) = ChainTipSender::new(None, Network::Mainnet);
+//! # let (_, _, chain_tip_change) = ChainTipSender::new(None, &Network::Mainnet);
 //!
 //! let crawler_task = mempool::Crawler::spawn(
 //!     &mempool::Config::default(),
diff --git a/zebrad/src/components/mempool/crawler/tests/prop.rs b/zebrad/src/components/mempool/crawler/tests/prop.rs
index f14ce04d18c..fa1e3ef5785 100644
--- a/zebrad/src/components/mempool/crawler/tests/prop.rs
+++ b/zebrad/src/components/mempool/crawler/tests/prop.rs
@@ -237,7 +237,7 @@ fn setup_crawler() -> (
 
     // the network should be irrelevant here
     let (chain_tip_sender, _latest_chain_tip, chain_tip_change) =
-        ChainTipSender::new(None, Network::Mainnet);
+        ChainTipSender::new(None, &Network::Mainnet);
 
     Crawler::spawn(
         &Config::default(),
diff --git a/zebrad/src/components/mempool/storage/tests.rs b/zebrad/src/components/mempool/storage/tests.rs
index 3a6c84b856d..e47808a3860 100644
--- a/zebrad/src/components/mempool/storage/tests.rs
+++ b/zebrad/src/components/mempool/storage/tests.rs
@@ -15,7 +15,7 @@ mod vectors;
 
 pub fn unmined_transactions_in_blocks(
     block_height_range: impl RangeBounds<u32>,
-    network: Network,
+    network: &Network,
 ) -> impl DoubleEndedIterator<Item = VerifiedUnminedTx> {
     let blocks = network.block_iter();
 
diff --git a/zebrad/src/components/mempool/storage/tests/vectors.rs b/zebrad/src/components/mempool/storage/tests/vectors.rs
index 89d626cef0a..48bb3cb8e2d 100644
--- a/zebrad/src/components/mempool/storage/tests/vectors.rs
+++ b/zebrad/src/components/mempool/storage/tests/vectors.rs
@@ -36,7 +36,7 @@ fn mempool_storage_crud_exact_mainnet() {
     });
 
     // Get one (1) unmined transaction
-    let unmined_tx = unmined_transactions_in_blocks(.., network)
+    let unmined_tx = unmined_transactions_in_blocks(.., &network)
         .next()
         .expect("at least one unmined transaction");
 
@@ -69,7 +69,7 @@ fn mempool_storage_basic() -> Result<()> {
 
 fn mempool_storage_basic_for_network(network: Network) -> Result<()> {
     // Get transactions from the first 10 blocks of the Zcash blockchain
-    let unmined_transactions: Vec<_> = unmined_transactions_in_blocks(..=10, network).collect();
+    let unmined_transactions: Vec<_> = unmined_transactions_in_blocks(..=10, &network).collect();
 
     assert!(
         MEMPOOL_TX_COUNT < unmined_transactions.len(),
@@ -162,7 +162,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
     });
 
     // Get one (1) unmined transaction
-    let unmined_tx_1 = unmined_transactions_in_blocks(.., network)
+    let unmined_tx_1 = unmined_transactions_in_blocks(.., &network)
         .next()
         .expect("at least one unmined transaction");
 
@@ -193,7 +193,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
     );
 
     // Get a different unmined transaction
-    let unmined_tx_2 = unmined_transactions_in_blocks(1.., network)
+    let unmined_tx_2 = unmined_transactions_in_blocks(1.., &network)
         .find(|tx| {
             tx.transaction
                 .transaction
diff --git a/zebrad/src/components/mempool/tests/prop.rs b/zebrad/src/components/mempool/tests/prop.rs
index 0b0a35cd19e..9f05b79d567 100644
--- a/zebrad/src/components/mempool/tests/prop.rs
+++ b/zebrad/src/components/mempool/tests/prop.rs
@@ -65,7 +65,7 @@ proptest! {
                 _tx_verifier,
                 mut recent_syncs,
                 mut chain_tip_sender,
-            ) = setup(network);
+            ) = setup(&network);
 
             time::pause();
 
@@ -115,7 +115,7 @@ proptest! {
                 _tx_verifier,
                 mut recent_syncs,
                 mut chain_tip_sender,
-            ) = setup(network);
+            ) = setup(&network);
 
             time::pause();
 
@@ -129,7 +129,7 @@ proptest! {
 
             for (fake_chain_tip, transaction) in fake_chain_tips.iter().zip(transactions.iter_mut()) {
                 // Obtain a new chain tip based on the previous one.
-                let chain_tip = fake_chain_tip.to_chain_tip_block(&previous_chain_tip, network);
+                let chain_tip = fake_chain_tip.to_chain_tip_block(&previous_chain_tip, &network);
 
                 // Adjust the transaction expiry height based on the new chain
                 // tip height so that the mempool does not evict the transaction
@@ -196,7 +196,7 @@ proptest! {
                 mut tx_verifier,
                 mut recent_syncs,
                 mut chain_tip_sender,
-            ) = setup(network);
+            ) = setup(&network);
 
             time::pause();
 
@@ -254,7 +254,7 @@ fn block1_chain_tip() -> Option<ChainTipBlock> {
 
 /// Create a new [`Mempool`] instance using mocked services.
 fn setup(
-    network: Network,
+    network: &Network,
 ) -> (
     Mempool,
     MockPeerSet,
@@ -319,7 +319,7 @@ impl FakeChainTip {
     /// Returns a new [`ChainTipBlock`] placed on top of the previous block if
     /// the chain is supposed to grow. Otherwise returns a [`ChainTipBlock`]
     /// that does not reference the previous one.
-    fn to_chain_tip_block(&self, previous: &ChainTipBlock, network: Network) -> ChainTipBlock {
+    fn to_chain_tip_block(&self, previous: &ChainTipBlock, network: &Network) -> ChainTipBlock {
         match self {
             Self::Grow(chain_tip_block) => {
                 let height = block::Height(previous.height.0 + 1);
diff --git a/zebrad/src/components/mempool/tests/vector.rs b/zebrad/src/components/mempool/tests/vector.rs
index 60e70674309..db1915a5305 100644
--- a/zebrad/src/components/mempool/tests/vector.rs
+++ b/zebrad/src/components/mempool/tests/vector.rs
@@ -44,7 +44,7 @@ async fn mempool_service_basic_single() -> Result<(), Report> {
     let network = Network::Mainnet;
 
     // get the genesis block transactions from the Zcash blockchain.
-    let mut unmined_transactions = unmined_transactions_in_blocks(1..=10, network);
+    let mut unmined_transactions = unmined_transactions_in_blocks(1..=10, &network);
     let genesis_transaction = unmined_transactions
         .next()
         .expect("Missing genesis transaction");
@@ -56,7 +56,7 @@ async fn mempool_service_basic_single() -> Result<(), Report> {
     let cost_limit = more_transactions.iter().map(|tx| tx.cost()).sum();
 
     let (mut service, _peer_set, _state_service, _chain_tip_change, _tx_verifier, mut recent_syncs) =
-        setup(network, cost_limit, true).await;
+        setup(&network, cost_limit, true).await;
 
     // Enable the mempool
     service.enable(&mut recent_syncs).await;
@@ -187,7 +187,7 @@ async fn mempool_queue_single() -> Result<(), Report> {
     let network = Network::Mainnet;
 
     // Get transactions to use in the test
-    let unmined_transactions = unmined_transactions_in_blocks(1..=10, network);
+    let unmined_transactions = unmined_transactions_in_blocks(1..=10, &network);
     let mut transactions = unmined_transactions.collect::<Vec<_>>();
     // Split unmined_transactions into:
     // [transactions..., new_tx]
@@ -203,7 +203,7 @@ async fn mempool_queue_single() -> Result<(), Report> {
         .sum();
 
     let (mut service, _peer_set, _state_service, _chain_tip_change, _tx_verifier, mut recent_syncs) =
-        setup(network, cost_limit, true).await;
+        setup(&network, cost_limit, true).await;
 
     // Enable the mempool
     service.enable(&mut recent_syncs).await;
@@ -277,10 +277,10 @@ async fn mempool_service_disabled() -> Result<(), Report> {
     let network = Network::Mainnet;
 
     let (mut service, _peer_set, _state_service, _chain_tip_change, _tx_verifier, mut recent_syncs) =
-        setup(network, u64::MAX, true).await;
+        setup(&network, u64::MAX, true).await;
 
     // get the genesis block transactions from the Zcash blockchain.
-    let mut unmined_transactions = unmined_transactions_in_blocks(1..=10, network);
+    let mut unmined_transactions = unmined_transactions_in_blocks(1..=10, &network);
     let genesis_transaction = unmined_transactions
         .next()
         .expect("Missing genesis transaction");
@@ -398,7 +398,7 @@ async fn mempool_cancel_mined() -> Result<(), Report> {
         mut chain_tip_change,
         _tx_verifier,
         mut recent_syncs,
-    ) = setup(network, u64::MAX, true).await;
+    ) = setup(&network, u64::MAX, true).await;
 
     // Enable the mempool
     mempool.enable(&mut recent_syncs).await;
@@ -513,7 +513,7 @@ async fn mempool_cancel_downloads_after_network_upgrade() -> Result<(), Report>
         mut chain_tip_change,
         _tx_verifier,
         mut recent_syncs,
-    ) = setup(network, u64::MAX, true).await;
+    ) = setup(&network, u64::MAX, true).await;
 
     // Enable the mempool
     mempool.enable(&mut recent_syncs).await;
@@ -600,10 +600,10 @@ async fn mempool_failed_verification_is_rejected() -> Result<(), Report> {
         _chain_tip_change,
         mut tx_verifier,
         mut recent_syncs,
-    ) = setup(network, u64::MAX, true).await;
+    ) = setup(&network, u64::MAX, true).await;
 
     // Get transactions to use in the test
-    let mut unmined_transactions = unmined_transactions_in_blocks(1..=2, network);
+    let mut unmined_transactions = unmined_transactions_in_blocks(1..=2, &network);
     let rejected_tx = unmined_transactions.next().unwrap().clone();
 
     // Enable the mempool
@@ -675,10 +675,10 @@ async fn mempool_failed_download_is_not_rejected() -> Result<(), Report> {
         _chain_tip_change,
         _tx_verifier,
         mut recent_syncs,
-    ) = setup(network, u64::MAX, true).await;
+    ) = setup(&network, u64::MAX, true).await;
 
     // Get transactions to use in the test
-    let mut unmined_transactions = unmined_transactions_in_blocks(1..=2, network);
+    let mut unmined_transactions = unmined_transactions_in_blocks(1..=2, &network);
     let rejected_valid_tx = unmined_transactions.next().unwrap().clone();
 
     // Enable the mempool
@@ -760,7 +760,7 @@ async fn mempool_reverifies_after_tip_change() -> Result<(), Report> {
         mut chain_tip_change,
         mut tx_verifier,
         mut recent_syncs,
-    ) = setup(network, u64::MAX, true).await;
+    ) = setup(&network, u64::MAX, true).await;
 
     // Enable the mempool
     mempool.enable(&mut recent_syncs).await;
@@ -909,7 +909,7 @@ async fn mempool_reverifies_after_tip_change() -> Result<(), Report> {
 
 /// Create a new [`Mempool`] instance using mocked services.
 async fn setup(
-    network: Network,
+    network: &Network,
     tx_cost_limit: u64,
     should_commit_genesis_block: bool,
 ) -> (
diff --git a/zebrad/src/components/sync/end_of_support.rs b/zebrad/src/components/sync/end_of_support.rs
index 6572cfe459a..f534f04753b 100644
--- a/zebrad/src/components/sync/end_of_support.rs
+++ b/zebrad/src/components/sync/end_of_support.rs
@@ -51,7 +51,7 @@ pub async fn start(
     loop {
         if network == Network::Mainnet {
             if let Some(tip_height) = latest_chain_tip.best_tip_height() {
-                check(tip_height, network);
+                check(tip_height, &network);
             }
         } else {
             info!("Release always valid in Testnet");
@@ -61,7 +61,7 @@ pub async fn start(
 }
 
 /// Check if the current release is too old and panic if so.
-pub fn check(tip_height: Height, network: Network) {
+pub fn check(tip_height: Height, network: &Network) {
     info!("Checking if Zebra release is inside support range ...");
 
     // Get the current block spacing
diff --git a/zebrad/src/components/sync/progress.rs b/zebrad/src/components/sync/progress.rs
index 9fbf6517c4a..e361d35529d 100644
--- a/zebrad/src/components/sync/progress.rs
+++ b/zebrad/src/components/sync/progress.rs
@@ -88,9 +88,9 @@ pub async fn show_block_chain_progress(
         .add(min_after_checkpoint_blocks)
         .expect("hard-coded checkpoint height is far below Height::MAX");
 
-    let target_block_spacing = NetworkUpgrade::target_spacing_for_height(network, Height::MAX);
+    let target_block_spacing = NetworkUpgrade::target_spacing_for_height(&network, Height::MAX);
     let max_block_spacing =
-        NetworkUpgrade::minimum_difficulty_spacing_for_height(network, Height::MAX);
+        NetworkUpgrade::minimum_difficulty_spacing_for_height(&network, Height::MAX);
 
     // We expect the state height to increase at least once in this interval.
     //
@@ -135,14 +135,14 @@ pub async fn show_block_chain_progress(
         let is_syncer_stopped = sync_status.is_close_to_tip();
 
         if let Some(estimated_height) =
-            latest_chain_tip.estimate_network_chain_tip_height(network, now)
+            latest_chain_tip.estimate_network_chain_tip_height(&network, now)
         {
             // The estimate/actual race doesn't matter here,
             // because we're only using it for metrics and logging.
             let current_height = latest_chain_tip
                 .best_tip_height()
                 .expect("unexpected empty state: estimate requires a block height");
-            let network_upgrade = NetworkUpgrade::current(network, current_height);
+            let network_upgrade = NetworkUpgrade::current(&network, current_height);
 
             // Send progress reports for block height
             //
diff --git a/zebrad/src/components/sync/tests/timing.rs b/zebrad/src/components/sync/tests/timing.rs
index 61d5bac60ea..be3d79e698f 100644
--- a/zebrad/src/components/sync/tests/timing.rs
+++ b/zebrad/src/components/sync/tests/timing.rs
@@ -149,7 +149,7 @@ fn request_genesis_is_rate_limited() {
     });
 
     // create an empty latest chain tip
-    let (_sender, latest_chain_tip, _change) = ChainTipSender::new(None, Network::Mainnet);
+    let (_sender, latest_chain_tip, _change) = ChainTipSender::new(None, &Network::Mainnet);
 
     // create a verifier service that will always panic as it will never be called
     let verifier_service =
diff --git a/zebrad/src/components/tracing/component.rs b/zebrad/src/components/tracing/component.rs
index 1129cc64b23..b1f9f8c8c82 100644
--- a/zebrad/src/components/tracing/component.rs
+++ b/zebrad/src/components/tracing/component.rs
@@ -80,7 +80,11 @@ impl Tracing {
     //
     // This method should only print to stderr, because stdout is for tracing logs.
     #[allow(clippy::print_stdout, clippy::print_stderr, clippy::unwrap_in_result)]
-    pub fn new(network: Network, config: Config, uses_intro: bool) -> Result<Self, FrameworkError> {
+    pub fn new(
+        network: &Network,
+        config: Config,
+        uses_intro: bool,
+    ) -> Result<Self, FrameworkError> {
         // Only use color if tracing output is being sent to a terminal or if it was explicitly
         // forced to.
         let use_color = config.use_color_stdout();
diff --git a/zebrad/tests/acceptance.rs b/zebrad/tests/acceptance.rs
index c27bd0098de..6ae68ce435f 100644
--- a/zebrad/tests/acceptance.rs
+++ b/zebrad/tests/acceptance.rs
@@ -220,7 +220,7 @@ fn generate_no_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
     let child = testdir()?
-        .with_config(&mut default_test_config(Mainnet)?)?
+        .with_config(&mut default_test_config(&Mainnet)?)?
         .spawn_child(args!["generate"])?;
 
     let output = child.wait_with_output()?;
@@ -282,7 +282,7 @@ fn generate_args() -> Result<()> {
 fn help_no_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
-    let testdir = testdir()?.with_config(&mut default_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut default_test_config(&Mainnet)?)?;
 
     let child = testdir.spawn_child(args!["help"])?;
     let output = child.wait_with_output()?;
@@ -327,7 +327,7 @@ fn start_no_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
     // start caches state, so run one of the start tests with persistent state
-    let testdir = testdir()?.with_config(&mut persistent_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut persistent_test_config(&Mainnet)?)?;
 
     let mut child = testdir.spawn_child(args!["-v", "start"])?;
 
@@ -354,7 +354,7 @@ fn start_no_args() -> Result<()> {
 fn start_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
-    let testdir = testdir()?.with_config(&mut default_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut default_test_config(&Mainnet)?)?;
     let testdir = &testdir;
 
     let mut child = testdir.spawn_child(args!["start"])?;
@@ -379,13 +379,17 @@ fn start_args() -> Result<()> {
 #[tokio::test]
 async fn db_init_outside_future_executor() -> Result<()> {
     let _init_guard = zebra_test::init();
-    let config = default_test_config(Mainnet)?;
+    let config = default_test_config(&Mainnet)?;
 
     let start = Instant::now();
 
     // This test doesn't need UTXOs to be verified efficiently, because it uses an empty state.
-    let db_init_handle =
-        zebra_state::spawn_init(config.state.clone(), config.network.network, Height::MAX, 0);
+    let db_init_handle = zebra_state::spawn_init(
+        config.state.clone(),
+        &config.network.network,
+        Height::MAX,
+        0,
+    );
 
     // it's faster to panic if it takes longer than expected, since the executor
     // will wait indefinitely for blocking operation to finish once started
@@ -405,7 +409,7 @@ async fn db_init_outside_future_executor() -> Result<()> {
 fn persistent_mode() -> Result<()> {
     let _init_guard = zebra_test::init();
 
-    let testdir = testdir()?.with_config(&mut persistent_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut persistent_test_config(&Mainnet)?)?;
     let testdir = &testdir;
 
     let mut child = testdir.spawn_child(args!["-v", "start"])?;
@@ -470,7 +474,7 @@ fn ephemeral(cache_dir_config: EphemeralConfig, cache_dir_check: EphemeralCheck)
 
     let _init_guard = zebra_test::init();
 
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     let run_dir = testdir()?;
 
     let ignored_cache_dir = run_dir.path().join("state");
@@ -560,7 +564,7 @@ fn ephemeral(cache_dir_config: EphemeralConfig, cache_dir_check: EphemeralCheck)
 fn version_no_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
-    let testdir = testdir()?.with_config(&mut default_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut default_test_config(&Mainnet)?)?;
 
     let child = testdir.spawn_child(args!["--version"])?;
     let output = child.wait_with_output()?;
@@ -581,7 +585,7 @@ fn version_no_args() -> Result<()> {
 fn version_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
-    let testdir = testdir()?.with_config(&mut default_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut default_test_config(&Mainnet)?)?;
     let testdir = &testdir;
 
     // unrecognized option `-f`
@@ -635,7 +639,7 @@ fn app_no_args() -> Result<()> {
     let _init_guard = zebra_test::init();
 
     // start caches state, so run one of the start tests with persistent state
-    let testdir = testdir()?.with_config(&mut persistent_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut persistent_test_config(&Mainnet)?)?;
 
     tracing::info!(?testdir, "running zebrad with no config (default settings)");
 
@@ -1026,7 +1030,7 @@ fn stored_configs_work() -> Result<()> {
 fn sync_one_checkpoint_mainnet() -> Result<()> {
     sync_until(
         TINY_CHECKPOINT_TEST_HEIGHT,
-        Mainnet,
+        &Mainnet,
         STOP_AT_HEIGHT_REGEX,
         TINY_CHECKPOINT_TIMEOUT,
         None,
@@ -1047,7 +1051,7 @@ fn sync_one_checkpoint_mainnet() -> Result<()> {
 fn sync_one_checkpoint_testnet() -> Result<()> {
     sync_until(
         TINY_CHECKPOINT_TEST_HEIGHT,
-        Testnet,
+        &Testnet,
         STOP_AT_HEIGHT_REGEX,
         TINY_CHECKPOINT_TIMEOUT,
         None,
@@ -1074,7 +1078,7 @@ fn restart_stop_at_height() -> Result<()> {
 fn restart_stop_at_height_for_network(network: Network, height: block::Height) -> Result<()> {
     let reuse_tempdir = sync_until(
         height,
-        network,
+        &network,
         STOP_AT_HEIGHT_REGEX,
         TINY_CHECKPOINT_TIMEOUT,
         None,
@@ -1088,7 +1092,7 @@ fn restart_stop_at_height_for_network(network: Network, height: block::Height) -
     // sync, rather than stopping immediately at the configured height
     sync_until(
         height,
-        network,
+        &network,
         "state is already at the configured height",
         STOP_ON_LOAD_TIMEOUT,
         reuse_tempdir,
@@ -1107,7 +1111,7 @@ fn restart_stop_at_height_for_network(network: Network, height: block::Height) -
 fn activate_mempool_mainnet() -> Result<()> {
     sync_until(
         block::Height(TINY_CHECKPOINT_TEST_HEIGHT.0 + 1),
-        Mainnet,
+        &Mainnet,
         STOP_AT_HEIGHT_REGEX,
         TINY_CHECKPOINT_TIMEOUT,
         None,
@@ -1129,7 +1133,7 @@ fn activate_mempool_mainnet() -> Result<()> {
 fn sync_large_checkpoints_mainnet() -> Result<()> {
     let reuse_tempdir = sync_until(
         LARGE_CHECKPOINT_TEST_HEIGHT,
-        Mainnet,
+        &Mainnet,
         STOP_AT_HEIGHT_REGEX,
         LARGE_CHECKPOINT_TIMEOUT,
         None,
@@ -1141,7 +1145,7 @@ fn sync_large_checkpoints_mainnet() -> Result<()> {
     // if this sync fails, see the failure notes in `restart_stop_at_height`
     sync_until(
         (LARGE_CHECKPOINT_TEST_HEIGHT - 1).unwrap(),
-        Mainnet,
+        &Mainnet,
         "previous state height is greater than the stop height",
         STOP_ON_LOAD_TIMEOUT,
         reuse_tempdir,
@@ -1165,7 +1169,7 @@ fn sync_large_checkpoints_mainnet() -> Result<()> {
 fn sync_large_checkpoints_mempool_mainnet() -> Result<()> {
     sync_until(
         MEDIUM_CHECKPOINT_TEST_HEIGHT,
-        Mainnet,
+        &Mainnet,
         STOP_AT_HEIGHT_REGEX,
         LARGE_CHECKPOINT_TIMEOUT,
         None,
@@ -1184,7 +1188,7 @@ fn create_cached_database(network: Network) -> Result<()> {
         format!("{STOP_AT_HEIGHT_REGEX}.*commit checkpoint-verified request");
 
     create_cached_database_height(
-        network,
+        &network,
         height,
         // Use checkpoints to increase sync performance while caching the database
         true,
@@ -1200,7 +1204,7 @@ fn sync_past_mandatory_checkpoint(network: Network) -> Result<()> {
         format!("{STOP_AT_HEIGHT_REGEX}.*commit contextually-verified request");
 
     create_cached_database_height(
-        network,
+        &network,
         height.unwrap(),
         // Test full validation by turning checkpoints off
         false,
@@ -1228,7 +1232,7 @@ fn full_sync_test(network: Network, timeout_argument_name: &str) -> Result<()> {
     // - the path from ZEBRA_CACHED_STATE_DIR
     if let Some(_timeout_minutes) = timeout_argument {
         create_cached_database_height(
-            network,
+            &network,
             // Just keep going until we reach the chain tip
             block::Height::MAX,
             // Use the checkpoints to sync quickly, then do full validation until the chain tip
@@ -1334,7 +1338,7 @@ async fn metrics_endpoint() -> Result<()> {
     let url = format!("http://{endpoint}");
 
     // Write a configuration that has metrics endpoint_addr set
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.metrics.endpoint_addr = Some(endpoint.parse().unwrap());
 
     let dir = testdir()?.with_config(&mut config)?;
@@ -1391,7 +1395,7 @@ async fn tracing_endpoint() -> Result<()> {
     let url_filter = format!("{url_default}/filter");
 
     // Write a configuration that has tracing endpoint_addr option set
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.tracing.endpoint_addr = Some(endpoint.parse().unwrap());
 
     let dir = testdir()?.with_config(&mut config)?;
@@ -1498,7 +1502,7 @@ async fn rpc_endpoint(parallel_cpu_threads: bool) -> Result<()> {
 
     // Write a configuration that has RPC listen_addr set
     // [Note on port conflict](#Note on port conflict)
-    let mut config = random_known_rpc_port_config(parallel_cpu_threads, Mainnet)?;
+    let mut config = random_known_rpc_port_config(parallel_cpu_threads, &Mainnet)?;
 
     let dir = testdir()?.with_config(&mut config)?;
     let mut child = dir.spawn_child(args!["start"])?;
@@ -1557,7 +1561,7 @@ async fn rpc_endpoint_client_content_type() -> Result<()> {
 
     // Write a configuration that has RPC listen_addr set
     // [Note on port conflict](#Note on port conflict)
-    let mut config = random_known_rpc_port_config(true, Mainnet)?;
+    let mut config = random_known_rpc_port_config(true, &Mainnet)?;
 
     let dir = testdir()?.with_config(&mut config)?;
     let mut child = dir.spawn_child(args!["start"])?;
@@ -1643,7 +1647,7 @@ fn non_blocking_logger() -> Result<()> {
 
         // Write a configuration that has RPC listen_addr set
         // [Note on port conflict](#Note on port conflict)
-        let mut config = random_known_rpc_port_config(false, Mainnet)?;
+        let mut config = random_known_rpc_port_config(false, &Mainnet)?;
         config.tracing.filter = Some("trace".to_string());
         config.tracing.buffer_limit = 100;
         let zebra_rpc_address = config.rpc.listen_addr.unwrap();
@@ -1835,9 +1839,12 @@ fn lightwalletd_integration_test(test_type: TestType) -> Result<()> {
     }
 
     // Launch zebra with peers and using a predefined zebrad state path.
-    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, use_internet_connection)?
-    {
+    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) = spawn_zebrad_for_rpc(
+        network.clone(),
+        test_name,
+        test_type,
+        use_internet_connection,
+    )? {
         tracing::info!(
             ?test_type,
             "running lightwalletd & zebrad integration test, launching zebrad...",
@@ -2079,7 +2086,7 @@ fn zebra_zcash_listener_conflict() -> Result<()> {
     let listen_addr = format!("127.0.0.1:{port}");
 
     // Write a configuration that has our created network listen_addr
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.network.listen_addr = listen_addr.parse().unwrap();
     let dir1 = testdir()?.with_config(&mut config)?;
     let regex1 = regex::escape(&format!("Opened Zcash protocol endpoint at {listen_addr}"));
@@ -2108,7 +2115,7 @@ fn zebra_metrics_conflict() -> Result<()> {
     let listen_addr = format!("127.0.0.1:{port}");
 
     // Write a configuration that has our created metrics endpoint_addr
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.metrics.endpoint_addr = Some(listen_addr.parse().unwrap());
     let dir1 = testdir()?.with_config(&mut config)?;
     let regex1 = regex::escape(&format!(r"Opened metrics endpoint at {listen_addr}"));
@@ -2137,7 +2144,7 @@ fn zebra_tracing_conflict() -> Result<()> {
     let listen_addr = format!("127.0.0.1:{port}");
 
     // Write a configuration that has our created tracing endpoint_addr
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.tracing.endpoint_addr = Some(listen_addr.parse().unwrap());
     let dir1 = testdir()?.with_config(&mut config)?;
     let regex1 = regex::escape(&format!(r"Opened tracing endpoint at {listen_addr}"));
@@ -2171,7 +2178,7 @@ fn zebra_rpc_conflict() -> Result<()> {
     // [Note on port conflict](#Note on port conflict)
     //
     // This is the required setting to detect port conflicts.
-    let mut config = random_known_rpc_port_config(false, Mainnet)?;
+    let mut config = random_known_rpc_port_config(false, &Mainnet)?;
 
     let dir1 = testdir()?.with_config(&mut config)?;
     let regex1 = regex::escape(&format!(
@@ -2198,7 +2205,7 @@ fn zebra_state_conflict() -> Result<()> {
 
     // A persistent config has a fixed temp state directory, but asks the OS to
     // automatically choose an unused port
-    let mut config = persistent_test_config(Mainnet)?;
+    let mut config = persistent_test_config(&Mainnet)?;
     let dir_conflict = testdir()?.with_config(&mut config)?;
 
     // Windows problems with this match will be worked on at #1654
@@ -2363,7 +2370,7 @@ fn delete_old_databases() -> Result<()> {
         return Ok(());
     }
 
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     let run_dir = testdir()?;
     let cache_dir = run_dir.path().join("state");
 
@@ -2479,7 +2486,7 @@ async fn submit_block() -> Result<()> {
 #[test]
 fn end_of_support_is_checked_at_start() -> Result<()> {
     let _init_guard = zebra_test::init();
-    let testdir = testdir()?.with_config(&mut default_test_config(Mainnet)?)?;
+    let testdir = testdir()?.with_config(&mut default_test_config(&Mainnet)?)?;
     let mut child = testdir.spawn_child(args!["start"])?;
 
     // Give enough time to start up the eos task.
@@ -2530,7 +2537,7 @@ async fn generate_checkpoints_testnet() -> Result<()> {
 #[tokio::test]
 async fn new_state_format() -> Result<()> {
     for network in [Mainnet, Testnet] {
-        state_format_test("new_state_format_test", network, 2, None).await?;
+        state_format_test("new_state_format_test", &network, 2, None).await?;
     }
 
     Ok(())
@@ -2548,7 +2555,7 @@ async fn update_state_format() -> Result<()> {
     fake_version.patch = 0;
 
     for network in [Mainnet, Testnet] {
-        state_format_test("update_state_format_test", network, 3, Some(&fake_version)).await?;
+        state_format_test("update_state_format_test", &network, 3, Some(&fake_version)).await?;
     }
 
     Ok(())
@@ -2567,7 +2574,7 @@ async fn downgrade_state_format() -> Result<()> {
     for network in [Mainnet, Testnet] {
         state_format_test(
             "downgrade_state_format_test",
-            network,
+            &network,
             3,
             Some(&fake_version),
         )
@@ -2580,7 +2587,7 @@ async fn downgrade_state_format() -> Result<()> {
 /// Test state format changes, see calling tests for details.
 async fn state_format_test(
     base_test_name: &str,
-    network: Network,
+    network: &Network,
     reopen_count: usize,
     fake_version: Option<&Version>,
 ) -> Result<()> {
@@ -2590,7 +2597,7 @@ async fn state_format_test(
 
     // # Create a new state and check it has the current version
 
-    let zebrad = spawn_zebrad_without_rpc(network, test_name, false, false, None, false)?;
+    let zebrad = spawn_zebrad_without_rpc(network.clone(), test_name, false, false, None, false)?;
 
     // Skip the test unless it has the required state and environmental variables.
     let Some(mut zebrad) = zebrad else {
@@ -2671,8 +2678,9 @@ async fn state_format_test(
             expect_newer_version = false;
         }
 
-        let mut zebrad = spawn_zebrad_without_rpc(network, test_name, false, false, dir, false)?
-            .expect("unexpectedly missing required state or env vars");
+        let mut zebrad =
+            spawn_zebrad_without_rpc(network.clone(), test_name, false, false, dir, false)?
+                .expect("unexpectedly missing required state or env vars");
 
         tracing::info!(?network, "running {test_name} using zebrad");
 
@@ -2833,7 +2841,7 @@ fn scan_task_starts() -> Result<()> {
     let test_type = TestType::LaunchWithEmptyState {
         launches_lightwalletd: false,
     };
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     let mut keys = IndexMap::new();
     keys.insert(ZECPAGES_SAPLING_VIEWING_KEY.to_string(), 1);
     config.shielded_scan.sapling_keys_to_scan = keys;
@@ -2878,7 +2886,7 @@ async fn scan_rpc_server_starts() -> Result<()> {
 
     let port = random_known_port();
     let listen_addr = format!("127.0.0.1:{port}");
-    let mut config = default_test_config(Mainnet)?;
+    let mut config = default_test_config(&Mainnet)?;
     config.shielded_scan.listen_addr = Some(listen_addr.parse()?);
 
     // Start zebra with the config.
@@ -2936,7 +2944,7 @@ fn scan_start_where_left() -> Result<()> {
     let test_type = TestType::UpdateZebraCachedStateNoRpc;
     if let Some(cache_dir) = test_type.zebrad_state_path("scan test") {
         // Add a key to the config
-        let mut config = default_test_config(Mainnet)?;
+        let mut config = default_test_config(&Mainnet)?;
         let mut keys = IndexMap::new();
         keys.insert(ZECPAGES_SAPLING_VIEWING_KEY.to_string(), 1);
         config.shielded_scan.sapling_keys_to_scan = keys;
diff --git a/zebrad/tests/common/cached_state.rs b/zebrad/tests/common/cached_state.rs
index b893024c9ad..58f6064cdf5 100644
--- a/zebrad/tests/common/cached_state.rs
+++ b/zebrad/tests/common/cached_state.rs
@@ -120,7 +120,7 @@ pub fn wait_for_state_version_upgrade<T>(
 /// Starts a state service using the provided `cache_dir` as the directory with the chain state.
 #[tracing::instrument(skip(cache_dir))]
 pub async fn start_state_service_with_cache_dir(
-    network: Network,
+    network: &Network,
     cache_dir: impl Into<PathBuf>,
 ) -> Result<(
     BoxStateService,
@@ -144,7 +144,7 @@ pub async fn start_state_service_with_cache_dir(
 /// Loads the chain tip height from the state stored in a specified directory.
 #[tracing::instrument]
 pub async fn load_tip_height_from_state_directory(
-    network: Network,
+    network: &Network,
     state_path: &Path,
 ) -> Result<block::Height> {
     let (_state_service, _read_state_service, latest_chain_tip, _chain_tip_change) =
@@ -168,7 +168,7 @@ pub async fn load_tip_height_from_state_directory(
 ///
 /// If the provided `test_type` doesn't need an rpc server and cached state, or if `max_num_blocks` is 0
 pub async fn get_future_blocks(
-    network: Network,
+    network: &Network,
     test_type: TestType,
     test_name: &str,
     max_num_blocks: u32,
@@ -199,7 +199,7 @@ pub async fn get_future_blocks(
 ///
 /// If the provided `test_type` doesn't need an rpc server and cached state, or if `max_num_blocks` is 0
 pub async fn get_raw_future_blocks(
-    network: Network,
+    network: &Network,
     test_type: TestType,
     test_name: &str,
     max_num_blocks: u32,
@@ -216,7 +216,7 @@ pub async fn get_raw_future_blocks(
 
     let should_sync = true;
     let (zebrad, zebra_rpc_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, should_sync)?
+        spawn_zebrad_for_rpc(network.clone(), test_name, test_type, should_sync)?
             .ok_or_else(|| eyre!("get_raw_future_blocks requires a cached state"))?;
     let rpc_address = zebra_rpc_address.expect("test type must have RPC port");
 
diff --git a/zebrad/tests/common/checkpoints.rs b/zebrad/tests/common/checkpoints.rs
index c67130845e4..f59dd8fb2a0 100644
--- a/zebrad/tests/common/checkpoints.rs
+++ b/zebrad/tests/common/checkpoints.rs
@@ -71,7 +71,7 @@ pub async fn run(network: Network) -> Result<()> {
 
     // Sync zebrad to the network chain tip
     let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, true)?
+        spawn_zebrad_for_rpc(network.clone(), test_name, test_type, true)?
     {
         zebrad_and_address
     } else {
@@ -155,8 +155,12 @@ pub async fn run(network: Network) -> Result<()> {
         "zebrad synced to the tip, launching zebra-checkpoints...",
     );
 
-    let zebra_checkpoints =
-        spawn_zebra_checkpoints_direct(network, test_type, zebra_rpc_address, last_checkpoint)?;
+    let zebra_checkpoints = spawn_zebra_checkpoints_direct(
+        network.clone(),
+        test_type,
+        zebra_rpc_address,
+        last_checkpoint,
+    )?;
 
     let show_zebrad_logs = env::var(LOG_ZEBRAD_CHECKPOINTS).is_ok();
     if !show_zebrad_logs {
diff --git a/zebrad/tests/common/config.rs b/zebrad/tests/common/config.rs
index a67f1d484c6..eac81c86571 100644
--- a/zebrad/tests/common/config.rs
+++ b/zebrad/tests/common/config.rs
@@ -29,11 +29,11 @@ use crate::common::cached_state::DATABASE_FORMAT_CHECK_INTERVAL;
 /// - an ephemeral state,
 /// - the minimum syncer lookahead limit, and
 /// - shorter task intervals, to improve test coverage.
-pub fn default_test_config(net: Network) -> Result<ZebradConfig> {
+pub fn default_test_config(net: &Network) -> Result<ZebradConfig> {
     const TEST_DURATION: Duration = Duration::from_secs(30);
 
     let network = zebra_network::Config {
-        network: net,
+        network: net.clone(),
         // The OS automatically chooses an unused port.
         listen_addr: "127.0.0.1:0".parse()?,
         crawl_new_peer_interval: TEST_DURATION,
@@ -113,7 +113,7 @@ pub fn default_test_config(net: Network) -> Result<ZebradConfig> {
     })
 }
 
-pub fn persistent_test_config(network: Network) -> Result<ZebradConfig> {
+pub fn persistent_test_config(network: &Network) -> Result<ZebradConfig> {
     let mut config = default_test_config(network)?;
     config.state.ephemeral = false;
     Ok(config)
@@ -142,7 +142,7 @@ pub fn config_file_full_path(config_file: PathBuf) -> PathBuf {
 /// Set `parallel_cpu_threads` to true to auto-configure based on the number of CPU cores.
 pub fn random_known_rpc_port_config(
     parallel_cpu_threads: bool,
-    network: Network,
+    network: &Network,
 ) -> Result<ZebradConfig> {
     // [Note on port conflict](#Note on port conflict)
     let listen_port = random_known_port();
diff --git a/zebrad/tests/common/get_block_template_rpcs/get_block_template.rs b/zebrad/tests/common/get_block_template_rpcs/get_block_template.rs
index 56a62ff4346..58b12446965 100644
--- a/zebrad/tests/common/get_block_template_rpcs/get_block_template.rs
+++ b/zebrad/tests/common/get_block_template_rpcs/get_block_template.rs
@@ -78,14 +78,14 @@ pub(crate) async fn run() -> Result<()> {
 
     let should_sync = true;
     let (zebrad, zebra_rpc_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, should_sync)?
+        spawn_zebrad_for_rpc(network.clone(), test_name, test_type, should_sync)?
             .ok_or_else(|| eyre!("getblocktemplate test requires a cached state"))?;
 
     let rpc_address = zebra_rpc_address.expect("test type must have RPC port");
 
     let mut zebrad = check_sync_logs_until(
         zebrad,
-        network,
+        &network,
         SYNC_FINISHED_REGEX,
         MempoolBehavior::ShouldAutomaticallyActivate,
         true,
diff --git a/zebrad/tests/common/get_block_template_rpcs/submit_block.rs b/zebrad/tests/common/get_block_template_rpcs/submit_block.rs
index 8e606606389..28f48fb2c14 100644
--- a/zebrad/tests/common/get_block_template_rpcs/submit_block.rs
+++ b/zebrad/tests/common/get_block_template_rpcs/submit_block.rs
@@ -42,7 +42,7 @@ pub(crate) async fn run() -> Result<()> {
     );
 
     let raw_blocks: Vec<String> =
-        get_raw_future_blocks(network, test_type, test_name, MAX_NUM_FUTURE_BLOCKS).await?;
+        get_raw_future_blocks(&network, test_type, test_name, MAX_NUM_FUTURE_BLOCKS).await?;
 
     tracing::info!("got raw future blocks, spawning isolated zebrad...",);
 
diff --git a/zebrad/tests/common/launch.rs b/zebrad/tests/common/launch.rs
index 0350888858c..82e4f451ead 100644
--- a/zebrad/tests/common/launch.rs
+++ b/zebrad/tests/common/launch.rs
@@ -236,7 +236,7 @@ pub fn spawn_zebrad_for_rpc<S: AsRef<str> + Debug>(
 
     // Get the zebrad config
     let config = test_type
-        .zebrad_config(test_name, use_internet_connection, None, network)
+        .zebrad_config(test_name, use_internet_connection, None, &network)
         .expect("already checked config")?;
 
     let (zebrad_failure_messages, zebrad_ignore_messages) = test_type.zebrad_failure_messages();
@@ -314,7 +314,7 @@ where
             test_name,
             use_internet_connection,
             replace_cache_dir,
-            network,
+            &network,
         )
         .expect("already checked config")?;
 
@@ -353,7 +353,7 @@ pub fn can_spawn_zebrad_for_test_type<S: AsRef<str> + Debug>(
     // Check if we have any necessary cached states for the zebrad config.
     // The cache_dir and network values don't matter here.
     test_type
-        .zebrad_config(test_name, true, None, Mainnet)
+        .zebrad_config(test_name, true, None, &Mainnet)
         .is_some()
 }
 
diff --git a/zebrad/tests/common/lightwalletd/send_transaction_test.rs b/zebrad/tests/common/lightwalletd/send_transaction_test.rs
index 870d3992b56..f9087771595 100644
--- a/zebrad/tests/common/lightwalletd/send_transaction_test.rs
+++ b/zebrad/tests/common/lightwalletd/send_transaction_test.rs
@@ -85,7 +85,8 @@ pub async fn run() -> Result<()> {
         "running gRPC send transaction test using lightwalletd & zebrad",
     );
 
-    let transactions = load_transactions_from_future_blocks(network, test_type, test_name).await?;
+    let transactions =
+        load_transactions_from_future_blocks(network.clone(), test_type, test_name).await?;
 
     tracing::info!(
         transaction_count = ?transactions.len(),
@@ -98,9 +99,12 @@ pub async fn run() -> Result<()> {
 
     // Start zebrad with no peers, we want to send transactions without blocks coming in. If `wallet_grpc_test`
     // runs before this test (as it does in `lightwalletd_test_suite`), then we are the most up to date with tip we can.
-    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, use_internet_connection)?
-    {
+    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) = spawn_zebrad_for_rpc(
+        network.clone(),
+        test_name,
+        test_type,
+        use_internet_connection,
+    )? {
         zebrad_and_address
     } else {
         // Skip the test, we don't have the required cached state
@@ -283,7 +287,7 @@ async fn load_transactions_from_future_blocks(
     test_type: TestType,
     test_name: &str,
 ) -> Result<Vec<Arc<Transaction>>> {
-    let transactions = get_future_blocks(network, test_type, test_name, MAX_NUM_FUTURE_BLOCKS)
+    let transactions = get_future_blocks(&network, test_type, test_name, MAX_NUM_FUTURE_BLOCKS)
         .await?
         .into_iter()
         .flat_map(|block| block.transactions)
diff --git a/zebrad/tests/common/lightwalletd/wallet_grpc_test.rs b/zebrad/tests/common/lightwalletd/wallet_grpc_test.rs
index e341f1a2cd5..284677b8dd9 100644
--- a/zebrad/tests/common/lightwalletd/wallet_grpc_test.rs
+++ b/zebrad/tests/common/lightwalletd/wallet_grpc_test.rs
@@ -85,9 +85,12 @@ pub async fn run() -> Result<()> {
 
     // Launch zebra with peers and using a predefined zebrad state path.
     // As this tests are just queries we can have a live chain where blocks are coming.
-    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) =
-        spawn_zebrad_for_rpc(network, test_name, test_type, use_internet_connection)?
-    {
+    let (mut zebrad, zebra_rpc_address) = if let Some(zebrad_and_address) = spawn_zebrad_for_rpc(
+        network.clone(),
+        test_name,
+        test_type,
+        use_internet_connection,
+    )? {
         tracing::info!(
             ?network,
             ?test_type,
@@ -134,7 +137,7 @@ pub async fn run() -> Result<()> {
 
     // Launch lightwalletd
     let (lightwalletd, lightwalletd_rpc_port) =
-        spawn_lightwalletd_for_rpc(network, test_name, test_type, zebra_rpc_address)?
+        spawn_lightwalletd_for_rpc(network.clone(), test_name, test_type, zebra_rpc_address)?
             .expect("already checked cached state and network requirements");
 
     tracing::info!(
@@ -182,10 +185,10 @@ pub async fn run() -> Result<()> {
         .into_inner();
 
     // Get `Sapling` activation height.
-    let sapling_activation_height = Sapling.activation_height(network).unwrap().0 as u64;
+    let sapling_activation_height = Sapling.activation_height(&network).unwrap().0 as u64;
 
     // As we are using a pretty much synchronized blockchain, we can assume the tip is above the Nu5 network upgrade
-    assert!(block_tip.height > Nu5.activation_height(network).unwrap().0 as u64);
+    assert!(block_tip.height > Nu5.activation_height(&network).unwrap().0 as u64);
 
     // The first block in the mainnet that has sapling and orchard information.
     let block_with_trees = 1687107;
diff --git a/zebrad/tests/common/shielded_scan/scan_task_commands.rs b/zebrad/tests/common/shielded_scan/scan_task_commands.rs
index 44021fe8304..1961c8f6815 100644
--- a/zebrad/tests/common/shielded_scan/scan_task_commands.rs
+++ b/zebrad/tests/common/shielded_scan/scan_task_commands.rs
@@ -80,14 +80,14 @@ pub(crate) async fn run() -> Result<()> {
     fs::remove_dir_all(std::path::Path::new(&scan_db_path)).ok();
 
     let (state_service, _read_state_service, latest_chain_tip, chain_tip_change) =
-        start_state_service_with_cache_dir(network, zebrad_state_path.clone()).await?;
+        start_state_service_with_cache_dir(&network, zebrad_state_path.clone()).await?;
 
     let chain_tip_height = latest_chain_tip
         .best_tip_height()
         .ok_or_else(|| eyre!("State directory doesn't have a chain tip block"))?;
 
     let sapling_activation_height = NetworkUpgrade::Sapling
-        .activation_height(network)
+        .activation_height(&network)
         .expect("there should be an activation height for Mainnet");
 
     assert!(
@@ -105,7 +105,7 @@ pub(crate) async fn run() -> Result<()> {
     let state = ServiceBuilder::new().buffer(10).service(state_service);
 
     // Create an ephemeral `Storage` instance
-    let storage = Storage::new(&scan_config, network, false);
+    let storage = Storage::new(&scan_config, &network, false);
     let mut scan_task = ScanTask::spawn(storage, state, chain_tip_change);
 
     tracing::info!("started scan task, sending register/subscribe keys messages with zecpages key to start scanning for a new key",);
diff --git a/zebrad/tests/common/sync.rs b/zebrad/tests/common/sync.rs
index 6f0b5c32c9d..5543640dd72 100644
--- a/zebrad/tests/common/sync.rs
+++ b/zebrad/tests/common/sync.rs
@@ -183,7 +183,7 @@ impl MempoolBehavior {
 #[tracing::instrument(skip(reuse_tempdir))]
 pub fn sync_until(
     height: Height,
-    network: Network,
+    network: &Network,
     stop_regex: &str,
     timeout: Duration,
     // Test Settings
@@ -298,7 +298,7 @@ pub fn sync_until(
 #[tracing::instrument(skip(zebrad))]
 pub fn check_sync_logs_until(
     mut zebrad: TestChild<TempDir>,
-    network: Network,
+    network: &Network,
     stop_regex: &str,
     // Test Settings
     mempool_behavior: MempoolBehavior,
@@ -328,7 +328,7 @@ pub fn check_sync_logs_until(
 }
 
 /// Returns a test config for caching Zebra's state up to the mandatory checkpoint.
-pub fn cached_mandatory_checkpoint_test_config(network: Network) -> Result<ZebradConfig> {
+pub fn cached_mandatory_checkpoint_test_config(network: &Network) -> Result<ZebradConfig> {
     let mut config = persistent_test_config(network)?;
     config.state.cache_dir = "/zebrad-cache".into();
 
@@ -365,7 +365,7 @@ pub fn cached_mandatory_checkpoint_test_config(network: Network) -> Result<Zebra
 #[allow(clippy::print_stderr)]
 #[tracing::instrument]
 pub fn create_cached_database_height(
-    network: Network,
+    network: &Network,
     height: Height,
     checkpoint_sync: bool,
     stop_regex: &str,
diff --git a/zebrad/tests/common/test_type.rs b/zebrad/tests/common/test_type.rs
index bb4291c3db7..2c3cd453d22 100644
--- a/zebrad/tests/common/test_type.rs
+++ b/zebrad/tests/common/test_type.rs
@@ -177,7 +177,7 @@ impl TestType {
         test_name: Str,
         use_internet_connection: bool,
         replace_cache_dir: Option<&Path>,
-        network: Network,
+        network: &Network,
     ) -> Option<Result<ZebradConfig>> {
         let config = if self.needs_zebra_rpc_server() {
             // This is what we recommend our users configure.
diff --git a/zebrad/tests/end_of_support.rs b/zebrad/tests/end_of_support.rs
index 2a2a4afc390..94c4d3cc967 100644
--- a/zebrad/tests/end_of_support.rs
+++ b/zebrad/tests/end_of_support.rs
@@ -18,7 +18,7 @@ fn end_of_support_panic() {
     // We are in panic
     let panic = ESTIMATED_RELEASE_HEIGHT + (EOS_PANIC_AFTER * ESTIMATED_BLOCKS_PER_DAY) + 1;
 
-    end_of_support::check(Height(panic), Network::Mainnet);
+    end_of_support::check(Height(panic), &Network::Mainnet);
 }
 
 /// Test that the `end_of_support` function is working as expected.
@@ -29,7 +29,7 @@ fn end_of_support_function() {
     let no_warn = ESTIMATED_RELEASE_HEIGHT + (EOS_PANIC_AFTER * ESTIMATED_BLOCKS_PER_DAY)
         - (30 * ESTIMATED_BLOCKS_PER_DAY);
 
-    end_of_support::check(Height(no_warn), Network::Mainnet);
+    end_of_support::check(Height(no_warn), &Network::Mainnet);
     assert!(logs_contain(
         "Checking if Zebra release is inside support range ..."
     ));
@@ -38,7 +38,7 @@ fn end_of_support_function() {
     // We are in warn range
     let warn = ESTIMATED_RELEASE_HEIGHT + (EOS_PANIC_AFTER * 1152) - (3 * ESTIMATED_BLOCKS_PER_DAY);
 
-    end_of_support::check(Height(warn), Network::Mainnet);
+    end_of_support::check(Height(warn), &Network::Mainnet);
     assert!(logs_contain(
         "Checking if Zebra release is inside support range ..."
     ));
@@ -59,7 +59,7 @@ fn end_of_support_date() {
     // Get the last one we have and use it as tip.
     let higher_checkpoint = list.max_height();
 
-    end_of_support::check(higher_checkpoint, Network::Mainnet);
+    end_of_support::check(higher_checkpoint, &Network::Mainnet);
     assert!(logs_contain(
         "Checking if Zebra release is inside support range ..."
     ));