iframe-proxy

Sansh2356 · 2025-12-06T16:45:35Z

Currently the orphan beads were not being persisted in DB leading to foreign key violation and causing error in subsequent bead propagation .
This PR adds the functionality for connecting the Braid with the db_handler using db_tx and thus persisting the beads if any present in orphan buffer as soon as all of its parents have been received .
It also removes request in BeadSync for the beads whose parents have not yet been received i.e. it is orphan bead which was redundant in nature causing unnecessary utilization of bandwidth .
Changes verbosity of logs and updating the tests accordingly .

The above was initial though but over the discussions me @mcelrath arrived at a conclusion that tight coupling b/w DB and Braid is not required and must be kept as separated as possible .

Removal of locks passed on for Braid into main thread only reducing the causes as well as checking of potential race conditions arising eventually leading to deadlocks.
Orphan persistence using the simple length check instead of anything else .
Removal of Timestamp based checking for IBD for the purpose of connecting DAG after receiving beads from sync nodes as explained under Refactor IBD #306 and ibd_manager moving into peer_manager.
The mining condition is to be moved into stratum component instead depending dynamically over Orphan-Occupancy above certain threshold alpha defined as latency param which will eventually done in forth-coming PR and adding batched insertions during IBD.
This also adds IBD retry to be initiated per request basis for respective timeouts to switch between sync peers to continue IBD from the previous state.
Adding ibd_flag for preventing downstream connections.
Replacing the Arc<Mutex<T>> wrapping around db connection pool to avoid unnecessary locking along with the clearing IBD buffers in case of stale or dropped and retried requests and clearing buffer after ibd is completed.
It also adds batched insertions along with sequential insertions for both orphan beads as well as the parent beads.

mcelrath

This PR creates a circular dependency, Braid <-> DBHandler.

In main.rs:517 around AddBeadStatus::BeadAdded we are writing new beads to the DB on a successful extend (which will automatically also add orphans to the braid if possible). So all we really need to do is update main.rs to save not only the new bead, but instead all new beads in the braid since the last save.

For instance, Before calling braid_data.extend(&bead) at main.rs:477, save let braid_prev_len = braid_data.beads.len() and then when writing to the DB, write all beads between braid_prev_len and the new braid_data.beads.len().

Copilot

Pull request overview

This PR addresses orphan bead handling and database persistence by decoupling the Braid structure from direct database operations. The changes simplify the architecture by removing the ibd_manager module and moving Initial Block Download (IBD) logic into the peer_manager, while implementing proper orphan bead persistence when all parents become available.

Key changes include:

Removal of ibd_manager module and migration of IBD state management to peer_manager
Decoupling SwarmHandler from Braid to reduce lock contention and architectural complexity
Implementation of orphan bead detection and persistence by tracking braid height changes during extension

Reviewed changes

Copilot reviewed 10 out of 10 changed files in this pull request and generated 18 comments.

Show a summary per file

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

mcelrath

Overall, this seems overly complex to me. I don't understand why prepare_bead_tuple_data takes so many arguments, its job is just to make json tuples for insert. Why does it take so many arguments?

Likewise InsertBeadSequentially should probably just be called InsertBeads and it should take a Vec<Bead>. Where they need to get things like BeadIdx, why just not pass in a reference to the Braid?

zaidmstrr

I reviewed this PR and found some areas of improvement and gave some suggestions. You are free to discuss them below.

…ls in BeadSync

…hecks into peer manager module changing insert bead function signature changing verbosity of ibd logs

…rebase removing typo removing not needed file

chore: rebasing over dev resolving conflicts in lockfile

…ntinue in db_handlers Currently the buffers being kept for ibd should be drained before retry and replaced at each retry and similarly if the ibd gets completed the in-memory data can be dropped. Removing the continue branches from db_handlers in place of concrete fallible error types in case any of the persistance mapping transaction is rollbacked or in case of error preventing inconsistent and unnecessary further iteration of remaining beads in case of both orphan and non-orphand beads.

…ms,logs This commit removes the Arc<Mutex<T>> locking around Connection Pool from sqlx since the inner type is already Arc<T> which further is wrapped at granular level to provide interior mutability thus is both Send+Sync and it removes the logging loop in batch insertion which was being used for testing and adding the check for duplicate bead that are received during the floodsub propagation

