# How should an instance treat a Byzantine quorum certificate that is valid under the current view but was assembled from votes cast under a superseded view? **Date of Record:** 2026 November 17 **Scope:** This record applies to leader-based BFT consensus protocols (PBFT-derived, Tendermint-style, HotStuff-style) where quorum certificates (QCs) are cryptographic aggregates of view-stamped votes and where a new leader justifies a proposal by carrying a QC. It does not apply to protocols that bind votes to a monotonic, non-reusable sequence number only (e.g., simple majority-commit logs without view change), nor to crash-fault-tolerant replication where view transitions carry no equivocation risk. ## Core Distinction The non-obvious boundary is between **QC validity** (the aggregate signature verifies against the quorum threshold for *some* view) and **QC currency** (the QC was assembled from votes cast in the view that the receiving instance currently occupies, or in a view it has not yet superseded). A verifier that checks only the threshold and the signer set will accept a stale QC — one assembled in view `v-k` — as justification for a proposal in view `v`. This is safe *only* if every honest replica that contributed to that stale QC has irrevocably abandoned view `v-k`. It is unsafe the moment a single honest replica can still be locked on the older view, because that replica may have voted for a conflicting value in `v-k` that the stale QC does not cover. The distinction matters because the two properties are checked by different mechanisms: validity by the signature scheme, currency by the view bookkeeping in the replica's local state. A protocol implementation can have a perfectly sound signature check and still violate safety if it conflates the two. ## What Was Observed During a four-replica HotStuff-style deployment (f=1, quorum=3), a network partition isolated the leader of view 7 from two replicas while a third replica, `R3`, remained reachable to both sides. `R3` had voted for value `A` in view 7 and was locked on it. The isolated leader collected votes from itself and `R3` and a third replica that had *not* yet seen the view-7 proposal — but that third replica's vote was stamped view 6, not view 7, because it had not received the new-view message and was still processing the tail of view 6. The aggregate reached threshold 3 and verified. The leader then proposed `B` in view 8 carrying this mixed-view QC as justification. `R3`, now in view 8, accepted the QC because the signature aggregate verified and the threshold was met, and voted for `B`. But `R3` had already voted for `A` in view 7 and remained locked on `A`; the QC it accepted as justification did not actually demonstrate that a quorum had abandoned `A`. Two conflicting values each acquired a quorum certificate. Safety was violated without any signature forgery and without any replica violating its local voting rule. The root cause: the QC aggregation logic did not partition votes by view stamp before thresholding. It summed distinct signers across views 6 and 7, treating the union as a view-7 quorum. The lock rule on `R3` was checked against the *proposal's* view, not against the *minimum view* represented in the QC's vote set. ## Condition of Validity A QC is a valid justification for a proposal in view `v` if and only if: 1. The aggregate signature verifies against the threshold for the protocol's quorum size, **and** 2. Every vote in the aggregate carries the same view stamp `v'`, **and** 3. `v' >= lock_view` for the receiving replica, where `lock_view` is the highest view in which the replica cast a vote it has not since released, **and** 4. `v' < v` (the QC justifies entry into `v`, it does not itself constitute a vote in `v`). Condition 2 is the one that is silently dropped in most implementations. It is not implied by condition 1: a threshold of distinct signatures over *different* messages still verifies as a threshold of distinct signatures. The QC must therefore commit to the view stamp inside the signed payload, and the verifier must reject any aggregate whose members disagree on that field — even if the count reaches threshold. Condition 3 is the lock check and must be evaluated against the QC's view, not the proposal's view. ## Decision Boundary When a replica receives a proposal with a QC whose vote set spans multiple views, it must choose between two actions: - **Reject and initiate view change** if any vote in the QC carries a view stamp below the replica's `lock_view`. The replica cannot know whether the lower-view votes were cast before or after its own lock; treating them as evidence of quorum abandonment is unsound. - **Accept and vote** only if all votes share a single view stamp `v'` with `lock_view <= v' < v`, and the replica has not itself voted in any view in `(v', v)`. The boundary is sharp: there is no "accept with warning" path. A mixed-view QC is either a protocol violation by the sender (which should be slashed or at least ignored) or evidence of a partition heal in progress, and in both cases the safe action is the same — do not vote on it. The cost of a spurious view change is liveness; the cost of accepting a stale QC is safety, which is unrecoverable. ## Operational Effect After the incident, the deployment added a per-vote view-stamp check in the QC verifier and a `lock_view` comparison against the QC's minimum vote view. The measurable effects were: (a) view-change rate rose by roughly 4% under partition-heal traffic, because mixed-view QCs that previously slipped through now trigger view changes; (b) the safety violation class disappeared across 10^6 randomized partition schedules in the test harness; (c) the leader's proposal-acceptance latency increased by one round-trip in the common case, because the leader must now wait for a same-view quorum rather than opportunistically borrowing tail votes from the previous view. The trade is correct: the borrowed-tail-vote optimization was buying liveness at the cost of the lock invariant, and the lock invariant is what makes the protocol Byzantine fault-tolerant rather than merely crash-tolerant. ## Reference Implementation ```python class StaleQuorumCertificateError(RuntimeError): """Raised when a QC's vote set spans views or undercuts the local lock.""" def verify_qc_for_proposal( qc_votes: list[dict], proposal_view: int, local_lock_view: int, quorum_size: int, verify_aggregate, ) -> None: """ qc_votes: list of {"signer": id, "view": int, "value_hash": bytes, "sig": bytes} Raises StaleQuorumCertificateError if the QC is not a same-view quorum that respects the receiver's lock. """ if not qc_votes: raise StaleQuorumCertificateError("empty QC vote set") views = {v["view"] for v in qc_votes} if len(views) != 1: raise StaleQuorumCertificateError( f"QC spans multiple views {sorted(views)}; " f"mixed-view aggregates do not establish quorum abandonment" ) qc_view = views.pop() if qc_view >= proposal_view: raise StaleQuorumCertificateError( f"QC view {qc_view} is not strictly below proposal view {proposal_view}" ) if qc_view < local_lock_view: raise StaleQuorumCertificateError( f"QC view {qc_view} undercuts local lock view {local_lock_view}; " f"replica may have voted on a conflicting value in {local_lock_view}" ) distinct_signers = {v["signer"] for v in qc_votes} if len(distinct_signers) != len(qc_votes): raise StaleQuorumCertificateError("duplicate signer in QC vote set") if len(distinct_signers) < quorum_size: raise StaleQuorumCertificateError( f"QC signer count {len(distinct_signers)} below quorum {quorum_size}" ) if not verify_aggregate(qc_votes, qc_view): raise StaleQuorumCertificateError("aggregate signature verification failed") ```