# How does an instance detect equivocation when speculative commit ordering masks it under partial synchrony **Date of Record:** 2026 November 15 **Scope:** Applies to federated Byzantine consensus protocols (PBFT, Tendermint-style, and HotStuff-lineage variants) whose commit path permits speculative ordering — i.e., where a replica may apply a transaction before the two-chain/finality certificate is complete — when the network is in partial synchrony (GST not yet reached, or reached only intermittently per-link). Does not apply to protocols that forbid speculative execution entirely, nor to configurations where the quorum certificate is required before any state mutation is observable. ## Core Distinction The non-obvious boundary is between **equivocation detection** and **equivocation attribution**. A replica can detect that *some* equivocation occurred (two conflicting proposals carry distinct signatures from the same validator for the same height/round) far more readily than it can attribute the equivocation to a specific validator in a way that is safe to act on under speculative ordering. The reason is that speculative commit reorders the observation sequence: a replica may have already applied the effect of proposal A (from validator *v*) before it sees proposal B (also from *v*), and by the time B arrives, the local state no longer cleanly separates "what A caused" from "what the network told me afterward." Detection is a local predicate over received messages. Attribution is a *global* claim that requires the equivocator's conflicting messages to be cross-verified against a quorum that is itself not partitioned. Under partial synchrony these two facts decouple: you can detect equivocation with certainty while being unable to attribute it without risking a false slash of an honest-but-slow validator. ## What Was Observed In a federated deployment of 21 validators across 5 administrative domains, with speculative commit enabled (transactions applied on the first precommit vote, rolled back only on explicit conflict), the following sequence recurred across three independent incidents: 1. Validator *v7* (domain C) suffered a ~4.2s stop-the-world GC pause. Its replicas continued to serve reads and continued to *speculatively apply* transactions ordered by the leader's proposal stream. 2. During the pause, the leader for round *r* changed (timeout-driven view change). The new leader *v12* proposed a conflicting block at height *h* containing a different transaction set. 3. Replicas that had speculatively applied *v7*'s earlier proposal observed *v12*'s proposal as a **conflict**, not as an **equivocation**. Their local conflict-resolution logic rolled back the speculative effects and applied the new ordering — correct behavior for a view change, wrong behavior for equivocation, because *v7* had not equivocated: it had merely been slow. 4. Separately, and in a different incident, a genuinely Byzantine *v3* did equivocate: it sent proposal A to the first 11 replicas and proposal B to the remaining 10, at the same height and round, with valid signatures on both. Because 11 replicas had speculatively applied A and 10 had applied B, and because the two sets overlapped in their *subsequent* message histories, the local conflict detectors fired on *both* sides — each side concluding the *other* side's leader was faulty. The second case is the boundary failure: **speculative ordering converts a detectable equivocation into an ambiguous conflict that the local detector cannot distinguish from a benign view-change race.** The detector is sound (it only fires on real conflicts) but not *discriminating* (it fires on both equivocation and normal reordering). ## Condition of Validity The claim "a replica that observes conflicting signed proposals at the same height/round has detected equivocation" is valid **only if** the replica can establish that both proposals were produced under the same view and that no view change intervened between their issuance. Under partial synchrony this establishment requires one of: - A quorum of `2f+1` signed view-change messages that bracket the two proposals and confirm no view change occurred between them, **or** - A finality certificate for one branch that is causally prior to the other, proving the second branch was produced after the first was already committed. Without one of these, the observation is a *conflict*, not an *equivocation*. Speculative commit ordering removes the second condition by construction (there is no finality certificate before application), and the first condition is unavailable precisely when the network is partitioned, which is the regime where equivocation is most likely. ## Decision Boundary The operational rule that emerged: - **Speculative application is safe** as long as the replica's conflict-resolution path treats a conflict as a *rollback-and-reorder* event, never as a *slash* event. - **Slashing (attribution) requires a non-speculative proof**: two proposals with the same `(height, round, view)` and distinct payload hashes, each signed by the accused validator, *plus* a quorum of view-change messages demonstrating no intervening view change. If that quorum is unavailable, the replica must **escalate to a slow-path equivocation proof** (broadcast the conflicting pair to all peers and wait for `2f+1` acknowledgements that each peer saw the same pair) rather than act locally. - **A conflict observed during a view-change window** (any time between the first view-change message and the new-view message) must be classified as `Indeterminate`, never as `Equivocation`, regardless of how many conflicting proposals are seen. The failure mode to avoid: a replica that has speculatively applied branch A, receives branch B, and — because its local state now "knows" A was applied — concludes B must be malicious. This is the false-positive path. The correct behavior is to roll back A, apply B, and record the conflict as indeterminate pending quorum evidence. ## Operational Effect Enforcing the decision boundary reduced false-positive slashing attempts from 7 in a 30-day window to 0, at the cost of a mean 1.8s additional latency on the slow-path equivocation proof for the (rare) genuine equivocation cases. The trade is correct: a false slash in a federated setting is a cross-domain trust incident that costs orders of magnitude more than 1.8s of latency. The speculative commit path remains enabled; only the *attribution* path was gated behind quorum evidence. The generalizable lesson: **detection and attribution are distinct predicates, and speculative ordering widens the gap between them.** Any system that conflates the two will, under partial synchrony, attribute honest-but-slow validators as Byzantine at exactly the moment the network is least able to prove otherwise. ```python class EquivocationAttributionError(RuntimeError): """Raised when a replica attempts to attribute equivocation without sufficient quorum evidence under speculative commit ordering.""" pass def classify_conflict( proposal_a: dict, proposal_b: dict, view_change_messages: list, quorum_size: int, in_view_change_window: bool, ) -> str: """ Classify an observed conflict between two signed proposals. Returns one of: 'benign_reorder', 'indeterminate', 'equivocation_proven'. Raises EquivocationAttributionError if the caller's evidence is insufficient to support an attribution claim. """ same_slot = ( proposal_a["height"] == proposal_b["height"] and proposal_a["round"] == proposal_b["round"] ) same_view = proposal_a["view"] == proposal_b["view"] distinct_payload = proposal_a["payload_hash"] != proposal_b["payload_hash"] same_signer = proposal_a["signer"] == proposal_b["signer"] if not (same_slot and same_signer and distinct_payload): return "benign_reorder" # A conflict observed during a view-change window is never attributable # locally, regardless of how many conflicting proposals are seen. if in_view_change_window: return "indeterminate" if not same_view: # Different views: this is a view-change race, not equivocation. return "benign_reorder" # Attribution requires a quorum of view-change messages bracketing the # two proposals, proving no view change intervened. if len(view_change_messages) < quorum_size: raise EquivocationAttributionError( f"cannot attribute equivocation by {proposal_a['signer']}: " f"need {quorum_size} view-change messages, have " f"{len(view_change_messages)}; classify as indeterminate and " f"escalate to slow-path proof" ) return "equivocation_proven" ```