braidpool · Sansh2356 · Dec 6, 2025 · Dec 11, 2025 · Dec 12, 2025 · Dec 12, 2025
@@ -33,9 +33,6 @@ serde_json = "1.0.140"
 clap = { version = "4.4.2", features = ["derive", "string"] }
 bitcoin = { git = "https://github.com/braidpool/rust-bitcoin.git", branch = "cpunet",features=["serde"]}
 bitcoin_hashes = { version = "0.16" }
-bitcoincore-rpc = { version = "0.19.0"}
-bitcoincore-rpc-json = { version = "0.19.0"}
-bitcoincore-zmq = { version = "1.5.2", git = "https://github.com/antonilol/rust-bitcoincore-zmq.git", features = ["async"] }
 shellexpand = "3.1.0"
 num = { version = "0.4.1", features = ["serde", "rand"] }
 rand = "0.8"

@@ -21,9 +21,6 @@ serde_json = { workspace = true }
 clap = { workspace = true }
 bitcoin = { workspace = true }
 bitcoin_hashes = { workspace = true }
-bitcoincore-rpc = { workspace = true }
-bitcoincore-rpc-json = { workspace = true }
-bitcoincore-zmq = { workspace = true }
 shellexpand = { workspace = true }
 num = { workspace = true }
 rand = { workspace = true }

@@ -121,6 +121,17 @@ braidpool_protocol! {
     }
 }
 
+/// Maximum size in bytes of a single bead-sync request or response frame.
+///
+/// A remote peer that sends more than this on a single request/response
+/// substream has its frame rejected before deserialization. Without this
+/// cap, `read_to_end` would allocate without bound and a malicious peer
+/// could OOM us during IBD.
+///
+/// Sized to comfortably hold one `IBD_HASH_PAGE_MAX`-sized hash list plus
+/// one `IBD_BATCH_SIZE` worth of beads at realistic per-bead sizes.
+pub const MAX_BEAD_SYNC_FRAME: usize = 4 * 1024 * 1024;
+
 /// Codec for encoding/decoding bead sync messages over libp2p.
 ///
 /// Implements the `libp2p::request_response::Codec` trait to handle serialization
