Transit Fabric releases

Taken from the Transit Fabric source repository at commit 91be12e (91be12ef98b775c7f045124e6b8c686c15439650, main), file docs/threat-model.md. Links into the private source tree are shown as plain text. Raw Markdown · Red-team pack In this page only, the table header is repeated above the rows that follow the paragraph in the middle of the table, so they render as table rows.

Threat model

Assume every miner is rational and adversarial, some validators are lazy or colluding, and the subnet owner is trusted only as far as the published code.

# Attack Who Mitigation Spec Sim / Unit test
T1 Declare capacity you don't have (including tolerance-band overclaiming) Operator Unpredictable capacity tests; inside CAP_TOLERANCE_PPM verified capacity is capped at min(declared, measured) (verified_capacity_mbps); outside tolerance OVERCLAIM_PENALTY_PPM haircut applies capacity-bonds.md overclaimer, adversarial_parameter_sweeps
T2 Serve canaries well, drop or degrade real traffic Operator Canaries padded and classed like paid traffic; client receipts receipts.md, measurement.md canary_only
T3 Generate your own traffic to farm usage Operator Only assigned paths and canaries count; unpaid self-traffic is free at best; client receipts required for paid receipts.md self_dealer
T4 Inflate byte counters or self-sign loop receipts Operator Co-signed hop receipts (up != down, verify_strict); ReceiptBook counter-proposals; verify_path_chain across neighbors receipts.md chain_check_and_monotonic_selection
T5 Split one box into many nodes or UIDs (sybil) Operator Dedupe by /64, /24, ASN; coverage paid once per group; capacity tests measure the shared pipe; proportional_ppm preserves <1 ppm active UIDs before apply_share_cap identity.md, scoring.md sybil_splitter, test_share_cap
T6 Fake geography for coverage bonuses Operator RTT triangulation from several vantage points; speed-of-light bounds measurement.md —
T7 Solver copies the leader's or reference solver's table Solver Commit-reveal; incumbent margin EPSILON_ROUTE; non-reference copycats within EPSILON_ROUTE of the reference solver's score or duplicating an earlier solver's gains_ppm profile are disqualified routing.md, scoring.md test_mech1_scoring_and_red_team_guards, mech1_red_team_solver_attacks, unearned_weight_to_owner_hotkey, unearned_weight_goes_to_the_first_party_uid, unearned_weight_without_a_first_party_uid_is_reported_not_assigned
T8 Solver colludes with operators or manipulates est_us (predicted_us) Solver + operator Usage concentration cap; sampled testing of paths; churn penalty; predicted_us computed deterministically from snapshot (route_predicted_us), never from solver est_us scoring.md, routing.md shortest_path_works, mech1_red_team_solver_attacks
T9 Validator copies others' results (weight copying) Validator Commit-reveal of probe results; Bittensor commit-reveal for weights measurement.md http_object_reveal_and_receipt_upload_roundtrip
T10 Validators disagree honestly and get clipped by Yuma Validator Score from pooled lower-median results, not private views measurement.md test_lower_median, end_to_end_multi_validator_tempo_determinism
T11 Owner farms its own mechanism Owner Reference solver's share (winner or runner-up), all-negative solver rounds and a Mechanism 0 with nothing earned are unearned weight: it goes to the disclosed first-party UID (TempoInput::first_party_uid, under a separate coldkey), never an owner-coldkey hotkey or a burn UID (retired, Task 15). With no first-party UID it is assigned to nobody and reported as TempoOutcome::unearned_ppm, and the live loop refuses to submit scoring.md §Unearned weight and the first-party UID test_mech1_scoring_and_red_team_guards, mech1_red_team_solver_attacks
T12 Abuse traffic exits through operators User Transit operators never egress (ForwardingTable drops non-fc00::/8 on non-exits); exits only via registered exit partners (ADR-0004) and registered gateways (ADR-0052) with abuse handling ADR-0004, datapath.md forwarding_enforces_adr0004_and_multi_hop_counters_and_receipts
T13 Probe agent IPs fingerprinted, canaries recognized Operator Rotate probe source IPs; route canaries through ingress nodes like real traffic measurement.md —
T14 MITIGATED (Pass-5 CRY-1, ADR-0023): node-key node-consent required; unconsented claims ignored, not quarantined; run_tempo uses resolve_live_bindings_with_consent. Was: Binding-conflict griefing: a UID lists competitors' public node keys in its own hotkey-signed NodeBinding, so those nodes are quarantined ("counts for neither") and their owners lose all capacity and usage credit Operator None today: NodeBinding carries no node-key consent. Proposed fix: require a per-node consent signature (node key signs (netuid, hotkey, not_before, not_after) under a new domain) and ignore unconsented entries instead of quarantining identity.md, identity::resolve_live_bindings — (proposed binding_griefer)
T15 MITIGATED (Pass-5 SCR-1): share cap always applies; a UID can at most double its own share from redistributed excess (USAGE_CAP_REDIST_MULT_PPM); sim dust_cap_harvester. Was: Share-cap dust capture: when an attacker adds dust UIDs (≥1 ppm of usage) to bring active usage UIDs to ≥ ⌈1e6/cap⌉, apply_share_cap water-fills the whale's clipped excess into the dust UIDs (4 active UIDs at a 25% cap means every UID ends at 250_000) Operator None today. The test_share_cap cases assert this outcome. Proposed fix: burn clipped excess, or never raise a UID above its uncapped share times PPM/(PPM-excess) scoring.md §Concentration cap, scoring::apply_share_cap test_share_cap (shows the behavior; proposed dust_cap_harvester)
T16 PARTIALLY MITIGATED (Pass-7: attested free). Residual, shared-hop coverage capture (ADR-0037, fix round 1): hop receipts carry no class, so pass 2 can fill an attacker route's client coverage with other flows' bytes on a hop it shares with them. With trusted vouchers, paid on the attacker's route is at most min(Q, smallest shared-hop total) for voucher quota Q, so the gain is at most 0.5 * (1 + RECEIPT_TOLERANCE_PPM) weighted credit per voucher byte, 0.5 * Q * (1 + tol) (re-derived by the red team, ADR-0037 fix round 4; sim shared_hop_coverage_capture, bounded there, measures 0.5 Q). With an empty allowlist only the hop totals bound it, so a non-empty trusted_issuers (or another way of choosing trusted issuers) is a mainnet launch requirement (scoring.md parameter table). With trusted_voucher_issuers set, validators credit free bytes on a route only up to client receipts that the trusted egress itself uploaded for that (ingress, egress) pair, minus paid coverage (receipts.md §Attested free; sim unattested_free_fabricator: 1 TiB fabricated free earns 0). The daemon now loads the issuer allowlist and vouchers (M4-07). Still OPEN: an allowlisted exit can attest arbitrary free bytes (a trust residual, bounded by W_FREE and the per-hop capacity cap); with the policy on, free on pairs that do not end at a trusted exit earns nothing (OQ-23); the policy is off when the allowlist is empty. Pass-6 status: PARTIALLY MITIGATED (Pass-5 SCR-11; Pass-6 TV-28): credited bytes per hop capped at verified capacity x window duration; sim closed_loop_fabricator. Pass-6: with TempoInput::trusted_voucher_issuers set, paid coverage per (client, egress) is capped by trusted-issuer voucher quota (issuer = egress) and uncovered paid bytes become free; node side BWOS_TRUSTED_VOUCHER_ISSUERS (vpn::check_trusted_voucher) refuses paid sessions without a trusted voucher. Still OPEN: crediting free bytes only with issuer-attested client receipts; the daemon does not yet feed the registry (M4-07). Was: Fabricated bytes on an assigned path where the attacker controls every node: demand pairs are every measured direct pair, so routes between an attacker's own nodes (in different UIDs) get assigned. Co-signing and the chain check prove nothing when one party controls both ends, so credit is bounded only by MAX_CLIENT_BYTES_PER_WINDOW (100 TiB) per hop and class Operator (2+ UIDs, incl. ADR-0022 private fabric opt-in) None today. Proposed fix: cap credited hop bytes at min(link avail_mbps, node verified caps) * window_secs / 8; credit free only with issuer-attested client receipts; do not build demand pairs whose src and dst are both unconsented same-owner nodes receipts.md, measurement.md, validator::ingest_and_verify_receipts_with_failover — (proposed closed_loop_fabricator)
T17 PARTIALLY MITIGATED (Pass-5 SCR-9/SCR-10; residual is T23): Mechanism 1 scores a trimmed mean (GAIN_TRIM_TOP_PPM), no Mechanism 0 credit on negative-gain routes, each byte credited once per path; sim bottom_half_self_dealer. Was: Lower-median self-dealing: a winning solver can reroute up to ⌊(n-1)/2⌋ of its lowest-gain demand pairs (e.g., ones that should go direct) onto paths of up to 16 nodes through its own operator UIDs without changing lower_median(gain_p). Each interior node is credited for both adjacent hops (2× bytes) Solver + operator None today. Proposed fix: score with a trimmed mean or a low quantile (e.g., p10) instead of the median; give mech0 usage credit only for pairs with gain_p >= 0; credit each flow once per path, not per node-hop scoring.md §Mechanism 1, validator::evaluate_solver_table — (proposed bottom_half_self_dealer)
T18 MITIGATED (Pass-5 SCR-2/SCR-3): missing probes and capacity tests count as failures; failed capacity tests record 0 Mbps; sim probe_dodger. Was: Unmeasured means perfect: compute_uptime_ppm(&[]) = 1e6 and Q_n defaults to PPM, and links with rtt<=0 are dropped from the next snapshot. A node that blackholes link probes (while still answering capacity tests, which it learns about one block ahead) drops out of the snapshot and then keeps A_u = 1e6 and full capacity credit with zero transit obligation Operator None today. Proposed fix: compute uptime over every live node's scheduled probes, count a missing measurement as a failure, and give A_u = 0 to a node with no snapshot links measurement.md §Uptime, probe::compute_uptime_ppm, validator::run_tempo — (proposed probe_dodger)
T19 HEADER PART SETTLED (ADR-0037, proposed); other leaks stand. Overlay links carry plain inner IPv6 with no class on the packet, so a relay has no class byte to read, mask, flip or forge, and hop receipts carry one unsplit total, never per-class counters. A relay that serves canaries well and degrades paid traffic can no longer tell them apart by a header byte or be paid differently per class on its hop (sim class_relabeller). Still OPEN: source address (public probe keys), size/rate profile (datapath.md §Residual leaks), and canary credit, which now has to come from the validators' own records (OQ-17). Canary plans (Task 14, ADR-0051, ADR-0053; not scored until PB-38). Canary-stream timing is no longer public: each validator's timing, sizes and classes come from its own secret plan, committed in its manifest at window open and revealed after the window ends (measurement.md §Canary plans). Which pairs carry how many bytes is a public draw from the committed seed and snapshot, weighted by bounded deduped verified capacity and capped per node, per UID and per path, and every validator's reveal must spend exactly its stake share of every pair. Shaping follows fabric-wide GlobalMarginals only (the default mix until PB-38 or PB-39 adds a producer). Validator-run nodes source and sink the stream and hold its sampling keys. Canary bytes come out of receipt usage and never reach a paid-traffic trigger. What is hidden: within an allocated pair a node can't predict a flow's start, size or class, and guesses on them gain nothing beyond sampling noise (sims canary_favourer, canary_slot_presence). What isn't: the pair (T145), and the packet shape and validator source address (T148). validator_canary_alloc_favour fails its reveal; canary_alloc_node_count_sybil gains nothing per unit of deduped verified capacity, and canary_alloc_uid_split holds one UID to the water-filled cap. Fix round 1 also pins the stake shares and the counting commitment to the seed block, and requires a fresh secret every window. Known residuals, for PB-38 and PB-39: (1) before paid traffic exists every transit flow is a canary, so there is nothing to hide among and only the end-to-end check protects; (2) flows to or from validator-run nodes can be spotted by the node next to them. Also T145 (public allocation pairs), T146 (a validator's plan isn't secret from the validator) and T147 (splitting above the per-node weight cap). The probe schedule for link:, path:, route: and direct: samples stays public. New exposure: a relay's paid/free split now depends on the ends' client receipts and attestation alone (scoring.md §Byte crediting 0). Residuals pinned by sims: shared-hop coverage capture (see T16; at most 0.5 * Q * (1 + tol) weighted with vouchers, shared_hop_coverage_capture), colluding ends claiming a whole path as paid (bounded by the smallest hop total without vouchers and by min(Q, T) with them, end_split_shifter). Hop crediting order (ADR-0037 fix rounds 1-3). Unsplit totals made the greedy crediting pass order-dependent. Fix round 3 replaced it with order-free crediting (scoring.md §Byte crediting 0).

What the sims and tests prove:

Not proved: inflation is now flagged only above the sum of path bottlenecks, which is looser than the greedy pass when paths overlap. With the allowlist the unflagged bytes earn nothing, because coverage and attestation still cap credit. Without it, looser flagging lets a colluding middle pair (b, c) on overlapping paths add up to one path's flow on their hop without owning either end of any path, and those bytes earn W_FREE. This applies only without the allowlist; with it, those bytes earn nothing (T16). Pass-7 status: PARTIALLY MITIGATED (Pass-7, ADR-0026). A 6-bit keyed tag over the class (packet-class-tag) in the upper bits of masked byte 5 rejects at least 63/64 of byte-5 tampers (exhaustive test t19_class_tag_rejects_single_byte5_tamper_exhaustively), so the malleability residual is a 1/64-per-packet guess that only moves credit between classes. Relays forward masked packets without unmasking them and count their bytes in one per-peer total, never the per-class counters behind hop receipts; masked bytes therefore earn no hop credit until hop receipts carry an unsplit total (OQ-17). Other leaks below still stand. Pass-6 status: PARTIALLY MITIGATED (Pass-6, ADR-0024). OverlayPacket::encode_masked blinds header byte 5 with a 2-bit pad keyed by an endpoint-only mask_key (packet-class-mask), so a relay sees the class byte uniform over 0..=3 (t19_*). Masking is opt-in and v0 hop receipts still split canary bytes. Still OPEN: source address (public probe keys), public schedule timing, size/rate profile, flow_id, per-class hop receipts, and malleability (a relay can flip the masked bit to downgrade credit: griefing only) (datapath.md §Residual leaks, OQ-17). Earlier status: OPEN; the payload fix does not close it (red-team re-check). SCR-6 made canary payloads fully random, but the overlay header still carries TrafficClass::Canary (byte 5, dataplane.rs ~L191), which every transit hop reads, and hop receipts count canary bytes separately. A node can serve canaries perfectly and degrade paid traffic. The paid_degrader sim (0.89x) assumes canaries can't be told apart, so it does not test this. Fix needs a wire-format ADR: drop the class byte from the hop-visible header (or encrypt it end to end to the validator), and stop hop receipts splitting canary bytes. Was: Canaries are distinguishable: UDP canaries start with the plaintext magic PIPR and use deterministic SHA-256 padding, and the schedule is public at window open. Transit nodes can serve canaries well and degrade paid traffic (T2/T13 mitigations do not hold) | Operator | Proposed fix: encrypt canary payloads end to end, without a magic prefix or recognizable padding, so they look identical to paid sessions; make the schedule commit-reveal per validator | measurement.md, receipts.md, probe::run_udp_canary_probe | canary_only (assumes indistinguishable canaries, so it does not cover this) |

