refactor(GuesserBuffer): Exfiltrate field mast_auth_paths

When switching to a new and improved block proposal, the MAST authentication
paths used for guessing change, but (under the new consensus rule set) the
remainder of the `GuesserBuffer` does not. This commit moves the field
`mast_auth_paths` out of this struct and into the relevant functions' argument
lists. As a result, the `GuesserBuffer` captures exactly that information that
does not change between block proposals and can remain immutable.

Co-authored-by: Thorkil Schmidiger <thor@neptune.cash>

Author: aszepieniec

neptune-core/src/application/loops/mine_loop.rs

@@ -46,6 +46,7 @@ use crate::protocol::consensus::block::block_transaction::BlockTransaction;
 use crate::protocol::consensus::block::difficulty_control::difficulty_control;
 use crate::protocol::consensus::block::pow::GuesserBuffer;
 use crate::protocol::consensus::block::pow::Pow;
+use crate::protocol::consensus::block::pow::PowMastPaths;
 use crate::protocol::consensus::block::*;
 use crate::protocol::consensus::consensus_rule_set::ConsensusRuleSet;
 use crate::protocol::consensus::transaction::transaction_proof::TransactionProofType;
@@ -238,14 +239,15 @@ fn guess_worker(
     }
     info!("Completed: guess preprocessing.");
 