@@ -138,8 +149,18 @@ impl Codec for BeadCodec {
     where
         T: AsyncRead + Unpin + Send,
     {
+        // `take(MAX + 1)` lets us distinguish "exactly at the cap" (valid)
+        // from "exceeded the cap" (reject) without an extra read.
         let mut buf = Vec::new();
-        io.read_to_end(&mut buf).await?;
+        io.take(MAX_BEAD_SYNC_FRAME as u64 + 1)
+            .read_to_end(&mut buf)
+            .await?;
+        if buf.len() > MAX_BEAD_SYNC_FRAME {
+            return Err(IoError::new(
+                ErrorKind::InvalidData,
+                "bead-sync request frame exceeds MAX_BEAD_SYNC_FRAME",
+            ));
+        }
         BeadRequest::consensus_decode(&mut buf.as_slice())
             .map_err(|e| IoError::new(ErrorKind::InvalidData, e))
     }
@@ -149,7 +170,15 @@ impl Codec for BeadCodec {
         T: AsyncRead + Unpin + Send,
     {
         let mut buf = Vec::new();
-        io.read_to_end(&mut buf).await?;
+        io.take(MAX_BEAD_SYNC_FRAME as u64 + 1)
+            .read_to_end(&mut buf)
+            .await?;
+        if buf.len() > MAX_BEAD_SYNC_FRAME {
+            return Err(IoError::new(
+                ErrorKind::InvalidData,
+                "bead-sync response frame exceeds MAX_BEAD_SYNC_FRAME",
+            ));
+        }
         BeadResponse::consensus_decode(&mut buf.as_slice())
             .map_err(|e| IoError::new(ErrorKind::InvalidData, e))
     }

@@ -22,7 +22,7 @@ pub enum GenesisCheckStatus {
     GenesisBeadsCountMismatch,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug)]
 
 pub struct Braid {
     pub beads: Vec<Bead>,
@@ -31,7 +31,7 @@ pub struct Braid {
     pub cohort_tips: Vec<HashSet<usize>>,
     pub orphan_beads: Vec<Bead>,
     pub genesis_beads: HashSet<usize>,
-    pub bead_index_mapping: HashMap<BeadHash, usize>,
+    pub bead_index_mapping: HashMap<BeadHash, (usize, u32)>,
 }
 
 impl Braid {
@@ -44,7 +44,10 @@ impl Braid {
         for (index, bead) in genesis_beads.into_iter().enumerate() {
             beads.push(bead.clone());
             bead_indices.insert(index);
-            bead_index_mapping.insert(bead.block_header.block_hash(), index);
+            bead_index_mapping.insert(
+                bead.block_header.block_hash(),
+                (index, bead.committed_metadata.start_timestamp.to_u32()),
+            );
         }
         let mut genesis_cohort: Vec<Cohort> = Vec::new();
         if bead_indices.len() != 0 {
@@ -110,7 +113,13 @@ impl Braid {
         // Insert bead into beads vector
         self.beads.push(bead.clone());
         let new_bead_index = self.beads.len() - 1;
-        self.bead_index_mapping.insert(bead_hash, new_bead_index);
+        self.bead_index_mapping.insert(
+            bead_hash,
+            (
+                new_bead_index,
+                bead.committed_metadata.start_timestamp.to_u32(),
+            ),
+        );
 
         // Find earliest parent of bead in cohorts and nuke all cohorts after that
         let mut found_parent_indices = HashSet::new();
@@ -123,7 +132,7 @@ impl Braid {
             // Find which parent indices are in this cohort
             for parent_hash in &bead.committed_metadata.parents {
                 if let Some(&parent_index) = self.bead_index_mapping.get(parent_hash) {
-                    if cohort.0.contains(&parent_index) {
+                    if cohort.0.contains(&parent_index.0) {
                         found_parent_indices.insert(parent_index);
                     }
                 }
@@ -133,7 +142,7 @@ impl Braid {
             // further back
             if !found_parent_indices.is_empty()
                 && found_parent_indices.len() == bead.committed_metadata.parents.len()
-                && (self.cohort_tips[i] == found_parent_indices)
+                && (self.cohort_tips[i] == found_parent_indices.iter().map(|idx| idx.0).collect())
             {
                 remove_after = Some(i + 1);
                 dangling.insert(new_bead_index);
@@ -163,7 +172,7 @@ impl Braid {
         for parent_hash in &bead.committed_metadata.parents {
             // Find the index of the parent bead
             if let Some(&parent_index) = self.bead_index_mapping.get(parent_hash) {
-                self.tips.remove(&parent_index);
+                self.tips.remove(&parent_index.0);
             }
         }
 
@@ -190,7 +199,10 @@ impl Braid {
         let mut i = self.orphan_beads.len();
         while i > 0 {
             i -= 1;
-
+            tracing::debug!(
+                "Processing orphan beads with blockhash - {:?}",
+                self.orphan_beads[i].block_header.block_hash()
+            );
             // Check if all parents are now available for this orphan
             let mut all_parents_available = true;
             for parent_hash in &self.orphan_beads[i].committed_metadata.parents {
@@ -203,10 +215,17 @@ impl Braid {
             if all_parents_available {
                 // Remove the orphan bead first, then process it
                 let orphan_bead = self.orphan_beads.remove(i);
-
+                tracing::debug!(
+                    "Orphan bead now has all parents, thus extending to local braid: {:?}",
+                    orphan_bead.block_header.block_hash()
+                );
                 // Now extend with the orphan bead
                 match self.extend(&orphan_bead) {
                     AddBeadStatus::BeadAdded => {
+                        tracing::debug!(
+                            "Orphan bead successfully added to braid: {:?}",
+                            orphan_bead.block_header.block_hash()
+                        );
                         // Recursively process remaining orphans as this addition
                         // might enable more orphans to be processed
                         self.process_orphan_beads();
@@ -219,7 +238,10 @@ impl Braid {
                         continue;
                     }
                     AddBeadStatus::ParentsNotYetReceived => {
-                        self.orphan_beads.push(orphan_bead);
+                        // extend() already re-queued the bead into self.orphan_beads
+                        // on its own ParentsNotYetReceived path; pushing again would
+                        // duplicate the entry.
+                        continue;
                     }
                 }
             }
@@ -233,7 +255,7 @@ impl Braid {
         for bead_hash in genesis_beads {
             let index = self.bead_index_mapping.get(bead_hash);
             let bead_exists = match index {
-                Some(idx) => self.genesis_beads.contains(idx),
+                Some(idx) => self.genesis_beads.contains(&idx.0),
                 None => false,
             };
             if !bead_exists {
@@ -249,34 +271,38 @@ impl Braid {
             if !self.bead_index_mapping.contains_key(&bead_hash) {
                 self.beads.push(bead.clone());
                 let new_index = self.beads.len() - 1;
-                self.bead_index_mapping.insert(bead_hash, new_index);
+                self.bead_index_mapping.insert(
+                    bead_hash,
+                    (new_index, bead.committed_metadata.start_timestamp.to_u32()),
+                );
                 self.genesis_beads.insert(new_index);
             }
         }
     }
-    /// utility function for GetBeadsAfter request
-    pub fn get_beads_after(&self, old_tips: Vec<BeadHash>) -> Option<Vec<Bead>> {
+    /// utility function for GetBeadsAfter request and returning only limit for pagination
+    /// sent of the given beadhash
+    pub fn get_beads_after(&self, old_tips: Vec<BeadHash>, limit: usize) -> Option<Vec<Bead>> {
         let old_tips: HashSet<BeadHash> = old_tips.into_iter().collect();
         tracing::warn!(
             old_tips=?old_tips,"Tips received from the peer for which beads are requested for during IBD"
         );
         //In case no tips are present i.e. the new braid-node has been initialized
         if old_tips.len() == 0 {
-            return Some(self.beads.clone());
+            return Some(self.beads.iter().take(limit).cloned().collect());
         }
         let mut response_beads = Vec::new();
         let mut smallest_index = usize::MAX;
         //finding the starting index
         for hash in &old_tips {
             if let Some(&index) = self.bead_index_mapping.get(hash) {
-                if index < smallest_index {
-                    smallest_index = index;
+                if index.0 < smallest_index {
+                    smallest_index = index.0;
                 }
             }
         }
         //If somehow no bead matched that can be due to possible latency/fork so send all the beads instead as fallback
         if smallest_index == usize::MAX {
-            return Some(self.beads.clone());
+            return Some(self.beads.iter().take(limit).cloned().collect());
         }
 
         tracing::debug!(
@@ -293,18 +319,25 @@ impl Braid {
             }
         }
         if smallest_cohort_index == usize::MAX {
-            return Some(self.beads.clone());
+            return Some(self.beads.iter().take(limit).cloned().collect());
         }
         tracing::debug!(
             smallest_index=?smallest_index,"Smallest possible cohort index for which the given smallest index is a part of",
         );
-        while smallest_cohort_index < self.cohorts.len() {
+        'cohort_walk: while smallest_cohort_index < self.cohorts.len() {
             let cohort = &self.cohorts[smallest_cohort_index];
-            for bead_index in &cohort.0 {
-                let curr_bead = self.beads[*bead_index].clone();
+            // HashSet iteration order is non-deterministic; sort by bead-index so
+            // the wire response is reproducible across runs and peers.
+            let mut sorted_indices: Vec<usize> = cohort.0.iter().copied().collect();
+            sorted_indices.sort();
+            for bead_index in sorted_indices {
+                let curr_bead = self.beads[bead_index].clone();
                 //Not including the beads that are already present in old_tips
                 if !old_tips.contains(&curr_bead.block_header.block_hash()) {
                     response_beads.push(curr_bead);
+                    if response_beads.len() >= limit {
+                        break 'cohort_walk;
+                    }
                 } else {
                     tracing::debug!("This bead is already present in old tips thus skipping");
                 }
@@ -378,7 +411,8 @@ pub mod consensus_functions {
         //utilizing the passed arguments as of parents instead of the internal braid one
         let current_beads = &braid_obj.beads;
         for bead in current_beads {
-            let current_bead_index = braid_obj.bead_index_mapping[&bead.block_header.block_hash()];
+            let current_bead_index =
+                braid_obj.bead_index_mapping[&bead.block_header.block_hash()].0;
             let parents = match parents.get(&current_bead_index) {
                 Some(b) => b,
                 _ => {
@@ -423,13 +457,13 @@ pub mod consensus_functions {
 
         let current_beads = &braid_obj.beads;
         for bead in current_beads {
-            let current_bead_idx = braid_obj.bead_index_mapping[&bead.block_header.block_hash()];
+            let current_bead_idx = braid_obj.bead_index_mapping[&bead.block_header.block_hash()].0;
             let parents = &parents[&current_bead_idx];
 
             for parent_bead_idx in parents.iter() {
                 bead_children_mapping
-                    .get_mut(&parent_bead_idx)
-                    .unwrap()
+                    .entry(*parent_bead_idx)
+                    .or_insert_with(HashSet::new)
                     .insert(current_bead_idx);
             }
         }
@@ -500,7 +534,7 @@ pub mod consensus_functions {
         parents: &HashMap<usize, HashSet<usize>>,
     ) -> &'a mut HashMap<usize, HashSet<usize>> {
         let mut dequeue: VecDeque<(usize, bool)> = VecDeque::new();
-        let current_bead_index = braid_obj.bead_index_mapping[&current_block_hash];
+        let current_bead_index = braid_obj.bead_index_mapping[&current_block_hash].0;
         dequeue.push_back((current_bead_index, false));
         while let Some((current, is_processed)) = dequeue.pop_back() {
             if is_processed {
@@ -575,7 +609,7 @@ pub mod consensus_functions {
         ancestors: &'a mut HashMap<usize, HashSet<usize>>,
         parents: &HashMap<usize, HashSet<usize>>,
     ) -> &'a mut HashMap<usize, HashSet<usize>> {
-        let current_block_idx = braid_obj.bead_index_mapping[&current_block_hash];
+        let current_block_idx = braid_obj.bead_index_mapping[&current_block_hash].0;
         //if bead entry already exists in the current ancestor mapping
         if let Some(current_bead_ancestors) = ancestors.get_mut(&current_block_idx) {
             current_bead_ancestors.clear();
@@ -964,29 +998,29 @@ pub mod consensus_functions {
         b: usize,
         dwork: &HashMap<usize, BigUint>,
         awork: &HashMap<usize, BigUint>,
-    ) -> Result<Ordering, BraidError> {
+    ) -> Ordering {
         if dwork[&a] < dwork[&b] {
-            return Ok(Ordering::Less);
+            return Ordering::Less;
         }
         if dwork[&a] > dwork[&b] {
-            return Ok(Ordering::Greater);
+            return Ordering::Greater;
         }
 
         if awork[&a] < awork[&b] {
-            return Ok(Ordering::Less);
+            return Ordering::Less;
         }
         if awork[&a] > awork[&b] {
-            return Ok(Ordering::Greater);
+            return Ordering::Greater;
         }
 
         if a > b {
-            return Ok(Ordering::Less);
+            return Ordering::Less;
         }
         if a < b {
-            return Ok(Ordering::Greater);
+            return Ordering::Greater;
         }
 
-        Ok(Ordering::Equal)
+        Ordering::Equal
     }
     /// Computes the **highest-work path** in the Braid DAG.
     ///
@@ -1044,9 +1078,8 @@ pub mod consensus_functions {
         //getting the maxima out of the genesis beads
         let max_gensis_bead = genesis_beads
             .iter()
-            .max_by(|a, b| bead_cmp(**a, **b, &descendant_work_braid, &ancestor_work).unwrap())
-            .ok_or(HighestWorkBeadFetchFailed)
-            .unwrap();
+            .max_by(|a, b| bead_cmp(**a, **b, &descendant_work_braid, &ancestor_work))
+            .ok_or(HighestWorkBeadFetchFailed)?;
         //populating the highest work path with indices representing the beads involved from the
         //entire braid for computation of highest work path
         let mut highest_work_path: Vec<usize> = vec![*max_gensis_bead];
@@ -1062,9 +1095,9 @@ pub mod consensus_functions {
             //getting the maximum via comparator
             let max_bead = current_bead_children_set
                 .iter()
-                .max_by(|a, b| bead_cmp(**a, **b, &descendant_work_braid, &ancestor_work).unwrap())
-                .ok_or(HighestWorkBeadFetchFailed)
-                .unwrap();
+                // Unwrap is infalliable so can be used here
+                .max_by(|a, b| bead_cmp(**a, **b, &descendant_work_braid, &ancestor_work))
+                .ok_or(HighestWorkBeadFetchFailed)?;
             highest_work_path.push(*max_bead);
         }