# Attack Who Mitigation Spec Sim / Unit test
T20 PARTIALLY MITIGATED (Pass-7, ADR-0025). Price floor MIN_VOUCHER_ALPHA_PER_GIB (1_000 raw α/GiB): a voucher backs at most effective_max_paid_bytes = min(max_paid_bytes, alpha_credit_u64 * 2^30 / floor) on nodes (verify_for_session, check_trusted_voucher) and in validator TV-28 quotas; the daemon loads the allowlist and vouchers (M4-07). Still OPEN: the floor applies to the issuer-declared alpha_credit_u64, not a proven burn, and the placeholder value needs calibrating; allowlist governance (OQ-14, OQ-19). Pass-6 status: PARTIALLY MITIGATED (Pass-6, TV-28). Validators with a non-empty trusted_voucher_issuers allowlist only count paid bytes covered by trusted-issuer vouchers, so a self-issuing exit outside the allowlist earns no paid credit (t20_*). Still OPEN: who governs the allowlist (on-chain exit-partner registry), the α price floor, and wiring it into the daemon (M4-07). Earlier status: OPEN (red-team pass 5; design question OQ-14). The issuer can be the attacker's own exit, so a voucher signature check in scoring proves nothing; needs on-chain burn proof or an exit-partner registry. receipts.md no longer claims negative-EV. Vouchers are not enforced in scoring: BandwidthVoucher (burn, max_paid_bytes, window) is checked only by the ingress and exit nodes, which are the attacker. The 5% burn applies to an issuer-chosen alpha_credit_u64 with no price floor, so the "strictly negative-EV" claim does not hold for a self-issuing aggregator in authorized_clients Operator + aggregator Proposed fix: validators require a valid voucher per paid client receipt; enforce minimum alpha_credit_u64 per byte so the burn is at least the expected emission per paid byte; define who governs authorized_clients receipts.md §Vouchers, ADR-0019 —
T21 MITIGATED (Pass-6, after the red team). Probe medians are stake-weighted lower medians (scoring::stake_weighted_lower_median, TempoInput::validator_stakes); zero-stake validators don't vote, and a key is aggregated only if its reporters hold PROBE_STAKE_QUORUM_PPM (1/3) of all validator stake, so minimum-stake sybil validators can neither move a median nor complete one for a key nobody else reported. Residual: colluding validators with ≥50% of reporting stake, or ≥1/3 of stake on keys no one else reports; the count-based quorum fallback (empty validator_stakes) is for sim/localnet only, and testnet MUST supply metagraph stakes; the daemon does not yet load them (M4-07). Earlier status: OPEN (red-team re-check, estimated). Validator-median griefing: probe results are combined by a lower median taken per validator, not per unit of stake (scoring::aggregate), and rtt_us = 0 sorts lowest, so ⌈n/2⌉ colluding (possibly low-stake) validators can fail any link or capacity test. Since SCR-2/SCR-3, those failures cost uptime (squared) and capacity. Validator Stake-weighted lower median with a 1/3 stake quorum per key (OQ-15 closed). measurement.md, scoring.md t21_* (incl. t21_sybil_validators_cannot_complete_median_without_stake_quorum)
T22 PARTIALLY MITIGATED (Pass-7). measurement.md §Probe vantage: validator-run probe agents originate every probe class (link:, direct:, path:, cap:, vantage:), each sample is the agent's own clock timing (no subtraction of an endpoint-delayable leg), samples reach scoring only through the validator-signed ProbeResultBatch, and current_snapshot MUST be the previous tempo's next_snapshot. Still OPEN: the destination of a pair answers direct: probes outside the overlay and can inflate direct_us, raising the gain of routes ending at itself (OQ-16 a); bwos-probe does not run link/direct/vantage probes yet (M4-08). Earlier status: OPEN (red-team re-check). Endpoint-skewed probes: the specs don't say who sends link and direct probes. With 8 path probes per window, most gains come from predicted latencies, so an operator at either end of a pair can make an overlay route look faster than direct. Operator Fix: say in measurement.md which vantage sends each probe class (validator-run probe agents only) (OQ-16). measurement.md —
T23 MITIGATED IN THE LIBRARY (Pass-7, three red-team rounds plus a fourth patch; top_quartile_dealer 1.00x). Mechanism 1: PER_HOP_LATENCY_OVERHEAD_US (500) per interior hop in route_predicted_us and every reference search, and a regret penalty (REGRET_WEIGHT_PPM 1.0x) on the mean per-pair regret over all pairs, trimmed ones included, against a capacity- and class-aware comparator judged on the route's unloaded values (realtime regret is measured on the reference realtime metric lat + loss + hop + 2*jitter, so neither a slower low-jitter nor a faster high-jitter detour is free) (routing::table_route_regrets, scoring::mech1_shares_with_regret). Mechanism 0: a path's credit is zeroed when its route's predicted latency exceeds the comparator by more than ROUTE_REGRET_TOLERANCE_PPM (100_000), averaged over the classes sharing the path; each path pays at most once per UID and per node_diversity group (16 alternating keys: 14/15 -> 1/15 with endpoint data, 2/15 without). Reference-solver tables are never gated (0 of 10,583 routes in a 400-trial scratch run; sim reference_solver_gate 0 of 741). Residual: the production solver can halve an honest relay's credit by adding one regretful class route to its path (needs per-class hop receipts); bulk prefers any wider path within 1.5x direct (ADR-0018); saturation hiding; group dedupe needs validator-supplied node_diversity (OQ-19, OQ-23). Finding 1 (ADR-0037 fix round 4, HIGH, fixed): per-path apportionment divided a shared hop by the sum of its paths' weight bytes, which are bottleneck bounds and can count a neighbour path's bytes, and zeroed the gated paths' portion. So a gated or suppressed path that carried nothing took, and forfeited, honest endpoints' share. Measured: a gated 1-hop beside an honest 2-hop, no allowlist, cost the ingress 50% and the relay 25%; with the allowlist and a forged voucher receipt, the exit lost 50%; n gated paths cut an honest endpoint to 1/(n+1). The denominator is now min(Σ w, credited bytes), so a gated path forfeits only what the hop credited beyond the eligible weight (scoring.md §Byte crediting 7; sim borrowed_weight_gate_griefer, honest loss 0, with a dedupe-group suppression case; the property test in validator::tests). Residual P1, gated-flow escape (fix round 5): the other side of the same rule. An eligible path's borrowed weight can cover a gated path's real flow on a shared hop. With the allowlist that weight is bought coverage, so the escape is at most Q * (1 + tol) per shared hop for a voucher of Q bytes (one_hop_weight_regret_bypass, LOW). Without the allowlist, a gated path's paid flow on hop k escapes by up to min(gated flow on k, Σ eligible borrowed weight on k), so up to its full flow, and the escaped bytes are credited at W_PAID, not W_FREE. Honest busy neighbours trigger it with no attacker: sim gated_flow_borrowed_escape measures 1.0x the ungated credit (pinned at bound 1.0). Follow-up: PB-32. Residual P2, long_path_l_dilution (pre-existing, not a regression of fix round 4): [SCR-10] divides a hop by the hop count L of the longest active path through it, so a gated long path through an honest 1-hop route's hop dilutes that route's endpoints even though it forfeits only its own weight: -66.6% at 3 hops. Planned fix: divide each path's portion by its own hop count. Sim long_path_l_dilution is planned under PB-32. Residual P3, group_keeper_flip (pre-existing): a node co-located in a dedupe group can pad its traffic within tolerance to raise its credit estimate on a shared path and take the keeper role from another member, including one with a different UID. Planned fix: split kept credit pro rata across members with different UIDs. Sim group_keeper_flip is planned under PB-32. Earlier status: OPEN (red-team re-check, measured). Trimmed-mean top-quartile dealing: Mechanism 1 drops the top 25% of gains (GAIN_TRIM_TOP_PPM), so a winning solver can push its best ⌊n/4⌋ pairs down to the trim cutoff and through its own nodes with identical score (150,000 ppm both ways); those routes still have gain ≥ 0 and earn Mechanism 0 credit. With per-path credit (SCR-10), 16 node keys on one host alternating between two UIDs capture 14/15 of a path's credit (estimated 1.87x). Solver + Operator Fix: penalise every overlay pair whose gain is below the best known route; per-hop latency charge in route_predicted_us; credit per distinct physical host/AS, not per key. scoring.md, routing.md — (proposed top_quartile_dealer)
T24 MITIGATED when validators supply node_diversity (Pass-6 red team; sim 1.772x -> 1.000x for /24 and tunnel-broker /48 splits). Each node has one dedupe group (its IPv4 /24, else its IPv6 /32 so that tunnel-broker /48s pool; no transitive merging, so a bridge node cannot pool unrelated operators); a group's capacity is pooled to its largest member and split pro rata, and the usage cap applies per group, then per UID (scoring/diversity.rs, scoring.md §Endpoint dedupe). node_diversity MUST be derived by the validator from probed endpoints, never self-reported; the daemon leaves it empty today (M4-07). Residual: an attacker can still spread over genuinely distinct /24s or /32s; co-location griefing halves a victim at the cost of the attacker's own capacity; honest co-located or IPv6-only operators in one /32 are underpaid (OQ-20). Earlier status: ACCEPTED RISK (T5 design point, measured 2.4x). The always-on usage share cap (SCR-1) pays a whale to split into sybil UIDs, each below the cap. Bounded by the /64, /24 and ASN dedupe in T5, which is specified but not implemented in code (red-team re-check). Operator Endpoint dedupe per /24 or /48 group with a pooled capacity and a per-group usage cap. scoring.md prefix_sybil_splitter, t24_*, scr1_*
T25 MITIGATED (red-team round 2, RT2-1; measured: fleet 2 -> 0 live nodes). Binding replay: an operator re-signs its NodeBinding while the old one is still live and committed; anyone replaying the old binding made both count as a same-UID conflict and quarantined the whole fleet Anyone Per UID and per (netuid, hotkey), only the live binding with the greatest not_before counts (as for wg-binding); an exact tie between distinct bindings is rejected identity.md §Binding resolution binding_replay (sim + identity unit test)
T26 MITIGATED (red-team round 2, RT2-2; measured 2.66x honest before, 0.64x after, 5 of 10 attackers; Pass-6 sim incoming_blackhole 0.497x, up from 0.408x, because honest peers now take at most one charge each after the blackholer's one-sided cap; the blackholer is still charged every failure). Incoming-probe blackhole: uptime charged only a node's outgoing links, so a node dropping every inbound probe (unroutable, zero transit obligation) kept full uptime while honest peers absorbed the failures Operator Every aggregated link result counts for both endpoints (node_probe_evidence) measurement.md §Uptime incoming_blackhole
T27 MITIGATED (red-team round 2, RT2-4; 1.0x -> 0.8x). Haircut dodge: run_tempo evaluated the overclaim haircut against the current declaration only, so lowering it after a failed test lifted the haircut at once Operator Haircut checked against the peak declaration over the last CAP_PENALTY_WINDOWS windows (TempoInput::declaration_history, tempo_verified_capacities). Pass-6: bwos-validator --state-dir persists both histories per window in cap-history.json (cap_history.rs, canonical JSON, atomic 0600 write, bounded to CAP_PENALTY_WINDOWS = 24, a corrupt file is set aside and history restarts empty), so the haircut survives restarts. Residual: a validator with lost history diverges from its peers for up to 24 windows. Under ADR-0039 team tests, the haircut is judged per test against the rate actually pushed, because the ramp pushes less than the declaration. So a dodger's haircut lifts once passing re-tests are half its rolling history, about 12 windows rather than 24. CAP_PENALTY_WINDOWS stays at 24, and the bound is restated as dodger ≤ honest: the dodger is haircut while its failed tests are the majority, and is never credited above what it carries (red team RT7). Task 4Dc re-ran it under the team rule as declaration_dodger_team (dodger ≤ honest; declaration_dodger still guards the single-agent rule, which runs until team mode) capacity-bonds.md declaration_dodger, declaration_dodger_team, end_to_end_multi_validator_tempo_determinism, cap_history_restart_preserves_overclaim_haircut
T28 PARTIALLY MITIGATED (Pass-7, library). Validator-declared simultaneous cohort tests (ProbeResultBatch.cap_cohorts, cohort-derived test_ids): a /24 or IPv6 /32 group is credited max(largest single, min(cohort aggregate, sum verified)), keyed by member list over members with capacity (burners excluded), lower median of samples in the last CAP_COHORT_FRESH_ENTRIES (8) entries, chunks never summed (sims colocated_cohort_honest 1.000x, sequential_key_replay 1.000x, cohort_burner_griefer 1.000x); the daemon persists cohort history (M4-07). Still OPEN: bwos-probe does not schedule or stream cohort tests (M4-08), so cohort credit is dormant in deployment; N keys on one box seen in different /24s (OQ-18). Earlier status: PARTIALLY MITIGATED (red-team round 2, RT2-3; shared foreign sink 4.0x -> 0). Shared capacity-test sink: the delivery digest was not bound to the node key and the sink was unauthenticated, so N node keys could point at one real sink (another operator's, or one shared box) and each earn full capacity credit (70% of Mechanism 0, and the T16 byte cap). Now the sink must return a cap-test-ack signed by the tested node's key over the validator-chosen test_id, stream digest and byte count; validators score unacked samples as 0 Mbps. Still OPEN: one operator holding all N keys on one box can answer N sequential tests (OQ-18); Pass-6 endpoint dedupe (T24) pools the capacity of nodes in one /24 or /48 when validators supply node_diversity, which bounds this for co-located keys Operator Simultaneous testing of nodes in the same endpoint /64, /24 or ASN (needs an endpoint registry, T5) measurement.md §Capacity tests, capacity-bonds.md shared_cap_sink, rt2_3_*
T29 PARTIALLY MITIGATED (Pass-7, three red-team rounds plus a fourth patch). Link blame is corroborated by validator vantage:<node> probes; a peer moves a node's uptime and Q_n only by min(cap_peer, cap_node)/cap_node of pooled (T24/T28) scoring capacity; zero-capacity peers are never evidence and zero-capacity nodes do not count toward their UID's uptime; an isolated end charged together with a non-isolated one pays min(cap)/max(cap); fleet uptime weights each node's samples by its scoring capacity, so a small fleet member cannot dominate it; a vantage-failing node that passes no link and is peered with at least MIN_DARK_PEER_UIDS (3) other UIDs takes its failures alone; a neutral failure gives the dropping side a Q_n sample at its lowest other sample; the daemon retains revocations and highest-seq consents (M4-07). Measured: asymmetric_sybil_framer 1.30–2.13x -> 1.000x (attacker total); shared-pipe sybils 1.70x -> at most 0.93x total; big node vs small victims: victims 0.84x -> at least 0.987x (sim big_node_griefer: 0.998x); dark node's peers unharmed; small fleet-mate framing victim 0.70x / attackers 1.14x -> victim at least 0.977x / attackers at most 1.001x in that configuration (sim small_fleet_mate_framer over six fleet mixes: attackers at most 1.001x, victim at least 0.917x), and a genuine fault on a small fleet member 0.19x -> 0.95x of the fleet; sparse_victim_framer 1.07x -> 1.043x. Still OPEN: a sybil majority with full-capacity sybils gains 1.04–1.09x; an attacker owning all (three or more, MIN_DARK_PEER_UIDS) peer UIDs of a node whose vantage probes are blocked can zero it (attackers 1.08x); sybils on one pipe seen in different /24s are not pooled (OQ-18); bwos-probe does not run vantage probes yet (M4-08). Pass-6 status: PARTIALLY MITIGATED (Pass-6 red team, four rounds; burner 1.737x -> 1.000x, fleet blame-shift 1.82x -> 0.024x, sybil-UID blame-shift 1.24x -> 0.971x, sparse-victim framing 1.35x -> at most 1.07x). Link results count only between live nodes of different UIDs on a current snapshot link or production route hop. Each failed link gets one verdict per window: it is charged to the end whose pass rate, leaving out every link with the other end's UID, is lower by more than LINK_BLAME_MARGIN_PPM (100_000), otherwise to both ends. A node can be blamed alone at most MAX_ONE_SIDED_CHARGES_PER_NODE (2) times per window, unless no validator has seen it serve (zero verified capacity and no passing acked capacity test) and its rate is strictly below ONE_SIDED_EXEMPT_RATE_PPM (250_000); at most MAX_CHARGED_LINK_FAILS_PER_UID (2) charges per other UID; failures charged to both ends cost uptime only (validator.rs LinkAttribution::new_with_vantage). Consents can be withdrawn or moved at once with a higher-seq node-signed NodeConsent (revoked: true withdraws); the highest started seq per (node, netuid) wins and lower seq can't be replayed (identity::effective_consents). Still OPEN: symmetric griefing by sybil UIDs that hold about half the network: once both ends pay, the larger side still gains share, worse when honest probe degree is sparse (attackers at most 1.07x, victims about 0.33x); closing it needs link evidence peers can't fake (validator-vantage link probes, OQ-16) or a per-UID cost. A revocation counts only once validators see it. Earlier status: OPEN (red-team round 2 re-check, estimated, not simulated). Burner-peer link griefing: an attacker binds zero-capacity node keys (nothing to lose) that drop probes to and from victims. Each failed link costs the victim uptime and an outgoing Q_n = 0 sample. This predates RT2-2: outgoing failures were already charged to the victim, and RT2-2 also charges the burner and adds incoming passes, so the victim's pass ratio does not get worse. Estimated about 3–4x honest against 9 victims. Also open, and predating RT2-1: a node's older, still-live node-consent cannot be withdrawn, so a node moved to a new operator is quarantined until that consent expires Operator Snapshot/route-hop-gated, cross-UID link attribution with leave-one-UID-out blame; sequenced consents with revocation. measurement.md §Uptime, identity.md burner_peer_griefer, fleet_blame_shifter, sybil_uid_blame_shifter, sparse_victim_framer, incoming_blackhole, t29_*
T30 MITIGATED ([INCENTIVE-HOP-01] red team F1, F4). Relay hop inflation: with hop-by-hop receipts, a relay that co-signs for any sender lets anyone (a fresh key acting as its own ingress, with a self-signed client receipt and a next hop it chooses) push bytes from sessions no production route carries onto a hop between two honest relays. The validator then flags that hop as inflated and zeroes every route through it. A related variant: two same-seq proposals from one upstream left a downstream hop advanced without its upstream hop Anyone A relay co-signs only on a path bgp_path + [self, next, …] that runs from client_receipt.ingress to client_receipt.egress and is a path/backup_path of the production table installed on it (POST /exit-route-table, -route-table), forwards only to registered peers at their registered endpoint, and serializes per upstream node from check to commit. Residual: a node that is itself the ingress of a production route can still send real, client-receipt-backed traffic over it (that is ordinary usage). Sybils on one relayed path still get interior credit if T23 dedupe has no endpoint data receipts.md §Overlay data plane, TV-31 incentive_hop01_relay_refusals_commit_nothing
T31 PARTIALLY MITIGATED ([INCENTIVE-HOP-01] red team F2, F3). Relay lock griefing: per-node proposal locks are held across the forward, so a request pointing the relay at a stalling server, or many junk next-hop keys, could block a relay's traffic to a node or fill its lock table Anyone Locks exist only for registered peers and production-path upstreams, next hops must use their registered endpoint, and every lock wait gives up after HOP_LOCK_WAIT (10 s, 503). Still OPEN (OQ-27): a slow registered peer still delays traffic to it; concurrent paths that wait on each other's locks in a cycle clear only at the deadline; a downstream that commits after its upstream timed out leaves seq out of step until the window rolls receipts.md §Overlay data plane incentive_hop01_relay_refusals_commit_nothing
T32 MITIGATED (Task 6d). Wheel table: a solver submits a table whose next hops towards a destination cycle, through backups behind its primaries or through classes that disagree. Backups of healthy primaries aren't scored, so a ring of backups scored the same as an honest table, while handing BGP a dispute wheel that flaps once the primaries fail (OQ-34) Solver A table is valid only if, for every destination, the next hops of all its routes, path and backup_path across classes, are acyclic (Table::next_hop_cycle); an invalid table scores -1e6 per pair, and nodes refuse it routing.md §Validation, "Next hops settle" backup_wheel_solver, every_valid_table_settles_whatever_links_fail
T33 MITIGATED (Task 6d red team, fix 1). Forced-detour dealing: with the next-hop rule, a destination whose classes want conflicting next hops forces some route onto a slower path. Regret's comparator was the unconstrained best, so the forced detour looked like regret, and the Mechanism 0 gate zeroed every relay on it; a solver that runs relays could aim the detour at a rival's pair and zero the rival at almost no cost Solver + Operator The comparator keeps the table valid too: when a best path would close a cycle with the other routes to the destination (the route's own backup included), the comparator is the reference solver's route for the pair, so a forced detour the reference also takes carries no regret and its relays keep their credit (round 2: no longer searched within the submitted table, T36); the reference solver moves each route onto its comparator until none is better (settle_regret), so its own tables carry none. Residual (round 3): a solver can force the reference branch with a backup of its own, but the comparator is then the reference's route, so it only substitutes a relay that is equal or better, and only on pairs the reference already detours. By design: an honest solver that resolves a conflict differently from the reference pays bounded regret (at most 1e6 ppm of the pair's direct latency) on each pair it resolves worse, as routing.md item 4 states. The reference route is taken without the capacity and attribute checks of items 2-3 (no practical harm in 60 random meshes; the spec says so) routing.md §Route regret, scoring.md forced_detour_dealer, t23_reference_tables_have_zero_regret, t23_reference_tables_are_never_gated (all-class, many sources per destination)
T34 MITIGATED for solvers that keep their last table (Task 6d red team, fix 2). Contested-hop jitter: an operator swings the latency of a link it controls by ±15% each window. Under the next-hop rule one route's change towards a destination can push the others there off their paths, so an incumbent that re-solves from scratch churns every window and pays CHURN_PENALTY, which can hand the round to a challenger Operator (against a solver) routing::stabilize_routes keeps each route from the solver's previous table while it's still valid and within ROUTE_SWITCH_MARGIN_PPM (10%) of the new best, without closing a cycle, which stops the cascade; bwos-solver -previous and the prototype loop use it. Chosen over a latency-free conflict order because the order already doesn't depend on latency (class priority, then pair); it's the paths that move. Residual: a swing large enough to clear the margin still moves the routes it affects, as it should routing.md §Reference solver, "Prototype loop" contested_hop_jitterer
T35 MITIGATED (Task 6d red team round 2). Stabilizer trap: a relay on an incumbent's kept path spikes its latency (68.5 ms against 40 ms direct) or its jitter past MAX_REALTIME_JITTER_US. The stabilizer compared only width, cost or latency and re-checked only path validity, so it put the old path back, which then scored a negative gain or i64::MIN Operator (against a solver) stabilize_routes keeps a path only if it still meets every limit of its class (routing::meets_class_limits: hop loss, realtime jitter, the class's latency ceiling against direct or the reference margin) and is within the margin by the class's scored measure, realtime's included. Round 3, capacity: under a per-pair demand a relay that cuts its self-reported capacity (1000 to 50 Mbps) made the fresh solve move off it, but the stabilizer kept the path with 3 overloaded nodes and links (bwos-solver links passed its demand without the guard main.rs had). A kept path must now carry the demand on top of the other routes' loads (validate_path_slice on the congested snapshot, then the demand against each residual), and a table that would overload more than the fresh one is dropped for it routing.md §Reference solver stabilizer_trap (limits and capacity)
T36 MITIGATED (Task 6d red team round 2). Backup-shaped comparator: backups are unscored, so a solver that routes a pair through its own slow relay could give another route to the destination, or the route itself, a backup whose hops made the pair's real best path look cycle-closing; the comparator, searched within the submitted table, then became the solver's own detour (regret 500,000 -> 0 ppm, relay credit 0 -> 1,000,000) Solver + Operator When the best path would close a cycle, the comparator is the reference solver's route for the pair, which the submitted table can't move (routing::regret_reference on the same inputs, solved once per window and shared by every table's regret and the Mechanism 0 gate) routing.md §Route regret, item 4 backup_shaped_comparator (both shapes), forced_detour_dealer
T37 MITIGATED (Task 6d red team round 2, low). Rank-tie grinding: the reference's re-search order broke equal-distance ties by lowest node ID, a public key an operator could grind to win ties Operator Ties are broken by a hash of the snapshot's window and the node ID (next_hops::tie_key), not known long ahead routing.md §Reference solver —
T38 OPEN, bounded (ADR-0039; scoring wired in Task 4B; producer pending). Nothing fills ProbeResultBatch.endpoints in the daemon yet, so in production no node has an underlay and this term pays nothing until the endpoint producer lands (roadmap PB-06). Faked underlay diversity. (a) An ASN adds a "second upstream" by BGP over a tunnel through its first provider, for example a cheap VPS with a BGP session. That is real in RIS and RouteViews but fails with the first provider, and it also removes the up: SRG label the network should carry. (b) A node opens its validator sessions from a VPS in a rare network, so its committed endpoint and underlay ASN are that network's, while its overlay peers' traffic may take another path Operator (a) The diversity term saturates: two neighbours earn DIVERSITY_WEIGHT_PPM, now a low 50_000, and more add nothing. Diversity multiplies only carried bytes, never capacity. (b) Probe and collector sessions must share a source (RT1), so the node is tested through that VPS. Its capacity is what the VPS path carries. The data plane to its overlay peers is not tied to it. Undetectable from public data in Phase B (OQ-39). (c) AS-path poisoning: announcing [.., A, X, A] makes X look left of A. RouteViews paths in which an ASN reappears after another are dropped (evidence::path_records, Task 4C fix round 1), but RIPEstat asn-neighbours aggregates paths, so its left neighbours can still include poisoned ones; the term saturating at two neighbours bounds that as in (a) measurement.md §Underlay, §Outside evidence, §STAMP probes and probe sessions, scoring.md §Coverage diversity_faker, roa_origin_shopper (Task 4B), as_path_poisoner (Task 4C), probe_session_forwarder (Task 18a)
T39 OPEN, bounded (ADR-0039; scoring wired in Task 4B; producer pending). Nothing fills ProbeResultBatch.endpoints in the daemon yet, so in production no node has an underlay and this term pays nothing until the endpoint producer lands (roadmap PB-06). Self-maintained outside evidence. PeeringDB entries and ASPA objects are published by the ASN holder, who may be the miner, so IXP presence and declared providers can be self-reported Operator holding its own ASN Neighbours come from public BGP paths seen by RIS and RouteViews. ASPA changes neither the count nor the labels, so publishing it is never penalised and faking it gains nothing. IXP presence is trusted from PeeringDB and bounded by IXP_PRESENCE_WEIGHT_PPM (a low 50_000, one IXP saturates). The underlay ASN needs an RPKI-valid origin seen in BGP, not a ROA alone. Residual: an attacker can register a fresh ASN per node and really announce each node's prefix from it, through its own AS and one upstream. Each fresh ASN then has two neighbours and a unique as: label, so it earns the saturated DIVERSITY_WEIGHT_PPM (at most 1.05x an honest single-homed node, on carried bytes only), for the cost of an ASN and prefix per node measurement.md §Outside evidence, §Underlay aspa_honest_publisher, roa_origin_shopper (Task 4B)
T40 MITIGATED in spec (ADR-0039). A validator forges or withholds outside evidence to favour a friend's node or zero a rival's diversity Validator A record counts only when present in usable evidence from at least MIN_VALIDATORS hotkeys holding PROBE_STAKE_QUORUM_PPM of stake (evidence::agreed_records). Evidence is signed, committed through the manifest, retained and served for 25 windows, and aged out after EVIDENCE_MAX_AGE_WINDOWS. Only the newest object per (validator, source) counts. Scoring never reads evidence live (Invariant 1) measurement.md §Outside evidence upstreams_and_ixps_come_only_from_committed_evidence (Task 4B), evidence_* (Task 4C)
T41 OPEN, needs a founder decision (ADR-0039 §7, OQ-43). Rented burst capacity. A node passes 60 s capacity tests on capacity it holds only briefly, rented or free under 95th-percentile billing, and is paid as if it were sustained. Measured against the schedule: at CAP_TEST_PERIOD 900 blocks a node gets about 8 tests a day. A 60 s test touches about 8 of a day's 288 five-minute billing buckets (2.8%), below the 5% that 95th-percentile billing discards, so the tests are free to a burst renter Notice (Task 4Dc fix round 2, red team N5): a test may wait up to CAP_TEST_DEFER_BLOCKS (4) blocks for its drawn team, so a node learns of a test up to (CAP_TEST_DEFER_BLOCKS + 1) × 12 s (about 60 s) before it starts, against 12 s without waiting. A burst renter still holds capacity from b to the test's end; the notice matters only for on-demand capacity that comes up in 12-60 s Operator Today: sustained 60 s team tests at unpredictable blocks, the rolling lower median of tests (capacity-bonds.md), and the test-rate ramp (RT4), which limits how fast any node's tested rate grows. Pay moves to carried paid traffic as it arrives: the capacity weight W stays 1_000_000 until attested paid traffic latches its trigger, then steps to 700_000 and the published schedule (Task 15, scoring.md §Capacity weight W). burst_renter gates (ratio to honest at most 1.0 once W < 1e6); burst_renter_95th and burst_renter_prelatch_per_cost (about 9.5x per unit of cost while pay is capacity-only, with the trigger gated off) are model-only until OQ-43, which the founder must decide before launch, and the diversity term pays only on carried bytes. The founder chooses between (a) accepting that verified capacity means port speed at bootstrap, and (b) testing at least 15 times a day, which roughly doubles validator traffic measurement.md §Team capacity tests, scoring.md burst_renter, burst_renter_95th (Task 15)
T42 OPEN, bounded (ADR-0039; in code, Task 4Dc: probe::team_capacity_mbps, validator::tempo_team_stage, sims below). Team-test manipulation. (a) A node throttles one team member to make room for the others. (b) A member colluding with the node pushes nothing but reports its full share. (c) A griefing member withholds its batch, or zeroes or omits its sample, to cut a victim's credit or force a haircut. (d) A node serves members one after another, using their start skew. (e) An attacker splits stake across hotkeys to land two members on one team. (f) A node faster than the team can push hopes to be skipped and keep old history. (g) A node times its traffic around tests, or widens its receipt bracket, so background it didn't carry during the test is credited. (h) A validator publishes a tiny share budget to cap a victim's team rate while voting in the median Operator, Validator team = min(declared, measured + bg), with measured = min(Σ c_i, q * S) (Task 4Dc fix round 1: capped c_i in the sum, T103), where q is the lower median of per-member ratios c_i / rate_i, with c_i = min(m_i, rate_i) and equal ratios ordered by the lower hotkey, over the members that revealed, and S is the summed rates of the whole scheduled team, revealed or not (OQ-93). All in kbps, m_i exact from the ack (OQ-91). The haircut reads ratio_t = (q * S + bg) / pushed with pushed = min(declared, S), so the 10% headroom never counts against a node that carries its declaration (round 4 RR1, sim headroom_underdeclarer: under-declaring at C / 1.1 at most 1.0x).
(a) A throttled honest member only lowers Σ c_i.
(b) Restated in Task 4Dc fix round 1 (red team F1): the colluder's share is capped at its rate, but the node can starve one honest member, which the lower median ignores, so it is credited k-1 shares for k-2 carried: 1.5x at k = 4, 2x at k = 3 (sims colluder_overreport_k4, colluder_overreport_k3, colluder_overreport_end_to_end; 1.82x and 2.73x with the uncapped sum). The minimum team of 3 rules out k = 2. A test down to two revealed members (two withheld) still takes the median term, so one colluding member there gets the node at most two shares for one carried, 2x, with no ratio_t (sim withholder_fix_k2_colluder, 1.64x); one griefing member there can zero that test (round 5 D). A test with one revealed member isn't a sample (red team F9). A colluder with a far larger budget than its teammates takes the water-fill's remainder on nodes tested above k × 2500 Mbps, about 1.7x instead of 1.5x with budgets 2500 × 3 and 100_000 (red team F7, documented, no code).
(c) A withheld batch is dropped from Σ and the median without rescaling, but stays in S, so withholding never haircuts an honest node and never lifts a node above an honest declarer of its real capacity (sims withholding_near_declaration, void_by_withholding; T102). A zeroed or omitted sample lowers measured by at most that member's share, rate_i / S. The haircut reads ratio_t, which comes from q, so a minority of members can't force one. A test with fewer than 3 revealed members gives no ratio_t (round 4 RT5). Sim sample_omission_griefer: victim at least (k−1)/k, 0.75x at k = 4 and 0.67x at k = 3, and a friend gains at most 1.0x from one colluder's omission (RT3).
(d) gains at most about skew / CAP_TEST_SECS.
(e) Two colluders on a team of 4 give 3x with a starved honest member (RT6, restated for F1; sim two_colluders, 3.64x before the cap), and two of a team of 3 credit two shares for nothing carried. Under the stake-proportional draw (T108) two seats on half a node's teams take about 41-47% of eligible stake at k = 4. Teams of three are rare for honest nodes (1-9% of tests) but not for an attacker's node parked late in the queue, which starts at its last chance with a member dropped on 31-62% of its tests (red team R5; validator_hotkey_overflow measured 0.29-1.00 for the beneficiary); since Task 4Dc fix round 3 such a short team's record can only lower verified capacity, never raise it above max(verified_prev, CAP_RAMP_FLOOR_MBPS) (T113, sim late_queue_short_team: 0.28x of an honest declarer, 1.57x without the cap). With s as a share of eligible stake: one colluder is on most teams from about 16% (with replacement; about 15% without replacement at 20 equal validators) at k = 4, or 21% at k = 3; two colluders, by splitting stake, are on most teams from about 38.6% at k = 4. For a co-located group (Task 4Dc red team B1, T125) the threshold was far lower: the group's pool is the max over its chunk cohorts of each one's lower median of few samples, and Σ verified doesn't bind for keys verified one after another, so one seat on one cohort's only sample gave ×1.5 (team of four) or ×2 (short team) at about 5% of stake (8 of 12 seed-runs above 1.0x). Since fix round 5 a short cohort aggregate is capped (B1(a)) and a team cohort needs two samples (CAP_COHORT_TEAM_MIN_SAMPLES, B1(b)), so one seat never raises a group: it now takes the colluder seated on both of one cohort's samples, 1.5x at most, in 1 of 12 seed-runs (sim colocated_cohort_lottery; residual T125).
The real bound for (b) and (e) is the rolling lower median of tests, which moves only when most of a node's tests are inflated. Yuma doesn't clip it, because all validators score the same samples. Once inflation stops, the median falls back after about 5 honest tests, roughly 12 windows.
(f) A node is never skipped for speed. The rate is capped at the team's budgets, pushed follows the cap, and the node is verified at what was measured (RT2, sim untestable_shelter at most 1.0x).
(g) Before Task 12b, background is the window average and lifts only ratio_t, never team (sims busy_honest_pre12b: no haircut; bg_priority_overdeclarer at most 1.0x). Residual before 12b (round 5 F3): a busy honest node is credited about 0.75 C, while a node that stalls its routed traffic during tests is credited C, no more than an idle honest node; busy_honest_pre12b reports both. After Task 12b (round 5 B, C, F1), each cross-UID receipt stream needs a gap-free run within one window, seq jumps from counter-proposals allowed, with every interval at most ceil(RECEIPT_INTERVAL / BLOCK_SECONDS) (3) blocks; its background is the slowest interval overlapping the test, or 0 (sim bracket_widener at most 1.0x). A crossing bracket adds 0, with no fallback, so the node can't pick the rule (F4). Residual after 12b: stalling real routed traffic during a test and carrying it in the overlapping intervals gives team <= C + 0.4 T with T <= C / 3.6, about 1.11x (sim bracket_stall_carry, bound 1.12x), and an estimated 1.48x at k = 4 with one colluding member, which the sim also reports. It needs routed traffic the node doesn't choose. Also after 12b: a node colluding with peers of other UIDs to inflate receipts gains at most 1 / (1 - 0.25), about 1.33x of measured, bounded by T16's defences; and an honest busy node loses background in tests whose bracket crosses a window boundary, about 3% of its tests, too few to move its lower medians.
(h) A drawn member needs cap_share_budget_mbps >= CAP_SHARE_BUDGET_MIN_MBPS (1,000), and a member with a zero water-filled rate is dropped, so a team of k pushes at least min(R, k * 1,000) Mbps and no member votes without streaming (sim low_budget_griefer). Residual: a validator at the floor with about 16% of eligible stake sits on most of a node's teams and holds a 10 Gbps node at about 0.85x in the lower median (8,500 Mbps of budget), under-credited but never haircut
measurement.md §Team capacity tests, capacity-bonds.md uplink_capped_datacenter, void_by_withholding, sample_omission_griefer, untestable_shelter, team_lottery_splitter, honest_ramp_no_haircut, headroom_underdeclarer, busy_honest_pre12b, low_budget_griefer, colluder_overreport_k4, colluder_overreport_k3, two_colluders, withholder_fix_k2_colluder, colluder_overreport_end_to_end (Task 4Dc), busy_honest_node, bracket_widener, bracket_stall_carry (Task 12b)
T43 MITIGATED (ADR-0039; in code, Task 4Dc). Echo cheat. A node acks a capacity test without carrying the bytes both ways: it echoes garbage, echoes from another box, or has a large downlink and a small uplink Operator Every byte is echoed on the same connection, and each member byte-checks a private random CAP_ECHO_CHECK_PPM of the blocks. A failed check zeroes that member's share, and failure at half the members zeroes measured. The node-signed cap-test-ack still binds the key (RT2-3). The test measures the lower of uplink and downlink. Code: bwos-probe cap --team (member side) and cap-sink -echo (node side); scoring counts a member only when echo-OK (ProbeResultBatch::team_member_mbps_for) measurement.md §Team capacity tests flashflow_echo_cheat (verified 0; corrupting 1e-4 of a 2.5 Gbps share passes a member's check with p ≈ 0.01); a_team_test_sums_members_and_fails_without_echo (bwos-probe, bwos-core), an_echo_ok_sample_needs_the_derived_test_id_and_a_clean_check
T44 PARTIALLY MITIGATED in spec (ADR-0039). STAMP shading and probe priority. (a) A node shades STAMP RTT through the reflector timestamps or by answering early. (b) It prioritises probes over real traffic Operator (a) Only T4 - T1 on the agent's clock is scored, and reflector timestamps go to dashboards only. Each test has a fresh random seq and a random send time, and a reply counts only after its test left. (b) link:, direct: and path: probes carry random payloads, not STAMP, so they can't be recognised by format (ruling 4). A direct: probe can still be recognised by its fixed destination port DIRECT_ECHO_PORT (8_620), random payload or not, so a node can treat it apart from other traffic (Task 4Db fix round 1, recorded). vantage: probes and capacity tests ride the probe session, which a node can recognise and favour. That stays OPEN until secure sampling on real traffic (ADR-0038) and pay moving to carried traffic. A related case (round 5 F3): before Task 12b, a node that stalls its routed traffic during capacity tests is credited its full capacity, while a busy honest node is credited about 0.75 of it (T42(g)) measurement.md §STAMP probes and probe sessions Task 4Db red team
T45 MITIGATED in spec, with a residual (ADR-0039, RT1); spec only, code open until 18b. Task 4Db records each probe session's source and has the check (ProbeAgent::set_collector_source), but no collector session exists to set it, so nothing is source-matched yet and bwos-probe serve's endpoints must not feed batches (measurement.md §STAMP probes and probe sessions). PB-48: its plan-mode vantage: and cap: samples do feed batches, from unmatched sessions, as a residual accepted only while every validator is founder-run (T300, OQ-284); capacity tests still never run over a probe session. Endpoint shopping and the probe-session forwarder. A node shows different endpoints to different validators, or opens its probe sessions through a forwarder with a larger pipe than its real one, to escape /24 pooling or be tested on capacity it doesn't route with. Validators each building node_diversity from their own view would also compute different weights (Invariant 1) Operator Each batch commits the endpoint its validator saw, which MUST be the source of the node's collector session too. A probe session from any other source is refused, and capacity tests run only over source-matched sessions. The node's endpoint is the stake plurality among reporters meeting the probe-key quorum, so every validator builds the same groups. Residual: a node can send all its validator sessions through one forwarder while its overlay peers' traffic takes another path. Peers' observed endpoints aren't committed measurement.md §Probed endpoints, §STAMP probes and probe sessions probe_session_forwarder (Task 18a, bound 1.000x of one pipe), node_diversity_is_built_from_probed_endpoints_not_declared_ones, sybil_split_k8 (Task 4B)
T46 OPEN (ADR-0039, accepted risk). SRG griefing. An attacker runs a node of another UID in a victim's network, or behind its single upstream, so the victim shares an SRG and loses SRG_SHARED_PENALTY_PPM of its diversity bonus Operator shared counts only nodes of other UIDs with verified capacity (RT7), so a zero-capacity key costs nothing. The attacker needs a node that passes capacity tests in that network. At defaults the victim's C_n falls from at most 1.1x to 1.05x, about 5% of its usage term. This is like co-location griefing in T24 scoring.md §Coverage srg_zero_cap_griefer (Task 4B, victim at least 0.99x)
T47 ACCEPTED RESIDUAL (ADR-0039, ruling 6). Inherited carrier diversity. A home or CGNAT node's committed endpoint belongs to its ISP, so it inherits the ISP's neighbours and IXPs, though its own access link is a single point of failure. Large eyeball ISPs look well connected Operator (passive) The underlay ASN comes only from the node's own committed endpoint. Diversity pays only on carried bytes, at low weights, and nodes in one ISP share as:<A>, so the SRG penalty halves it once two UIDs' nodes are there measurement.md §Underlay, scoring.md §Coverage — (red team)
T48 MITIGATED (ADR-0039; in code, Task 4Dc: probe::team_schedule). Slot crowding. An operator binds many fresh zero-capacity node keys, each with a large declaration, so their due tests fill validators' CAP_TEST_MAX slots and honest nodes go untested Operator Within a block, proven nodes (verified_prev > 0) are assigned before unproven ones. Unproven-node tests go round-robin by UID: within a block, the next is the one whose UID has the fewest tests so far in the window, then by slot key (round 4 RT7). At most CAP_TESTS_PER_UID_MAX (4) unproven-node tests per UID count in a window, counted in the window each test ends in, so tests carried across a boundary count (round 4 RR5). Bound (zero_cap_slot_crowder): honest proven nodes keep their test rate, and a crowder UID gets no more unproven-node tests in a window than any honest UID with due tests. With U_a crowder UIDs and U_h honest UIDs competing for scarce slots, honest UIDs keep at least U_h / (U_a + U_h) of them, so with one crowder UID honest new nodes reach 0.9 of declared in at most twice the windows they need without it. Each extra crowder UID costs a registration. The ramp starts every new node at CAP_RAMP_FLOOR_MBPS. Slot order within a tier uses a block-hash-keyed hash, so no one can grind a key for it measurement.md §Team capacity tests zero_cap_slot_crowder, declared_flood_cotest; proven_nodes_are_assigned_slots_before_unproven_ones_and_unproven_tests_are_capped_per_uid, unproven_slots_go_round_robin_by_uid, tests_carried_in_count_toward_the_per_uid_cap_of_the_window_they_end_in
T49 MITIGATED (ADR-0039, red team RT1; code in Phase B Task 11a, signed.rs). Attestation-key squatting. A hotkey lists a victim validator's ed25519 key, or its probe WireGuard key, in its own AttestationKeyRecord, so the duplicate rule maps the key to no one and the victim's probe batches stop counting Validator (or anyone with a staked hotkey) A record is valid only with the ed25519 key's own attestation-key-pop proof of possession. probe_wg_pub must be the X25519 form of that ed25519 key, so the proof covers it. Only records from hotkeys with positive stake count. Task 11a's set builder refuses a key listed under two hotkeys. Only a key's real holder can create a duplicate. The ed25519 key must be canonical, torsion-free and have its sign bit clear, since A and −A map to one X25519 key (round 4 RT8). A hotkey may hold one record per probe agent, each with its own key. The probe WireGuard key must be canonical too, and every ed25519 signature is verified strictly (verify_strict). Residual (round 5 F2, replacing round 4's): the probe agent's WireGuard private key is the scalar that signs its batches, but a leaked probe key can't forge counted batches, because a counted batch must match the hotkey's on-chain commitment. The real risk is the attestation key: nodes accept signed inputs on ed25519 attestations alone. It comes only from the hotkey's single record flagged attest, never a probe agent's record unless flagged, and it must be kept off field probe boxes. A leaked attest key can attest inputs until its record's not_after passes, so keep not_after short. Two more residuals: (i) a hotkey with two valid attest records has no attestation key, so rotating by overlapping an old and a new attest record leaves a gap with no listed key until the old one lapses; rotation needs the old record to expire before the new one counts; (ii) records naming the same key under one hotkey are deduplicated by greatest not_after, which can drop an attest flag when one key appears in two records with different flags measurement.md §Team capacity tests, encoding.md attestation_key_squatter (Task 11a; the victim's batches still count), a_non_canonical_or_torsioned_ed25519_key_is_refused, a_hotkey_may_hold_one_record_per_probe_agent, attestation_key_is_never_a_probe_agent_key_unless_flagged (Task 11a)
T50 MITIGATED (ADR-0039, red team RT5; code in Phase B Task 11a, validator::probe_stage). Quorum stall by stake that can't probe. Staked hotkeys that hold no attestation-key record raise the total stake a probe key must reach, so no key reaches quorum and every node takes missing-measurement failures Validator Quorums are measured against recorded_stake, the stake of hotkeys with a valid record committed before the window's first block, so no one can trigger a freeze after seeing the results. Below PROBE_PARTICIPATION_FLOOR_PPM (50%) of all stake, the window carries forward the previous window's metrics where no fresh result reaches quorum, and charges no failures for them. At most PROBE_CARRY_MAX_WINDOWS (2) windows in any PROBE_CARRY_SPAN_WINDOWS (24) carry; past that budget keys are scored fresh against recorded_stake, so a freeze, or alternating freezes, can't shelter an offline node (round 4 RT2, round 5 F5). A probe that was attempted and failed is a reported value (rtt_us = 0), never an absence, so failures reach quorum inside a carried window too measurement.md §Team capacity tests, §Results and commit-reveal recordless_stake_staller (Task 11a; honest nodes see no uptime failures), selective_freeze (Task 11a; an offline node earns 0 after 2 windows), freeze_alternator (Task 11a; an offline node earns at most 2 windows' credit in any 24)
T51 PROPOSED (ADR-0046), not built. transfer deadline gaming: a client, or a miner acting as one, sets a very tight deadline so its order's need_mbps grabs spare capacity or forces wide paths Client / Operator transfer is routed last and graded on the capacity left after every other class, so a tight deadline displaces no non-transfer pair. need_mbps is capped at TRANSFER_MAX_ORDER_MBPS, and above the cap the order is late best effort. A pair's aggregated need is capped at TRANSFER_MAX_PAIR_MBPS. Orders are funded for their whole volume when trusted issuers are set, and a tighter deadline is quoted at a higher price (ADR-0046 §7). The per-window cap ranks entries by funded remaining bytes, not deadline, so a tight deadline doesn't jump the queue. Among transfer pairs the reference serves earliest deadline first routing.md / scoring.md "Proposed (ADR-0046)" transfer_deadline_gamer. Expected bound: every non-transfer pair's gain and regret are byte-identical with and without the order; the order's need never exceeds the cap; the order's demand-set rank is unchanged by its deadline; the attacker pays for the full volume
T52 PROPOSED (ADR-0046), not built. transfer volume inflation and order splitting: declare far more volume than will ever be sent, or split one job into many small orders, to reserve spare capacity, inflate the pair's need through per-order rounding, crowd out other orders or shape the demand set Client / Operator Remaining volume and need are recomputed each window from receipts committed in manifests, plus the in-lag graded estimate. An order with no committed delivered bytes for TRANSFER_IDLE_WINDOWS is dropped. Undelivered volume earns no Mechanism 0 credit, because only carried, receipted bytes are credited. A funded order prepays its volume. Need is summed in bit/s and rounded up to Mbps once per pair. Orders are at least TRANSFER_MIN_ORDER_BYTES. One client has at most TRANSFER_MAX_CLIENT_SHARE_PPM of the entries, each pair's need is capped at TRANSFER_MAX_PAIR_MBPS, and the per-window cap ranks by funded remaining bytes routing.md / scoring.md "Proposed (ADR-0046)" transfer_volume_inflator. Expected bound: capacity held by an idle order is at most TRANSFER_MAX_ORDER_MBPS for TRANSFER_IDLE_WINDOWS + TRANSFER_DELIVERY_LAG_WINDOWS windows; non-transfer classes are unaffected; Mechanism 0 credit for unsent volume is 0. transfer_order_splitter: splitting one order into N (same total bytes and deadline, N limited by TRANSFER_MIN_ORDER_BYTES) raises the pair's need_mbps by at most ceil(N / 1e6) Mbps (1 Mbps for any N up to 10^6), adds no demand-set entry and doesn't change the entry's rank. One voucher's bytes are deducted once across all orders naming it (RT F5), so N orders can't each claim a voucher's full value. Residual: client keys are free, so the per-client share cap is only a weak limit against splitting, with or without funding (splitting across keys costs nothing extra). The binding limits are funding, the per-window cap, the per-pair need cap and the destination cap. Destination squatting (fix round 3, R7): idle clients' orders, with committed delivery below 10% of their in-lag share, are demoted behind sending clients for the per-window and destination caps. Reserved voucher bytes are consumed on expiry, not released. transfer_destination_squatter (56 funded idle orders to fresh destinations). Bound: demoted within TRANSFER_DELIVERY_LAG_WINDOWS + 1 windows and dropped TRANSFER_IDLE_WINDOWS later, sending clients take the slots, and the reserved bytes are spent. Known residual on testnet: with an empty allowlist, orders are unfunded and keys free, so a squatter can re-file at no cost, behind sending clients. Idle drop (fix round 4): only windows in which the order's in-lag share was above 0 count towards TRANSFER_IDLE_WINDOWS, so an order the network gave no rate (left out by a cap, unrouted, or with no delivered rate) isn't dropped and its reservation isn't burned for capacity it never had. A demoted squatter left out of the set therefore isn't dropped either; it holds its reservation until it re-enters and stays idle, or its late grace ends
T53 PROPOSED (ADR-0046), not built. transfer width attraction and stripe dealing (the OQ-23 bulk residual applied to transfer). An operator with wide nodes, or a solver dealing for it, routes transfer pairs through them to earn Mechanism 0 credit. Width, not price, is the lever. A link's cost is max(cf, ct) of its ends, so a low declaration alone doesn't make it cheap. The surcharge 1 + 2·util² keeps a wide node's links cheap at the same load, so it can declare up to MAX_COST_PPM and still undercut a busy 1.0x path. Dilution: a costly dealer stripe hides behind a cheap, wide stripe in a rate-weighted mean. Allocation dealing: inflating a stripe's mbps to claim more of a shared hop's bytes Operator / Solver + Operator Width is demand-capped: no gain, regret or comparator term rewards width beyond need_mbps, and Σ mbps <= need_mbps. Regret and the Mechanism 0 gate are per stripe, against the comparator's costliest needed stripe, so a diluted dealer stripe past ROUTE_REGRET_TOLERANCE_PPM gets 0 credit. Pay per byte uses min(declared, routed link cost), never above what the router priced. Apportionment uses validator-measured delivered_k, never mbps. Per-stripe and rate-weighted regret (laundering), a laundering cap at the comparator's allocation plus tolerance, costs from the solved-on snapshot (comparator poisoning), and no oversubscription when solved with a max-min fair split. Not relied on: the 24-window cost cooldown, which run_tempo now enforces with fixed 24-window epochs (PB-31, Task 31, T56). Pay capped at the routed link cost doesn't throttle declaration changes either scoring.md "Proposed (ADR-0046)"; ADR-0046 §5 transfer_width_attractor (a 10 Gbps relay declaring 2.0x against a busy 1 Gbps relay declaring 1.0x with room for the need). Expected bound: credit per byte is at most honest x declared/effective cost (the surcharged cost the router used). Dilution case: a dealer stripe costing more than 1.1x the comparator's marginal stripe earns 0, whatever the route's mean. stripe_mbps_apportion_dealer (a dealer stripe with inflated mbps sharing hops with an honest stripe). Bound: each stripe's weight equals its modelled delivery share within one floor; the pair's weights total min(need, rate); mbps above modelled delivery changes nobody's weight; synthetic routes move nothing. "Measured delivery" is a snapshot model, because receipts aren't split by stripe. marginal_stripe_launderer (a dealer stripe priced exactly at the comparator's marginal carries most of the need while a cheaper honest path has room). Bound (restated, fix round 4): price, not share. Each credited byte costs at most 1.1x the comparator byte it displaces. A dealer at the marginal cost can carry 100% when the comparator's stripes are within 10% of each other; otherwise its credited share is at most 1.1x the comparator's allocation at or above cost_k / 1.1, plus TOL * min(need, rate), and regret_p > 0 once the route's mean is past 1.1x the comparator's. laundering_cap_tolerance_flip (honest stripe costs flip across the comparator's within ±10%). Bound: 1.00x, because the cap uses A(cost_k / 1.1) * 1.1 plus slack and keeps the tolerance. stripe_regret_noise (±10% cost noise on an honest route). Bound: regret 0, from the deadband on both regret terms. comparator_residual_inflater (inflating the residual the comparator sees, to make it allocate at a dealer's cost level). Bound: at most the tolerance, 1.1x the comparator's allocation plus slack. comparator_cost_drop_griefer (a griefer drops its declared cost after tables are committed, to make the comparator cheaper through its node). Bound (derived, ADR-0046 §5, replacing round 2's underived 0.95x): base costs come from the solved-on snapshot, so a later declaration moves the comparator by 0. A rival keeps 1.00x unless the griefer adds enough real, verified capacity to cut the comparator's marginal cost by more than the 10% tolerance (at utilisation 0.5, about 28% more capacity). oversubscribed_mbps_dealer (a table whose stripes' Σ mbps exceeds a link's residual on the solved-on snapshot). Bound: the table loses its transfer routes, and inflating one stripe's mbps never changes another's delivered_k (max-min fair split). Residual: 10% over the comparator's marginal cost and allocation, as for every class. Residuals recorded in fix round 4: (1) reshuffles: an honest route whose split differs from the greedy comparator's by more than 10% plus slack loses some credit; honest_split_reshuffle (splits 0% to 50% from the comparator's at equal or lower path_cost) MUST show 1.00x up to 10% plus slack and reports the loss beyond, recorded here before the cap is paid. (2) Mechanism 1 deadband: transfer regret has the 10% deadband in Mechanism 1, which the other classes don't (theirs counts from the comparator). Its congestion-priced cost moves more with measured capacity than latency does, and max_k regret_k takes the worst of up to four stripes, so without it honest regret would grow with stripe count. A solver can place a stripe 10% over the comparator with no Mechanism 1 penalty, matching Mechanism 0's gate. (3) Broken in-tree: a stripe prefix that isn't an in-tree, or a transfer route with a backup_path, fails Table::validate and so the whole table, latency classes included. Only the solver can cause it, since it depends on the table's paths alone, and the other transfer-only failures (prefix budget, oversubscription, Σ mbps > need) still drop only the transfer routes
T54 PROPOSED (ADR-0046), not built. Time-shifting one's own traffic: a miner buys transfer orders between its own nodes and lets the network move the bytes into quiet windows, where each byte is a larger share of the usage term Operator (as client) transfer bytes are ordinary paid/free bytes under the existing rules: voucher price floor (T20), [SCR-10] once per path, entity dedupe of own-UID endpoints (§Endpoint dedupe), [SCR-11] capacity cap, USAGE_SHARE_CAP with bounded redistribution, and the regret gate. ADR-0046 adds no class weight and no off-peak multiplier scoring.md §Byte crediting; ADR-0046 §3 offpeak_transfer_wash. Expected bound: alpha per paid GiB of the miner's own transfer traffic is at most 1.00x the same bytes sent as non-transfer paid traffic in the same windows (transfer adds no edge). The absolute bound is the existing paid wash-trading bound
T55 PROPOSED (ADR-0046), not built. transfer load shield: a solver fills a fast relay's links with transfer stripes so that a latency-class detour through its own relay looks capacity-forced, with no regret Solver + Operator Non-transfer classes are graded as if transfer loads didn't exist (regret comparators, capacity checks, congestion-priced cost). transfer loads still count in overloaded_nodes. Stripe prefixes have their own next-hop graphs, so transfer routes can't force a cycle-conflict detour (T33) on another class either scoring.md / routing.md "Proposed (ADR-0046)" transfer_load_shield. Expected bound: every non-transfer route's regret and Mechanism 0 multiplier are identical with and without the table's transfer routes
T56 MITIGATED (Task 30 red team, PB-31, Task 31 fix round 1; 10.0x -> 1.0x). Declaration cooldown bypass. can_update_declaration implemented the CAP_CHANGE_WINDOWS (24) cooldown, but nothing outside tests called it, so run_tempo scored whatever declaration it was given. An operator could discount cost_ppm to 0.2x to win routes and raise it to 2.0x (10x the Mechanism 0 per-byte pay, ADR-0018) the window after the table was assigned. The first fix (per-UID state) was bypassed three ways: flipping the declaration's hotkey (measured 10x), withdrawing to the default cost (5x), and moving nodes between UIDs (10x per move). Its local checked_window also made stateless and restarted validators diverge Operator run_tempo scores a per-node cooldown epoch (validator::tempo_declaration_epoch). Only declarations signed by the UID's metagraph hotkey, for nodes bound to it, count. A node keeps the cost_ppm it had at the epoch's first window, and its mbps can only go down until the next epoch, whichever UID it is bound to; a withdrawn node is still billed at its carried values. The state is a pure function of the chain reads since the epoch's first window (at most 24), so a validator without state rebuilds it from TempoInput::declaration_reads. Fix round 2: Mechanism 0 bills each node at the lower of its epoch cost and the cost in the snapshot the table was solved on (billing_cost_ppm, TempoInput::current_snapshot_costs), so a raise at an epoch boundary never re-prices routes chosen before it (epoch_boundary_raise: 0 mis-priced windows). An epoch cache that can't be saved (key churn past MAX_EPOCH_NODES) no longer fails the tempo (epoch_state_key_churn). Residuals (fix round 2 check adds (F1) and (F2)): (F1) stale costs: nothing ties current_snapshot_costs to current_snapshot, so a misconfigured validator passing an older outcome under-bills boundary raisers for the epoch; fix with PB-12 (carry costs in the signed snapshot, or tag them with the snapshot window). (F2) None vs Some: a validator passing None bills a boundary raiser one window at the new price; every daemon passes None until PB-14 persists the costs, so validators agree but the cap is inactive in production; an empty map must be passed as Some. (1) re-key: an operator can replace a 0.2x node with a fresh node key mid-epoch; the new key gets at most 1.0x, and is billed at most what its routes were solved on (rekey_mid_epoch: 1.0x), so the price moves (up to 5x the old key's) but never above what the solver saw, after a new key, consent, binding and capacity tests. A tighter cap at the UID's lowest price is deliberately not used. (2) Dating gap until declarations are named through a manifest object domain (OQ-45): the read dates a declaration by the commitment that names its hash, but the declaration object itself is off-chain. An operator can withhold it from some validators (those then see the node as absent and carry its state, so withholding never raises a price), and a validator rebuilding an epoch needs the objects of every read since the epoch's first window, so it depends on how deep the object store archives them. (3) A validator with neither state nor reads starts the epoch at the current read and can disagree with its peers until the epoch ends; the live loop must fill the reads (PB-14) capacity-bonds.md §Where the cooldown is enforced cost_raise_after_assignment, epoch_boundary_raise, rekey_mid_epoch, epoch_state_key_churn, declaration_hotkey_flip, withdraw_to_default_cost, fleet_move_cost_flip, stateless_validator_raise, downtime_backdate_divergence, declaration_cooldown.rs, two_validators_with_the_same_previous_declarations_compute_identical_weights
T57 MITIGATED, residual bounded (Task 10 red team, fix rounds 2 to 4). Refresh ignorer: a kernel node keeps no refused routes (no soft-reconfiguration inbound, OQ-44), so a new table reaches the paths its FRR holds only when each peer sends its routes again on ROUTE-REFRESH. A peer X that leaves route refresh out of its OPEN, or never answers, keeps an old table's primary path at 200 on node V, draws V's traffic towards R, and drops it, so the V-R link takes the blame. Reproduced in solver_bgp_e2e.sh step 5d (a no-root peer run with --ignore-route-refresh, tests only): FRR 8.4.4 and 10.7.1 both kept X's path at 200 after a table that made X the backup. Residual (fix round 4, F3): a quarantined peer is released when it answers correctly at an apply that changed its paths or lists, so an ignorer that alternates, answering while quarantined and ignoring the apply after, gets at most one 10 s window per two applies. Open follow-ups (Task 10 final check): (a) changed_peers compares only each peer's own, primary and backup lists, but a change in which UID owns an origin alters FRR's filter without changing any list, so fail-closed should also count every peer as changed when the snapshot changed; (b) "answered" should be judged on the last neighbour read that succeeded after the route reads, not strictly on the last read; (c) the read a quarantined peer is judged on can start up to one read's length before judge_at; (d) deploy/wan-stack/tests.sh:348 counts RouteUnassigned log lines, which aggregation (node::UNASSIGNED_LOG_INTERVAL) makes unreliable, and the controller will fix that file Operator After every apply, bwos-node refresh-check sends clear bgp ipv6 unicast * soft first, then waits up to 10 s for each peer to answer and leave only paths the new policy gives at the preference it gives, and hard-clears that peer alone if not (datapath.md, "A new table"). A peer cleared for not answering or for stale paths is quarantined: at every later apply it's judged once the honest peers have answered, but no earlier than QUARANTINE_JUDGE_SECS (2 s, the judge floor) after it's asked, not given the wait; it's released when it answers correctly at an apply that changed its paths or lists. So an ignorer gets at most one 10 s window per two applies. A peer is called unanswered only if the last neighbour read succeeded; otherwise it's unverified, which never quarantines. It fails closed: a peer it can't verify in time is cleared if its lists changed against the table applied before, it's quarantined, or a stale path from it was seen, and otherwise logged as unverified; it exits non-zero with the errors in the apply's JSON datapath.md steps 5d (cleared at the deadline, quarantined), 5e (quarantined, cleared at the judge floor without the wait) and 5f (a vtysh too slow to read: the peers whose lists changed cleared, exit non-zero, no stale path 20 s after the commit; then a window-only table: nobody cleared, both peers unverified, no session reset), on FRR 8.4.4 and 10.7.1; refresh_check unit tests incl. it_fails_closed_when_frr_cannot_show_a_peers_routes_in_time, failing_closed_clears_only_the_peers_whose_lists_changed_and_the_quarantined, a_peer_is_unverified_not_unanswered_when_no_neighbour_read_succeeds_after_the_ask, an_honest_quarantined_peer_answering_at_half_a_second_is_not_cleared; sim refresh_ignorer_framer (model-only: 20 applies a window, quarantined 48 s of 4,320 s; alternating, the residual bound, 120 s; without the quarantine 200 s; all attacker 1.000x, victims 1.000x, as one framed link is a neutral failure under T29)
T58 ACCEPTED RESIDUAL (ADR-0042). Signed-input capture. Whoever holds the attest keys of at least SIGNED_INPUT_QUORUM_PPM (two thirds) of a validator set's stake can feed every node any table, snapshot, peer directory or next validator set, because nodes check only ed25519 attestations and never the chain Colluding validators, or a thief of their attest keys Attestations have their own domains, so no solver, probe or record signature can be lifted into one (D9). A key outside the set or a repeated key counts for nothing, and every signature is verified strictly. Nodes refuse an older window and a different object for the window they hold, so a captured quorum can't silently swap a table within a window or roll one back. The attest key stays off field probe boxes and its record's not_after is kept short (ADR-0042, "The attest key is the real risk"). A two-thirds stake collusion is outside what the design defends, as for Yuma routing.md §Signed tables, snapshots and peer directory, ADR-0042 a_table_attested_by_one_third_is_refused, an_attestation_from_a_key_outside_the_set_counts_for_nothing, a_duplicate_attestation_counts_once, a_solver_route_table_signature_is_not_a_table_attestation, an_older_window_signed_table_is_refused_and_the_last_one_kept (Task 11a)
T59 MITIGATED (ADR-0042, red team 2 and 3; node flow Task 11c). Stale trust root and exit veto. A node is bootstrapped from a --validators file and follows rotations only through sets attested by the set it holds. (a) A node offline across rotations, or given an old file, trusts a set whose keys may since have lapsed or leaked. (b) A quorum signs a far-future set or input that nothing can replace. (c) Stake holding more than a third of a set leaves the chain and keeps its veto over the set's successor for as long as nodes hold the set Anyone who supplies the bootstrap file; holders of old attest keys; a departing validator with over a third of a set (a) Every set carries not_after <= block + VALIDATOR_SET_LIFETIME_BLOCKS (24 windows). Past it the node accepts nothing more from the set and re-anchors on the operator's --validators file, logging a JSON event. It does so on an attested directory past not_after; when the operator installs a file, which overrides whatever its block; or when no set has been accepted for VALIDATOR_SET_LIFETIME_BLOCKS × BLOCK_SECONDS of monotonic time. That last trigger is the exit veto: counting from sets, not inputs, keeps a selective blocker that still attests directories to about 24 windows, not about 48, and it is a reload trigger only, never a block or trust decision. On the automatic triggers a file older than the held set, or already expired, is refused (F4). (b) accept_next_set needs a higher block by at most MAX_SET_ADVANCE_BLOCKS (2 windows), tables and snapshots are at most the directory's window + 1, a directory is never before the set's block or past its not_after, its window is at most block / 360 + 1 and advances at most (block − held.block) / 360 + 1 from the held one, and a newer directory never lowers block. A captured quorum could chain sets 720 blocks apart faster than real time, so nodes rate-limit set and directory blocks against their monotonic clock, the slack counted once from the first directory after anchoring (F2; residual T87). (c) A set's stake is each hotkey's minimum metagraph stake over SET_STAKE_LOOKBACK_WINDOWS (24), so departed stake weighs nothing in the next set, and the set it still sits in lapses within 24 windows. The exit veto is bounded by operator file replacement: once the set lapses (trigger 1, by directory or clock floor) or the set timer fires (trigger 3), the node reloads its file, and if that still holds an older or the same set it refuses it, raises validator_set_stale and stays on its last inputs until the operator installs a current set (sim set_exit_veto: 24 + R windows, R the operator's response). An eclipse delays expiry at most by the time left at the last directory: the floor runs at half the chain's pace from the last accepted directory (each one raises it to its block; rotations and re-anchors keep it, and only a rollback override drops it), so a binding or set with t blocks left at the last accepted directory expires within 2t blocks of the node's uptime after it, and of real time within one Linux or macOS boot, whatever is withheld; a set expires, and the stale alarm fires, within about 58 h of uptime (twice the 8_640-block lifetime, 2 × 28.8 h) after its last directory. Restarts never reset the floor: its progress is written every FLOOR_SAVE_BLOCKS (5) of its blocks with no input arriving and at every restore onto a new clock, and a restore resumes it from the block it had reached. A restart in the same boot (by boot_id, or macOS kern.bootsessionuuid) keeps its clocks, downtime included; one onto a new clock loses at most the run since the last write, under 2 min 10 s of uptime, which the bound adds once per such restart (fix rounds 3 and 4; sim eclipse_restart_expiry; tests signed_input_an_eclipse_with_restarts_still_expires_within_2t, signed_input_the_floor_counts_from_the_last_directory_not_the_first, signed_input_a_reanchor_during_an_eclipse_keeps_the_floor, signed_inputs_cli_a_reboot_with_the_clock_held_back_still_expires_the_set). Task 11c runs the re-anchor flow, walks every next/<identity> set (or after/<block> when no store knows the held set, OQ-67 (b)) before the directory, and checks expiry on a clock floor so withholding directories can't keep a set alive (datapath.md, "Signed inputs"). Residuals: the file is only as fresh as its operator keeps it; each anchoring on the file grants one jump (T87) routing.md §Signed tables, snapshots and peer directory, ADR-0042 item 5 a_new_validator_set_needs_the_old_sets_quorum, a_far_future_set_is_refused, a_far_future_directory_window_is_refused, a_directory_cannot_move_block_backwards, a_set_expires_and_its_stake_is_the_lookback_minimum (Task 11a); sim set_exit_veto (a 40% blocker is out of the node's set N = 24 + R windows after its chain stake reaches 0, R the operator's response swept over 2, 10 and 40 windows; payoff max(N - R) = 24 against bound 24) and set_exit_veto_is_the_lifetime_plus_the_operators_response (N = VALIDATOR_SET_LIFETIME_BLOCKS / 360 + R for each R); signed_input_only_an_attested_expired_directory_triggers_a_reanchor, signed_input_an_installed_file_overrides_even_an_older_set, signed_input_the_set_timer_counts_from_the_last_accepted_set, signed_input_set_and_directory_blocks_advance_no_faster_than_the_clock (Task 11c)
T60 OPEN, detected and recorded (ADR-0042, red team 6; Task 11c). Equivocating quorum. Validators holding the quorum attest two different objects for one domain and window, and show different nodes different tables, snapshots or directories Colluding validators with more than two thirds of a set's stake Honest validators attest at most one object per domain and window. AppliedInputs refuses a second attested object for the window it holds as SignedError::Conflict, so a node never switches within a window. Both node kinds keep the first and record the pair as evidence (both objects and their attestations, in the state directory's evidence/), logged once as SignedInputEquivocation naming only the keys that signed both (OQ-68), the first pair per domain and key and at most MAX_EVIDENCE_RECORDS (64) and MAX_EVIDENCE_BYTES (16 MiB) in all, so equivocations can't fill a disk (RT5), and do the same for equivocations a fetch finds across peers, so the equivocation can be shown to others; what is done with the evidence (slashing, publication, a failure challenge) is open routing.md §Signed tables, snapshots and peer directory, ADR-0042 item 7 an_older_window_signed_table_is_refused_and_the_last_one_kept, a_directory_cannot_move_block_backwards (Task 11a; Conflict on a second attested object); signed_input_a_second_attested_object_for_one_window_is_evidence (Task 11c), signed_input_evidence_is_capped_and_first_per_key (fix round 1)
T61 MITIGATED (Task 4C, ADR-0039; fix round 1). Forged or withheld outside evidence. A validator signs records the source never published (a fake origin, upstream or ix_presence for a miner's ASN), or leaves a real record out Validator Scoring reads only agreed records (validator::tempo_agreed_records): a record counts when at least MIN_VALIDATORS hotkeys with positive stake carry it and they hold PROBE_STAKE_QUORUM_PPM of the total (recorded_stake once attestation-key records exist; OQ-59). With records, a window under PROBE_PARTICIPATION_FLOOR_PPM of recorded stake agrees nothing (red team RT1), and with no stakes and no records nothing is agreed outside sim and localnet (RT5). One validator's object can neither add nor remove an agreed record. usable_evidence drops bad signatures, wrong-source records (the object is invalid as a whole) and all but the newest object per (validator, source). Residual: validators holding a third of recorded stake, with recorded stake at least half of all stake, can jointly add records (the probe-key bound, T21). The minimum is therefore 1/6 of all stake: a third of a recorded half (sim origin_stripper, fix round 2) measurement.md §Outside evidence evidence_minority_injector, origin_stripper; a_record_from_one_validator_is_not_agreed, agreed_records_need_the_stake_quorum, agreed_evidence_quorum_is_measured_against_recorded_stake, below_the_participation_floor_nothing_is_agreed, the_count_quorum_needs_the_explicit_switch, a_record_from_the_wrong_source_invalidates_the_object
T62 OPEN, bounded (Task 4C), OQ-58. Stale evidence re-signed. A validator keeps importing an old snapshot under each new window, so a record the source has withdrawn (a revoked ROA, a de-peered upstream) stays in its usable evidence Validator validate refuses fetched_block > (window + 1) * WINDOW_BLOCKS (fix round 1), which only catches an impossible claim; an old fetched_block passes. The quorum bounds it: the record stays agreed only while enough stake reports it, so one validator alone keeps nothing alive measurement.md §Outside evidence fetched_block_after_the_window_is_invalid
T63 MITIGATED (Task 4C fix round 1, red team RT2). Scope pollution. Fix round 0's evidence-scope added the origin ASN of any retained origin record covering a scope endpoint, from any validator, so one validator could add tens of thousands of ASNs to every honest scope and push honest scoped imports past MAX_WIRE_BYTES, where they were refused Validator Scope ASNs now come only from this validator's own evidence or from agreed records (evidence::scope_origin_asns). An origin prefix shorter than /8 (IPv4) or /16 (IPv6) makes an object invalid. On overflow, records that entered only by scope ASN are dropped and endpoint matches kept (evidence::fit_to_wire). Scope endpoints are public unicast only (R12). Residual, fix round 2 (F3): colluders who reach agreement (at least 1/6 of all stake, T61) could use fake origins to widen honest scopes until an import overflowed and dropped its ASN-only records, so they could remove honest IXP and upstream records, not only add fake ones. Now agreed origins are capped at MAX_AGREED_SCOPE_ORIGINS per endpoint, and on overflow the underlay (priority_asns) records are the last ASN matches dropped. What remains: up to four fake ASNs per endpoint in a scope, and records of ASNs that are neither own, underlay nor among the capped agreed ones can still be dropped by an overflow measurement.md §Outside evidence scope_polluter, origin_stripper; agreed_scope_origins_are_capped_per_endpoint, scope_asns_come_only_from_own_or_agreed_records, fit_to_wire_drops_asn_only_records_on_overflow, an_overflowing_scoped_import_keeps_the_endpoint_matches, origin_prefixes_shorter_than_8_or_16_are_invalid
T67 OPEN, model-only (ADR-0038, not scored). Sample favouring and blame by omission. (a) A relay forwards the packets it guesses are sampled and drops some of the rest, so end-to-end sampling under-reports its loss. (b) A relay drops packets and leaves their digests out of its HopDigestBatch, so attribute_loss charges the loss to the link into it, keyed by the point before it: the previous hop, or the ingress if the relay is the first hop Operator (a) The epoch key is secret while packets cross and sampling is a keyed hash of the hop digest, so a guess is independent of the sample, and the batch is signed and published before the ingress reveals the key (check_batch_order, per ingress): the favourer's sampled loss equals its real loss. (b) Not prevented: without per-packet acknowledgements the two ends of a link can't be told apart. The omitter can't escape its own link, though: since fix round 1 the ingress is point 0, so digests no hop holds go on the ingress-to-first-hop link instead of on nobody (sim first_hop_omitter). Attribution is evidence about the link, never the hop alone, and whatever pays or penalises on it charges the link or corroborates with validator vantage probes (T29). A hop missing a digest that a later point holds proves its own batch incomplete. Withheld and late batches are T71 receipts.md §Hop digests, measurement.md §Secure sampling sample_favourer, first_hop_omitter (model-only); sampling_ignores_hop_limit_and_traffic_class, attribute_loss_blames_the_hop_that_dropped, loss_before_the_first_hop_is_charged_to_the_ingress_link, a_digest_batch_for_an_epoch_whose_key_is_revealed_is_refused
T68 OPEN, model-only (ADR-0038, not scored). Forged digests and spoofed sources. (a) A hop claims digests it never received, to take credit for delivery or to cover an upstream colluder's drops. (b) A node injects packets with another node's source address so a path appears to carry its traffic Operator (a) Only digests in the ingress's own sampled set count, and delivery is credited only where the next point also holds the digest, so a forged digest earns nothing and only moves blame onto the forger. (b) Pay requires end-to-end source verification: sampled delivery counts only digests the source's own batch holds (verified_delivered); a sampled packet at a hop that the claimed source never committed is spoof evidence. (c) Replay: a relay on the victim's path drops the original and replays it over a path its own operator holds, perhaps claiming it in that path's source batch. The model credits each digest at most once, to the path whose source batch and every hop hold it and that no other source's batch claims, so replaying earns nothing and claiming loses both paths the digest (griefing the victim path's other hops). That crediting rule isn't specified yet (OQ-66). Residual: a colluding ingress, hop and egress can sign anything (ADR-0038 §9) receipts.md §Hop digests, OQ-66 digest_forger, source_spoofer (model-only; credit through verified_delivered)
T69 OPEN, model-only (ADR-0038, not scored). False reports. A reporter files link-failure or spoof claims with no evidence, with forged or unsigned batches, with reveals that don't chain to the ingress's anchor, or against a path it owns a node on, to farm the failure bounty Any UID's hotkey A claim is confirmed only if every cited HopDigestBatch and SampleKeyReveal verifies, every reveal chains to the anchor (check_reveal_chain), and the objects themselves show the loss or spoof; a claim citing no digests is never confirmed. No credit to a reporter whose UID owns a node on the reported path. Spoof credit is 0 while HOP_DIGESTS_SCORED is false (Task 16c). The order rule keeps revealed keys per ingress and takes a reveal only if the ingress it names signed it, so nobody can void the evidence about another ingress's flow by signing reveals for the window's last epoch (red team RT1, fixed in fix round 1) receipts.md §Hop digests, ADR-0038 §6 false_reporter, reveal_kill_switch (model-only); a_self_signed_reveal_from_an_unrelated_key_refuses_nothing
T70 OPEN, recorded (ADR-0038 red team RT2), not scored. The reveal names no egress. A SampleKeyReveal carries ingress, window and epoch but not the flow's egress, and one ingress serves many egresses. (a) Grinding: an ingress with several flows, or one that re-anchors, can choose after seeing what was lost which key chain it says applied to a flow. (b) Cross-flow false claims: a reporter pairs one flow's reveal with another flow's batches, so packets that flow never carried look sampled and lost Ingress operator; any UID's hotkey Planned fix, not built: an egress field in SampleKeyReveal; one anchor per (ingress, egress, window), committed before the window starts; the ingress's batch split into per-egress sent sets, so a sampled set is tied to one flow. Until then HOP_DIGESTS_SCORED stays false and Task 16c pays no spoof credit measurement.md §Secure sampling, ADR-0038 §9 planned sims anchor_grinder, cross_flow_reporter
T71 OPEN, recorded (ADR-0038 red team RT4), not scored. Omission and withholding blame the hop behind. A hop that drops packets and omits their digests, or publishes no batch, a late batch, or two batches for one epoch, makes attribute_loss charge the loss to the link into it, keyed by the point before it (T67 b) Operator Planned fix, not built: a missing, late or duplicated batch puts the epoch's loss on both of that node's links, keyed to that node, so withholding never helps; and a per-link, per-epoch packet count in the co-signed hop receipt, so a downstream node that co-signed n packets can't claim fewer digests without contradicting its own signature receipts.md §Hop digests planned sim downstream_framer
T72 OPEN, recorded (ADR-0038 red team RT5), not scored. The egress knows every key. The key chain derives from the flow's mask_key, which the egress holds too, so the egress can compute every epoch key in advance, tell a colluding relay which packets will be sampled, or treat sampled packets differently itself Egress operator with a relay Planned fix, not built: derive the chain from a secret only the ingress holds, so the egress learns each key from the reveal like everyone else. ADR-0038 §9 lists it as a known limit until then measurement.md §Secure sampling, ADR-0038 §9 —
T73 OPEN, recorded (ADR-0038 red team RT6), not scored. The two ends have a veto. Attribution needs the ingress's batch (the sampled set) and the egress's (what arrived). An end that withholds its batch voids attribution for the whole path, and an egress that leaves digests out frames the last hop Ingress or egress operator Planned fix, not built: when an end's batch is missing, attribution falls back to the co-signed hop receipts for that path and epoch, and the missing end is charged for the gap receipts.md §Hop digests planned sim edge_veto
T74 OPEN, recorded (ADR-0038 red team RT7), not scored. Determinism. Validators may disagree on whether a batch came before its reveal (OQ-63), may hold different ones of two batches or two reveals published for one epoch, and nodes' epochs don't align under clock skew, so evidence citing batches isn't byte-identical across validators (Invariant 1) Any node; network conditions Planned fix, not built: an ingress reveals keys only after an on-chain manifest commitment of a per-window batch index (OQ-64 option a), so what counts is fixed on chain before anyone learns the sample, and a second object for one epoch voids that node's epoch (T71). Until then nothing is scored receipts.md §Hop digests, measurement.md §Secure sampling, OQ-63, OQ-64 —
T75 MITIGATED (Task 11b, red team 4 of Task 11a). Hiding the latest input. Anyone who can store an object (a loopback caller, or a mirror that copies objects in) adds an unattested, under-quorum or out-of-bounds object with a higher window or block, even u64::MAX, so latest serves it and nodes never see the real one. Or they flood the store with such objects so every latest request re-verifies thousands of signatures Anyone able to put objects into a store; any remote reader for the CPU cost latest admits only objects a node holding the store's current set would take (signed::rank_published): the set's quorum, the directory bounds of ADR-0042 item 7, tables and snapshots at most the latest directory's window + 1, and validator sets reached by accept_next_set from the anchor (so at most MAX_SET_ADVANCE_BLOCKS a step). Keys are checked from the highest down and results are cached until a publication object is stored, so repeated reads verify nothing. Object PUT stays loopback-only. Residual: a loopback writer can still make one ranking pass expensive, bounded by MAX_STORED_OBJECTS and MAX_ATTESTATIONS routing.md §Distribution object_store_latest_ignores_unattested_and_out_of_bounds_objects, object_store_latest_returns_the_validator_set_with_the_highest_block
T76 MITIGATED in core, node flow open (Task 11b). Bad mirrors. A peer serves a junk, stale, truncated or oversized copy, never answers, trickles bytes, or withholds one of two equivocating objects. A validator's peer serves junk attestations for the merge Any peer a node or validator fetches from fetch::get has one 5 s deadline for the whole exchange, a body limit checked before and while reading (digits-only Content-Length), and http:// with IP literals only, so no resolver call escapes the deadline. Peers are deduplicated, capped at MAX_FETCH_PEERS and asked in parallel, so silent peers cost one timeout in total (fix round 1). Every copy is checked after the fetch (hash, structure, rank_published), a bad one is recorded and the next peer used, and fetch_latest asks every peer so an equivocation shows up when any honest peer holds the other object. publish_attested keeps only attestations that verify over the object's own bytes. Residual: a node whose peers all collude is served only their objects; it stays on its last accepted inputs and can be held back, never moved to a forged one (OQ-68, Task 11c) routing.md §Distribution fetch_latest_tries_the_next_peer_on_a_bad_copy, fetch_latest_records_an_equivocation_across_peers, fetch_times_out_on_a_silent_server, fetch_latest_total_time_bounded, publish_attested_drops_peer_attestations_that_do_not_verify
T77 MITIGATED (Task 11b fix round 1, review and red team finding 1). Copies fill the live store. Every republish round merges new attestations into a new copy with a new hash. The store is write-once and the round put the merged copy into the live store without dropping the copies it superseded, so copies built up until MAX_STORED_OBJECTS refused every put, and publishing and receipt ingest stopped Any validator running serve, triggered by peers' attestations arriving over time; a peer that varies its attestations speeds it up Publisher::republish_once puts each merged object into the live store and then calls drop_superseded_copies there: copies whose valid signers are all on the merged copy are removed, and a copy with a signer the merged one lacks is kept. publish_attested does the same on the store it is given. Old windows still aren't pruned (OQ-67) routing.md §Distribution republish_keeps_one_copy_per_object, publish_attested_keeps_one_copy_per_object
T78 OPEN, recorded (ADR-0044). Another process of the same user reaches the agent's control socket or its keychain entry and acts as the owner Local malware running as the owner Socket mode 0600 and a peer UID check; the channel's command set is closed and none of its commands reads or writes a key; the hotkey is optional and the solver role off by default adr/0044, desktop design §4.2, §7 bwos-ipc tests
T79 OPEN, recorded (ADR-0044). The owner is tricked into importing a hotkey, or a coldkey, into the agent Social engineering; a malicious script Import is an explicit command in the agent's own process, never over the channel, with a one-sentence warning; a coldkey is refused; nothing else reads ~/.bittensor adr/0044 agent import tests (PB-21 part 2)
T80 OPEN, recorded (ADR-0044). The binding request is altered between export and signing, binding the node key to another hotkey Local malware; a compromised UI bwos bind shows the node key and hotkey it signs; the signed binding is verified against the node key on import adr/0044, identity.md agent binding tests (PB-21 part 2)
T81 MITIGATED (Task 11b fix round 1, review and red team finding 2). Attestation crowding. A peer serves valid attestations from throwaway keys, fresh each round. The merge kept every key that verified, so the merged copy grew every round (and with T77, so did the store); past MAX_ATTESTATIONS, keys sorting before the real validators pushed real attestations out and the copy fell below quorum A malicious or compromised peer validator, or anyone who can store a copy locally publish_attested merges, and /v0/attestations serves, only keys in ObjectStore::known_attestation_keys() (anchor, current set, stored sets), dropping outsiders before any cut; its own attestation is always kept. Residual: a stored set, even an unattested one, adds its keys to the known set, and only a loopback caller can store one routing.md §Distribution attestations_for_serves_only_known_set_keys, publish_attested_ignores_fresh_outside_keys_each_round
T82 OPEN, bounded (Task 4B; Task 4C red team residual). Underlay ambiguity grief. Validators who reach evidence agreement (T61) get a fake origin and a matching fake roa_origin agreed for a victim's prefix, at the same length as the real one. Agreed origins enter a scope at most MAX_AGREED_SCOPE_ORIGINS per endpoint, lowest ASN first, so they pick low fake ASNs. Two RPKI-valid origins then share the longest prefix, and the victim has no underlay ASN Colluding validators An ambiguous underlay is treated as no evidence: no upstreams, ixps or srg, diversity_ppm = 0, and unknown risk, so the victim can't be an interior node of a resilient route with a backup (RT9). Endpoint dedupe doesn't read the ASN, so it is unchanged. The victim loses at most DIVERSITY_WEIGHT_PPM + IXP_PRESENCE_WEIGHT_PPM of C_n (1.1x to 1.0x), only on carried bytes. The colluders gain nothing directly. It needs T61's stake minimum (1/6 of all stake) measurement.md §Underlay ("Ambiguous underlay"), scoring.md §Coverage underlay_ambiguity_griefer, underlay_ambiguity_mass_grief (every honest node hit, fix round 1), resilient_unknown_risk_steering (latent until resilient is in demand, OQ-81); an_ambiguous_underlay_gives_no_bonus_and_an_unknown_srg
T83 MITIGATED, residuals recorded (PB-04; OQ-73 closed by Task 9 fix round 1). ASN squatting: a node's overlay ASN is its key's, so an attacker grinds a node key whose ASN equals a victim node's (about 95 million keys for a chosen ASN, cheap) to originate the victim's /128 or get the victim left out of the snapshot. A fleet-mate originating another fleet node's /128 is the same attack without the grinding, under the old UID-based ASN Operator; stranger Fleet-mates have distinct ASNs. The snapshot builder leaves out every live node that loses its ASN (Task 9 fix round 1, ADR-0033 item 4 amendment): F1 incumbency comes from the committed snapshot (current_snapshot), so every validator computes the same; F2 the earliest binding commitment on chain wins, then the lower asn_tie of the hash of the block after it, and a grinder can't commit before it has seen its victim's key, so it always loses, to an incumbent or to a newcomer; F3 the snapshot carries each ASN's claim for SNAPSHOT_INCUMBENCY_WINDOWS windows after its node was last in it, so a squatter can't take the ASN while the node's binding or consent is lapsed or it is quarantined. Origins refuse a colliding peer alone (F4), and two snapshot nodes with one ASN refuse the snapshot, so a collision never reaches a node's origin lists. Residuals: (1) until Task 19b fills binding_committed_blocks, only incumbency ranks anyone, so two colliding newcomers are both left out (round 1's newcomer blocking). (2) An operator who serves its binding, or otherwise leaks its key, before the commitment is included lets a grinder put M colliding keys in the same block; the tie then picks among M + 1, so the victim keeps its ASN with probability 1/(M+1), not one half (run-a-node.md). (3) A key committed early ranks before every later node it happens to collide with, incumbents included: an incumbent whose binding was committed later than a colliding key is evicted when that key goes live. With K committed (possibly dormant) keys, up to 1024 per fleet binding (MAX_FLEET_NODES), and N later nodes, about K·N/95M random later nodes are evicted (inferred), each of which rotates its key. Recommended follow-up rank: first admitted window (the first snapshot the node was in), then commitment block, then the tie, so a dormant early commitment can't outrank a node already admitted; Task 19b must reset a node's commitment block when its binding lapses, so a lapsed binding committed again ranks from its new block Task 19b: residual (1) closed: the live loop fills binding_committed_blocks from its chain reads and resets the block on any lapse. scoring.md §Snapshot inputs, datapath.md "Route origin validation", adr/0033 item 4 a_ground_key_that_collides_with_an_incumbent_is_refused_and_the_incumbent_stays, the_earliest_binding_commitment_wins_between_newcomers, a_claim_outlives_a_lapse_and_then_expires, sims asn_incumbent_evict, asn_grind_newcomer_block, asn_squat_after_lapse, fleet_mate_origin_hijack
T84 MITIGATED (Task 9 final check). Claim-map growth: a snapshot keeps each ASN claim for SNAPSHOT_INCUMBENCY_WINDOWS (24) windows after its node was last in it, so one UID binding MAX_FLEET_NODES (1024) fresh keys every window would keep about 24 × 1024 claims. With a block and a tie each, that passes MAX_OBJECT_BYTES (4 MiB): measured in the T84 test with the cap taken out, the signed snapshot reached 4,318,080 bytes before window 30 and canonical encoding refused it, so the signed snapshot can't be published and every node keeps the last one Operator Each claim records its node's uid; a UID holds at most MAX_FLEET_NODES claims, the claims whose node was in a snapshot longest ago dropped first, then the lowest ASN (validator::cap_claims_per_uid). A UID's nodes in the snapshot are its newest claims, so only lapsed ones go. Residuals: a UID rotating keys drops its own lapsed claims, so its old ASNs free early, which costs only that UID. Across UIDs the map is still unbounded below 4 MiB: about 24 UIDs each at the cap with full claims would pass it (inferred from the measured size, about 170 bytes a claim), as would the nodes of a snapshot that large. A global bound needs ADR-0046's MAX_SNAPSHOT_NODES (proposed), which should cap claims as well as nodes scoring.md §Snapshot inputs, routing.md one_uid_rotating_fresh_keys_keeps_its_claims_capped_and_the_snapshot_publishable, the_claim_cap_drops_the_oldest_then_the_lowest_asn
T87 OPEN, bounded (Task 11c, fix round 1). Anchoring jump. A node's rate limit on set and directory blocks counts from the first directory it accepts after anchoring on the operator's file (at start or on a re-anchor). Before that first directory it accepts sets and directories up to the file's set's not_after (anchor_cap) plus MAX_SET_ADVANCE_BLOCKS, so a captured quorum that catches a node at an anchoring can move it up to one set's remaining life ahead at once, and from there chain sets at real-time speed. Restarts don't re-grant it (RT1): the base is persisted with a wall-clock stamp Holders of attest keys with a quorum of the set a node holds, at the node's start or a re-anchor now_block <= anchor_cap + 2 × MAX_SET_ADVANCE_BLOCKS + elapsed / BLOCK_SECONDS (anchor_cap + 1440 + elapsed), where anchor_cap is the file's set's not_after, never a later held set's. A restart comes back on the lower of the persisted base and the held directory's block, moved on by the wall-clock downtime, and that credit is capped at the held set's remaining life (fix round 2, F1), so the cap after a restart is never above held set not_after + 720 + blocks elapsed since the restore, however far a spoofed wall clock jumps. The credit is recomputed at every poll after a restore onto a new clock, until the next re-anchor, so a forward jump while running counts too, within that same cap. A wall clock behind the state's stamp at the restore (no RTC, a start before NTP syncs, or a stamp taken while the clock was pushed) is taken as unknown: the rate limit gets that whole cap at once (fix round 3). The stamp itself is the wall clock read at the first poll or restore plus monotonic time since, so a clock moved while the node runs never reaches it. The expiry floor and the set timer get no downtime credit on a new clock at all (fix round 4), so a clock jump can't expire bindings or raise an alarm either. Across restarts onto new clocks now_block <= first + 720 + uptime / 12 s + Σ cᵢ, where restart i's credit cᵢ is the wall-clock downtime capped at the held set's remaining life at that restore, and is that whole remaining life when the wall clock is behind the stamp, whatever the real downtime (so even an honest boot with no RTC takes the full cap); with an honest clock this is first + 720 + Σ downtime / 12 s plus the uptime. The operator's file is an override that drops the captured inputs (rollback). Residual: a wall clock moved around a restart, or forward at any poll after one, widens the cap by up to the held set's remaining life, once per restart (OQ-77) datapath.md "Signed inputs", ADR-0042 item 5 signed_input_set_and_directory_blocks_advance_no_faster_than_the_clock, signed_input_restarts_cannot_chain_anchoring_jumps, signed_input_a_wall_clock_jump_across_a_restart_is_bounded, signed_input_a_forward_spoof_while_running_does_not_lock_out_after_a_restart, signed_input_a_credit_after_a_rotation_keeps_the_new_sets_timer, signed_input_a_restart_onto_a_new_clock_gives_the_set_timer_no_credit, signed_inputs_cli_the_set_timer_counts_uptime_across_a_reboot
T88 MITIGATED (Task 11c). Fetch stall. A store that accepts a connection and never answers, or trickles bytes, holds a node's input path, and on a single-threaded node its forwarding Any listed store, or anyone on the path to it Fetching runs on its own thread (signed_input::Fetcher) with FETCH_TIMEOUT per request across all peers at once; the node's loop takes a finished poll only if one is waiting. Peers are IP literals, so no resolver call runs outside the deadline datapath.md "Signed inputs", routing.md §Distribution a_slow_object_server_never_stalls_forwarding
T89 ACCEPTED (Task 11c). State tampering. The node trusts its own signed-inputs.json after a restart without checking attestations again, so whoever can write the state directory can make it apply any table Anyone with write access to the node's state directory That directory also holds, or sits beside, the node key, so write access there already owns the node. The set it holds is validated (ValidatorSet::validate) and the directory structurally checked on load; a state that doesn't parse is logged (SignedStateUnreadable) and the node starts from the operator's file datapath.md "Signed inputs" a_restarted_node_loads_its_last_applied_window_and_refuses_older
T90 OPEN, bounded (Task 4B). Forged agreed underlay. The same colluders get fake origin, roa_origin, upstream and ix_presence records agreed for their own nodes' prefixes, giving those nodes a unique network with two upstreams and an IXP Colluding validators with miners Diversity saturates at two upstreams and one IXP, and multiplies only carried bytes. A forged node therefore earns at most 1e6 + DIVERSITY_WEIGHT_PPM + IXP_PRESENCE_WEIGHT_PPM (1.1x) of its own usage term, and only while T61's stake minimum holds measurement.md §Underlay, scoring.md §Coverage agreed_underlay_forger, underlay_ambiguity_mass_grief (with T82: colluder share at most 1.1^2 of its honest share)
T91 MITIGATED (Task 4B fix round 3, finding 1); inert until an endpoint producer exists. Stuffing the endpoint-less pool. Fix rounds 1 and 2 pooled every node with verified capacity and no endpoint into one global group credited up to its largest member, so an attacker with many cheap endpoint-less nodes took a share of the largest honest member's capacity (about 50x at 100 nodes of 10 Mbps), and an honest endpoint-less node got 1/n of its own Operator An endpoint-less node gets zero scoring capacity while endpoint dedupe is on: nothing to K_u, its own dedupe group, usage credit for bytes on assigned paths kept and capped at its own verified capacity. No shared pool exists to stuff. Residual: an honest node without an endpoint (a carrier spreading it over several /24s, or a split vote, T92) loses its capacity credit for the window. Dedupe turns on only when the batches carrying endpoints meet the stake quorum (finding 3), so a few validators running a producer can't zero everyone measurement.md §Probed endpoints ("Dedupe"), scoring.md §Endpoint dedupe unknown_group_stuffer, endpoint_absent_sybil, cgnat_honest_node; nodes_with_capacity_and_no_endpoint_fail_closed, the_winning_prefix_needs_a_majority_and_dedupe_needs_the_stake_quorum
T92 MITIGATED, with a residual (Task 4B fix round 3, finding 2); inert until an endpoint producer exists. Picking a node's dedupe group with two hotkeys. A colluding pair can meet MIN_VALIDATORS and the quorum together and report a victim inside a /24 of its choosing, pooling victims' capacity Colluding validators The winning prefix must also hold more than half of the stake that reported the node, so the pair wins only with a majority of the reporters, and honest validators agreeing on one prefix keep the group. Residual: a split vote. When honest reports split across two prefixes (a dual-stack node), no prefix may hold a majority, or the larger side misses the quorum (honest 30% and 25% with the attacker silent). The node then has no endpoint: it keeps usage credit and gets no capacity credit (T91). Colluders can turn a split that would pass (honest 40% and 15%) into one that doesn't by reporting a third prefix, a grief with no gain to them measurement.md §Probed endpoints ("Quorum and majority per prefix") endpoint_minority_pool_griefer (one and two hotkeys; split-vote figures in its detail); the_winning_prefix_needs_a_majority_and_dedupe_needs_the_stake_quorum
T93 A node shades the STAMP RTT on the probe session it opened: it answers a test before it arrives, guesses the next one, or writes timestamps that shorten the RTT (Task 4Db, ADR-0039) Operator Every seq is fresh OS randomness and the gaps are exponential, so nothing can be answered early; a reply counts only if its sender_seq and ssid match a test already sent and it comes within STAMP_REPLY_DEADLINE_MS; the RTT is T4 - T1 on the agent's clock and the node's timestamps never enter it. A node can only add delay measurement.md §STAMP probes and probe sessions a_stamp_reply_before_its_test_left_or_after_the_deadline_is_lost, a_reply_with_a_foreign_seq_or_ssid_counts_for_nothing
T94 OPEN, recorded (Task 4Db). A node gives its probe sessions priority over real traffic, and looks better to vantage: than it treats customers. It knows which sessions are probe sessions and that STAMP is a probe Operator Not closed by probing. Link, direct and path canaries stay random-payload and inside ordinary traffic; only measuring carried traffic (ADR-0038 secure sampling, pay moving to carried traffic) closes it measurement.md §STAMP probes and probe sessions, Residuals —
T95 A probe key is used as a way into the node: a listed probe peer, or someone holding its key, sends BGP, transit or traffic to other addresses on the probe session, or spoofs another source, or floods the node's reflector with STAMP tests (Task 4Db) A validator's probe agent; a thief of its key A probe peer is never in the FIB or a route's path and has no BGP or BFD; the node takes only STAMP tests from its probe address to its own /128 and drops the rest in drop_probe_peer. The reflector answers each probe peer at most PROBE_PEER_STAMP_PER_SEC (20) tests a second, with a burst of PROBE_PEER_STAMP_BURST (20), from a token bucket on the node's clock; tests over it are dropped and counted in stamp_rate_limited (fix round 1, red team RT4) datapath.md §Peer admission, "Probe peers" a_probe_peer_gets_no_bgp_session_and_no_routes, a_probe_peer_flood_is_rate_limited
T96 Strangers open sessions to a probe agent to use up its session slots, its memory or its handshake work, so the agent can't probe honest nodes and they take vantage: failures (Task 4Db; fix round 1, red team RT1) Anyone on the internet; a framer The agent opens a session only for a bound key (a node it knows by its binding), so strangers never take a slot, and the slot count is checked before any key agreement. Every session's Tunn shares one boringtun rate limiter (PROBE_AGENT_HANDSHAKES_PER_SEC, 100), checked before the agent's own handshake parse: past it, an initiation needs a cookie for its source address, so a spoofed flood costs the agent no key agreement. At most MAX_PROBE_SESSIONS (1_024); the socket drops datagrams over 1,500 bytes measurement.md §STAMP probes and probe sessions bound_nodes_get_a_session_after_1024_strangers, sim vantage_denial_framer (bound 1.05x)
T97 MITIGATED for the cases policy_griefer covers (Phase B Task 7, PB-23; fix round 1); inert until a policy producer exists (OQ-88). Policy griefing of solvers. A relay's operator sets allowed_peers to refuse the sources a rival solver's table routes through it, hoping the rival's table turns invalid, regretful or dead in the data plane Operator, possibly with a solver Policy is read only from the committed snapshot, and a table is graded against the snapshot it was solved on (window == snapshot.window + 1), so every solver reads the policy before solving. The reference solver and the regret comparator read it, so respecting it is never regret. Nodes render it only from the solved-on snapshot (bgp-overlay refuses a policy snapshot of another window). What the sim covers: a relay refusing a source, with two honest solvers solving on the committed snapshot. No solver's rank changes, and the relay carries fewer routes, not more. Not claimed: that a policy can never draw more transit to a node. Policy only removes options at its own node, but removing a rival's path can shift a pair onto another relay the same operator runs. That's bounded by the other relay's own capacity and price, and not covered by a sim routing.md §Operator policy and §Validation ("Operator policy"), datapath.md §Operator policy, scoring.md §Mechanism 1 policy_griefer; a_route_through_a_node_whose_policy_excludes_the_previous_hop_is_invalid, a_policy_change_applies_from_the_next_committed_snapshot, the_reference_solver_respects_operator_policy
T98 MITIGATED (Task 7 fix round 1, red team F1); inert until OQ-88. Endpoint capture (Invariant 2). A source or destination names only its own colluding relay in allowed_peers, so every valid table must send its pairs through that relay, and the reference does too Operator with a relay Policy binds a node only as a relay, never as a route's end: an endpoint's policy constrains none of its own pairs, in validity, the reference solver, the comparator and rendering routing.md §Operator policy ("Policy binds transit only"), §Validation rule 0 policy_endpoint_capture (1.0x: the colluding relay carries 0 of the endpoint's pairs with the policy, as without; an honest table stays valid); an_endpoint_keeps_its_capacity_and_its_choice_of_relays_under_policy
T99 MITIGATED (Task 7 fix round 1, red team F2); inert until OQ-88. Regret-gate bypass. A source sets max_transit_mbps = 0. The first version lowered its whole capacity in the search view, so the regret comparator found no path from it, and the Mechanism 0 regret gate never zeroed a dealer's slow detour from that source through the dealer's relay Operator with a solver The transit cap is a separate per-node cap, checked only where the node is interior. Endpoints keep their snapshot capacity in every search, so the comparator still finds the fast path and the gate zeroes the detour routing.md §Validation ("Reference solver and regret") policy_regret_gate_bypass (0 ppm credit left on the gated detour); an_endpoint_keeps_its_capacity_and_its_choice_of_relays_under_policy
T100 MITIGATED (Task 7 fix round 1, red team F3); inert until OQ-88. Capacity pay for unusable capacity. A node keeps full verified capacity, and so its K_u share, while its policy (max_transit_mbps = 0, an empty or tiny allowed_peers) keeps solvers from using it Operator Scoring capacity is capped at min(deduped, max_transit_mbps), scaled by the share of other live nodes allowed_peers names, and naming fewer than two gives 0 scoring.md §Endpoint dedupe ("Policy cap") policy_capacity_farmer (0 Mbps credited above what policy leaves usable, in five cases); capacity_credit_is_capped_by_max_transit_and_scaled_by_admitted_peers
T101 MITIGATED (Task 7 fix round 1, red team F4); inert until OQ-88. Churn flapping. An operator flips its relay's policy every window, so each solver routing through it must move its routes and pay CHURN_PENALTY, against an incumbent with a previous table and not against a newcomer Operator, possibly with a rival solver Policy follows the declaration epoch: the policy in force for a window is the one read at its epoch's first window, so a change, tightening included, waits for the next boundary (validator::policies_in_force). A pair whose previous route breaks the policy in force isn't counted in churn_ppm. Residual: a route that breaks only the table-wide cap (rule 3) when moved still counts as churn routing.md §Operator policy ("When a policy applies"), scoring.md §Mechanism 1 policy_churn_flapper (0 ppm penalty, bound below EPSILON_ROUTE); a_policy_change_waits_for_the_next_epoch_tightening_included, moving_off_a_path_the_policy_now_forbids_is_not_churn
T102 MITIGATED (Task 4Dc fix round 1; OQ-93 closed). Withholding against a node just under its declaration. A member streamed its share but revealed no batch; it was dropped and the test judged on the other members' sent, though the node had spread its capacity over every stream, the headroom included. An honest node carrying x of its declaration showed ratio_t ≈ x / 1.1, haircut at x = 0.97 (0.59x of its credit) Validator S, pushed and the median term use the whole scheduled team's rates, revealed or not; Σ c_i stays over the revealed members (capped shares, T103, which this rule needs: without them two absent members and a colluder gave 3.64x). An honest node at 97% keeps 0.75x of its credit, never haircut; withholding never lifts a node above an honest declarer of its real capacity measurement.md §Team capacity tests ("Members that reveal nothing") withholding_near_declaration (0.749x, gating), void_by_withholding (swept 500-1000, at most 0.88x), withholder_fix_k2_colluder; a_withheld_batch_never_haircuts_an_honest_node
T103 MITIGATED, residual restated (Task 4Dc fix round 1, red team F1). Uncapped Σ m_i: one colluding member reporting m ≫ rate, with a node-signed ack, while the node starves one honest member gave 1.82x at k = 4, 2.73x at k = 3, and 3.64x with two colluders, no haircut. Cohort aggregates were inflated the same way Validator + Operator measured = min(Σ c_i, median) with c_i = min(m_i, rate_i), in node and cohort combining. Residual: (k-1)/(k-2) for one colluder (1.5x / 2x) and (k-1)/(k-3) for two (3x at k = 4), on the tests the colluder sits on (T42(b), (e)) measurement.md §Team capacity tests ("Combining", "Residuals") colluder_overreport_k4 (1.500x), colluder_overreport_k3 (1.997x), two_colluders (3.000x), colluder_overreport_end_to_end (1.500x); an_overreporting_member_is_capped_in_the_sum
T104 MITIGATED (Task 4Dc fix rounds 1-4, red team F3, N3, N4). Proven tiny-sybil slot flood: four UIDs of 1024 proven keys at 5 Mbps, each test taking four member slots whatever its rate, cut honest proven tests to 12% and honest fresh tests to 0 at 8 validators Operator Every tier, cohorts included, goes in a round-robin by UID by the smallest t_uid / weight_uid, where weight_uid = max(Σ prev_pooled_capacities, CAP_RAMP_FLOOR_MBPS × clamp(unproven nodes, 1, CAP_TESTS_PER_UID_MAX)): pooled capacity (T112), 0 for an endpoint-less node and one node per UID while dedupe is off (T114). A cohort is keyed by its members' smallest t_u / (weight_u · m_u / N_u) (T111, T115). A test that can't start holds its drawn free members for the block and waits up to CAP_TEST_DEFER_BLOCKS (4), then is skipped; a tier-3 test over the UID's CAP_TESTS_PER_UID_MAX is dropped before it is drawn. Bounds (fix rounds 3-4, worst of 3 seeds × 4 windows, make sim-flood): 0.85 for at most 8 flood UIDs at 8 or more validators, 0.80 for at most 16 at 8, 0.75 for at most 12 at 6 (16 at 6 not gated: 0.72 / 0.76); fresh 0.5 under 4 UIDs and 0.33 under 8-16, an entry delay (measured single 0.82-0.95, fleet 0.80-0.95, fresh 0.33-0.75; see measurement.md "Per-UID fairness"). Cost: notice of up to about 60 s (T41) measurement.md §Team capacity tests ("Slots, order and per-UID cap") proven_sybil_slot_flood; tiers_two_and_three_go_round_robin_by_uid, a_due_test_waits_for_a_free_team, a_failed_assignment_waits_rather_than_dropping
T105 OPEN (red team F4), blocks team mode. Test target not bound to the endpoint: nothing committed ties a team stream to the endpoint validators see on the node's sessions, so one sink box holding N node keys can answer the tests of N nodes whose endpoints are in N /24s (about 16x for 20 keys behind a 10 Gbps box) Operator Normative: team mode MUST NOT be enabled (Task 19b MUST NOT fill block_hashes) before Task 18b runs team streams inside source-matched probe sessions with a per-validator member agent; cap --team --target is localnet and test only. Plan Tasks 18b and 19b carry it measurement.md §Team capacity tests ("Team mode MUST NOT be enabled before Task 18b") test_target_offload (Task 18b)
T106 MITIGATED given Task 19b's anchor (Task 4Dc fix rounds 1-2, red team F6, N2, review R10). validator_sets trusted structurally, ties broken by a grindable hash: a forged same-block set could control E(b), an expired set stayed in force, and validators holding different sets disagreed Validator validator::verified_set_chain(anchor, sets) walks from TempoInput.prev_validator_set, the set in force at the previous window from chain state (Task 19b); a set counts only if the current set's quorum attests it (signed::accept_next_set); two accepted sets at one block are both refused and the current set stays; a set is in force only while b <= not_after; no anchor, no E(b). Before signed sets, a hotkey without an attestation record is never drawn (R8). See T109 Task 19b: the anchor is the metagraph-built set at the window's first block from committed records (the re-anchor rule; no committed in-force set hash exists yet), the same for every validator with the same reads. measurement.md §Team capacity tests ("Eligible validators") validator_set_tiebreak; validator_set_tiebreak_refuses_both_sets_at_one_block
T107 OPEN, recorded (red team F8; OQ-90). Cohort ceilings and chunk steering. (a) A group's credit is at most one team's budgets (10 Gbps at k = 4) and its best 16-node chunk, so a CGNAT /24 of 160 honest home nodes is credited as about 16 (0.1x). (b) Chunks are cut by sorted node key, which is free to grind: a planted key can push an honest member into a chunk of one, which isn't a cohort. (c) A budget-starved cohort member's low record entered its measured Operator (c) fixed in Task 4Dc fix round 1: a budget-starved member's record is ratio_only. (a) and (b) aren't redesigned; OQ-90's per-/24 measurement and ordering members by a block-hash slot key before chunking are the candidates measurement.md §Cohort capacity tests a_cohort_member_never_streams_more_than_its_budget, a_climbing_ramp_is_not_an_overclaim (ratio-only records)
T108 MITIGATED (Task 4Dc fix round 2, red team N1). Overflow draw: teams were drawn only among validators with a free slot, and every hotkey brings CAP_TEST_MAX slots whatever its stake, so under load (or the attacker's own key flood) tiny-stake hotkeys filled whole teams: 32 hotkeys at 3.85% of stake gave all-attacker teams on 73% of the attacker's tests and 66% of honest nodes' tests at 8 validators (the declaration credited for nothing; victims zeroed and haircut) Validator + Operator The team is drawn by stake from all of E(b) at each block; members without a free slot are dropped; the test starts with all drawn members free, or at least CAP_TEAM_MIN_VALIDATORS at its last chance, else waits. Bound: all-attacker teams at most 0.01 of tests, two or more attacker seats at most twice the stake-proportional rate, honest single-node UIDs at least 0.85 of their due tests (measured 0.000, 0.000 and 1.00 at 8 and 16 validators). The deferral's late-queue concentration (red team N6) goes with it: the late-queue beneficiary had no all-attacker team and no team of three measurement.md §Team capacity tests ("The team") validator_hotkey_overflow; the_draw_is_by_stake_never_by_free_slots
T109 MITIGATED given Task 19b's anchor (Task 4Dc fix round 2, red team N2, review minors 1-2). verified_set_chain grouped sets by block before checking attestation, and anchored on the lowest self-attested set: an unsigned set at an honest set's block voided it (at every block: no team tests), and a self-attested set below the honest chain took over E(b) Validator A trusted anchor parameter (TempoInput.prev_validator_set, from chain state); only sets the current set's quorum accepts are candidates, so an unattested or self-signed set can neither veto nor anchor; equivocation is counted only among accepted sets. Residual: the anchor is trusted as given, so Task 19b MUST take it from chain state Task 19b: prev_validator_set comes from chain reads, never a gossiped object. measurement.md §Team capacity tests ("Eligible validators") validator_set_tiebreak (unsigned sets at 200 and 300, attacker-signed sets at 50 and 250: chain stays [100, 200, 300])
T110 MITIGATED (Task 4Dc fix round 2, red team N3, N4). Schedule starvation after F3's fix: (a) a flood packaged as cohorts (tier 1, t_uid = 0, no cap) gave honest single-node UIDs 0.25, fleets 0.03 and fresh nodes 0.00 at 12 × 1024 keys and 8 validators; (b) the unweighted round-robin by UID gave a 200-node honest fleet 0.57 (0.22 against 12 flood UIDs) Operator Cohort tests count against every member's UID in the round-robin; the round-robin is weighted by the UID's verified capacity; tests hold their drawn free members (T104). Measured at 8 validators: 12 UIDs as node tests single 0.91, fleet 0.87; as cohorts single 0.97, fleet 0.86; fresh 1.00. Residual: a UID's weight is its own verified capacity, which only tests (and T42's colluder residuals) raise, so weight can't be bootstrapped beyond what inflated credit already gives; splitting into UIDs gains CAP_RAMP_FLOOR_MBPS of weight per UID registered measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") proven_sybil_slot_flood
T111 MITIGATED (Task 4Dc fix rounds 3-4, red team R1; bound re-ruled in round 4, review B2). A cohort was keyed by its members' largest t/w: honest multi-operator cohorts behind one /24 got 0.55 of due cohort tests with no flood and 0.18 under the 4 × 1024 flood (8 validators); cohort credit lapsed and the group was pooled to one member (about 0.6x on average) Operator Cohorts are keyed by the members' smallest t/w, still charged to every member UID (N3 stays closed: 12 × 1024 as cohorts 0.93 / 0.91). Measured (cgnat_cohort_turns, 3 seeds × 4 windows): mean 0.91, worst seed 0.88 with no flood; under the flood mean 0.83, worst seed 0.76. Gated at mean 0.9 and worst 0.85 with no flood, mean 0.80 and worst 0.75 under it. The lower flood bound is ruled, not a gap: about 16 cohort tests fall due per seed (±0.1 by sampling alone), and cohort-credit lapse, what pay sees, is 9/240 cohort-windows with or without a flood (T116(a)). Round 4 keys a cohort by each member UID's per-node weight (T115), unchanged for single-node UIDs. Residual: home nodes weigh the ramp floor, so once each member has had its own test the cohort trails larger UIDs measurement.md §Team capacity tests ("Per-UID fairness") cgnat_cohort_turns; a_cohort_takes_its_least_tested_members_turn
T112 MITIGATED (Task 4Dc fix round 3, red team R2, R4). Schedule weight from unpooled per-node verified capacity: 4 UIDs × 1024 co-located keys at 50-200 Mbps (≤ 1.1 Gbps in flight) cut honest single UIDs to 0.76-0.78 and the fleet to 0.51. The per-UID floor held a multi-node fresh UID to 0.38-0.57 Operator Weight = Σ pooled previous capacity (TempoInput.prev_pooled_capacities, the T24 figure pay uses, filled by Task 19b); floor CAP_RAMP_FLOOR_MBPS × clamp(unproven nodes, 1, CAP_TESTS_PER_UID_MAX). Measured: co-located flood single 0.93, fleet 0.89, fresh 0.75; fresh 0.50 under the 4-UID node flood (gated 0.5), 0.33-0.50 under 8-16 flood UIDs (gated 0.33 since fix round 4). Residual: bootstrapping the weight now needs real pooled capacity; colluder inflation (T42) remains; UID splitting: up to 4 × CAP_RAMP_FLOOR_MBPS (+400 Mbps) of weight per registered UID with four unproven keys (tier-3 capped); 32 holder UIDs × 4 keys keep the fleet at 0.87, 64 at 0.76 (red team L2, T116(b)). Endpoint-less keys and dedupe off: T114 Task 19b: the loop carries prev_pooled_capacities. measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") colocated_flood_weight, proven_sybil_slot_flood; unproven_nodes_each_bring_the_ramp_floor_weight
T113 (a) MITIGATED, (b) OPEN for Task 19b (Task 4Dc fix round 3, red team R5, R6). (a) A late-queue node started at its last chance with three on 31-62% of tests, so T42's one-colluder residual was 2x there and two-of-three needed only the k = 4 draw's stake. (b) The set walk had no re-anchor: a ≥ 1/3 withhold or a gap of more than 720 blocks freezes E(b); an expired set still accepted a successor Validator + Operator (a) A test started at its last chance with a drawn member dropped (CapAssignment.short) records team capped at max(verified_prev, CAP_RAMP_FLOOR_MBPS): it can lower, never raise. (b) An expired set accepts no successor (verified_set_chain); Task 19b's plan item now names one anchor source (the committed in-force set hash), the re-anchor rule (metagraph-built set at the window's first block) and the first team-mode window's anchor Task 19b: (b) the loop uses the re-anchor rule's set every window. measurement.md §Team capacity tests ("The team", "Eligible validators"); plan Task 19b late_queue_short_team (0.281x, 1.572x uncapped), validator_set_tiebreak (expired anchor: [100]); a_short_last_chance_team_can_only_lower
T114 MITIGATED with dedupe on; with dedupe off team mode isn't enabled (Task 4Dc fix rounds 4-5, red team E1, A1, review B4). Endpoint-less keys escaped the pooled schedule weight: pooled_capacities was scoring_caps, and the fail-closed endpointless_nodes rule applied only to K_u. A box showing two /24s to split validators, with 4 UIDs × 1024 keys verified at 200 Mbps by sequential tests, cut the honest fleet to 0.51 (0.30 at 8 UIDs) and singles to 0.78 of due tests (bound 0.85), and made R3's 5 Mbps floods one-box cheap. With endpoint dedupe off (production today: no producer until PB-06) every weight was unpooled Operator The schedule weight applies pay's rules (validator::schedule_weights, TempoOutcome.pooled_capacities): with dedupe on, an endpoint-less node weighs 0; with dedupe off, each UID weighs its largest single node, one pipe, not the sum. Measured (endpointless_flood_weight, worst seed): dedupe on, 4 / 8 UIDs single 0.93 / 0.92, fleet 0.89 / 0.86, fresh 0.75. With dedupe off team mode isn't enabled (T124), so the rest bounds only the schedule weight, now each UID's lower-median node (round 5): 200 Mbps keys, fleet 0.86 / 0.82 (gated 0.85 / 0.80); one 1 or 10 Gbps anchor per UID, fleet 0.87 / 0.84 (gated 0.85 / 0.80; the largest node gave 0.51 / 0.30 and 0.07 / 0.04); every key at 1 Gbps, fleet 0.50 / 0.29 (gated 0.45 / 0.25), where no per-UID statistic helps (review B4; sim dedupe_off_anchor_weight). The fleet's weight returns with endpoints (PB-06) measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID", "Per-UID fairness"), §Probed endpoints ("Dedupe", "Residuals") endpointless_flood_weight, dedupe_off_anchor_weight; schedule_weights_zero_endpointless_nodes_and_keep_one_pipe_per_uid_when_dedupe_is_off, prev_pooled_capacities_order_the_round_robin, run_tempo pooled-capacity assertions in the [T24] test
T115 MITIGATED (Task 4Dc fix round 4, red team E2). Cohort ride-along. Cohorts were keyed by the members' smallest t/w, so one proven attacker key in each of a fleet's /24s made tier-1 cohorts that ran at the fleet's turn and were charged to it. 200 keys at 5 Mbps (one UID) cut the fleet's node tests from 0.97 to 0.67, singles from 0.96 to 0.86 and fresh UIDs from 1.00 to 0.57 at 8 validators Operator A cohort is keyed by min_u t_u / (w_u · m_u / N_u), m_u being u's members in the cohort and N_u its schedule nodes, so a UID lends only its per-node weight; every member UID is still charged. Measured (cohort_ride_along, worst seed): fleet node tests 0.92, singles 0.95, fresh 0.75 (bounds 0.85, 0.85, 0.5); the riders' cohorts run at 0.43 of due. R1's CGNAT cohorts are unchanged (single-node UIDs, m = N = 1); 12 × 1024 packaged as cohorts now go last and the flood competes as node tests (single 0.88, fleet 0.89, fresh 0.33) measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") cohort_ride_along, proven_sybil_slot_flood, cgnat_cohort_turns; a_cohort_borrows_only_its_members_per_node_weight
T116 (a), (b) OPEN, LOW; (c) MITIGATED in fix round 5 (Task 4Dc fix round 4, red team L1-L3). (a) Cohort credit is kept for 8 history entries, but a cohort falls due about once per 2.5 windows, so about 4% of cohort-windows lapse with no attacker (9/240), and a multi-operator CGNAT group is paid as one member then (about 3.5% of such groups' capacity term on average). (b) The unproven floor gives each registered UID up to 400 Mbps of weight (64 holder UIDs × 4 keys: fleet 0.76). (c) The short cap (T113) doesn't cover a short cohort test's aggregate Operator (a) Documented; OQ-95 proposes credit until the cohort's next due test. (b) Documented in T112's residual and T104's formula; each holder UID costs a registration, and tier 3 is capped per UID. (c) Fix round 5 caps a short cohort test's aggregate at Σ max(verified_prev(n), CAP_RAMP_FLOOR_MBPS) (validator::short_capped_cohort, T125). In team mode (a) is about 15% with two samples required (T125) measurement.md §Team capacity tests ("A last-chance team of three can only lower"), §Cohort capacity tests (item 5); capacity-bonds.md §Endpoint dedupe cgnat_cohort_turns (lapse figures from the red team's round-3 re-check)
T117 MITIGATED (PB-29). Provider session leak. A kernel node that also peers with its hosting provider announces overlay fc00::/8 routes or its overlay ASN to the provider, which sends transit out of the overlay (Invariant 4) and exposes the topology; or takes a provider route, which the provider can use to steer overlay traffic A hosting provider, or an operator by misconfiguration The provider session is its own bgpd instance in VRF bwos-provider, with its own RIB and kernel table. Outbound permits only the operator's announce list and nothing else (the implicit deny drops the provider's own default, fc00::/7 and the rest), with fc00::/8 le 128 denied first as a second layer; the VRF's table ends in an unreachable default and the forward filter drops anything entering on bwos-provider, so a packet from the provider side can not be routed into the overlay when the provider's default is gone; inbound accepts only ::/0 and 0.0.0.0/0; nothing is imported between the VRF and the overlay; check_provider_bgp refuses an overlay-range neighbor and a node-range ASN; a table update never touches the instance; the interface can not be the host's default route. Residual: a single-NIC host can not use it yet (OQ-96); the provider's default route is not used by the host, which keeps its own, by design datapath.md "Provider BGP stays separate" provider_bgp_separation.sh (a leak attempted from inside the VRF stops at the outbound map; mutating the map fails it), overlay_bgp provider unit tests, kernel_install.sh
T118 MITIGATED (Task D1 fix round 1, red team F1). Receipt-store lockout by node-key sybils of one UID. A UID binds about 123 node keys and uploads 8 non-dominating one-receipt batches per key per window, filling the store so honest nodes' batches are refused, and refills each new window first Operator (bound node keys) A node's first batch for a window is always admitted from a reserve; extras are capped per window (MAX_RECEIPT_EXTRA_BATCHES_PER_WINDOW) and per UID (RECEIPT_UID_QUOTA_PER_NODE per node it has, from --receipt-nodes-file's UID map); new uploads outside [current − 4, current + 2] are refused; one UID holds at most RECEIPT_UID_EXTRAS_CAP extras. Residual: bounds count batches, not bytes; a byte budget is a Task 19b requirement (OQ-98) receipts.md §Submission object_store::tests::f1_r3_sybils_of_one_uid_cannot_lock_out_honest_first_batches (red team R3)
T119 MITIGATED (Task D1 fix round 1, red team F2). Window receipt file inflated past the run-tempo read bound. About 35 full batches made window-<w>.json exceed 16 MiB, so run-tempo skipped the whole window and every operator's receipts were uncounted at that validator; past 256 MiB a restart moved it aside and truncated it Operator, or a busy honest fleet One file per batch (receipts/window-<w>/<node>-<hash>.json, each under MAX_OBJECT_BYTES); run-tempo reads the window directory with the bound per file; an oversize file is never moved aside, and .corrupt names are unique receipts.md §Submission tests::f2_r1_a_window_past_the_file_bound_is_scored_in_full_after_a_restart (red team R1)
T120 MITIGATED (Task D1 fix round 1, red team F5, review I1). Object-store connection and verification exhaustion. One source IP holds every one of the 64 connections, or one bound key keeps every verification slot busy with batches whose last receipt signature fails, so honest receipt uploads and reads get 503 Anyone; operator with one bound key At most MAX_HTTP_CONNECTIONS_PER_IP (8) connections per non-loopback source, IPv6 keyed by /64 (N5); cheap checks and the batch's own signature before a verification slot is taken, and failed uploads refused again from a cache (N4); at most one verification per node key under the global 4. Residual: several bound keys, or sources in several /64s, can still hold slots; a cool-down after a failed receipt check is for Task 19b. Red team recheck 2: 8 sources (IPv4 addresses or /64s of one /48) still hold all 64 connections, with no reserve for bound nodes; a keyless upload naming a node with 8 full batches costs about 2.6 ms under the store lock; the failed-upload cache is flushed by 4,096 keyless uploads and re-signing gets round it (Task D1b) receipts.md §Submission, traffic-verification.md TV-27 object_store::tests::f5_one_source_ip_cannot_take_every_connection, f5_one_node_cannot_starve_another_nodes_verification, sec1_reads_are_not_blocked_behind_receipt_verification
T121 MITIGATED (Task D1 fix round 2, red team N3). Dump file pile-up across restarts makes a window unscorable. After each restart the in-memory quotas started from zero, so a UID added a full quota of non-dominating files to the window per run until the window directory passed MAX_RECEIPT_WINDOW_FILES, the dump stopped working for the window and run-tempo failed the whole tempo Operator (bound node keys), plus restarts serve reads the dump back into the store at startup, so quotas carry over; the dump and run-tempo keep at most MAX_BATCHES_PER_NODE_WINDOW files per node per window, the highest ranked; a file count is skipped past with a warning, never failing the dump or the tempo receipts.md §Submission tests::n3_s4b_restarts_dont_pile_up_files_or_fail_the_tempo (red team S4b), tests::n3_load_caps_files_per_node_and_never_fails_on_count
T122 PARTLY MITIGATED (Task D1 fix round 2, red team N1, review R-I2). Receipt-store memory exhaustion by full batches across the retained windows. A large UID filled every window in [current − 48, current + 2] with full batches (about 1 MB each held), over 100,000 batches Operator (bound node keys) New uploads are accepted only for [current − RECEIPT_PAST_INGEST_WINDOWS, current + 2] (7 windows); one UID holds at most its firsts plus RECEIPT_UID_EXTRAS_CAP per window. Residual: kept up for 48 windows it still accumulates; the byte budget is a Task 19b requirement (OQ-98). Steady state is 65,280 batches for one 1,024-node UID after 50 windows (red team recheck 2, T1), so about 160 nodes OOM a 16 GiB validator in about 51 windows (Task D1b) receipts.md §Submission object_store::tests::n1_s3_one_uid_holds_batches_in_seven_windows_not_fifty_one (red team S3)
T123 OPEN (Task D1b; red team recheck 2, R2-1). Restore crash loop. The startup restore of the receipt dump holds every batch twice (the dumper's file cache plus the store), about 1.55x a normal store, and runs before the listener opens, so a validator OOM-killed by T122 is killed again inside restore and stays down until the dump is deleted by hand Operator (bound node keys), via T122 Planned: restore without filling the file cache, newest window first, under a memory budget, with the listener open during restore. Until then the rehearsal allowlist is curated receipts.md §Submission red team harness task-D1-redteam-recheck2-harness.rs T2 (to become a test in D1b)
T124 MITIGATED (Task 4Dc fix round 5, red team A1, review B4). With endpoint dedupe off the schedule weight was each UID's largest single node's unpooled verified capacity, which one anchor key per flood UID sets, and nothing pools keys, so one box can anchor every UID: 8 UIDs × 1024 keys at 5 Mbps plus one 1 Gbps anchor each cut the honest 200-node fleet to 0.30 of due tests, a 10 Gbps anchor to 0.04 (about 60% of fleet nodes would get no sample in the 24-window span). With every key at 1 Gbps by sequential tests (OQ-18) no per-UID statistic helps (0.29) Operator Team mode MUST run only with endpoint dedupe on: run_tempo uses team-mode tests only when tempo_endpoint_trigger is met and otherwise runs the single-agent tests as before; Task 19b's preconditions say so. Defence in depth: with dedupe off a UID weighs its lower-median node (anchor cases: fleet 0.87 / 0.84). Residual: none while team mode is gated; the dedupe-off figures in T114 bound the weight only measurement.md §Team capacity tests ("Team mode MUST NOT run with endpoint dedupe off", "Capacity-weighted round-robin by UID"); capacity-bonds.md; plan Task 19b dedupe_off_anchor_weight; the [T24] run_tempo test's team-mode block; schedule_weights_zero_endpointless_nodes_and_keep_one_pipe_per_uid_when_dedupe_is_off
T125 MITIGATED, residual OPEN, dormant until team mode (Task 4Dc fix round 5, red team B1, L3). A co-located group's pool is the max over its chunk cohorts of each cohort's lower median of few samples, and Σ verified doesn't bind for co-located keys. One colluding validator at about 5% of stake, seated once on one cohort's only sample, gave ×1.5 (team of four) or ×2 (short team) on the group's capacity term: 8 of 12 seed-runs above 1.0x Operator + Validator (a) A short cohort aggregate is capped at Σ max(verified_prev(n), CAP_RAMP_FLOOR_MBPS). (b) In team mode a cohort needs CAP_COHORT_TEAM_MIN_SAMPLES (2) samples in the span, so one seat never raises a group. Measured (colocated_cohort_lottery, 12 seeds × 8 windows): at most 1.5x, above 1.0x in 1 of 12 runs (ruled 1.0x in all; gated at 1.5x). Residuals: (i) both of a cohort's samples with the colluder seated, 1.5x; OQ-99 proposes samples from teams with disjoint members, to land with Task 19b before team mode. (ii) Cost to honest groups: credit lapses in about 15% of cohort-windows in team mode (4.5% before), and a group with few cohort tests gets only its largest single (the lottery group's mean credit 0.29x of its box). (iii) For co-located keys (a) doesn't bind (16 × 200 Mbps = 3.2 Gbps) measurement.md §Team capacity tests ("A short cohort test's aggregate is capped too"), §Cohort capacity tests item 5; capacity-bonds.md §Endpoint dedupe; scoring.md CAP_COHORT_TEAM_MIN_SAMPLES colocated_cohort_lottery, cgnat_cohort_turns (lapse); a_short_cohort_aggregate_is_capped_at_its_members_capped_capacities, a_team_cohort_needs_two_samples_for_credit
T126 OPEN, LOW, documented (Task 4Dc fix round 5, red team C1-C3). (a) Rider keys split across many UIDs get one front cohort turn per UID, charged to the fleet too: 64 UIDs give fleet 0.74, the same as T112's holder UIDs. (b) Real capacity buys turns spent on endpoint-less keys: each flood UID with one real 10 Gbps anchor in its own /24 and 1023 endpoint-less keys at 200 Mbps, at 8 UIDs, gives singles 0.82 (bound 0.85), fleet 0.87, fresh 0.38. (c) schedule_weights keys "dedupe on" on a non-empty node_diversity, not the stake trigger Operator (a) Ordinary UID splitting, one registration per turn (T112). (b) Costs 80 Gbps of verified, paid capacity; scheduling weight-0 nodes as tier 3 would close it, but with dedupe off every non-median node weighs 0, so it isn't cheap; left to Task 19b (PB-06). (c) Not reachable in production: bwos-validator's fill_node_diversity overwrites the field with tempo_node_diversity, empty below the trigger; only hand-built inputs are stricter than K_u (stated in schedule_weights' doc and measurement.md) measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") red team round-4 re-check (task-4Dc-recheck4), cohort_ride_along
T127 MITIGATED (Task 15, audit F5; fix round 1 H1). Fake paying client: a key the validators haven't authorized signs client receipts for "paid" traffic between its own nodes to move pay from capacity to usage, where fabricated bytes earn (3.14x at launch in the audit). The round-1 variant: one authorized client signs a bare 1,000 GiB receipt each window with no traffic behind it (authorized_client_latch) Operator + client key Attested paid bytes are only credited paid: backed by co-signed hop receipts on a creditable production route and client coverage after the voucher gate, from clients in authorized_clients, each session capped at its ingress node's verified capacity for the window, and only with at least ALPHA_TRIGGER_MIN_CLIENTS (3) distinct authorized clients. The trigger is also gated off (ALPHA_TRIGGER_ENABLED = false) until the latch comes from committed medians. Residual: ALPHA_TRIGGER_MIN_CLIENTS authorized clients colluding with real routes can move it once the gate is on scoring.md §Capacity weight W fake_paying_client, authorized_client_latch, paid_bytes_from_unauthorized_clients_are_not_attested
T128 MITIGATED (Task 15, audit S4). Unsigned or zero-signed capacity declaration: an SS58 hotkey_sig was never verified, so a declaration signed with 64 zero bytes, or by anyone, scored the same as a signed one Anyone CapacityDeclaration::verify (sr25519 for SS58 hotkeys, refusing zero signatures and the all-zero account; ed25519 for hex hotkeys) in node_declarations and declared_capacities, both also requiring the declaring UID's own metagraph hotkey (fix round 1 L2); a declaration that fails declares nothing. Manifests are verified where fetched (Task 19b) Task 19b: manifests are verified where fetched (live::admit_manifest: signature, exact commitment hash, the committing hotkey's, the netuid), and SS58 binding signatures too (OQ-131). scoring.md §Capacity declarations are verified, capacity-bonds.md zero_sig_declaration, foreign_key_declaration, a_capacity_declaration_with_a_bad_sr25519_signature_scores_zero
T129 MITIGATED (Task 15, design §3; fix round 1 H3, M3). Unearned weight to an owner-coldkey hotkey: weight the burn UID took went to the owner's hotkey, which the chain penalises by cutting the subnet's TAO share and which reads as self-mining. Variants: with no first-party UID, earned shares were renormalised over the unassigned part (3.33x, unassigned_unearned_renormalized); with no capacity anywhere before the latch, Mechanism 0 went 100% to the first-party UID (first_party_take_when_no_capacity) Owner The burn UID is removed. Mechanism 1's unearned weight goes only to first_party_uid. Mechanism 0's never does. Any mechanism with unassigned weight gives no weights, the helpers return the unassigned ppm, and validate_weights and run-tempo refuse. Residual: the validator can't tell a first-party UID from an owner-coldkey one; Task 19b commits first_party_uid on chain and checks its coldkey against the subnet owner's (OQ-102) Task 19b: the loop checks the first-party UID's coldkey against the subnet owner's every window and holds Mechanism 1 back on a match; committing the UID on chain is OQ-212. scoring.md §Unearned weight and the first-party UID unearned_weight_to_owner_hotkey, unassigned_unearned_renormalized, first_party_take_when_no_capacity
T130 OPEN, dormant while ALPHA_TRIGGER_ENABLED is false (Task 15 fix round 1, red team H2, M1). Latch split brain: each validator's latch comes from its own view of the receipts, so one missing batch, a late joiner, or a node withholding its batch from one validator in one window of every run leaves validators on different W for good Operator, validator Gated off: W is 1_000_000 for everyone. Before the gate turns on, Task 19b commits per-window attested bytes and the latch uses their stake-weighted lower median; with the gate on and the latch state unknown, run_tempo gives no weights (OQ-102). N-of-M windows would close withholding. Fix round 2: the latch state is known only with a latch record or history from window 0 (N2). Three colluding authorized clients still latch it with the gate on (N3): before the gate turns on, the trigger must cap per client and per ingress node and count only source-verified or trusted-egress bytes (scoring.md §Capacity weight W, preconditions) scoring.md §Capacity weight W latch_split_brain, late_joiner_latch, late_joiner_latch_gate_on, receipt_withholder_resets_trigger and three_client_latch (model-only)
T131 OPEN, gated (Task 12b fix round 2; probe::BACKGROUND_IN_TEAM off until PB-38, OQ-106). Hop receipts from real counters and background from receipt runs. (H1) Team-test background lifts only ratio_t while the gate is off, enforced in scoring (sim gate_holds_in_run_tempo). (H2) Hop totals count forwarded transit only, never the node's own flows, link-address traffic or keepalives (sim own_traffic_burster); junk transit through a node's sybil UIDs still gets the full cap on the gate-on path, 1.333x (sim sybil_uid_background, model-only), which is why background in team waits for PB-38's canary or digest-verified carriage. (H3) A node's background is max(Σ in, Σ out), and a cohort counts boundary streams once and internal ones never (sims relay_direction_double_count, cohort_internal_stream). (M1) The co-signing tolerance applies to each increment (sim tolerance_swing_bracket). (M2, open, Task 19b blocker) A rival can evict a node's run by co-signing late. (a) Counter inflation. A relay whose counters report more to its next hop than the next hop counted: beyond RECEIPT_TOLERANCE_PPM the next hop counter-proposes, nothing is co-signed, and the relay is credited nothing for that hop (sim counter_inflater, regression guard, no gain). Within the tolerance the next hop co-signs the claim: +4,000 ppm on one hop gives the relay about +0.2% (detail of counter_inflater), as an honest relay's noisy counter would. (b) Stall and carry with claimed blocks (T42(g)). As first written the co-signer took a block within one block of its view either way, and a staller showed all of T as background (1.263x at T = C / 3.6). Under rule (a) a claim is at or one below the co-signer's view, but the receipt after the test can still lag a block: 1.175x at T = C / 3.6, 1.290x at the background cap, 1.734x with one colluding member at k = 4. Not scored until Task 19b supplies block_hashes with dedupe on; fixed by PB-38's per-digest timing checks on routed traffic (ADR-0051, ADR-0053) Operator Co-signed totals within tolerance; rule (a) for block; the tight-interval run rule (probe::stream_background_mbps); the CAP_BACKGROUND_MAX_PPM cap; bracket_stall_carry model-only (UNTIL_PB38) receipts.md §Hop receipts from counters, measurement.md §Background traffic counter_inflater, bracket_stall_carry (Task 12b)
T132 MITIGATED (Task 16a, audit F2). Clone farm on the Mechanism 1 ladder: UIDs submit copies of the reference solver's table or of an outside solver's, exact or with a route made worse, to take rungs or the old 30% runner-up pool (a clone 2.5% worse passed the gains_ppm copycat test) Solver (sybil UIDs) A table within CLONE_DISTANCE_PPM (2% of (src, dst, class) keys on a different path) of one committed in the same block or earlier scores 0, ordered by SolverSubmission::commit_block; the reference solver's table counts as block 0, so its clones always score 0. Near-clones more than 2% away that are worse than the reference took lower rungs until fix round 1 (T138) scoring.md §Clone protection, §The ladder ladder_clone_farm; a_table_matching_an_earlier_one_within_clone_distance_scores_zero, the_earlier_committed_of_two_clones_keeps_its_score, two_clones_committed_in_the_same_block_both_score_zero
T133 MITIGATED (Task 16a). Prediction liar: a solver's routes claim latencies (est_us) the network doesn't deliver, so what it publishes as its routes' performance is false Solver Each route's positive gain is scaled by how well est_us matches the graded latency (the worst of next-snapshot prediction, latency samples and the UID's own path probe): full credit within PREDICTION_TOLERANCE_PPM (25%), none at 50% or with no est_us; a route at or below direct keeps its negative gain. est_us halved grades 0. Residual: a lie inside 25% costs nothing, and est_us buys nothing either, since gains never read it scoring.md §Grading item 3 prediction_liar; a_route_is_graded_on_the_worst_view_and_its_prediction
T134 MITIGATED (Task 16a). Next-window overfitter: a solver tunes its table to the snapshot it was solved on, chasing links that dip for one window, or self-owned links measured fast while tables are graded Solver Tables are graded on the next window's snapshot, built from measurements no solver had seen when it committed, and churn is charged against prev_table; the reference solver keeps paths within ROUTE_SWITCH_MARGIN_PPM. Residual: regret is still judged on the solved-on snapshot, so it charges the stabilised reference for the dip it ignored (pre-existing [T23] behaviour) scoring.md §Grading items 1 to 7 next_window_overfitter
T135 OPEN, LOW (Task 16a). Same-block clone griefing: anyone who can predict a solver's table (a public solver's output, the reference solver's) can commit a copy in the same block or earlier, and the original then scores 0 Solver Commit-reveal hides a table until reveal, so only predictable tables can be copied, and a copy of a public solver's table is work anyone could do. Residual: an outside solver running published code with public inputs can be zeroed at will. Its table is also within 2% of anyone else running that code scoring.md §Clone protection two_clones_committed_in_the_same_block_both_score_zero
T136 MITIGATED (Task 16a fix round 1, red team MH3). Grading-window steering: a solver that also runs relays attracts the reference's routes through its nodes, then drops them out of (or loses on) the window that builds the graded snapshot, so those routes graded -1e6 and its own table won, was paid and counted as outside_won Solver + Operator A hop broken in the graded snapshot (loss above PROBE_LOSS_MAX_PPM, a node gone) and a failed path probe grade as direct for every table; an outside solver is selected, paid above the reference or outside_won only if it is also at least the reference on the solved-on grade. A commit deadline early in the window is a Task 19b rule. Residual: delaying (not breaking) its own relays still lowers the reference's gain, short of the solved-on gate; a solver that predicts the next window better than the solved-on snapshot shows is held to the reference there (OQ-107) Task 19b: route tables are read at the commit deadline (S + 36). scoring.md §Grading items 3, 8, 9; §The production table reference_steering_saboteur; a_table_worse_than_the_reference_on_the_solved_on_grade_is_neither_selected_nor_paid
T137 MITIGATED (Task 16a fix round 1, review Critical). Production-table copier: last window's production table ran in the open, so a griefer commits its routes for the next window before the incumbent re-commits them; by commit order the incumbent's table was the clone, the griefer took its rung (666_667 ppm) and production Solver current_prod_table counts as committed at block 0 and owned by incumbent_solver_uid: any other non-reference table within CLONE_DISTANCE_PPM of it scores 0, and the incumbent re-committing it is ordered before every solver scoring.md §Clone protection prev_production_copier; a_copy_of_last_windows_production_table_scores_zero_and_its_incumbent_keeps_it, a_copy_of_the_production_table_scores_zero_but_its_owner_keeps
T138 MITIGATED (Task 16a fix round 1, red team H1, H2). (a) Near-clone ladder farm: sybils 4% from the reference each took a rung below it (498_037 ppm in all). (b) Zero-churn overfitter: no prev_table meant no churn, and regret charged the stabilised reference for the dips it ignored, so a dip-chaser graded 1.054x the reference Solver (sybil UIDs) (a) Only solvers above the reference by EPSILON_ROUTE take rungs; the reference's rung and all below it are unearned (first-party share disclosed). (b) With prev_table None, churn is against the production table; a route kept on the production path within ROUTE_SWITCH_MARGIN_PPM carries no regret, for every solver; prev_table is validator-derived (Task 19b). Residual: a winner's own sybils just above the reference (OQ-107 (6), Task 16b) Task 19b: prev_table is the table the UID committed at the previous read. scoring.md §The ladder, §Grading item 6 near_clone_ladder_farm, zero_churn_overfitter; churn_without_prev_table_is_against_production_and_kept_production_paths_carry_no_regret
T139 MITIGATED (Task 16a fix round 1, red team M4, M5). (a) Unprobed near-clone: path probes were keyed by UID and only the incumbent was probed, so a copy on the same slow paths graded on the faster snapshot. (b) commit_block failed open: a missing block (0) sorted before every real one Solver (a) Path probes are keyed by path (route:<digest>), so every table on a probed path reads the same result. (b) commit_block is Option<u64>, the first block this UID committed this table hash at the fixed read block; None counts as committed last measurement.md "Path probes are keyed by path"; scoring.md §Clone protection an_unprobed_near_clone_cannot_outrank_a_probed_reference_on_the_same_paths, an_unknown_commit_block_counts_as_committed_last
T140 OPEN, model-only until Task 16b (Task 16a fix round 2, red team N2). Perturbed production leech: last window's production table is public, so a leech re-commits it with a few pairs perturbed, more than CLONE_DISTANCE_PPM from it and so no copy, and takes the rung below the incumbent while adding nothing (285_714 ppm in the sim) Solver Partial: copies within 2% of the production table score 0 (T137), tables are revealed only after the commit deadline (Task 19b), and every rung must beat the reference by EPSILON_ROUTE. Closing it: Task 16b ranks each rung on its marginal gain over the tables ranked above it (OQ-107 (6)) scoring.md §Grading item 9, §The ladder perturbed_prod_leech (model-only)
T141 Damping griefer (Task 13, PB-17). An attacker flaps the session it shares with a rival so the rival's routes are suppressed for flapping and the rival loses score beyond the seconds the link was really down Operator Damping is per (peer, prefix) and counts only withdrawals, so only paths that cross the flapping session are suppressed: the attacker's own paths and what it relays, at the rival; nothing of the rival's at third parties, whose sessions with the rival never flap. On the no-root node a peer's own /128 stays in use on its own session while damped (never passed on), so link probes across the shared link pass whenever it's up: no honest UID loses more than the real outage, with one or three attacker UIDs, six or seven flaps or a sustained schedule. Residual (OQ-108): FRR can't exempt that path, so on a kernel rival the shared link's probes fail while the attacker's /128 is damped, up to about 48 min after seven flaps; that is what the attacker can already do by dropping probes on its own link, it is neutral under T29 with one attacker UID, and it costs the attacker as much on the same link datapath.md §Flap damping damping_griefer (Task 13); seven_flaps_in_a_minute_suppress_the_peers_routes, a_damped_peers_own_route_is_used_here_but_not_passed_on
T142 One flapping node churns the fabric (Task 13, PB-17). A node (broken or hostile) whose sessions go up and down every few seconds makes every node re-run selection and pass updates on, and one restart must not be punished as flapping Operator RFC 2439 damping on both node kinds with RFC 7196's values: seven flaps in about a minute suppress the flapper's paths at its neighbours, which stop passing them on; six, or one restart, don't. A no-root node also holds a peer's paths back for 2 s after BFD Down where a backup exists. Updates a peer is owed are paced per prefix (node's pending set), so churn can't overflow another session's queue datapath.md §Flap damping churn_flapper.sh, one_restart_is_not_damped, six_flaps_in_a_minute_do_not_suppress, hold_down_keeps_the_backup_for_two_seconds_after_bfd_down, damping_settles_a_ring_of_primaries
T143 OPEN (Task 13, OQ-114). Damping shadows a node from validators: a path damped at an intermediate hop carries no multi-hop canary (ADR-0051), so the node reads unavailable until reuse Operator, Validator Vantage sessions are direct, so unaffected. PB-38 must exempt canary prefixes from damping, or score availability on direct sessions. Not built datapath.md "Flap damping" Sim damping_vantage_shadow reserved
T144 OPEN (Task 13, OQ-115). Damage spreads past the flapping link: an attacker's flaps on one session make a rival's other neighbours damp paths they relearn through the rival Operator Not measured yet datapath.md "Flap damping" Sim damping_upstream_flap reserved
T145 OPEN (Task 14, OQ-116). Public canary pairs: the canary allocation is a deterministic draw from the window's committed seed and snapshot, so every node knows during the window which pairs carry canaries and how many bytes. Once customer traffic exists, a flow on an unallocated pair is customer traffic, and a node can drop or delay those while carrying every flow on allocated pairs Node Partial: within an allocated pair, a flow's start, size and class come from each validator's secret plan and fabric-wide marginals, so a node can't predict them (sims). The pair itself, the packet shape and the source address are not hidden (T148). Before customer traffic exists there are no unallocated flows to degrade. Customer flows are checked by hop-digest sampling (ADR-0053 §2), which can only lower a score. Closing it: PB-38 or PB-39 (OQ-116) measurement.md §Canary plans, "Residuals" canary_favourer, canary_slot_presence (timing, size and class only)
T146 OPEN, bounded (Task 14). A validator's plan is secret from nodes, not from the validator: it can tell a friendly node its timing, or grind secrets until its flows land where a rival is weak Validator Each validator's bytes per pair are fixed by the public allocation and its stake share, and the reveal must spend exactly that (verify_reveal), so collusion moves only that validator's own evidence, never its share or another validator's. canary_plan_is_derived stops hand-picked timing, though not grinding. Planned fix for grinding (red team F5): commit SHA-256(secret_w) in window w - 1 and key the draws on `secret seed, so the secret is fixed before the seed exists. Fix round 1 pins the counting commitment to the seed block plus CANARY_COMMIT_CUTOFF_BLOCKS and requires a fresh secret every window (canary_secret_is_fresh`), so a validator can't swap or replay a plan. Results are aggregated across validators by stake-weighted median (PB-38, ADR-0051 requirement 5)
T147 OPEN, LOW (Task 14). Splitting above the canary weight cap: a node's canary weight is min(deduped verified capacity, CANARY_NODE_WEIGHT_CAP_MBPS), so a node above the cap that splits into nodes under it, in separate /24s, gets more canary bytes. Each part still has to pass its own capacity test. Also, a UID never draws its own nodes as destinations, so splitting one operator across several UIDs gains slightly more destination bytes Node Bounded by the per-UID cap CANARY_UID_CAP_PPM, water-filled since fix round 1 (F4), so it is a real cap (sim canary_alloc_uid_split). Under the cap, weight is linear, so splitting into nodes gains nothing (at most 1.001x in the sim). Splitting across UIDs gets around the cap and adds the own-destination gain (red team F4b); planned: group by coldkey in PB-38 (OQ-119). Each UID costs a registration. Not scored until PB-38, which sets the cap with the pay formula measurement.md §Canary plans, "Allocation" canary_alloc_node_count_sybil (under the cap)
T148 OPEN (Task 14 fix round 1, red team F1). Canary packet shape: filling packets to the overlay MTU (1_420) with a remainder tail removed the packet-size tell (an even split at 1_280), but canaries are still one-way UDP, with no reverse traffic, from a validator's source address. A relay or end that sees these can favour canaries Node Not mitigated yet. The node side (OQ-117) MUST hide validator addresses and shape reverse traffic per class before PB-38 scores canaries measurement.md §Canary plans, "Injection" and "Residuals" canary_packets_add_up_to_the_entry (sizes only)
T150 A solver publishes a broken or forked update chain (Task 16b, PB-08). A wrong prev, a skipped seq, updates closer than the interval, more than MAX_UPDATE_ROUTES routes, a cycle-closing change, or two updates for one seq Solver, Relay The node applies the whole attested chain or keeps its last good table (apply_update); validators attest one update per (window, seq) after checking the solver signature and the chain routing.md §Incremental updates Sim update_chain_breaker; unit tests in table_update.rs and signed.rs
T151 The incumbent removes production routes to dodge the time weighting (Task 16b). It removes the production routes of pairs its new table does badly on so they count less Solver A removed route counts min(q, direct) for the blocks it was down and every key weighs the whole window (live_adjusted_score). This closes that move only; steering the graded table by changing routes is T154 scoring.md §Grading item 4 Sim mid_window_self_steerer
T152 The first prev forks by signature (Task 16b fix round 1, F3). sr25519 signatures are randomized, so a solver can publish two copies of one table that differ in hotkey_sig and split nodes and validators Solver The first prev hashes the table's signing bytes, which every copy shares; nodes keep no signature routing.md §Incremental updates Sim base_sig_splitter
T153 OPEN (Task 16b fix round 1, F8, OQ-122). Mechanism 0 credits transit on current_prod_table, not the table as updated. The incumbent can steer credit with updates (latent, about 2.8x once the paid-traffic trigger is on), and honest relays on updated routes are not credited Operator, Solver Latent while the trigger is off. Enabling the paid-traffic trigger waits on OQ-122 scoring.md §Grading item 4 None yet
T154 Updates rewrite the graded table after grading (fix rounds 1 and 2, F1, F2, N2, N4). A burst of future-dated updates, many ungraded changes, an update that overloads a capped relay, or one heavy pair moved or flipped, swap what runs for most of the window Solver Attested only when due (MAX_UPDATE_BLOCK_SLACK), within the window, at most MAX_UPDATE_CHANGE_PPM of routes, each route at most MAX_ROUTE_CHANGES_PER_WINDOW times, and validate_under_demand on the updated table at the window's demand_mbps_per_pair, so no relay goes over max_transit_mbps; the budget is demand-weighted only once demand is per pair (OQ-128), and its size stays open (OQ-123, OQ-124) routing.md §Incremental updates Sims update_burst_rewriter, ungraded_update_steerer, update_cap_overloader, heavy_pair_steerer
T155 Nodes end on different update seqs (fix round 1, F4). A node that missed an update refuses the next, and traffic can loop between nodes on different tables Relay, Network By-number lookup seq/<window>/<n> and a catch-up walk routing.md §Incremental updates Sim seq_gap_splitbrain
T156 Rivals copy the incumbent's updates (fix round 1, F7). A rival commits the production table after an update to escape the clone check against the base Solver First update no earlier than the commit deadline; clone check against every prefix of the chain scoring.md §Clone protection Sim update_leech
T157 OPEN (liveness, fix round 1, F9). Validators holding more than a third of stake can withhold attestations and stop updates Validator Liveness only: the base table still runs routing.md §Incremental updates None
T158 The incumbent frames a challenger as a copy (Task 16b fix round 2, N1). After a challenger's table is revealed, the incumbent updates production to within CLONE_DISTANCE_PPM of it, and the per-version clone check zeroes the challenger Solver A table is checked only against production versions published before its commitment (commit_block after the update's block); with the commit deadline at FIRST_UPDATE_DELAY_BLOCKS a table committed in time meets only the base table. Residual: a table whose commit block is unknown (OQ-129) scoring.md §Grading item 4 Sim prod_version_framer
T159 Withheld, backdated updates (fix round 2, N3). The incumbent holds signed updates back and presents them in one burst late in the window, so updates that never ran count in the chain and the grade's time weighting Solver Validators attest only chain - MAX_UPDATE_BLOCK_SLACK <= block <= chain + MAX_UPDATE_BLOCK_SLACK, from a required chain-block input; nodes activate an update on their own clock with no allowance routing.md §Incremental updates Sim backdated_update_burst
T160 MITIGATED (ADR-0054). Wallet signatures replayed across protocols: a browser wallet's <Bytes>-wrapped signature over a Transit Fabric manifest or binding passed off as a Substrate extrinsic, as another Transit Fabric domain's object, or a signature from another dapp's signRaw passed off as a Transit Fabric object. Also phishing: any dapp the operator connects can ask the wallet to sign a Transit Fabric manifest Operator (as victim), any dapp Only the raw signing bytes or exactly <Bytes> + them + </Bytes> verify, the wrapped form only for messages starting BWOS-v0/, and only for commitment-manifest (an SS58 binding's signature is checked nowhere until OQ-131); every other hotkey-signed domain stays raw-only, and a wrapped signature over one is refused (vector raw_only_wrapped), as is a wallet's hex-text wrapping. A wrapped message can't be an extrinsic payload (ends in ASCII, not the genesis and block hashes). A signed manifest does nothing until the hotkey commits its hash in a separate transaction identity.md "Linking with a browser wallet", ADR-0054 wallet_link_vectors (every_other_wrapping_is_refused, wrapped_signatures_do_not_cross_domains), site/link/test/
T161 MITIGATED, residual LOW (ADR-0054, fix round 1 I-2). A tampered page or library builds a different binding or manifest (another hotkey's nodes, dropped objects) before the wallet prompt. Was: @polkadot/* from cdn.jsdelivr.net Third party, the page's host The four libraries are one vendored bundle (site/link/vendor/polkadot.js, built by build.sh from exact versions and a lockfile) whose sha256 is in SHA256SUMS and checked by make link-page-test in CI; CSP script-src 'self' 'wasm-unsafe-eval', no third-party origin. The page shows the nodes a binding adds and drops and needs an explicit confirmation; the wallet shows the bytes; nothing commits without a second approval. Residual: whoever serves the page can still change it, and frame-ancestors must be sent as a header (site/link/README.md) ADR-0054 site/link/test/ (bundle checksum, imports, CSP)
T162 MITIGATED (ADR-0054, fix round 1 I-3). A hostile link replaces a fleet: a link URL (or pasted list) that omits the operator's nodes, or adds an attacker's consenting node, makes the new binding drop or add nodes Third party When the committed manifest names a binding, the page requires it (hash checked), shows the nodes added, removed and kept, requires a strictly later not_before, and enables Sign only after "these are my nodes" is ticked for exactly what was reviewed identity.md "Linking with a browser wallet" site/link/test/ (checkPreviousBinding, bindingDiff, checkSupersedes)
T175 Validator free-rides measurement (ADR-0055). Scoring is deterministic from revealed inputs, so a validator downloads the others' reveals, recomputes the weights exactly and measures nothing. Its dividends match a measuring validator's, with no bandwidth cost Validator A capped slice of Mechanism 0 (indexed to allocated bytes and steered by a participation controller, 1% to 15%, starting at 5%) pays verified, node-signed measurement bytes, capped by stake share. A copier has no node-signed evidence of its own and earns no slice. Residual: the copier keeps its dividends, so measuring wins only while the slice covers bandwidth (OQ-140). Gated off until ADR-0055 §8 scoring.md §Measurement work; measurement.md §Measurement work Sim validator_free_rider
T176 Faked canary delivery with colluding nodes (ADR-0055 §6). A validator sends no canaries on pairs whose ingress and destination both collude, and both sign digests and receipts anyway Validator, Operator An entry counts only with both ends' signed hop digests and co-signed leg receipts. The pairs are a block-hash draw that excludes same-UID pairs, so the faked share is at most c^2 of the validator's canary bytes. Faking saves only cost, never adds pay. Colluding capacity must pass others' median tests ADR-0055 §2, §6 Sim validator_free_rider (faker, c up to 50%)
T177 Faked capacity-test seats with a colluding tested node, and the headroom ack gap (fix round 1 item 2). The tested node signs a cap-test-ack for a seat the validator never streamed, or acks a colluder's whole stream where an honest node carrying its declaration acks 1 / 1.1 of it, so before fix round 1 a colluder's seats verified at 1.0 against honest validators' 0.909 Validator, Operator The seat is drawn by stake, never chosen. Its allocation is rate * CAP_TEST_SECS * pushed / S, exactly what an honest node acks, and its credit is min(ack, allocation, the seat's share of the team's measured result) (measurement_work::cap_test_seat), so a full-stream ack earns no more than an honest one (sim validator_headroom_ack). The faked share is c in expectation, so the saving is at most c of capacity-test cost. The fake capacity sample is a separate threat, bounded by the team median (T21, T108) ADR-0055 §2, §6 Sims validator_free_rider, validator_headroom_ack
T178 Measurement spam. A validator sends more than its allocation, through unplanned flows, longer or faster streams, or a padded plan, to raise its work share Validator min(verified, allocated) per entry and per seat, applied inside work_fraction_ppm, and the share is capped at s_v * slice. A padded plan fails verify_reveal and loses all its canary credit ADR-0055 §3 Sim validator_canary_spam
T179 Claiming another validator's evidence. A copier declares another validator's source and sink node keys, or replays its acks Validator Source and sink keys count only through the validator's own ADR-0039 attestation-key records, with proof of possession. Acks and plans name the validator. A key claimed by two hotkeys counts for neither ADR-0055 §1 Unit tests when Task 19b builds the join
T180 Griefing a rival validator's work pay. A node drops one validator's canaries, which it can tell apart by their source node Operator Shares are never renormalised, so no other validator gains. The node fails its own canary checks (PB-38). The lost slice goes to all operators pro rata, so the dropper's gain is about its own Mechanism 0 share of it ADR-0055 §3 Sim reserved: validator_work_griefer
T181 Self-weight masking. Subtensor masks a validator's weight on its own UID, except the owner's (localnet check, ADR-0055 §5). Work paid to the validator's own UID would be cut by 1 - s_v, and to 0 at half the stake or more Validator Work is paid only to a measurer UID named by hotkey in the manifest, never to the validator's own UID ADR-0055 §5 bwos-chain localnet test self_weight_and_cross_weight_incentive
T182 Measurer UIDs crowd out operators. Up to 64 measurer UIDs take UID slots on a full subnet Validator Only measurer UIDs of counted validators with work are paid, so an idle one is pruned. Headroom in max_allowed_uids is OQ-141 ADR-0055 §5 None yet
T183 MITIGATED (fix round 1 item 1). Phantom declared capacity. A node declares far more than it carries (100 Gbps). Seats were allocated declared * 1.1 / team * CAP_TEST_SECS, but a team can stream only the ramp-capped, budget-capped R(n). So honest validators on the node's teams were allocated bytes they could never send and their work fraction fell toward 0, while a colluding validator whose node acked the whole allocation kept f_v near 1 Validator, Operator A seat is allocated the water-filled rate * CAP_TEST_SECS * pushed / S that was really streamed, and verified at most the seat's share of the team's measured result (measurement.md §Measurement work). The declaration raises neither. Residual: an honest seat on a node that carries less than R(n) verifies only what it carried, at most a 2x ramp shortfall on that node's seats; the node pays for it in its own capacity haircut ADR-0055 §2; measurement.md §Measurement work Sim validator_phantom_declarer
T184 MITIGATED, residual = T176/T177 (fix round 1 item 3). Validators that also run nodes. A validator whose own nodes sit on its canary pairs or are the tested node of its seats has them sign for bytes it never sent, at no collusion cost; or it registers a fabric node key as its attestation key, so its own source or sink is a signing end Validator Entries signed by a node of a UID whose coldkey is the validator's keep their allocation and verify nothing (WorkEvidence.own_uids): dropping them from the allocation as well would let it skip their cost and keep its full fraction (the drop-both rule in sim validator_own_fleet). A validator with an attestation key that is a bound fabric node key has all its work refused (attest_key_is_node). Residual: a fleet under another coldkey is collusion, bounded by T176 and T177 ADR-0055 §6; measurement.md §Measurement work Sim validator_own_fleet
T200 OPEN, MEDIUM (verification red team A). The participation controller ratchets. Inside the 0.67 to 0.82 dead band k holds, and below target it rises, so it only climbs: a pause or one noisy dip raises the slice for good. Base 5.6% to 8.0%, bear to the 15% cap, 1.65x to 2.06x for an attacker that pauses Validator Planned: a leaky band (k * 0.97 in band, k * 1.0625 below target), mean over 2 to 3 periods. Gate prerequisite ADR-0055 §10 A; OQ-148 Sim validator_controller_ratchet (to write)
T201 OPEN, MEDIUM (verification red team B). Quality drag on the controller. Participation is Σ s_v f_v, so cutting honest validators' work fractions raises k; phantom ramps inflate A_total about 2.1x Validator, Operator Planned: count only stake with f_v at least half the median; index A_total on min(allocated, measured share) per seat. Gate prerequisite ADR-0055 §4.1, §10 B; OQ-149 Sim validator_controller_quality_drag (to write)
T202 OPEN, LOW-MEDIUM (verification red team C). A teammate's zero report. A revealed zero lowers measured_n and cuts each honest teammate's seat by 1 / k'; withholding can help colluders Validator Planned: cap each seat at stream * min(1, c_j / rate_j), j the lower-median revealed member. Gate prerequisite ADR-0055 §10 C Sim validator_teammate_zero_report (to write)
T203 ACCEPTED (verification red team D). The own-fleet rule avoided with a second coldkey. A validator registers its fleet under another coldkey, so own_uids misses it Validator, Operator Ordinary collusion, inside ADR-0055 §6's c bound; OQ-147 accepted ADR-0055 §6, §10 D Sims validator_free_rider (faker), validator_own_fleet
T204 OPEN (verification red team E). k depends on the full history. k is carried window to window, so a validator that misses or mis-replays a window computes a different slice from then on Validator Planned: record k per scoring release, or derive it from a fixed recent span. Gate prerequisite ADR-0055 §10 E; OQ-160 None yet
T205 OPEN (verification red team). Too few independent recorders. With one or two operators measuring, their measurement sets the medians and the controller Validator Gate condition: at least 5 recording coldkeys ADR-0055 §10 F None yet
T165 OPEN, bounded (ADR-0056 revision 1, OQ-135; not scored). Peer-load collusion: a cartel holding a UID share f_uid of the draw tells its node which slices are the cartel's, and the node sheds them. A colluding source sends nothing, which sheds ingress alone; with sink blinding the node can drop a slice before egress only when its R_out and sink both collude Operator Credit reads only hidden slices, which the node can't tell apart. Endpoints are drawn uniformly per UID, slot-capped (T174). Inflation <= 1/(1 − f) on a symmetric port and <= 1/((1 − f)(1 − f²)) on an egress-bound one: at 100 Gb/s, 1.111x, 1.245x, 1.417x, 1.639x symmetric and 1.122x, 1.294x, 1.549x, 1.939x egress-bound at f_uid = 0.1 to 0.4. Without sink blinding, egress-bound was 1.231x to 2.694x. The founder's 1/(1 − f²) + tol fails at every f measurement.md §Peer-load capacity tests, "Bounds" capacity_peer_collusion (gates); capacity_peer_collusion_f2 (founder's bound, gates nothing until OQ-135)
T166 MITIGATED for reports (ADR-0056; not scored). Framing through peer reports: peer sinks under-report or withhold digests, peer sources send nothing, to lower an honest node's credit. Framing through load is T173, through relays T217, through validators T216 Operator Peer sink reports are diagnostics only and never set the node's credit: change 0 at framer shares 0.1 to 0.5. A source that sends nothing only lightens the load. A call with fewer than 3 revealed hidden results is void measurement.md §Peer-load capacity tests, "Running a call" capacity_peer_framing
T167 OPEN, blocks scoring (ADR-0056 revision 1; T148, OQ-117, OQ-166). Hidden slices identified: a node that can tell validator slices from peer slices serves them first, declares far above its capacity, and the ramp compounds it Operator Hidden validators self-select by VRF; terminating relays H_in/H_out are drawn from all peers and never validator-run, so no validator address reaches N or R_out; hidden slices use the peer-slice sender, not the canary sender. Residual tells: the relays themselves know (leak about 2 f_uid a slice), published plans, shape (OQ-166). Indistinguishable: at most 0.984x at any declaration up to 100x. Leak 0.2: 0.62x; 0.5: 1.35x; full: 94.5x (the first draft's 2.0x was its declaration cap). Peer-load credit MUST NOT be scored before this closes measurement.md §Peer-load capacity tests, "Hidden slices" capacity_selective_throttle (gates); capacity_hidden_leak_ramp (gates nothing until it closes)
T168 PARTIAL (ADR-0056 revision 1, OQ-43 resolved, OQ-136). Burst capacity at call time: a node holds its declared capacity only some of the time. Calls come at secret times; a short call is retested, and the bond applies on a short retest or 2 short calls in an epoch Operator A node that holds D for a share ρ of calls is within 1 + tol per unit of cost at every ρ (worst 1.055x at 10x, ρ = 0.75), and worse off outright below ρ = 0.40 at 10x (0.60 at 2x). The retest alone, without strikes, allowed 1.162x. Residual: a 95th-percentile renter holds D at every call, so calls don't deter it; PB-38's sustained-carriage bound has to (OQ-136). An honest node with 1% transient faults keeps 99.8% of its credit capacity-bonds.md §Peer-load calls capacity_burst_renter_calls
T169 OPEN, LOW (ADR-0056 revision 1, OQ-137). Peer pool and duty: a 100 Gb/s call needs 660 endpoints (three a slice), and the per-UID draw gives every UID the same expected duty, so small nodes carry a larger share of their capacity Operator At most 8 endpoints per UID and floor(spare / s) per node in one call. A short pool samples only the slices that ran (slices_run). Fabric-wide duty 0.34% of capacity-time; per node 2.7% for 1 Gb/s nodes, 0.46% for 10 Gb/s, 0.05% for 100 Gb/s. Validator bytes per call at most 7.5 GB whatever the node's size; a 100 Gb/s node is credited 99,999 Mb/s with validators at 1 Gb/s measurement.md §Peer-load capacity tests, "Eligible endpoints" capacity_big_node, capacity_peer_duty
T170 OPEN, LOW (ADR-0056). usable over-credits: the one-hop cut assumes each neighbour can source and sink its whole term, and sybil neighbours can raise it Operator usable only ever caps a sample (a min), so raising it can't inflate credit. Each neighbour's term is capped by its own ramp ceiling and the snapshot link; a big node beside one big neighbour is capped at 14 Gb/s, not 107. The closed form matches an integer max-flow on 300 random one-hop networks measurement.md §Peer-load capacity tests, "usable" capacity_usable_cap
T171 OPEN (ADR-0056, OQ-138). Long burst credits: a policer whose bucket outlasts T − T_meas, or a cloud plan that bursts above its baseline for minutes, passes a 30 s call at its burst rate Operator T_meas (the last 20 of 30 s) measures any bucket that drains within 10 s at its committed rate (90 Gbit at 10 Gb/s line, 1 Gb/s committed). Larger buckets leak: 3,250 Mb/s at 135 Gbit, 5,500 Mb/s at 180 Gbit. Longer calls or random T_meas placement are OQ-138 measurement.md §Peer-load capacity tests, "Measurement and path proof" capacity_token_bucket
T172 OPEN, bounded (ADR-0056, OQ-139). The coordinator leaks: the validator that draws a call's peer slices and knows its times can tell a friendly node which sessions aren't its peer slices, and when it will be called, as T146 for canary plans Validator The draw is recomputed from the revealed secret, so the coordinator can't hand-pick endpoints, only leak. Hidden validators self-select by VRF, so the coordinator doesn't know who they are. It is one stake-drawn validator per node and window. A withheld plan_secret voids its calls and is charged to it. Mitigation open: split the call among several coordinators (OQ-139) measurement.md §Peer-load capacity tests, "The draw" Not simulated
T173 OPEN, bounded for outsiders, not for participants (ADR-0056 revision 1, OQ-167; not scored). Flood framing: anyone floods an honest node's port by about 12% during a call, or a drawn source oversends on its session, making the call short. In the first draft call blocks were public (b − 1) and one short call applied the bond Anyone, Operator Call and retest times come from the coordinator's committed plan_secret; a short call only zeroes its sample and is retested; the bond needs a short retest or 2 strikes. A blind flooder's loss is at most its flood duty φ (0.31 of φ at φ = 0.1; first draft: 0.1% of the day zeroed the node). Sessions are policed to the instructed rate, so an oversend costs nothing on a node with link headroom. Residual: participants learn of a call at its start, so a cartel endpoint (in 49% of calls at f_uid = 0.01, 97% at 0.05) can tip a flooder, costing the node 63% to 100% of its credit; a link-bound node is equally exposed to oversends measurement.md §Peer-load capacity tests, "Calls" and "Retests" capacity_flood_framing, capacity_peer_oversend
T174 MITIGATED (ADR-0056 revision 1). Draw feedback: with peers weighted by spare capacity, an inflated cartel has more spare, so more draw slots, so more collusion, and busy honest nodes make it worse Operator Endpoints are drawn uniformly per UID, then within the UID, with at most CAP_PEER_UID_SLOTS per UID a call, so credit buys no draw weight; N's ASN is excluded. Per UID the cartel holds its share f_uid of the UIDs with a free slot, and inflation stays within 1/(1 − f_uid) (1.30x at f0 = 0.2, f_uid 0.26). Spare-weighted, f0 = 0.3 grows to 0.61 and 2.0x. Residual: busy honest UIDs raise f_uid measurement.md §Peer-load capacity tests, "The draw" capacity_spare_feedback
T215 MITIGATED (ADR-0056 revision 1). Lazy sources: a drawn source that sends less than its slice saves its own bandwidth and lightens every node it is drawn for, inflating every over-declarer (1.42x with 30% idle sources) Operator Each source has a duty record of per-slice delivered ratios, counted from the hop digests of distinct nodes under test (under-countable, never over-countable); its median below 0.95 charges the source the bond, never the node. Idle and 90% senders are charged every time at framer shares up to 0.4; honest sources 0.05% at 0.2, 11.6% at 0.4. Laziness down to 95% escapes: at most 1.05x measurement.md §Peer-load capacity tests, "Source duty" capacity_lazy_sources
T216 MITIGATED, residual MEDIUM (ADR-0056 revision 1). Griefing and favouring validators on hidden slices: in the first draft two griefers of four zeroed a sample through the lower median Validator The sample is the mean of the hidden results, so each bad result moves it by at most 1/m (25%, 50% for one and two of four); short needs a majority (upper median); the bond needs a majority twice (P(majority)² a call: 0.0025 at stake share 0.25). Long-run loss is about the griefers' stake share (0.06, 0.25, 0.47 at 0.1, 0.25, 0.4). Residual: two favouring validators of four lift a node delivering half to 0.80 of its declaration measurement.md §Peer-load capacity tests, "The call outcome" capacity_validator_grief_quorum
T217 OPEN, blocks scoring (ADR-0056 revision 1, OQ-166). Hidden-slice tells and relay drops: the terminating relays H_in and H_out know they carry a validator's slice and can tell N; past plans give timing fingerprints; and a framer relay on a hidden slice's path (H_in, R_out, H_out) can drop it Operator Relays are drawn per call from all peers, never validator-run; hidden slices use the peer-slice sender; leaks feed T167. Framer relays at share 0.1 cost a 10 Gb/s node 23% of a sample (31% at 100 Gb/s), short in 1.6% to 9.4% of calls; at 0.3, 75%. Not mitigated: needs relays that can't tell (OQ-166) or relay duty records measurement.md §Peer-load capacity tests, "Hidden slices" capacity_peer_framing (detail), capacity_hidden_leak_ramp
T185 MITIGATED by design, not scored yet (ADR-0057). Location spoof: a node delays or drops sites' probes to be placed in a dearer region, the Helium GPS-spoofing analogue Operator Delay can only raise an RTT, and the separation rule puts sites of different regions further apart than any node can be in range of both. So the only placements open to a node are its true region and unplaced. Unplaced pays GEO_PRICE_MIN_PPM, at or below every price, and ΣS counts unplaced nodes, so no other region's price falls. Prices have no memory of supply, so a spoof in one window moves no later price. Unplacing resets probation measurement.md §Network position; scoring.md §Locational price Sim geo_location_spoof: 4 attackers (small EU node, EU whale with half of EU, AF node, node between regions) x 129 delay patterns x 2 schedules, best 1.000x honest, 0 placements outside the true region
T186 MITIGATED by design (ADR-0057). Sybil split for price: one operator splits into many nodes or UIDs, or registers fresh keys in a scarce region, to collect more of its price Operator Placement is per node by physics, so pieces at one place share one region. S_r and ΣS don't change and pay is linear in priced capacity (floors only lose). Demand is never node-derived. A fresh key is on probation (at most 1.0x) for GEO_PROBATION_WINDOWS scoring.md §Locational price Sim geo_sybil_split: k in {2, 3, 8, 16}, one UID or k UIDs, in AS and EU, worst 1.000000x
T187 OPEN, bounded (ADR-0057; revisions 1 and 2). Validator site collusion: validators report false low geo_rtt figures (and test RTTs) from their own sites to place a colluding operator's far-away nodes in their region, or false figures to cause conflicts; or false high figures to unplace a rival (denial) Validator, Operator Placement needs GEO_PLACE_MIN_SITES (2) in-range sites with disjoint validator sets, and every covered location has GEO_SITE_REDUNDANCY (3), so one validator can neither place nor unplace a node. A site's figure needs a strict stake majority. False figures place a node only in the colluders' own region, conflicts go to the cheaper region, and conflicts are listed publicly. Residual: two colluding validators, each running a site of one region, can place a node there (1.175x), and two deniers of three can unplace a rival. Before enabling (OQ-196): vetted, distinct site operators; a light-cone tripwire on any node whose figures at two sites sum to less than their separation allows; and a flag on placed nodes that are slow to their region's other placed nodes measurement.md §Network position geo_site_collusion: one colluding site 1.000 (1.175 before revision 1); half of two sites' stake 1.000 (1.175 with >=); two colluding validators 1.175, the residual. geo_site_denial: any one denier of 3 sites 1.000 (twin sites: 1.916); two deniers 1.916, the residual
T188 CLOSED for miners, DORMANT for customers and the company (ADR-0057, OQ-186, OQ-187). Demand steering: raise a region's price by creating demand there. Ways in: node count (today's all-pairs demand set), customer traffic (the company buying from itself, ADR-0053), or the prior Operator, Customer, Company All-pairs and synthetic demand are never counted. Matrix demand has weight 1e6 - GEO_PRIOR_WEIGHT_PPM = 0 at launch. The prior moves only on ADR-0049's scheduled, public path scoring.md §Locational price geo_sybil_split covers node count; matrix and prior levers are policy (OQ-186, OQ-187)
T189 OPEN until the usable-capacity cap merges (ADR-0057 §6). Unusable capacity paid at a scarce price: a node in a scarce region with no peers that could route through it is paid up to GEO_PRICE_MAX_PPM for capacity nobody can use, and its supply lowers the price for that region's useful nodes Operator Dependency: the peer-load capacity-test design caps scoring_capacity at usable capacity, and pricing uses that figure. PB-44 MUST NOT enable pricing before it merges unless GEO_PRICE_MAX_PPM is held at 1e6 scoring.md §Locational price None until that design lands
T190 OPEN, LOW, behavioural (ADR-0057 §4). Herding: every operator moves to the same scarce region at once, on the same price map, and prices oscillate Operator Probation (at most 1.0x for a day after a move) is a switching cost, and real moves take time and money. Moves that each improve their mover converge, because the region game has an exact potential. Prices aren't smoothed on supply, because that opens T191 scoring.md §Locational price Sim geo_price_stability: 3 movers a window, 10% margin, 0 cycles, 0 potential drops, 0 tail price changes; the herd contrast (all at once, no margin) cycles 394 times and gates nothing
T191 MITIGATED by design (ADR-0057 §4). Supply-withholding pump: a whale withholds capacity, or unplaces itself (free when its region already sits at P_MIN), to raise its region's price, then collects the lag Operator Prices are memoryless in supply: only demand is smoothed. Without clamps, a region's pay is exactly its demand share, so withholding only lowers the withholder's fraction of it. With clamps, the region's total doesn't rise scoring.md §Locational price Sim geo_location_spoof (withholding 10/50/90%, held or alternate, best 1.000x); geo_price_stability reports the pump a price moving average would open: 1.0117x at α = 0.1 vs 0.9973x memoryless
T192 CLOSED as an exploit, folded into T196 (ADR-0057 revision 1). Front-end proxy: a host in a scarce region answers probes and forwards transit to capacity in a crowded region, to be paid the scarce price. The design-phase row claimed the hairpin's latency, seen by link probes and Q_n, catches this. It doesn't: Q_n scores loss and latency against the path the table assigns, and a front only has to be good enough, not free of hairpin Operator See T196. When the endpoint is the front box, peer links come only from the endpoint prefix, so capacity and carriage are the front box's own. That is real ingress capacity in the scarce region, so it is paid as such, whatever the box does with the traffic behind it measurement.md §Network position geo_endpoint_front
T193 OPEN, bounded by OQ-43 (ADR-0057). Burst-rented capacity in a scarce region: rent capacity for its capacity tests to collect up to 3x, or rent into a rival's region to push its price down Operator Prices are memoryless, so a burst moves prices only while the capacity is there, and the renter pays the rent. Burst renting itself is OQ-43 / Task 15b, and pricing raises its stake by up to GEO_PRICE_MAX_PPM scoring.md §Locational price Existing burst_renter* sims apply, unpriced
T194 MITIGATED by process (ADR-0057). Invalid region table: sites a, b of two regions closer by chord than (R_a + R_b) * c / 2, so an honest node is in range of both and could choose by delay; or a region with fewer than two independent sites Publisher The publishing tool checks separation by chord and the two-site minimum, and refuses the table. Conflicts at run time go to the cheaper region and are listed publicly measurement.md §Network position Unit tests placement_needs_two_independent_sites, per_site_radii_set_the_separation; the sims' world() and geo_coverage_band assert separation
T195 OPEN, bounded, dormant (ADR-0057, OQ-189). Atlas anchor forgery: an Atlas ping is ICMP or TCP, not a STAMP exchange on the node-key-authenticated vantage session, so an anchor's host or its network forges a fast reply for a colluding node's endpoint, or the host misstates the anchor's position Outside party, Operator Dormant: the launch region table lists no Atlas site, and none is listed until the terms are verified. If listed: anchors only (never volunteer probes, whose positions hosts set), each admitted by a proximity proof from a validator site of its region. A forged figure can place a node only in the anchor's own region, and a conflict goes to the cheaper region, the same bound as T187 measurement.md §Network position Not simulated
T196 MITIGATED by design (ADR-0057 revisions 1 and 2, red team Critical). Thin front in a scarce region: one node key on several boxes, so a cheap box near a scarce region's sites makes the node look placed there while capacity in a crowded region is paid the scarce price (1.5x measured, up to P_MAX / P_MIN = 6x). Variants: (i) a session front answering the scarce sites' vantage sessions from its own address; (ii) an endpoint front with a back box carrying the data plane; (iii) an anycast front; (iv) any of these inside one provider's IPv6 /32, which revision 1's prefix match let through (revision 2's Critical) Operator (a) Vantage figures count only from sessions whose source matches the committed endpoint: the exact IPv4 address (a carrier-NAT pool's /24), or the IPv6 /64. (b) Every timing a site's agents see counts toward its figure. (c) Honest peers accept peer links only from the endpoint. (d) Capacity is priced above P_MIN only up to dedicated in-region tests whose own RTT is within their site's radius; delay can hide a near box, never fake one. Note: with Europe's 4 ms radius most European boxes are unplaced, so a front's back box trips no Europe conflict. The light cone's conflict rule doesn't help there; (a), (c) and (d) do. Residual: a front box's own capacity is real ingress in the scarce region and is paid as such (T192) measurement.md §Network position; scoring.md §Locational price Fixed vs before (W 0.7 and 0.3): geo_split_session_front 0.790 vs 1.513; geo_endpoint_front 0.213 vs 1.523; geo_anycast_front 0.923 vs 1.513 (1.513 with (a)-(c) only); geo_v6_prefix_front 0.790 / 0.213 vs revision 1's 1.513 / 1.523
T197 OPEN, LOW, bounded (ADR-0057 revisions 1 and 2). Carry abuse. (i) Outage freeze: a validator takes its site down, freezing placements that need it. (ii) Relocation gain: a node that moves away and drops (rather than delays) its old region's probes stays silent there, so it keeps that region's price Validator, Operator The carry lasts at most GEO_OUTAGE_CARRY_WINDOWS (24) windows. A node placed elsewhere is placed there at once. A site reporting the node out of range ends the carry. In-region capacity is carried, not re-measured, and expires after GEO_INREGION_MAX_AGE_WINDOWS. With three sites per location, one site down freezes nothing measurement.md §Network position geo_site_outage: AF node 1.28x through a 10-window outage of 2 of its 3 sites (0.50x without the carry); a 40-window outage keeps 24 windows, then 0.50x. geo_location_spoof's drop-all pattern gains nothing (1.000)
T198 MITIGATED by design, residual open (ADR-0057 revision 2, red team Medium). One shared in-region box behind many nodes: 8 nodes anycast from one 50 Mbps box near a scarce region's sites, so each node's in-region tests measure 50 Mbps Operator In-region capacity is pooled within a region per UID and per origin ASN of the endpoint: a simultaneous cohort in-region test caps the group's sum (geo::pool_in_region). Residual: sybil UIDs with distinct origin ASNs (each one costs an ASN) aren't pooled measurement.md §Network position geo_shared_inregion_box: one UID 0.988, 8 UIDs with one ASN 0.988 (1.094 unpooled); 8 UIDs with 8 ASNs 1.094, the residual
T220 MITIGATED (ADR-0058). Copied inline binding: a hotkey copies another fleet's inline payload (or lists any node keys) into its own commitment to claim or quarantine those nodes Operator The payload carries no hotkey; it stands for a binding by the committing UID's own metagraph hotkey, and a node counts only with an effective consent to that hotkey (Binding resolution, rule 2). Unconsented entries are ignored, never quarantined (T14) identity.md §Inline node binding inline_resolves_under_consent_and_takes_precedence
T221 OPEN until Task 19b activation (ADR-0058 §6, OQ-201). Version split: code from before ADR-0058 reads a multi-field registration as not Transit Fabric's and drops its manifest too, so old and new validators would score different inputs (Invariant 1) Operator (any hotkey that commits inline) Nothing scores from chain commitments before Task 19b; its reader fills TempoInput::inline_bindings only from an ADR-0049 activation block before which every validator ignores inline layouts; local and test active from window 0 identity.md §Inline node binding, "Activation" none yet (Task 19b)
T222 MITIGATED (ADR-0058). Hostile or malformed commitments passed off as Transit Fabric's: foreign Raw data, a short first field, an empty or fourth field, another hash in field 0, a RawN whose bytes aren't N long, trailing bytes Anyone who commits Exactly two layouts are read ([Sha256], [Sha256 | None, Raw, Raw?] with the canonical 128-byte split); the payload decodes strictly (version, exact length, 1..=7 sorted valid keys, window); anything else is not Transit Fabric's: skipped by readers and never replaced by bwos bind or the page encoding.md §Commitment fields only_bwos_layouts_parse, inline_binding_vectors_match, commitment_records_decode_inline_bindings, the page's layout test
T223 MITIGATED (ADR-0058 fix round 1). Inline binding wiped or a stale manifest binding resurrected. Every manifest recommit (validators and solvers recommit often) wrote [Sha256] alone, silently dropping the inline binding and bringing back whatever binding the manifest names The operator's own tools Every Transit Fabric commit path reads the registration first and keeps fields 1 and 2 (manifest_commit_content: bind commit --manifest, attest-key commit, the page). Non-Transit Fabric registrations are refused. Reverting to the manifest's binding happens only by explicit choice (--drop-inline, or the page's drop box) identity.md §Inline node binding, "Recommits keep it" manifest_commit_content_keeps_inline_unless_dropped, bind_commit_manifest_keeps_inline, trust_commit_keeps_inline (localnet)
T224 Reopened by the PB-45b red team (H1: a flood of consents crowded honest UIDs out of the capped reveal; M1: old revocations displaced a node's current consent), mitigated in fix round 1; fix round 2 (H3: the first-come pool brought crowd-out back; M4: a superseded consent took a quota slot), mitigated. Consent delivery over the probe session abused: a node or forwarder pushes consents for other nodes, floods, or replays a lower seq Operator Accepted only when node is the session's own node key (bound by its live wg-binding; a --test-identity session forwards nothing), verified, one datagram of at most MAX_FORWARD_PAYLOAD; a per-session token bucket and repeat memory, the repeat checked first so resends spend no token; a pending pool per session node (its current consent, newest revocation and up to MAX_NODE_OBJECTS objects, a new one replacing the least recently sent in the node's most-held domain; tests the_pool_replaces_within_the_most_held_domain, a_new_manifest_every_window_never_evicts_the_declaration, a_resend_is_handed_on_again_as_sent), so a node replaces only its own entries; a reveal lists one current consent and one newest revocation per node (only the revocation when it supersedes the consent), newest first, only under a hotkey a binding lists the node with, at most MAX_REVEAL_CONSENTS_PER_UID per UID; per (node, netuid) only the highest-seq started consent and revocations win (effective_consents, no resurrection) identity.md §Delivery over the probe session consent_flood_cannot_displace_other_uids; revocation_heavy_node_keeps_current_consent; the_pool_keeps_each_nodes_latest_and_is_bounded_per_node; repeats_spend_no_tokens; a_newer_revocation_is_listed_alone; sim consent_crowd_out; a_consent_counts_only_for_the_sessions_own_node; test/netns/probe_forward.sh
T225 Reopened by the PB-45b red team (H2: locally received items could reach scoring through consent_state or the store, so validators diverged), mitigated in fix round 1; fix round 2 (H2: batch-sign listed what it was given, and serve --consents-out was documented as feeding --consents-file), mitigated; live loop wiring is Task 19b's. Consent divergence: validators receive different consent subsets (loss, timing, or a validator withholding a revocation), so honest validators score different live sets Validator, network Received items wait in a pending pool (ForwardPool) that feeds only the validator's own reveal and its probe agent's plan, which is not scored (the file tools too: serve --pool-out writes a pool that only batch-sign --pool reads, revealing against the chain read, and --consents-file refuses it); scoring reads only the union of revealed lists that pass the chain checks (no forgery, no resurrection, any one honest validator restores a withheld revocation); a post-cutoff arrival changes nothing until the next window's reveal identity.md §Delivery over the probe session post_cutoff_forward_does_not_change_outcome; the_union_of_reveals_keeps_a_revocation_one_validator_withheld; batch_sign_reveals_the_pool_against_the_chain_read; test/netns/probe_forward.sh
T226 OPEN until Task 19b (ADR-0058 §5, OQ-204). ASN grinding and churn by recommit. If an inline node's ASN-ranking block were its registration's current block, every recommit would push honest incumbents back, and a hotkey could recommit until asn_tie(block_hash_after, key) wins a collision Operator An inline node's block is the first registration that listed it under that UID with no break at any read block since; its tie uses the hash of the block after that one, so a recommit keeping the node changes neither. Derived from Commitment events or carried forward in committed inputs (OQ-204) identity.md §Inline node binding, "Collisions" asn_grind_inline_recommit (to write with Task 19b)
T250 MITIGATED in design (ADR-0059 revision 1), not active. Capacity hog across shards: a solver wins one shard with a table that loads relays, endpoint-and-relay nodes or finite links another shard needs. Revision 0 left links unsplit, counted endpoint traffic in the allocation but not the check, and rechecked nodes only (red team round 1, High) Solver Node, relay and link capacity split separately before solving (reference load plus locality-weighted slack); a shard table is valid only if validate_under_demand passes and compute_overloaded_nodes is 0 on its view; the merged recheck uses compute_overloaded_nodes on the full snapshot and evicts invalid-on-view shards first routing.md §Proposed (ADR-0059), scoring.md §Proposed (ADR-0059) shard_capacity_hog, shard_link_hog (link 300/300, node 400/400; hog invalid on view; only its shard evicted), allocations_fit_and_cover_the_reference
T251 Proposed (ADR-0059), not active. Merge nondeterminism: validators compute different merged tables, so nodes see conflicting attested production tables (T60) or none reaches quorum Validator, network The merge is a pure integer function of committed inputs (plan, solved-on snapshot with placement, demand, reference, allocations, selected tables), BTreeMap only, sorted output, fixed solver label, no signature; validators attest the table and a recomputable merge record routing.md §Proposed (ADR-0059) shard_merge_determinism
T252 Proposed (ADR-0059), not active. Merge-order gaming: a solver gets its routes accepted ahead of a rival's at a conflict Solver Order is the committed plan's shard id, never score, UID or commit block; with one class group the union is disjoint per destination and order-free (no fallback) routing.md §Proposed (ADR-0059) shard_merge_determinism (region plans: zero fallbacks)
T253 Proposed (ADR-0059 revision 1), class groups only, not active. Cross-shard cycle sabotage: a higher-priority class shard's winner picks next hops towards shared destinations that force a lower shard's routes off, to lower its rival's grade Solver Displaced routes fall back to the reference's, then direct, in the merge only; every table is graded as submitted (live blocks included), so displacement can't lower a rival's score; merge harm dropped; class splits not enabled until a red team scoring.md §Proposed (ADR-0059) shard_cycle_saboteur (victim's grade 795_000 with and without the saboteur; 0 if graded on the merged slice), a_cross_class_cycle_falls_back_to_direct_in_the_later_shard
T254 Proposed (ADR-0059), not active. Shard-shopping: solvers crowd the easiest shard, or try to move weight towards the shard they entered Solver W_s comes from smoothed regional demand d_r with a 5% floor, never from entrants, scores or pair counts; each shard has its own ladder (the top rung keeps at least half); an unbeaten shard's weight is unearned within the first-party cap, so a solver who beats the reference there takes it scoring.md §Proposed (ADR-0059) weights_have_a_floor_sum_to_a_million_and_ignore_entrants; shard_crowding (to write, PB-46)
T255 Proposed (ADR-0059), not active. Cross-shard clone dodge: copy another shard's routes, last window's production routes for keys that moved shard, or another class's paths for the same (src, dst) Solver Shard keys are disjoint, so no table copies another shard's key for key; the prod-copy check runs per shard against the merged production table restricted to the shard's current keys, moved keys included; a copied other-class path must still beat the shard's reference by EPSILON_ROUTE and pass the solved-on gate scoring.md §Proposed (ADR-0059) cross_shard_copier (to write, PB-46)
T256 Proposed (ADR-0059), not active. Collusion across shards: one entity wins several shards and coordinates them, for example to route through its own relays Solver + operator With one class group shards don't interact in the merge; regret, the usage concentration cap and the Mechanism 0 regret gate bound relay dealing per shard as for one table (T8); winning every shard pays what winning today's single contest pays scoring.md §Proposed (ADR-0059) shard_collusion_pair (to write, PB-46)
T257 OPEN, low (ADR-0059). Placement steering: an operator moves its destination node's pairs into another shard (by going unplaced or moving region) to land in a colluding solver's shard Operator + solver Shard membership is ADR-0057 placement on the solved-on snapshot (light cone, two independent sites, hysteresis); moving pairs changes D_s and which ladder grades them, never the grading rules or a route's pay routing.md §Proposed (ADR-0059) — (model only)
T258 Proposed (ADR-0059), not active. Update interference: two shards' incremental updates, each valid alone, combine at a node into a cycle or an overload, or nodes applying chains in different orders diverge Solver, network One chain per (window, shard) on disjoint keys; each checked on its shard view (capacity within allocation) and against the merged table's structure; towards destinations shared by several shards, only removals and direct routing.md §Proposed (ADR-0059) shard_update_race (to write, PB-46)
T259 OPEN, efficiency (ADR-0059, OQ-232). Allocation starvation: the reference-anchored split holds back a solver whose better routing uses relays differently from the reference; or an operator shapes allocations through the snapshot Solver, operator Slack goes by locality (reference load plus the shard's own endpoints), falling back to W_s, so a shard has room where its pairs are; allocations read only the snapshot, demand, plan, d_r and reference; published before the commit deadline routing.md §Proposed (ADR-0059) — (efficiency against a single table to measure, PB-46)
T260 Proposed (ADR-0059), not active. Selective reveal: a solver in several shards reveals only the shard tables that look good after the deadline Solver One commitment per UID over the whole bundle (route-table-bundle); a partial reveal doesn't match the hash and counts as no submission scoring.md §Proposed (ADR-0059), encoding.md unit test with the bundle (PB-46)
T261 Proposed (ADR-0059 revision 1), not active. Sybil destinations: an operator registers many destination nodes in a region so demand sampling inflates that shard's weight (pair-count weights), or owns every destination of a shard Operator + solver W_s from ADR-0057's smoothed regional demand d_r (prior plus non-synthetic), never pair counts, with a 5% floor; a non-residual shard with fewer than SHARD_MIN_DEST_UIDS (3) destination UIDs folds into the residual scoring.md §Proposed (ADR-0059) shard_sybil_region_capture (0 ppm moved; pair-count rule would give 666_666 ppm), thin_shards_fold_and_regional_demand_sets_weights
T262 Proposed (ADR-0059 revision 1), not active. Shard-view regret dodge: a solver detours a pair through its own relay where its shard view gives a faster relay no capacity although another shard left it unused, so the detour is regret-free on the view and its relay passes the Mechanism 0 gate Solver + operator Regret and the Mechanism 0 gate are computed on the full snapshot with the merged table's other loads (OQ-238 (b)); slack split by locality (OQ-232 (b)) scoring.md §Proposed (ADR-0059) shard_view_dealer (0 ppm on the view, 200_000 ppm under the rule)
T263 Proposed (ADR-0059 revision 1), not active. Recheck blame: when the merged table fails the recheck and no shard is invalid on its view (stale or broken allocations), evicting the highest id punishes an honest shard for another's overload Solver Evict, per overloaded node, relay cap or link, the shard with the largest load on it (ties to the higher id) routing.md §Proposed (ADR-0059) shard_recheck_blame (evicts {1}, the overloader, not {2})
T230 OPEN (Task 19b, OQ-211). Selective serving: a committing hotkey serves a named object (its record, batch, binding or declaration) to some validators only, so they score different inputs and Yuma clips some of them Validator, operator The loop fetches from its own store and every peer and counts a missing object as absent, the same for all who lack it; no quorum on fetched objects yet measurement.md §Live loop —
T231 MITIGATED (Task 19b). Copying another validator's probe batch, or naming it in one's own manifest Validator A batch counts only when signed by a key the committing hotkey's record maps to it; the loop withholds its own batch until the read block has passed, and commitments are read at that block by hash measurement.md §Live loop a_bound_tested_node_earns_mechanism_0_through_the_loop
T232 MITIGATED (Task 19b). Equivocating publication after a restart: a validator that crashed between signing and recording could attest a second object for the same window Validator (bug or attacker with a restart) attest-guard.json records (domain, latest_key, attestation hash), synced, before the publisher signs; a different object for a recorded key is refused measurement.md §Live loop live_t60_guard_survives_a_restart
T233 MITIGATED (Task 19b). Demo or file inputs reaching live scoring (F1), or a testnet validator scoring with one-validator-one-vote Owner, operator error live refuses --demo, --input, --stakes-file, --signed-inputs; on test a read with no staked hotkey is an error measurement.md §Live loop live_with_no_inputs_sets_no_weights_and_never_uses_demo_input, live_on_test_without_a_stake_source_is_an_error
T234 MITIGATED (Task 19b fix round 1, F1). Evidence-slot griefing: any UID named a hash nobody serves in its outside-evidence slot, or copied another validator's hash, and every validator held both mechanisms back for about 25 windows Any UID, validator Fix round 2: missing evidence never holds weights (an unfetched object just isn't counted); slots count only for hotkeys in the window's validator set with a permit, per (hotkey, window), a shared hash to the earliest commitment measurement.md §Live loop a_miner_evidence_slot_never_holds_back_weights, a_copied_evidence_hash_does_not_hold_back_weights
T235 MITIGATED (Task 19b fix round 1, F2). Tarpit pull bases: an axon that accepts and never answers stalled every read for a fetch timeout per object, delaying the validator's own commit past its read block Any UID Fix round 2: every fetch of a read or a scoring pass starts at once and the batch is waited on once, each object racing its sources and returning on the first verified copy, so a tarpit costs only its own hotkey's objects; unfetched manifests re-read until the scoring deadline; the own commit runs first in each pass measurement.md §Live loop tarpit_axons_do_not_delay_own_commit, tarpit_axons_sorted_first_do_not_drop_an_honest_manifest
T236 MITIGATED (Task 19b fix round 1, F5). SSRF through a pull base: an axon pointing a validator at its loopback, a private network or a metadata address Any UID fetch::check_pull_base: a bare http://<ip>:<port>, IP literal only (no DNS, so no rebinding), no path or query; global unicast only on test identity.md §Commitment manifest pull_bases_are_bare_ip_bases_and_global_unicast_on_test
T237 MITIGATED (Task 19b fix round 1, F3, F6). State drift and rank-by-timing: a missed window was marked scored and its carried state skipped; and among bindings older than the read horizon, commit timing still set the ASN rank Validator (outage), operator Scoring in order with retry and catch-up; every binding as old as the horizon ranks from the oldest window's first block measurement.md §Live loop restart_before_scoring_still_scores_the_window
T238 MITIGATED (Task 19b fix round 3, C1). Copied-hash fetch blocking: a hotkey commits a manifest naming another hotkey's object hash, with a dead axon that sorts first; fetches deduped and failures remembered by (domain, hash) alone marked the object failed before the owner's axon was asked Any UID Requests grouped by (domain, hash); one job races the peers and the axon of every hotkey naming the hash; failures remembered per source measurement.md §Live loop copied_hash_with_dead_axon_does_not_block_owner
T239 MITIGATED (Task 19b fix round 3, H1). Fetch starvation: about eleven junk UIDs naming objects that sort first, on tarpit axons, filled the in-flight cap, and requests past it were dropped, so probe batches and route tables were never fetched Sybil UIDs No drop: jobs queue and start one hotkey at a time in turn until the budget ends, each hotkey holding at most MAX_FETCHES_PER_HOTKEY measurement.md §Live loop, scoring.md parameters junk_uids_cannot_starve_probe_results_or_tables
T240 MITIGATED (Task 19b fix round 3, H2). Withholding a table at the probe draw: a solver serves nothing at S + 36, so none of its paths is drawn for path probes, then serves the table at scoring time and is graded unprobed Solver Only tables fetched at the draw are graded, recorded in D(w) as drawn_tables; anything else is no submission. A validator that missed the draw holds Mechanism 1 back (OQ-224 (a), M-a). Residual: a draw that failed is retried until S + 36 + DRAW_GRACE_BLOCKS, so a table first served in those 12 blocks is drawn by a validator whose own draw failed, never by one whose draw succeeded; the timely quorum's grading decides measurement.md §Live loop table_withheld_at_probe_draw_is_not_graded, a_missed_probe_draw_holds_mechanism_1_back
T241 MITIGATED (Task 19b fix round 3). First-party slot takeover: the first party was pinned by UID number, so after its deregistration whoever registered into the UID took all of Mechanism 1's unearned weight Any registrant --first-party-hotkey <ss58>, resolved to its UID at each read block; --first-party-uid removed measurement.md §Live loop, operations/testnet.md the_first_party_is_pinned_by_hotkey_not_uid
T264 OPEN, LOW (Task 20). A validator feeds a solver a forged snapshot. A solver started without --validator-set trusts the first validator's latest set on first use; that validator can serve a set of its own keys and a snapshot it alone attests, so the solver solves on a fake topology Validator Testers get a validator-set.json anchor with the tester release and pass it with --validator-set; the daemon walks it with accept_next_set and takes only a snapshot the set attests at SIGNED_INPUT_QUORUM_PPM (demand per pair included), refusing two attested ones for a window. First-use trust is only a fallback and logs a validator_set_trusted_on_first_use warning. Even then only that solver is harmed: its table fails validate_under_demand on the real snapshot and scores 0, and the forger gains nothing routing.md §Route table, run-a-solver.md daemon_refuses_an_unattested_snapshot
T265 MITIGATED by design (Task 20). A solver copies a rival's table before committing its own, or an incumbent re-commits after seeing rivals Solver Validators read solver commitments at the deadline block's hash and pull tables only when that read is taken, once S + 36 is final (scoring.md §Grading item 9, OQ-220, OQ-222); the daemon serves its table once block S + 36 exists (best head), so it is there for the path-probe draw (T240) but no commitment can still land in time, sends no commitment within COMMIT_MARGIN_BLOCKS of the deadline, and never commits a second table manifest before it (a later commitment would rank its table after any copy; the incumbent's update manifest comes after the read). A hand-rolled solver serving early only exposes itself scoring.md §Grading item 9, identity.md §Pulling a hotkey's objects daemon_commits_a_manifest_whose_table_hash_matches_what_it_published
T280 Reopened by the PB-45b red team (H1: the same object revealed once per forwarding node crowded out other UIDs' manifests; H2: admitted objects went straight into the store; M2: an object under another hotkey, or a binding through objects, could be admitted), mitigated in fix round 1; fix round 2 (H1: one outsider-forwarded manifest made a validator's whole object list fail, voiding every UID's), mitigated. Forwarded operator objects abused: a node forwards another UID's objects, objects no commitment names, or floods validators' stores; or one validator reveals objects others never admitted Operator, validator The agent keeps only verifying objects in FORWARDED_DOMAINS (no route tables), tagged with the session's node key; a validator admits one only if the chain names it at the read block for a UID (manifest by sealed hash in field 0 and the binding only through binding, both chain-pinned so from any forwarder; then what the manifest names, only as forwarded by the UID's own nodes; each only with the UID's own hotkey; inline binding takes precedence); a list counts per UID, so one UID's bad entries drop only that UID's; each (domain, hash) is revealed once, at most MAX_REVEAL_OBJECTS_PER_UID per UID, within MAX_REVEAL_FORWARD_BYTES; only the union of revealed lists, re-admitted against the same chain read, reaches the store, from the next window identity.md §Delivery over the probe session reveal_objects_honest_load_keeps_every_manifest; only_the_bound_uids_committed_objects_are_admitted; an_outsider_forwarded_manifest_voids_nothing; reveal_of_any_pool_passes_its_own_check (property); reveal_caps_at_maximum_fit_the_byte_budget; test/netns/probe_forward.sh
T281 Residual (PB-45b, OQ-261). The reveal cutoff can't be checked by others: a validator can list a consent or object it received after FORWARD_REVEAL_CUTOFF_BLOCKS, up to its commit Validator Harmless to the set: every entry is node- or hotkey-signed and re-checked (consents by effective_consents, objects by admit_forwarded), so a late entry can only add what the chain already fixed at A(w). Since the cold-start fix (forwarded objects count in their own window, OQ-261) a permit-holding operator re-committing every window can decide at its own commit whether its forwarded declaration counts for w, the same option as serving only at scoring time (OQ-211), bounded by the declaration cooldown; the batch is fixed at commit, so nothing changes after others score identity.md §Delivery over the probe session, "Bounds" —
T282 MITIGATED (PB-45b integration fix round, H1). One missing binding voids every consent: the scorer dropped a batch's whole consent list when one consent's node wasn't listed in its own bindings (a binding it hadn't fetched, OQ-211), so one UID's withheld binding cost every UID's forwarded consents in that batch Operator, validator accepted_reveal_consents: the list's shape (the signer's alone) or nothing; then each consent on its own, the listing before the signature, and the per-UID quota only over listed consents identity.md §Delivery over the probe session a_consent_the_scorer_cannot_place_voids_no_other_uids
T283 MITIGATED (PB-45b integration fix round, M1). Local store consents bypass the union: live scored every consent in its own store, which a loopback PUT or a peer's copy fills differently at each validator (Invariant 1) Operator, validator live scores no store consent; consents count only through the revealed union and the consent state it feeds. Kernel nodes lose their path until OQ-260 measurement.md §Live loop a_consent_only_in_the_local_store_does_not_count
T284 MITIGATED (PB-45b integration fix round, M2). Any staked hotkey reveals: a batch from any hotkey with a record could add forwarded consents and objects, and its unrevealed batch was re-asked for the whole 120 s scoring budget Staked hotkey Only batches committed by a validator-permit holder at A(w) feed the union, checked before any signature; re-asks only for permit holders, at most PROBE_BATCH_REASKS (4) a pass measurement.md §Live loop only_permit_holders_batches_feed_the_union
T285 MITIGATED (PB-45b integration fix round, L1). Scoring starves the draw: a long catch-up or re-ask loop ran past S + 36 + DRAW_GRACE_BLOCKS, so the validator missed the path-probe draw and held Mechanism 1 back Validator (load), any UID (slow objects) Catch-up scoring and the re-ask loop stop when a draw is due and not taken (draw_pending) measurement.md §Live loop a_missed_probe_draw_holds_mechanism_1_back
T286 MITIGATED (PB-45b integration fix round, L3). Pool file swap: read_probe_pool checked the size by path and read the path again, so a file replaced in between was read unbounded Local process Opened once, read to at most MAX_POOL_FILE_BYTES + 1 identity.md §Delivery over the probe session a_cold_start_past_the_commit_block_still_reveals
T287 MITIGATED (PB-45b integration fix round, L4). Unreachable cutoff and a silent cold start: the spec's cutoff was S + 350, after the commit at S + 300; and a validator first started past S + 300 committed before reading A(w), so its batch revealed nothing Validator (restart) FORWARD_REVEAL_CUTOFF_BLOCKS = 60, so the cutoff is the commit block (asserted at build time); a cold start reads A(w) alone before committing identity.md "Bounds" a_cold_start_past_the_commit_block_still_reveals
T300 ACCEPTED RESIDUAL, only while every validator is founder-run (PB-48, corrected in PB-48, T45, OQ-284). Unmatched probe sessions feed batches. Each validator has its own probe session with the node, so an operator can answer each validator's vantage probes and capacity tests from a different box: a forwarder, or a second box holding its node key, with more uptime or a bigger pipe than its data plane. It needn't be one box for all validators, so the stake-weighted median gives no protection Operator Bounded, not closed. Capacity credit needs a passing signed link with a node of another UID on the committed snapshot (T303), so a box with no data plane earns nothing. Every test's target is committed and capacity pools by its /24 (T304). The declaration still caps capacity, and only node-key acks count. Closed by Task 18b's source match, or by dropping --agent-results before any third-party validator holds a permit (OQ-284) measurement.md §STAMP probes and probe sessions ("Until Task 18b"), §Live loop probe_one_box_many_keys, pb48_only_data_plane_nodes_have_a_link, test/netns/probe_kernel_session.sh
T301 Residual (PB-48, OQ-283). A capacity test aimed at the probe session's source address: a node whose sink port is closed (and, without the agent's --cap-dial-listen, a node behind NAT) fails every test and earns no capacity pay. A third party can't make it fail, since the agent dials the source the node's own handshake proved and only the node key acks, but it can occupy the sink's 32 slots (4 per source IP) while a test is due. The NAT dial-out (red team fix 9) is built (T312, T313) Operator, third party cap-sink -persist keeps MED-INFRA-01's per-connection header deadline, concurrency cap and per-IP cap, and serves test after test, so a scanner delays a test at most to the agent's next try; a failed test lowers the rolling lower median, never more. A dialled test is credited at most CAP_DIALED_CEILING_MBPS measurement.md §Live loop ("The agent's work") a_persistent_sink_serves_test_after_test, pb48_capacity_needs_targets_bytes_and_three_reporters (the dialled cap)
T302 MITIGATED (PB-48). The agent's files as a side door into scoring: a results file with direct: or forged samples, another window's results, or a plan that aims the agent's tests elsewhere Local process on the validator host live takes results only for the window it commits, strictly parsed within 16 MiB, with only vantage:, link: and cap: keys and targets for cap: samples (AgentResults::validate). A key its --probe-results file has keeps the file's. Acks must name the batch's validator and window, to_metric_map still checks every ack's node signature, and a link: sample is only the agent's report of the far end's signed echo. The merged batch must validate before it is signed. The plan names only the attestation key, nodes and test blocks, never an address measurement.md §Live loop ("The probe agent's plan and results") agent_results_carry_only_vantage_link_and_cap_samples, merging_adds_the_agents_samples_acks_and_targets_and_keeps_the_files, the_probe_agents_results_reach_scoring_in_the_committed_batch
T303 MITIGATED (PB-48, red team fix 1, critical). Probe-only nodes paid: a bwos-node probe-session (or a no-root node with no --peer) answered vantage probes and capacity tests with no data plane at all, and was paid for capacity it never offered transit on Operator Under PB-48's rules (validator::cap_rules_on) capacity goes only to a node with a passing link: result, either way, with a live node of another UID on a pair of the committed snapshot or production table (data_plane_nodes). Capacity is also what weighs uptime and caps bytes, so the node then earns nothing. A link probe is relayed by the node to a BGP peer it has a session with and echoed by that peer, signed with the peer's node key over (relay, peer, the agent's fresh nonce) (probe::LinkEcho, domain link-echo). No node can fake a peer's echo. Residual: two colluding UIDs can echo each other's probes with no real transit between them. That costs two UIDs and two /24s, and is the T29 sybil-mesh residual measurement.md §Live loop, scoring.md §Mechanism 0 probe_one_box_many_keys (8 probe-only keys 0x), a_node_relays_link_probes_to_its_peer_who_signs_the_echo, pb48_only_data_plane_nodes_have_a_link, localnet live_localnet (probe-only miner unpaid)
T304 MITIGATED (PB-48, red team fix 1, critical). One box, many keys: each key's capacity test ran in turn and saw the whole pipe, so N keys on one box earned N pipes while endpoint dedupe was off Operator Each cap: sample commits its target (ProbeResultBatch::cap_targets). Scoring takes each node's target by stake plurality (aggregate_cap_targets, carried as prev_cap_targets) and pools capacity by cap_target_groups (final verification: /24 within one UID); a node with no target gets none. Co-located nodes of any UIDs are drawn and tested together (T316). Residual: keys on one pipe spread over several /24s are tested apart (T322) measurement.md §Live loop ("Pooling") probe_one_box_many_keys (8 keys 1.000x one at most), pb48_one_box_many_keys_pools_to_one_pipe, cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids
T305 MITIGATED (PB-48, red team fix 2, high). Every validator tested a node in the same block, so three validators' tests shared one pipe and an honest node was measured at a third of its capacity Honest operator (harm) Validator r starts a due test (r mod CAP_STAGGER_RANKS) * CAP_TEST_STAGGER_BLOCKS (3) blocks after its due block, its rank among the read's permit holders by hotkey, so tests don't overlap. live moves the plan's block every block. Residual: past 16 validators ranks wrap, and the draw range shrinks to CAP_PLAN_BLOCKS (235) measurement.md §Live loop cap_tests_are_staggered_proven_first_and_capped_per_uid, staggered_tests_credit_an_honest_node_its_capacity (at least 0.9 C with 3 validators)
T306 MITIGATED (PB-48, red team fix 3, high). Downlink only: the single-agent test pushed bytes to the node and timed its ack, so a node with a fast downlink and a slow uplink was credited the downlink Operator The plan's test is echoed (team_stream against cap-sink -echo), paced at the declaration for CAP_TEST_SECONDS, with private byte checks, so it measures min(up, down) measurement.md §Live loop ("The agent's work") an_echoed_test_measures_the_slower_direction (1000/40 measured at about 40)
T307 MITIGATED (PB-48, red team fix 4, medium-high). Uptime from the samples a node chose to give: a node online for a few minutes of the window passed its window vantage: sample like one online throughout Operator The agent takes one sample per interval slot, and every elapsed slot of the window (less the one in progress) with no sample counts as a lost one (window_vantage_sample), so an honest node online throughout loses none, and a failing window sample counts the share of the window the node answered (1e6 - loss) in uptime, not 0 or 1 measurement.md §STAMP probes and probe sessions ("The window's sample"), §Uptime missing_intervals_count_as_lost, the_agent_takes_one_sample_per_interval_slot, pb48_vantage_counts_the_share_of_the_window_online (28% online scores 0.28)
T308 MITIGATED (PB-48, red team fix 5, medium). Test-slot crowding: a UID's many unproven or overclaiming nodes held the agent's CAP_TEST_MAX slots Operator The plan orders tests as the team schedule does, proven nodes first, with at most CAP_TESTS_PER_UID_MAX unproven tests per UID per window (cap_tests_due). A test whose echo is under CAP_ABORT_PPM (1%) of its paced rate after CAP_ABORT_AFTER_SECS stops there, and then can't carry the bytes its credit needs measurement.md §Live loop cap_tests_are_staggered_proven_first_and_capped_per_uid
T309 MITIGATED (PB-48, red team fix 6, medium). Session exhaustion: any bound key could hold one of the agent's 1,024 sessions Operator, third party Plan mode binds exactly the plan's nodes (listed by a registered UID's binding at A(w)), at most MAX_PROBE_SESSIONS_PER_UID (64) per UID, of which at most MAX_UNCONSENTED_SESSIONS_PER_UID (16) without a consent; keys no longer planned are unbound measurement.md §STAMP probes and probe sessions ("Who gets a session") PlanRun::bind_plan (plan-mode test), a_probe_only_node_is_sampled_at_the_interval_until_unbound
T310 MITIGATED (PB-48, red team fix 7, low-medium). Single-validator influence on capacity: a validator could credit a rate from a short burst, and two validators completed a cap: median Validator Under PB-48's rules a cap: sample counts only with an ack of at least cap_min_ack_bytes of its rate (what the rate moves in CAP_TEST_SECONDS, at most 256 MiB, less the tolerance; credit is min(declared, measured), so at the declared rate this is the declaration's bytes), and a cap: key needs cap_min_reporters reporters, clamp(revealing - 1, 2, 3) of the window's revealing staked validators (verification) scoring.md §Parameters pb48_capacity_needs_targets_bytes_and_three_reporters, cap_reporters_follow_the_revealing_validators
T311 MITIGATED (PB-48, red team fix 8, medium security). The kernel install exposed the WireGuard key: its copy was readable by the probe-session and sink user, and the sink read the node key Local process on a kernel node The probe session uses the node key's X25519 form (ADR-0061), so no WireGuard key is copied. bwos-probe-session runs as bwos-probe reading only /etc/bwos-probe/node.key. bwos-cap-sink runs as bwos-capsink, which reads nothing secret: it gets each ack signed over /run/bwos-sign/ack.sock (group bwos-sign), and the socket signs only a cap-test-ack for its own node ADR-0061, run-a-node.md §2b test/netns/kernel_install.sh (sink user can't read a key, no wg.key copy), the_probe_session_key_is_the_node_keys_x25519_form
T312 MITIGATED (PB-48, red team fix 9, interim; final verification). A dialed capacity test of a node behind NAT can't tell one box from several behind one public IP, or the node's data plane from another box behind the same NAT Operator A dialed target is credited at most CAP_DIALED_CEILING_MBPS (100, proposed), is the connection's source IP (which must be the probe session's), and is drawn with every node of its /24 (cap_draw_key), so every box behind one public IP is tested at once, sharing its rate; it pools by /24 within its UID like a pushed one (T319). The test is the pushed test's echoed min(up, down) stream with its byte checks, abort and node-key ack, paced within the agent's budget under min(declared, ceiling); data-plane and reporter rules are unchanged measurement.md §Capacity tests of nodes behind NAT a_dialed_test_needs_the_issued_token_from_the_sessions_ip, pb48_capacity_needs_targets_bytes_and_three_reporters (the dialed cap), staggered_dial_batches_behind_one_back_end_gain_nothing, netns probe_kernel_session (H dialed through the masquerade, measured at its 30 Mbit/s uplink)
T313 MITIGATED (PB-48, red team fix 9; final verification F1). The dial path as an attack surface: a third party dialing the agent's listener to take a test slot, replay a token or exhaust it; an agent (or a forged request) making a node dial a third party or flood it with tests Third party, validator The request travels only inside the node's WireGuard probe session; the node dials only that probe peer's configured endpoint IP, at most once per CAP_DIAL_MIN_GAP_SECS per peer and CAP_DIAL_MAX_CONCURRENT dials at once, and only with its node key; the agent takes a connection only from a source IP holding an unexpired token none has been taken on, one per token, and closes any other on accept with no slot (T320); the hello must name a token it issued for a test due now, from the session's source IP, before CAP_DIAL_WAIT_SECS, spent on use, within CAP_DIAL_HELLO_SECS, at most CAP_DIAL_MAX_HANDSHAKES at once measurement.md §Capacity tests of nodes behind NAT a_dial_request_over_the_session_is_taken_once_per_gap, a_dialed_test_needs_the_issued_token_from_the_sessions_ip, a_dial_request_and_hello_round_trip_and_refuse_junk, a_flood_from_tokenless_ips_does_not_stop_a_due_nodes_dial
T314 MITIGATED (PB-48 verification C1, critical). Plan exclusion by double listing. A binding is signed by its hotkey alone, so any UID could list a victim's node keys. The plan kept only nodes exactly one UID listed, and cut the list at 2048 in key order, so a second listing dropped a consented node from every validator's plan, and a crowd of low-sorting keys pushed others out Operator probe_plan::plan_candidates: a consented node counts under its consent's UID (the lowest UID whose binding lists it under the consent's hotkey), however many others list it. An unconsented node gets a delivery session only, under the first listing UID with room. Per-UID quotas (MAX_PROBE_SESSIONS_PER_UID, MAX_UNCONSENTED_SESSIONS_PER_UID) apply before UIDs take turns up to MAX_PLAN_NODES measurement.md §Live loop ("The plan") a_double_listing_or_a_crowd_of_keys_drops_no_ones_node
T315 MITIGATED (PB-48 verification H1, high). The strict capacity rules switching off. They were on only in windows whose batches carried a target, so a window with no started test reopened round 1's untargeted and many-keys claims Operator, validator The rules latch: run_tempo applies them whenever prev_cap_targets is non-empty, which carries forward, in aggregation (verify_and_aggregate_probes_attested_under) and pooling alike measurement.md §Live loop ("PB-48's capacity rules") cap_rules_stay_on_once_a_window_turned_them_on
T316 CLOSED (PB-48 verification H2; final verification). Unfair pooling. /24 pooling across UIDs merged honest operators sharing an ISP's or cloud's /24 into one pipe, and IPv6 pooled at /32; the exact-address rule that replaced it left one box with K addresses under K UIDs earning about K times Operator (honest, harmed); operator Nothing pools across UIDs any more (cap_target_groups: one UID's targets, pushed or dialed, by /24 or /48). Instead tests are drawn by the carried target's /24 (/48) whatever the UID (probe_plan::cap_draw_key) and a draw group's tests run at once within the agent's budget, so co-located nodes share one pipe's rate and each is measured at its share: K UIDs on one box earn about one box. Honest neighbours on their own pipes are paced max-min fair within the budget and judged at their pace, so each keeps what it measured (T318) measurement.md §Live loop ("The plan", "The agent's work", "Pooling") cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids, group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once (4 UIDs on one 1 Gbps box: at most 1000; 4 honest UIDs in one /24: 500 each), sim probe_one_box_many_keys (8 keys on one box 1.000x at most)
T317 DOWNGRADED to residual T322 (PB-48 verification H3; final verification). Cheap /24 evasion. Keys on many cheap addresses in different /24s, tunnelled to one back end, passed their tests one after another, each at the back end's full rate Operator H3 drew a UID's tests together (uid_draw_key), which also tested an honest fleet's separate boxes at once and under-measured it against the validator's link (T318). The draw is now by the carried target's /24 (/48), whatever the UID, so every node of one network is tested at once (T316) and a late or sessionless member can't be tested apart from its group (a test joining a started group waits a window; a member without a session for 120 s fails). Keys spread over several /24s, under one UID or many, are drawn apart (T322) measurement.md §Live loop ("The plan") a_networks_tests_are_due_and_start_together_whatever_their_uids
T318 MITIGATED (PB-48 final verification F2, high). Concurrent group tests overloading the validator: eight 1 Gbps members of one group against a 2 Gbps validator each measured about 250 Mbps, then pooled down to the largest member and cut as overclaims, so an honest fleet was credited a fraction of its real total Honest operator (harm); validator link --cap-test-budget-mbps (CAP_TEST_BUDGET_MBPS, 2000): a group holds min(budget, Σ declared) and starts only if nothing runs or it fits, so no group pushes the agent past the budget; members' rates are their ceilings water-filled within it (cap_test_rates), recorded as paced_mbps; scoring judges each test against its own pace by the median of the validators' verdicts (T327, T326); each UID's members of a group test are one cohort, whose aggregate (capcohort:, now under cap_min_reporters) credits the UID's /24 group its measured sum, split by measured shares. A fleet on separate /24s is no longer tested at once. Residual: a group's credit per test is at most the budget (T323) measurement.md §Live loop ("The agent's work", "Judged at its pace", "Pooling"), scoring.md §Parameters group_rates_share_the_budget_max_min_fair, group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once (four 500 Mbps pipes credited 2000, not 500; eight 1 Gbps nodes credited the 2000 budget with no overclaim cut)
T319 MITIGATED (PB-48 final verification F3, high). A dialed test let the node choose its start: it dialed when it liked within the wait, so one back end could serve a UID's NAT nodes in staggered dial batches, each test seeing the whole pipe, and dialed targets pooled only by exact address Operator Once any member asks for a dial, every stream of the group, pushed or dialed, starts at CAP_DIAL_HOLD_SECS (20 s) after the group started, past the dial deadline; connections are held with their headers sent, and one not in by then fails. Dialed targets pool by /24 (/48) within their UID like pushed ones measurement.md §Capacity tests of nodes behind NAT ("One start") staggered_dial_batches_behind_one_back_end_gain_nothing (three dials 0.7 s apart through one 40 Mbit/s back end: about 40 in all, first bytes within 300 ms), cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids
T320 MITIGATED (PB-48 final verification F1, high). Dial-in slot exhaustion: any source IP got a hello slot, so about 16 IPs could hold all 8 slots (6 a minute each) and every NAT node's test failed Third party On accept, before any read, a connection is taken only from a source IP holding an unexpired token none has been taken on (one per token); any other is closed at once with no slot. The listener keeps no per-IP map, only the tokens, which expire with their tests; CAP_DIAL_MAX_HANDSHAKES is 64 and only token holders reach it measurement.md §Capacity tests of nodes behind NAT ("Admission") a_flood_from_tokenless_ips_does_not_stop_a_due_nodes_dial (2000 tokenless sources and 64 held connections, then the node's dial is taken once)
T321 MITIGATED (PB-48 final verification, medium). Unproven-node ordering by key: a UID's CAP_TESTS_PER_UID_MAX unproven tests were its lowest-sorting keys, so an operator could grind keys to choose which nodes are tested Operator Due tests are ordered by (proven first, block, cap_test_order), SHA-256("BWOS-v0/cap-test-order" || 0x00 || hash of b - 1 || node_pub), drawn per block; the same order picks a crowded group's CAP_GROUP_MAX_TESTS measurement.md §Live loop ("The plan") a_uids_unproven_tests_are_drawn_by_block_hash_not_key_order
T322 Residual, corrected (PB-48 final verification and release round; was T317's, OQ-285, OQ-286). One back end behind addresses in several networks, each drawn apart, so its tests run at different blocks and each sees the back end's whole rate. Some variants cost nothing: a Hurricane Electric tunnel gives a free IPv6 /48 per tunnel, and a VPN or proxy service gives exits in many /24s, all served by one box Operator Bounded, not closed. Closed for free variants within reach: all of a UID's dialed nodes are drawn together wherever they are (T325), and IPv6 is drawn by /32, so a tunnel broker's /48s of one /32 are tested at once. Still open: exits in different IPv4 /24s or IPv6 /32s, under one UID or several. Each still needs a probe session from that exit, a passing signed link with another UID's node on the committed snapshot (T303), and credit is min(declared, measured). The full fix, random spot co-tests across a UID's groups, is OQ-286, before mainnet; Task 18b's source match and team tests (OQ-99) also bound it measurement.md §Live loop ("The plan") a_networks_tests_are_due_and_start_together_whatever_their_uids (one IPv6 /32 drawn together), a_uids_dialed_nodes_are_drawn_together_wherever_they_are
T323 Residual (PB-48 final verification). The budget's limits. A crowded /24 (or a fleet above the budget in one) is credited at most the agent's budget per test, so honest neighbours on fast pipes in a crowded cloud /24 are under-credited, and beyond CAP_GROUP_MAX_TESTS some wait for a later draw. Judging at the pace also means a member whose real rate meets its pace escapes the overclaim haircut, and a passing paced-down test is left out of the measured median while a full one is in the span (T326), so old full tests keep a node's credit for up to CAP_PENALTY_WINDOWS though only crowded tests followed Honest operator (harm); operator; validator Rates are max-min fair, so no member takes another's share and each is judged at its own pace; credit never exceeds what was measured; the lower-median pace needs cap_min_reporters; which members are tested in a crowded group is drawn per block (T321). Validators should set --cap-test-budget-mbps to their real link rate. Team tests (OQ-99) spread a test over several validators measurement.md §Live loop ("Budget", "Rates", "Judged at its pace") group_rates_share_the_budget_max_min_fair, group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once
T324 MITIGATED (PB-48 release round, low). A dial grant spent by a bad hello: a node whose first dial failed (a garbled or late hello) had used its token's one grant, so its retry was closed on accept and its test failed Operator (honest, harmed) A connection whose hello fails, for any reason, gives one grant of its source IP back (DialListener::release); a good hello on another token of the same IP returns the grant it was taken on. Still one connection at a time per token, and only from the token's IP measurement.md §Capacity tests of nodes behind NAT ("Admission") a_node_whose_first_dial_fails_can_retry
T325 MITIGATED (PB-48 release round, high, the free parts of T322). A UID's NAT nodes dialing from many networks, and IPv6 nodes on many free tunnel /48s, were drawn apart, so one back end passed their tests one after another Operator A dialed node is drawn by its UID (cap_draw_key, BWOS-v0/cap-dial-draw), so all of a UID's dialed nodes are tested at once wherever they are, up to CAP_DIALED_GROUP_MAX_TESTS (20, which fit the default budget at the 100 Mbps ceiling); a pushed IPv6 node is drawn by its /32. Pooling is unchanged: never across UIDs, /48 within one measurement.md §Live loop ("The plan") a_uids_dialed_nodes_are_drawn_together_wherever_they_are, a_networks_tests_are_due_and_start_together_whatever_their_uids
T326 MITIGATED (PB-48 release round, medium). Crowding a victim: a crowd of nodes in a victim's /24 cut its pace, and each window's test was then judged against the latest pace and entered the measured median, so the victim's credit stayed cut for most of the span after the crowd left; one UID's many nodes also took most of a shared budget Operator Rates are fair across UIDs first, then within each (cap_test_rates_by_uid), so one UID's crowd takes one UID's share. Each test is judged against its own pace (per-window verdicts, cap-history.json), and a test that passed at a pace the budget cut below the declaration is a lower bound, left out of the measured median while a full test is in the span. A node only ever crowded is credited what it measured measurement.md §Live loop ("Rates", "Judged at its own pace") crowding_a_victims_slash_24_does_not_cut_its_credit_once_the_crowd_leaves, group_rates_are_fair_across_uids_first
T327 MITIGATED (PB-48 release round, medium). Mixed medians: the median measure was judged against the median pace, so validators with different budgets mixed one's measure with another's pace (a 2 Gbps and a 10 Gbps validator could fail an honest node, or pass an overclaim) Validator, operator Each validator's verdict is its own measured / paced (probe::cap_verdict_ppm, cap:<node>:verdict_ppm, under cap_min_reporters), and scoring takes the median of the verdicts measurement.md §Live loop ("The cap: sample") the_verdict_is_each_validators_measure_over_its_own_pace
T328 MITIGATED (PB-48 release round, medium). Newcomers locked out: a group crowded with proven nodes filled its CAP_GROUP_MAX_TESTS before any unproven node, so a new honest node in a busy cloud /24 was never tested and never proven Operator (honest, harmed) Up to CAP_GROUP_UNPROVEN_SLOTS (4) of a group's slots are kept for unproven nodes when that many are due (still CAP_TESTS_PER_UID_MAX per UID, drawn by cap_test_order); with none due the proven take them measurement.md §Live loop ("Order") a_crowded_group_keeps_slots_for_newcomers
T329 MITIGATED (PB-48 release round, medium). Hold-time DoS: a group reserved its budget at start and held it through the 20 s dial hold, and the queue breaked behind a group that didn't fit, so a UID whose nodes refused every push could stall the agent's tests Operator The budget is taken only once a group's connections are made, at its connected members' ceilings (the dialed ceiling for dialed members), and given back when its streams end (Budget); at most CAP_GROUPS_RUNNING_MAX groups run, and one that can't start doesn't hold back the rest; a UID's members may cause one agent at most CAP_HOLD_SECS_PER_UID_PER_WINDOW (60 s) of holds a window, after which its failed pushes aren't offered a dial measurement.md §Live loop ("Running", "Budget", "Hold cap") the_budget_is_shared_and_never_exceeded, the_hold_ledger_caps_a_uids_dial_holds_per_window, staggered_dial_batches_behind_one_back_end_gain_nothing