+    let mast_auth_paths = block.pow_mast_paths();
     let pool = ThreadPoolBuilder::new()
         .num_threads(threads_to_use)
         .build()
         .unwrap();
     let guess_result = pool.install(|| {
         rayon::iter::repeat(0)
             .map_init(rand::rng, |rng, _i| {
-                guess_nonce_iteration(&guesser_buffer, threshold, rng, &sender)
+                guess_nonce_iteration(&guesser_buffer, &mast_auth_paths, threshold, rng, &sender)
             })
             .find_any(|r| !r.block_not_found())
             .unwrap()
@@ -308,6 +310,7 @@ impl GuessNonceResult {
 #[inline]
 fn guess_nonce_iteration(
     guesser_buffer: &GuesserBuffer<{ BlockPow::MERKLE_TREE_HEIGHT }>,
+    mast_auth_paths: &PowMastPaths,
     threshold: Digest,
     rng: &mut rand::rngs::ThreadRng,
     sender: &oneshot::Sender<NewBlockFound>,
@@ -320,7 +323,7 @@ fn guess_nonce_iteration(
         return GuessNonceResult::Cancelled;
     }
 
-    let result = Pow::guess(guesser_buffer, nonce, threshold);
+    let result = Pow::guess(guesser_buffer, mast_auth_paths, nonce, threshold);
 
     match result {
         Some(pow) => GuessNonceResult::NonceFound { pow: Box::new(pow) },
@@ -1067,6 +1070,7 @@ pub(crate) mod tests {
             Some(target_block_interval),
             network,
         );
+        let mast_auth_paths = block.pow_mast_paths();
         let threshold = previous_block.header().difficulty.target();
         let num_iterations_launched = 1_000_000;
         let tick = std::time::SystemTime::now();
@@ -1077,7 +1081,13 @@ pub(crate) mod tests {
         let num_iterations_run =
             rayon::iter::IntoParallelIterator::into_par_iter(0..num_iterations_launched)
                 .map_init(rand::rng, |prng, _i| {
-                    guess_nonce_iteration(&guesser_buffer, threshold, prng, &worker_task_tx);
+                    guess_nonce_iteration(
+                        &guesser_buffer,
+                        &mast_auth_paths,
+                        threshold,
+                        prng,
+                        &worker_task_tx,
+                    );
                 })
                 .count();
         drop(worker_task_rx);
@@ -2140,9 +2150,10 @@ pub(crate) mod tests {
 
         let guesser_buffer =
             successor_block.guess_preprocess(None, None, ConsensusRuleSet::default());
+        let mast_auth_paths = successor_block.pow_mast_paths();
         let target = predecessor_block.header().difficulty.target();
         loop {
-            if BlockPow::guess(&guesser_buffer, rng.random(), target).is_some() {
+            if BlockPow::guess(&guesser_buffer, &mast_auth_paths, rng.random(), target).is_some() {
                 println!("found solution after {counter} guesses.");
                 break;
             }

neptune-core/src/application/rpc/server.rs

@@ -5951,7 +5951,7 @@ mod tests {
                 );
 
                 let pow: BlockPow = random();
-                let resulting_block_hash = pow_puzzle.auth_paths.fast_mast_hash(pow);
+                let resulting_block_hash = pow_puzzle.pow_mast_paths.fast_mast_hash(pow);
 
                 block1.set_header_pow(pow);
                 block1.set_header_guesser_address(guesser_address.into());
@@ -5964,9 +5964,12 @@ mod tests {
                 // Check that succesful guess is accepted by endpoint.
                 let consensus_rule_set = ConsensusRuleSet::Reboot;
                 let guesser_buffer = block1.guess_preprocess(None, None, consensus_rule_set);
+                let mast_auth_paths = block1.pow_mast_paths();
                 let target = genesis.header().difficulty.target();
                 let valid_pow = loop {
-                    if let Some(valid_pow) = Pow::guess(&guesser_buffer, random(), target) {
+                    if let Some(valid_pow) =
+                        Pow::guess(&guesser_buffer, &mast_auth_paths, random(), target)
+                    {
                         break valid_pow;
                     }
                 };

neptune-core/src/application/rpc/server/proof_of_work_puzzle.rs

@@ -18,7 +18,7 @@ use crate::Block;
 #[derive(Clone, Debug, Copy, Serialize, Deserialize)]
 pub struct ProofOfWorkPuzzle {
     // All fields public since used downstream by mining pool software.
-    pub auth_paths: PowMastPaths,
+    pub pow_mast_paths: PowMastPaths,
 
     /// The threshold digest that defines when a PoW solution is valid. The
     /// block's hash must be less than or equal to this value.
@@ -53,7 +53,7 @@ impl ProofOfWorkPuzzle {
         let id = Tip5::hash(&auth_paths);
 
         Self {
-            auth_paths,
+            pow_mast_paths: auth_paths,
             threshold,
             total_guesser_reward: guesser_reward,
             id,
@@ -67,16 +67,20 @@ impl ProofOfWorkPuzzle {
     pub fn solve(&self, consensus_rule_set: ConsensusRuleSet) -> BlockPow {
         use rayon::prelude::*;
         info!("Starting PoW preprocessing");
-        let guesser_buffer =
-            BlockPow::preprocess(self.auth_paths, None, consensus_rule_set, self.prev_block);
+        let guesser_buffer = BlockPow::preprocess(
+            self.pow_mast_paths,
+            None,
+            consensus_rule_set,
+            self.prev_block,
+        );
         info!("Done with PoW preprocessing");
 
         info!("Now attempting to find valid nonce");
         let solution = (0u64..u64::MAX)
             .into_par_iter()
             .map(|i| {
                 let nonce = Digest(bfe_array![0, 0, 0, 0, i]);
-                BlockPow::guess(&guesser_buffer, nonce, self.threshold)
+                BlockPow::guess(&guesser_buffer, &self.pow_mast_paths, nonce, self.threshold)
             })
             .find_map_any(|x| x)
             .expect("Should find solution within 2^{64} attempts");

neptune-core/src/lib.rs

@@ -5,7 +5,7 @@
 // enables nightly feature async_fn_track_caller for crate feature log-slow-write-lock.
 // log-slow-write-lock logs warning when a write-lock is held longer than 100 millis.
 // to enable: cargo +nightly build --features log-slow-write-lock
-#![cfg_attr(feature = "track-lock-location", feature(async_fn_track_caller))]
+// #![cfg_attr(feature = "track-lock-location", feature(async_fn_track_caller))]
 //
 // If code coverage tool `cargo-llvm-cov` is running with the nightly toolchain,
 // enable the unstable “coverage” attribute. This allows using the annotation

neptune-core/src/protocol/consensus/block/mod.rs

@@ -1305,14 +1305,17 @@ pub(crate) mod tests {
         let network = Network::Main;
         let genesis = Block::genesis(network);
         let mut invalid_block = invalid_empty_block(&genesis, network);
+        let mast_auth_paths = invalid_block.pow_mast_paths();
 
         for consensus_rule_set in ConsensusRuleSet::iter() {
             let guesser_buffer = invalid_block.guess_preprocess(None, None, consensus_rule_set);
             let target = Difficulty::from(2u32).target();
             let mut rng = rng();
 
             let valid_pow = loop {
-                if let Some(valid_pow) = Pow::guess(&guesser_buffer, rng.random(), target) {
+                if let Some(valid_pow) =
+                    Pow::guess(&guesser_buffer, &mast_auth_paths, rng.random(), target)
+                {
                     break valid_pow;
                 }
             };

neptune-core/src/protocol/consensus/block/pow.rs

@@ -278,9 +278,6 @@ pub struct GuesserBuffer<const MERKLE_TREE_HEIGHT: usize> {
 
     hash: Digest,
 
-    /// Authentication paths for all fields but the PoW field
-    mast_auth_paths: PowMastPaths,
-
     /// The hash of the parent block of this guesser buffer.
     prev_block_digest: Digest,
 }
@@ -290,7 +287,6 @@ impl<const MERKLE_TREE_HEIGHT: usize> Default for GuesserBuffer<MERKLE_TREE_HEIG
         Self {
             merkle_tree: MTree::default(),
             hash: Default::default(),
-            mast_auth_paths: Default::default(),
             prev_block_digest: Default::default(),
         }
     }
@@ -401,15 +397,15 @@ impl<const MERKLE_TREE_HEIGHT: usize> Pow<MERKLE_TREE_HEIGHT> {
         // iterate log-many times over the buffer to compute leafs from buds
         let mut outs = ins.clone();
         let mut buds = &mut ins;
-        let mut leafs = &mut outs;
+        let mut resulting_leafs = &mut outs;
         let mut num_swaps = 0;
         for i in 0..NUM_BUD_LAYERS {
             for j in 0..num_checkpoints {
                 let range = (j * checkpoint_distance)..((j + 1) * checkpoint_distance);
                 range
                     .clone()
                     .into_par_iter()
-                    .zip(leafs[range].par_iter_mut())
+                    .zip(resulting_leafs[range].par_iter_mut())
                     .for_each(|(k, leaf)| {
                         *leaf = Tip5::hash_pair(buds[k], buds[(k + (1 << i)) % Self::NUM_LEAFS]);
                     });
@@ -418,11 +414,11 @@ impl<const MERKLE_TREE_HEIGHT: usize> Pow<MERKLE_TREE_HEIGHT> {
                     return Default::default();
                 }
             }
-            std::mem::swap(&mut leafs, &mut buds);
+            std::mem::swap(&mut resulting_leafs, &mut buds);
             num_swaps += 1;
         }
 
-        std::mem::swap(&mut leafs, &mut buds);
+        std::mem::swap(&mut resulting_leafs, &mut buds);
         num_swaps += 1;
 
         let (mut leafs, internal_nodes) = if num_swaps & 1 == 1 {
@@ -450,13 +446,13 @@ impl<const MERKLE_TREE_HEIGHT: usize> Pow<MERKLE_TREE_HEIGHT> {
         GuesserBuffer::<MERKLE_TREE_HEIGHT> {
             merkle_tree,
             hash,
-            mast_auth_paths,
             prev_block_digest,
         }
     }
 
     pub fn guess(
         buffer: &GuesserBuffer<MERKLE_TREE_HEIGHT>,
+        mast_auth_paths: &PowMastPaths,
         nonce: Digest,
         target: Digest,
     ) -> Option<Self> {
@@ -483,7 +479,7 @@ impl<const MERKLE_TREE_HEIGHT: usize> Pow<MERKLE_TREE_HEIGHT> {
             path_b,
         };
 
-        let pow_digest = buffer.mast_auth_paths.fast_mast_hash(pow);
+        let pow_digest = mast_auth_paths.fast_mast_hash(pow);
         if pow_digest > target {
             None
         } else {
@@ -511,12 +507,14 @@ impl<const MERKLE_TREE_HEIGHT: usize> Pow<MERKLE_TREE_HEIGHT> {
                 Self::leaf(leaf_prefix, index_b),
             )
         } else {
-            let index_a =
-                Self::bitreverse(index_a.try_into().unwrap(), Self::MERKLE_TREE_HEIGHT as u32)
-                    as u64;
-            let index_b =
-                Self::bitreverse(index_b.try_into().unwrap(), Self::MERKLE_TREE_HEIGHT as u32)
-                    as u64;
+            let index_a = u64::from(Self::bitreverse(
+                index_a.try_into().unwrap(),
+                Self::MERKLE_TREE_HEIGHT as u32,
+            ));
+            let index_b = u64::from(Self::bitreverse(
+                index_b.try_into().unwrap(),
+                Self::MERKLE_TREE_HEIGHT as u32,
+            ));
             (
                 Self::leaf(leaf_prefix, index_a),
                 Self::leaf(leaf_prefix, index_b),
@@ -691,7 +689,7 @@ pub(crate) mod tests {
                 let mut successful_guess = None;
                 'inner_loop: for _ in 0..120 {
                     let nonce = rng.random();
-                    if let Some(solution) = Pow::guess(&buffer, nonce, target) {
+                    if let Some(solution) = Pow::guess(&buffer, &auth_paths, nonce, target) {
                         successful_guess = Some(solution);
                         break 'inner_loop;
                     }