Research
Resource Locks and Fast Unlock for Shared Balances in Certificate-Based Payment Systems
Stablecoin treasuries and merchant pools break FastPay's single-writer assumption; the impossibility result and hybrid protocol tell implementers when an unlock is safe.

- arXiv
- 2610.41207
- Published
- 2026-10-30
- Authors
- Lingkang Shangguan
AI summary
Overview
Research area: Distributed systems and Byzantine fault-tolerant (BFT) payment protocols, specifically certificate-based payment systems and shared-balance resource management.
Technical level: Advanced. The paper combines formal impossibility proofs, protocol design, safety and liveness proofs, and mechanized TLA+ model checking.
Scope: The paper proves that client-driven certificate payments cannot safely unlock shared balances unless certificate formation is visible to validators, and proposes a hybrid protocol that preserves the FastPay fast path for personal accounts while adding an Echo/Ready certification path and per-version agreement for shared resources.
What This Paper Is About
Certificate-based payment systems such as FastPay settle a payment with one round of signatures from a quorum of validators, with the client collecting signatures and validators never communicating directly. This design is safe only as long as locks are never undone: each account has a single writer, and an equivocating owner simply leaves its own account locked as a penalty. Stablecoin workloads, however, need balances that several accounts can debit, such as treasuries, merchant pools, allowances, and subscriptions. There, honest accounts can race, votes can split, and locks must be undone, which the client-driven design cannot support safely because a quorum certificate may exist only in a client's hands. The paper's goal is to keep the fast client-driven path where it is safe and add visible certification and fast unlock only where shared balances require it.
Key Contributions
-
A characterization of when client-driven certification is complete, namely when each account has a single writer and no lock is ever released, together with a proof that no unlock rule over validators' reports is safe without visible certificate formation (Proposition 2).
-
A hybrid protocol with dual-nonce admission: personal transactions run the unchanged FastPay path, while shared transactions are submitted to any validator and certified through a two-phase Echo/Ready broadcast, with admission requiring both the sender's nonce and the resource's nonce to be free.
-
A fast-unlock mechanism: validators detect contention, freeze the affected resource version, resolve it with a single validated agreement instance scoped to that version, and release the nonces of losing transactions.
-
Proofs of consistency, no overdraft, validity, finality, and liveness, plus integration with the PDCC reconfiguration protocol and an open-source TLA+ model exhaustively checked with TLC that also reproduces the impossibility counterexample.
Main Findings
-
Client-driven certification is safe only without unlock: Lemma 1 shows that if honest validators sign at most one transaction per slot and never release a slot, client-driven certification is safe even when certificates are known only to clients.
-
No unlock rule is safe without visible certification: Proposition 2 states that for (n=3f+1), (f \geq 1), where a transaction is final once a quorum has signed it even if signatures are broadcast among validators, no function (\mathsf{Select}) mapping quorum reports to a transaction or (\bot) can release or reassign a slot without contradicting some final transaction. The counterexample uses (f=1) with honest validators (h_1, h_2, h_3) and Byzantine validator (b), conflicting transactions (A) and (B), and a quorum ({h_1, h_3, b}) that reports (A, B, B) in both executions (X) and (Y).
-
One echo per resource slot: Lemma 3 shows an honest validator echoes at most one transaction per resource slot and none after freezing it; Lemma 4 consequently shows at most one transaction per resource slot can have an echo quorum.
-
Finality is visible to unlocking: Lemma 5 shows that if a shared transaction (T) on slot (s) is final, then (\mathsf{Select}(F)=T) for every freeze set (F) for (s). Lemma 6 shows that if a freeze set exists and selects a different value, (T) can never become final later.
-
Dead transactions release nonces safely: Lemma 7 shows a dead transaction is never final and never executed; Lemma 8 shows that if two different transactions share a nonce slot and both have a quorum, at least one is dead.
-
Resource slots resolve consistently: Theorem 9 shows all honest validators resolve each resource slot the same way, whether by executing a final transaction or by applying the validated agreement decision.
-
No two executed transactions share a slot: Theorem 10 establishes consistency across both personal and shared transactions.
-
Validity and no overdraft hold: Theorem 11 shows every executed transaction was signed by its sender, the sender was authorized for the debited resource, and the debit executes only when the executing validator's balance covers it.
-
Finality and liveness hold under stated assumptions: Theorem 13 shows a final transaction is eventually executed by every honest validator and no conflicting transaction is executed; Theorem 14 shows liveness after GST assuming partial synchrony and that the validated agreement terminates.
-
Cost profile: Personal transactions cost (O(n)) messages and reach finality in 2 delays with no consensus; uncontended shared transactions cost (O(n^2/B)) with batches of (B) and reach finality in 3 delays with no consensus; a contended slot adds one validated agreement instance and resolves in (\tau + 1 +) one validated agreement, scoped to that slot only.
-
Analytical byte model: Personal bytes are approximately (n|tx| + n\sigma + n|\mathsf{Cert}|), while shared bytes are approximately (n|tx| + 2n^2h/B). With (n=100), (|tx|=250) B, (h=100) B, and (B=1000), the shared-path overhead is (2n^2h/B = 2) kB per transaction against 25 kB for disseminating the body, about 8%. The paper explicitly states these are analytical figures, not measurements.
-
Reconfiguration preserves finality: Lemma 15 shows no final transaction is lost when moving from configuration (c) to (c+1), and Lemma 16 shows no two executed transactions share a slot across configurations. Payments pause for one settlement round at each reconfiguration.
-
Model checking results: With (n=4), three honest validators and one Byzantine validator ((f=1)), and four transactions, the full Echo/Ready protocol produced 41,333,964 distinct states at depth 30 with no violation. TLC generated 346 million states, of which 41.3 million are distinct, and terminated in about six minutes on a laptop. A variant treating a shared transaction as final at a bare echo quorum found a violation at depth six, matching Proposition 2.
Methodology in Plain English
The author starts with a formal system model: a committee of (n=3f+1) validators, at most (f) Byzantine, with quorums of (2f+1) validators, unforgeable signatures, safety under asynchrony, and liveness under partial synchrony after an unknown GST. Accounts have personal balances and nonces; shared resources have balances, version numbers called resource nonces, and authorization sets of accounts allowed to debit them.
The first step is an impossibility argument. The author constructs two executions that are indistinguishable to a quorum of validators but in which different transactions are final, showing that any unlock rule based only on validator reports can contradict a final transaction. This motivates making certificate formation visible to validators.
The protocol design then separates concerns. Personal transactions keep the original client-driven FastPay path, where a client collects (2f+1) votes into a certificate and validators never need to communicate. Shared transactions use Bracha-style two-phase broadcast per resource version: validators admit a transaction only if both the sender's nonce and the resource's nonce are free, then broadcast Echo; after (2f+1) echoes a validator stores the echo quorum and broadcasts Ready; after (2f+1) readies the transaction is final. There is no leader and no consensus on the uncontended path.
When contention occurs, validators freeze the affected resource version, report what they echoed and stored, and run one validated agreement instance for that version. The selection rule accepts only a transaction whose echo quorum someone stored, which includes every final transaction. Losing transactions are marked dead and their sender nonces are released. The author proves safety and liveness with a sequence of lemmas and theorems, then extends the protocol to PDCC reconfiguration with a seal-then-install transition and closing reports. Finally, the protocol is modeled in TLA+ and exhaustively checked with TLC on a small instance, including a variant that reproduces the impossibility counterexample.
Why This Matters
This work clarifies a boundary that is easy to miss in fast payment-system designs: client-driven certification is complete only when locks are never undone. It connects the consensus-number result for shared asset transfer to practical payment protocol design and shows that visible certification is not optional for shared balances. For research, it provides a clean impossibility result, a hybrid architecture, and a mechanized model that other protocol designers can reuse.
Real-world applications include:
- Corporate treasuries with several payers debiting the same balance.
- Merchant pools debited by refunds and payouts.
- Delegated allowances and subscriptions where multiple authorized accounts draw on one balance.
- Custodial wallets operated by many signing workers.
For industry, the result matters because stablecoin payments increasingly require shared balances, and the paper's design avoids paying for global consensus except when writers actually contend. Personal payments remain on the FastPay path with (O(n)) messages and two delays to finality, while shared-resource payments use visible certification and only invoke agreement for the specific contended version. This preserves horizontal scalability and sub-second settlement for the common case while making shared balances safe.
Future Directions
-
Prototype and measurement: The paper states that the byte-overhead figures are an analytical model, not measurements, and that measuring them on a prototype is future work.
-
Shortening the reconfiguration pause: The paper notes that payments pause for one settlement round at each reconfiguration and leaves shortening this pause, for example by sealing per account range, to future work.
-
Extending the mechanized model: The TLA+ model does not cover reconfiguration or liveness, which are covered only by the proofs. Extending the model to those aspects is a natural next step.
-
Generalizing model checking: The TLC run covers (n=4), (f=1), and four transactions exhaustively, not all (n) and workloads. The general case rests on the proofs, so broader machine-checked coverage remains open.
Target Audience
This paper benefits researchers and protocol engineers working on BFT payment systems, blockchain settlement, and distributed consensus, especially those familiar with FastPay-style certificate payments or Bracha broadcast. It is also suitable for advanced graduate students studying Byzantine fault tolerance, formal verification, and the design of scalable payment architectures. Readers looking for an introductory treatment of consensus or blockchain payments may find the formal proofs and protocol details demanding.
Authors’ abstract
Certificate-based payment systems such as FastPay settle a payment with one round of signatures from a quorum of validators and avoid global ordering. The client collects the signatures, and validators never talk to each other. We observe that this client-driven design is complete only as long as no lock is ever undone. Each account has a single writer, a conflict can only come from that writer's own misbehavior, and the account stays locked as the penalty. Stablecoin…
The full abstract on arXiv