… in case of failure or timeout This adds a ibd_complete atomic flag share between stratum server in main swarm loop that will prevent the mining connections from downstream miners until IBD is completed. It also modifies peer_manager module to add request monitoring in case of timeout or in-between peer is disconnected .

…nsertions This removes the holding of locks in bead_sync loop and reducing the contention between locks, along with that it also improves upon the existing bulk insertion method in which if the threshold of BATCH_SIZE is reached then it chunks into min batch size and insert each chunk. It also changes the prototyping of value serialization function in db_handlers.rs to reduce the round-trip between serde and concrete value and removing unused params of functions such as in SwarmHandler and removing oneshot for sending intermediate data to peer manager required for bead_sync.

… overhead We already had batches based bead fetching on the basis of beadhashes, but the beadhashes were not batched leading to potential memory overhead during the initial `GetBeadsAfter` call. In this we limit the call of beadhashes to batch size and changes in `Codec` implementation to take the buffer instead of usize::MAX to the framesize to limit the req/resp call. chore(ibd): Redoing some comments and updating test in db handler

zaidmstrr

I found some possible issues that needs to taken a look. While the reviewing process is still going on from my side. Until then you can look at the issues I have found.

zaidmstrr · 2026-06-05T13:58:52Z

+
+    /// Record an in-flight IBD request to `peer_id`. Called immediately after
+    /// `bead_sync.send_request(...)` returns its `OutboundRequestId`.
+    pub fn set_ibd_inflight(&mut self, peer_id: PeerId, request_id: OutboundRequestId) {


The function has no guard to hold the correct invariant. Thus, can include the possible race conditions. Also, this is called in many places inside main.rs under independent code blocks.

zaidmstrr · 2026-06-05T14:06:28Z

                // Try to retrieve the parent
                //This is not required if a bead exists in DB it would already been extended to local braid as well
                // Parent not found and can't be retrieved
                self.orphan_beads.push(bead.clone());


The orphan_beads Vec is an unbounded buffer and has no checks on the capacity limits. Any malicious peer can send any number of malformed beads with unknown parents and can crash the buffer with OOM.

zaidmstrr · 2026-06-05T15:22:07Z

+    let mut ibd_initiated = false;
+
+    // Flag to indicate IBD completion - prevents miner connections until synced
+    let ibd_complete = Arc::new(AtomicBool::new(false));


The variable is never set to false after being used or setting it to true. Which can introduce unexpected behaviour later in the code.

Copilot

Pull request overview

Copilot reviewed 18 out of 20 changed files in this pull request and generated 11 comments.

+                        // Trigger IBD when peer count threshold is reached
+                        {
+                            let  peer_manager = peer_manager_arc.write().await;
+                            if !ibd_initiated && peer_manager.num_connected_peers() >= MIN_PEERS_FOR_IBD {
+                             info!(
+                                 peer_count = peer_manager.num_connected_peers(),
+                                 threshold = MIN_PEERS_FOR_IBD,
+                                 "Peer threshold reached, initiating IBD"
+                             );
+                             match swarm_command_sender.send(SwarmCommand::InitiateIBD).await {
+                                 Ok(_) => {
+                                     ibd_initiated = true;
+                                     info!("IBD trigger sent based on peer count");
+                                 }
+                                 Err(error) => {
+                                     error!(error=?error, "Failed to send IBD initiation command");
+                                 }
+                             }
+                         }
+                        }


+                                    let next_batch_offset = match peer_manager_arc
+                                        .write()
+                                        .await
+                                        .next_batch_offset(peer, IBD_BATCH_SIZE)
+                                    {


+                                        let req_id = swarm.behaviour_mut().request_beads(peer, &pruned_beads[next_batch_offset..(next_batch_offset+IBD_BATCH_SIZE)].to_vec());
+                                        peer_manager_arc.write().await.set_ibd_inflight(peer, req_id);


+                                        let req_id = swarm.behaviour_mut().request_beads(peer, &pruned_beads[next_batch_offset..].to_vec());
+                                        peer_manager_arc.write().await.set_ibd_inflight(peer, req_id);


+                                    // Initiate `GetBead` request cycle before taking the peer_manager lock,
+                                    // then batch handle_update_incoming + set_ibd_inflight into one acquire.
+                                    let req_id = if pruned.len() <= IBD_BATCH_SIZE {
+                                        swarm.behaviour_mut().request_beads(peer, &pruned)
+                                    } else {
+                                        swarm.behaviour_mut().request_beads(peer, &pruned[0..IBD_BATCH_SIZE].to_vec())
                                    };
-                                    // Initiating `GetBead` request cycle
-                                    if pruned_ref.len() <= IBD_BATCH_SIZE{
-                                        swarm.behaviour_mut().request_beads(peer, &pruned_ref);
-                                    }
-                                    else{
-                                        swarm.behaviour_mut().request_beads(peer, &pruned_ref[0..IBD_BATCH_SIZE].to_vec());
+                                    {
+                                        let mut peer_manager = peer_manager_arc.write().await;
+                                        peer_manager.handle_update_incoming(peer, pruned);
+                                        peer_manager.set_ibd_inflight(peer, req_id);


+                        let mut peer_manager = peer_manager_arc.write().await;
+                        let active = peer_manager.take_ibd_inflight_if_matches(&peer, request_id);
+                        if active {
+                            peer_manager.handle_update_retry_count(peer);


+                             let mut peer_manager = peer_manager_arc.write().await;
+                             let was_ibd = peer_manager.take_ibd_inflight_for_peer(&peer_id);
+                             if was_ibd {
+                                 peer_manager.handle_update_retry_count(peer_id);


+    pub fn load_from_config_file(path: &str) -> Result<BraidpoolConfig, ConfigError> {
+        let contents = fs::read_to_string(path).map_err(|e| ConfigError::TomlParseError {
+            error: e.to_string(),
+            path: path.to_string(),
+        })?;


+                                    {
+                                        let mut peer_manager = peer_manager_arc.write().await;
+                                        peer_manager.handle_update_ibd_peer_tips(peer, tips.0);
+                                        peer_manager.set_ibd_inflight(peer, req_id);
                                    }


+                                        if retry_cnt > 0 {
+                                            peer_manager.handle_update_retry_count(lowest_latency_peer);
                                        }


mcelrath · 2026-06-05T18:46:37Z

This report summarizes the open findings from the re-review after rebasing onto the updated upstream.

Security | High | node/src/main.rs:901 – Unbounded GetAllBeads response. Any peer can request the full DAG, which clones and serializes all beads. Impact: peer-triggered CPU/RAM exhaustion and outbound bandwidth spikes. Fix: remove or gate GetAllBeads, use paged GetBeadsAfter only, and enforce a hard response-size cap before encoding.

Bob's take: valid. Use GetBeadsAfter only with paging. Add a config setting which limits the number of simultaneous peers we will serve IBD to. (Bitcoin uses 8 "full relay" peers)

Database | High | node/src/main.rs:1007 – Duplicate inserts in batch. removed_orphans and beads_to_insert are concatenated without de-duplication, so resolved orphans can appear twice. Impact: Bead PK/UNIQUE violations and full batch rollback, stalling IBD. Fix: de-dup by BeadHash before batching (preferred) or use INSERT OR IGNORE with guarded dependent inserts.

Bob's take: valid. IMHO the whole flow is overly complex. You have three data structures representing "beads to be added" (beads_to_insert, removed_orphans, and InsertBeadSequentially from floodsub). Ideally there should be just ONE interface, InsertBeads(Vec<Bead>) Also consider using an automatically de-duped data structure like HashSet or HashMap.

Performance | Critical | node/src/main.rs:607/1007 – Orphan-tail cloning under braid write lock. Per-bead cloning of orphan tail and bead-index mapping occurs under the write lock, producing O(n^2) work. Impact: long lock holds and latency spikes as DAG grows. Fix: avoid tail cloning per bead; have braid return an explicit resolved-orphans set and process outside the write lock.

Bob's take: valid. The simplest fix to this is to have extend() return the list of beads added including any resolved orphans, rather than trying to guess about orphans after the fact. (main.rs:589 and main.rs:988)

Performance | High | node/src/braid/mod.rs:197 – O(n^2) orphan processing. process_orphan_beads removes from a Vec and recurses, repeatedly scanning/shifting. Impact: quadratic time on large orphan backlogs. Fix: use a queue (VecDeque) plus lookup (HashSet/index map), or an iterative retain/partition pass.

Bob's take: This is #299 territory, those algorithmic improvements need to be a separate PR and should be fixed there.

Performance | Medium | node/src/db/db_handlers.rs:539 – N+1 orphan reinserts. InsertBeadSequentially reinserts removed orphans one-by-one with serialization and DB I/O. Impact: sync lag for large orphan tails. Fix: batch orphan reinserts using the bulk insert path.

Bob's take: valid. Build a vector and use InsertBeadsBatch instead. Sequential inserts in SQL is very slow compared to batch inserts.

Rust | High | node/src/main.rs:282 – expect on behaviour creation. BraidPoolBehaviour::new(...).expect(...) panics on startup failures. Impact: non-recoverable crash instead of error propagation. Fix: return/propagate the error (e.g., map to io::Error).

Bob's take: valid. Simple fix.

Rust | Medium | node/src/main.rs:1469 – expect on hardcoded targets. Parsing "1d00ffff" uses expect. Impact: runtime panic if parsing changes. Fix: use CompactTarget::from_consensus(0x1d00ffff) or handle the Result.

Bob's take: valid. Just switch to CompactTarget::from_consensus() instead. Simple fix. Correct fix is correctly deferred with the explicit TODO.

Rust | Medium | node/src/uncommitted_metadata/mod.rs:23 – Default signature expect. Default metadata parses a hardcoded signature with expect. Impact: runtime panic if constant changes or parse fails. Fix: use pre-validated constant bytes or a fallible constructor.

Bob's take: this is explicitly deferred functionality. Just add a TODO here too.

Rust | Medium | node/src/committed_metadata/mod.rs:95 – Default pubkey expect. Default metadata parses a hardcoded pubkey with expect. Impact: runtime panic in default construction. Fix: use pre-validated constant bytes or a fallible constructor.

Bob's take: same as above, just add a TODO here.

Rust | Medium | node/src/utils/mod.rs:84 – create_test_bead in production module. Public function uses test-only constants and expect. Impact: accidental prod usage with panic paths. Fix: move under #[cfg(test)] or into utils::test_utils.

Bob's take: valid. This should be part of the test framework under #[cfg(test)]

Architecture | Medium | node/src/main.rs:607 – Orphan persistence inferred via slice. Resolved orphans are inferred from beads[bead_id+1..], coupling main to braid internals. Impact: misidentified resolved orphans and fragile persistence logic. Fix: have braid return an explicit resolved_orphans set.

Bob's take: same as #3.

Architecture | Medium | node/src/db/db_handlers.rs:599 – DB insert failures not propagated. Insert errors are logged and dropped. Impact: in-memory braid can diverge from DB silently. Fix: propagate errors to sync logic and retry/backpressure or fail the batch.

Bob's take: valid. Return Err from the handler and have the caller apply backpressure or retry or crash loudly. (e.g. pause IBD if the error is transient). This is a correctness issue. We can't allow the db to diverge from the in-memory representation under any circumstances. It becomes an immediate consensus failure.

Architecture | Medium | node/src/main.rs:980 – IBD orchestration split across main and PeerManager. Sync logic lives in main while state lives in PeerManager. Impact: tighter coupling and harder testing of IBD flow. Fix: reintroduce an IBD manager/state machine with explicit APIs.

Bob's take: This is probably the biggest issue with this PR. PeerManager holds IBD‑specific state (cached bead queues, inflight request tracking, offsets, reset logic), while main.rs drives the actual IBD flow: initiating IBD, validating responses, computing next batch offsets, sending next requests, and handling error paths (disconnect, reset, retry). This means you can't reason about the IBD lifecycle in a single place, and it makes unit testing almost impossible (requiring a full swarm event loop). This has implicit coupling: main has to know how PeerManager's internal IBD fields behave and what resets are required. (more below)

Cryptography | Low | node/src/main.rs:1469 (and metadata defaults) – Placeholder pubkey/signature/targets. Mining broadcast still uses hardcoded pubkey/signature and fixed targets. Impact: not spec-compliant; unsafe to treat as production-ready. Fix: wire to configured miner pubkey, real signatures, and targets derived from difficulty.

Bob's take: explicit future work. Add TODO's where appropriate so we find the right sites when this is implemented in a follow-on PR.

I think I may have made the suggestion to deprecate ibd_manager and I think it was a mistake (sorry) and the AI is right on this. Here's some concrete suggestions:

IBDManager should own only paging/requests/retries/inflight state. It should not parse/validate/insert beads. Add systematic unit tests for IBDManager. This will remove most of the issues around requiring the entire Swarm to test and make it easier to review and merge.
Create a new ingest_beads() function that handles validation, braid extension, orphan resolution, DB insert, and scoring. It becomes a one-shot, if it doesn't error, memory and DB are consistent and we're in consensus. If it does, it needs either retry logic or a loud failure and a crash. The application cannot reliably continue.
Delete GetAllBeads and use only GetBeadsAfter with paging. Delete InsertBeadSequentially and use only InsertBeadsBatch that takes a vector.
extend() should return the inserted beads.
Centralize peer scoring inside ingest_beads(). Right now it's split across floodsub and IBD handlers. Compute invalid/added counts once in the ingest path and update the score there.
Do DB and scoring work outside the Braid lock.

Tests binding fixed ports (3353, 3356, 3357, 3358, 5050) caused AddrInUse failures when tests ran concurrently or a previous test left a server listening. This was a known flake documented across multiple PRs (braidpool#309, braidpool#474). Add bound_addr_tx: Option<oneshot::Sender<SocketAddr>> to run_stratum_service. After binding, the actual address is sent through the channel so tests can connect to the real port. All 5 tests now use port 0 (OS-assigned) and await the oneshot receiver before connecting, no sleep needed, no race window. Production call in main.rs passes None.

…477) * fix(tests): replace hardcoded stratum ports with OS-assigned port 0 Tests binding fixed ports (3353, 3356, 3357, 3358, 5050) caused AddrInUse failures when tests ran concurrently or a previous test left a server listening. This was a known flake documented across multiple PRs (#309, #474). Add bound_addr_tx: Option<oneshot::Sender<SocketAddr>> to run_stratum_service. After binding, the actual address is sent through the channel so tests can connect to the real port. All 5 tests now use port 0 (OS-assigned) and await the oneshot receiver before connecting, no sleep needed, no race window. Production call in main.rs passes None. * fix: use actual bound port in stratum endpoint logging server_endpoints and the warning log were using self.stratum_config.port which shows 0 when OS port assignment is used. Switch to bound_addr.port() so logs always show the real listening port.

Sansh2356 requested review from mcelrath and zaidmstrr December 6, 2025 16:45

Sansh2356 closed this Dec 6, 2025

Sansh2356 reopened this Dec 8, 2025

Sansh2356 marked this pull request as draft December 8, 2025 07:07

mcelrath requested changes Dec 10, 2025

View reviewed changes

Sansh2356 marked this pull request as ready for review December 15, 2025 12:29

Sansh2356 requested a review from mcelrath December 15, 2025 12:31

mcelrath requested a review from Copilot December 19, 2025 14:51

Copilot started reviewing on behalf of mcelrath December 19, 2025 14:51 View session

Copilot AI reviewed Dec 19, 2025

View reviewed changes

mcelrath requested changes Dec 19, 2025

View reviewed changes

Comment thread node/src/db/db_handlers.rs

Comment thread node/src/db/mod.rs Outdated

Comment thread node/src/db/mod.rs Outdated

mcelrath marked this pull request as draft December 19, 2025 19:11

Sansh2356 mentioned this pull request Dec 20, 2025

Roadmap #147

Open

37 tasks

Sansh2356 force-pushed the orphan-bead-handling branch from 92717d9 to 35ca7bc Compare December 22, 2025 06:52

Sansh2356 marked this pull request as ready for review December 22, 2025 16:56

Sansh2356 force-pushed the orphan-bead-handling branch 2 times, most recently from 493d099 to a35e079 Compare December 26, 2025 18:38

Sansh2356 mentioned this pull request Dec 28, 2025

Refactor IBD #306

Open

Sansh2356 force-pushed the orphan-bead-handling branch from a35e079 to 64690f7 Compare January 9, 2026 07:26

Sansh2356 mentioned this pull request Jan 9, 2026

rpc:enhancement and braidpool-cli addition #333

Merged

Sansh2356 force-pushed the orphan-bead-handling branch from 64690f7 to 3ea09ef Compare January 26, 2026 16:28

zaidmstrr reviewed Feb 12, 2026

View reviewed changes

Comment thread node/src/peer_manager/mod.rs Outdated

Comment thread node/src/peer_manager/mod.rs Outdated

Comment thread node/src/db/db_handlers.rs

Sansh2356 force-pushed the orphan-bead-handling branch from fdc819d to 633c8fc Compare March 25, 2026 17:10

Sansh2356 requested a review from priyashuu as a code owner March 25, 2026 17:10

Sansh2356 requested review from mcelrath and zaidmstrr March 25, 2026 17:11

Sansh2356 force-pushed the orphan-bead-handling branch from 633c8fc to e0109fc Compare March 25, 2026 17:14

Sansh2356 force-pushed the orphan-bead-handling branch 2 times, most recently from 5d2e2bd to c17b3e7 Compare April 11, 2026 09:34

Sansh2356 force-pushed the orphan-bead-handling branch from ec8668f to e9b1596 Compare May 12, 2026 21:23

Sansh2356 force-pushed the orphan-bead-handling branch from b754a6b to 9116335 Compare June 4, 2026 05:09

Sansh2356 added 16 commits June 4, 2026 10:41

fix: Persisting orphan beads in DB and removing redundant request cal…

bd0f4f9

…ls in BeadSync

refactor: removing braid atomic refs for locking in main thread

e98b056

feat: orphan beads persisted without tight coupling

f2ed9ce

removing ibd_manager and timestamp based checking in favour of sync c…

e5f7bb7

…hecks into peer manager module changing insert bead function signature changing verbosity of ibd logs

adding batched insertions along with reducing insertion logic redundancy

4c9c822

separating raw batch-query to sub-queries and adding test for batch

59bc587

removing original master head to adapt current branch changes during …

4fc4f16

…rebase removing typo removing not needed file

removing GetParents call immediately after orphan_bead is received

15feaeb

changing verbosity of logs and formation

8404821

adding more error types and removing unwanted unwraps

8284ef3

fix(typo): removing commented logs and fmt check

f01748e

chore: rebasing over dev resolving conflicts in lockfile

Sansh2356 force-pushed the orphan-bead-handling branch from 9116335 to 7832048 Compare June 4, 2026 05:13

zaidmstrr reviewed Jun 5, 2026

View reviewed changes

mcelrath requested a review from Copilot June 5, 2026 16:03

Copilot started reviewing on behalf of mcelrath June 5, 2026 16:03 View session

Copilot AI reviewed Jun 5, 2026

View reviewed changes

Sansh2356 closed this Jun 5, 2026

nkatha23 mentioned this pull request Jun 8, 2026

Fix(tests): replace hardcoded stratum ports with OS-assigned port 0 #477

Merged

Sansh2356 mentioned this pull request Jun 14, 2026

Updating db handlers for orphan insertions and batched queries #478

Open

File	Description
node/src/main.rs	Removes IBD manager initialization, adds orphan bead detection logic based on braid height differences, moves bead propagation logic into SwarmCommand handler
node/src/lib.rs	Removes `propagate_valid_bead` method from SwarmHandler, simplifies SwarmCommand enum to use PropagateMinedBead variant
node/src/stratum.rs	Updates mined bead propagation to send SwarmCommand instead of calling SwarmHandler directly, removes IBD flag checks from connection acceptance
node/src/peer_manager/mod.rs	Adds IBD-related state tracking (tips, batch offsets, retry counts) to PeerInfo, implements handler methods for IBD state management
node/src/db/mod.rs	Changes InsertTupleTypes to pass full bead data structures instead of pre-computed JSON strings
node/src/db/db_handlers.rs	Moves `prepare_bead_tuple_data` into DBHandler impl, adds orphan bead insertion loop, makes DB_CHANNEL_CAPACITY public
node/src/ibd_manager/mod.rs	Entire module deleted as functionality moved to peer_manager
node/src/braid/mod.rs	Adds logging for orphan bead processing, removes Serialize/Deserialize derives
node/src/braid/tests.rs	Updates test signatures to async/await, fixes function name typo
node/src/rpc_server.rs	Removes blank line (whitespace cleanup)

		let req_id = swarm.behaviour_mut().request_beads(peer, &pruned_beads[next_batch_offset..(next_batch_offset+IBD_BATCH_SIZE)].to_vec());
		peer_manager_arc.write().await.set_ibd_inflight(peer, req_id);

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Conversation

Sansh2356 commented Dec 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

mcelrath left a comment

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

mcelrath left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

zaidmstrr left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

zaidmstrr left a comment

Choose a reason for hiding this comment

Uh oh!

zaidmstrr Jun 5, 2026

Choose a reason for hiding this comment

Uh oh!

zaidmstrr Jun 5, 2026

Choose a reason for hiding this comment

Uh oh!

zaidmstrr Jun 5, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

mcelrath commented Jun 5, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Sansh2356 commented Dec 6, 2025 •

edited

Loading