Research
Compact Shielded CSV: Post-Quantum, Private, Lightweight Client-Side Validation Blockchain
Upgrading a blockchain to quantum-resistant cryptography makes signatures and zero-knowledge proofs dramatically larger, and today those artifacts are posted on-chain, so the chain bloats.

- arXiv
- 2609.32015
- Published
- 2026-09-25
- Authors
- Dragos I. Ilie, Uri Lee, Iain D. Stewart, Jonathan Zhu, Elliot Jones, William J. Knottenbelt
AI summary
Overview
Research area: Post-quantum blockchain cryptography — private, client-side-validated payment systems built from hash commitments and recursive zero-knowledge proofs.
Technical level: Advanced. The paper assumes familiarity with nullifiers, Merkle/Merkle mountain range commitments, zero-knowledge proof-carrying data (PCD), and post-quantum signature/proof size trade-offs.
Scope (one sentence): The paper specifies a complete protocol — chain format, consensus rules, off-chain proof circuits, and sender/recipient/miner algorithms — for a shielded payment chain whose on-chain footprint stays at three 32-byte hashes per single-input transaction regardless of how large the underlying post-quantum proofs and signatures become.
What This Paper Is About
Upgrading a blockchain to quantum-resistant cryptography makes signatures and zero-knowledge proofs dramatically larger, and today those artifacts are posted on-chain, so the chain bloats. Compact Shielded CSV attacks this by removing all authorisation data (proofs and signatures) from the chain entirely: the chain becomes a pure data-availability layer recording small hash commitments, while validity is established peer-to-peer by recursive zero-knowledge proofs held off-chain. The goal is a shielded (private) payment chain that keeps maximal privacy, prevents double-spending and griefing, and whose on-chain cost does not grow when the cryptography migrates to post-quantum primitives.
Key Contributions
-
Signature-free, proof-free on-chain spend authorisation. The network never validates a signature or proof for a spend. For a single-input transaction the on-chain footprint is just 3 hashes (3 × 32 bytes): a nullifier, a degriefer, and a commitment to the transaction; for N inputs it is 2N+1 hashes. This size is independent of the size of the underlying cryptographic proofs and signatures.
-
The degriefer (novel mechanism). Defined as dg = H(n, sk, t) — binding a nullifier, the owner's secret key, and the transaction identifier in a single hash. It replaces the signature as proof of ownership and, crucially, prevents griefing: a griefer who sees a nullifier in the mempool cannot compute the correct degriefer for a different transaction, and the legitimate owner can prove this off-chain.
-
Double-spend prevention without on-chain verification. Nullifiers may be published multiple times on-chain, each paired with a degriefer. Conflicts are handled by requiring each blob's conflict list K to be committed through a blob contextual identifier bcid = H(t, H(P), H(K)), and by an
InvalidBlobpredicate with two witness types — a pair witness (wrong degriefer) and a txid witness (mismatched nullifier set or conflict list) — that lets an honest user refute any conflicting blob. -
A minimal consensus rule set plus a full off-chain protocol. Only four consensus rules (C1–C4) are needed: chain extension via parent/header hash and MMR history root, no duplicate nullifiers within a blob, empty coinbase pairs, and a valid blobs root over contextual identifiers with correct conflict lists. The off-chain side is formalised as three composable circuits (Φ_mempool, Φ_blob with regular/coinbase constructors, Φ_coin with include/advance constructors) plus five algorithms: Build, Deliver, AcceptCoin, AcceptTx, Mine.
Main Findings
- Constant on-chain cost per transaction: 3 hashes (3 × 32 bytes) for a single-input transaction and 2N+1 hashes for N inputs, independent of any size growth caused by post-quantum migration of the underlying primitives.
- Quantified motivation for the design: Groth16 compresses proofs to 128 bytes, and migrating to post-quantum alternatives is expected to increase this roughly 125× to 1,000×. ECDSA signatures are typically 64 bytes, while post-quantum signature sizes are expected to grow in the region of ~3× to 40×, with some schemes more than 100×, depending on the signature family and parameters.
- Comparison to Shielded CSV: Shielded CSV (built on Bitcoin) uses recursive zero-knowledge proofs off-chain and reduces on-chain data to approximately 64 bytes per transaction via an aggregate Schnorr signature constructed with NISSHAC, but its Schnorr signatures are not post-quantum and it is unclear how large a post-quantum signature with Schnorr-style aggregation would need to be.
- Griefing is the price of removing on-chain proofs, and the degriefer pays it: without proofs or signatures on-chain, an observer could replay a mempool nullifier to block the legitimate spender; the degriefer closes this at the cost of one hash.
- Conflicts are resolved by conflict lists, not by the network: a blob's conflict list is the list of contextual identifiers of earlier conflicting blobs in chain order; these identifiers are well defined by induction over chain positions, and a miner supports the rule by indexing its chain's blobs by nullifier so a new conflict list resolves with lookups.
- Miner incentive alignment: a coinbase blob message is derived from the mempool messages of all other blobs in the block, so its validity requires every one of them to have a valid mempool proof; misbehaving forfeits the entire block subsidy and all fees.
- Privacy properties: the nullifier n = H(sk, cid) hides the recipient's spend from the coin's creator, who knows cid but not sk; the salt ρ in cid = H(t, j, ρ) hides the link between coin identifier and transaction; the index j prevents the Faerie Gold issue even if a creator reuses the salt; the
advanceconstructor lets a sender restate a coin message at the chain tip so the recipient learns nothing about when the transfer happened. - Security reasoning is by construction, not measurement: no implementation, benchmark, proving-time, proof-size measurement, or empirical evaluation is reported in the available content (the text is truncated partway through Algorithm 5,
Mine).
Methodology in Plain English
The authors design a protocol rather than measure a system. They start from two existing ideas — Zcash-style shielded transactions with nullifiers and notes, and Todd's client-side validation, where full transaction data and validity proofs travel peer-to-peer instead of being posted globally — and then remove the last piece of authorisation data that conventional designs put on-chain.
The chain itself is reduced to an append-only, ordered list of blobs. A blob is a transaction commitment t plus a list of (nullifier, degriefer) pairs. Blocks commit to blobs through a Merkle root over blob contextual identifiers, which mix in the blob's conflict list, and to history through a Merkle mountain range root over prior headers. Four acceptance rules are all a node checks; the heaviest work is bookkeeping conflict lists, which a miner does by indexing blobs by nullifier.
Because nothing on-chain is verified, correctness is pushed into off-chain zero-knowledge proof-carrying data. Three circuits compose: a mempool circuit proving a blob is valid against its conflict list, a blob circuit proving inclusion in a block (with a separate coinbase variant that aggregates all other blobs' mempool proofs), and a coin circuit proving a coin of a given value belongs to a public key, with an advance step to re-anchor it at a newer header. Each coin proof recursively embeds the proofs of its inputs, back to coinbase, so verification cost and proof size are independent of history length. The authors then write out the operational algorithms for the four parties: sender builds and broadcasts, sender delivers coins, recipient accepts a coin, miner accepts into the mempool and mines. A recurring operational warning is that wallet data — especially pending transactions, kept until all their nullifiers are spent — is essential and its loss is potentially damaging.
Why This Matters
Impact on research. The paper reframes post-quantum migration as a data-placement problem rather than a bandwidth problem: if the large artifacts never touch the chain, their size growth stops mattering for global validation. The degriefer is a small, general primitive that could be reused wherever an on-chain authorisation object must be shrunk to a single hash. It also gives a concrete target for the open question left by Shielded CSV about post-quantum, aggregatable signatures.
Real-world applications.
- Private peer-to-peer payments that must survive the arrival of a cryptographically relevant quantum computer without a proportional rise in node storage and bandwidth.
- A data-availability layer for client-side-validated assets, where the chain orders and timestamps spends while proofs move between wallets.
- Lightweight and mobile wallets that verify a single recursive proof instead of replaying chain history.
- Miner and indexer infrastructure: nullifier-indexed blob storage for conflict-list resolution, and mempool admission based on proof verification rather than signature checks.
Industry relevance. Any chain planning a post-quantum upgrade faces the 125×–1,000× proof growth and ~3×–100×+ signature growth cited in the paper; this design offers an architectural answer that keeps per-transaction on-chain cost at three 32-byte hashes. It also removes signature-verification load from full nodes, which changes the hardware profile of running a node.
Future Directions
- Concrete instantiation and measurement. The paper states that any quantum-resistant proof system, for example a hash-based recursive one, can instantiate the construction, but no proving times, proof sizes, verifier costs, or throughput figures appear in the available content. Building and benchmarking such an instantiation is the obvious next step.
- A full formal security analysis. The excerpt gives definitions (degriefer,
InvalidBlob,InChain) and informal arguments, but does not present a theorem-and-proof treatment of double-spend safety, griefing resistance, or privacy; the truncated remainder may address this and is not visible. - Robustness to wallet data loss. The paper notes that since every proof is built from data only the acting party keeps, any loss of wallet-side data is potentially damaging, and pending transactions must be retained until their nullifiers are spent. Backup, recovery, and delegation schemes for that state are unresolved.
- Peer-to-peer delivery and availability of coin proofs. Coin messages and their recursive proofs move off-chain between users; how senders, recipients and miners are incentivised to store and serve these objects, and how denial-of-service against delivery is handled, is not specified in the available content.
Target Audience
Protocol designers and cryptography engineers working on privacy-preserving or post-quantum blockchains; researchers in zero-knowledge proof-carrying data and client-side validation (readers of Todd's and Shielded CSV's work); and wallet, mining, and node-infrastructure teams who need to understand what a signature-free, proof-free on-chain footprint implies for their systems. Readers without a background in nullifier-based shielded transactions and recursive proofs will find the protocol specifications dense, since the paper defines its objects formally and does not include a tutorial or empirical results.
Authors’ abstract
We propose Compact Shielded CSV, a private client-side validation blockchain for peer-to-peer payments designed for the postquantum era. Upgrading existing blockchains to quantum-resistant cryptography substantially increases on-chain overhead. By keeping all large cryptographic artifacts off-chain, Compact Shielded CSV keeps a minimal on-chain footprint independent of the size of the underlying cryptographic proofs and signatures. For a single input transaction, the onchain…
The full abstract on arXiv