Research
Privacy-Preserving Compliance on Public Ledgers via Selective Disclosure Authorization Schemes
Public blockchains like Ethereum achieve trustless consensus by making everything public, which conflicts with data-minimization rules for regulatory compliance: proving you are old enough or…

- arXiv
- 2606.20760
- Published
- 2026-06-18
- Authors
- Supriya Khadka, Sanchari Das
AI summary
Overview
Research area: Blockchain privacy / applied cryptography — specifically zero-knowledge proof (ZKP) schemes for regulatory compliance and identity authorization on public ledgers.
Technical level: Advanced. The paper defines cryptographic security games, a formal syntax, and a Circom/Groth16 implementation, though the empirical portion is small and readable.
Scope (1 sentence): The paper formalizes Selective Disclosure Authorization Schemes (SDAS) and builds ZK-Compliance, an Ethereum prototype that binds a zero-knowledge compliance proof to the on-chain sender so that a proof observed in the public mempool cannot be reused by another caller.
What This Paper Is About
Public blockchains like Ethereum achieve trustless consensus by making everything public, which conflicts with data-minimization rules for regulatory compliance: proving you are old enough or eligible for a service normally means putting identity attributes on-chain forever, or handing them to a centralized verifier. Zero-knowledge proofs let a user prove a predicate without revealing the underlying data, but existing constructions ignore an execution-layer problem — proofs are generated off-chain and submitted later through a public mempool, creating a window for front-running and proof reuse. The authors address this by formalizing authorization as a context-bound, revocable on-chain state transition rather than a stateless proof presentation, and by implementing sender binding in a working prototype.
Key Contributions
-
SDAS formalization. Introduces Selective Disclosure Authorization Schemes as a primitive that separates attribute validity from stateful on-chain authorization, with an explicit execution-context tuple Γ := (χ_addr, χ_chain, χ_contract) corresponding to the EVM variables
msg.sender,block.chainid, andaddress(this). -
Two new security definitions. Defines Ledger-Bound Attribute Unlinkability (an on-chain authorization record leaks nothing about the specific witness) and Context-Aware Sender Binding (a proof generated for one execution context cannot be used in another or replayed to force redundant state execution), each modeled as a game between a challenger and an adversary.
-
ZK-Compliance prototype. An Ethereum-based instantiation using Groth16 over BN128, with a browser-native proving flow (SnarkJS/WASM) and a user-controlled "Grant, Verify, Revoke" lifecycle implemented in a contract, using a 14-constraint Circom circuit that anchors the proof to the executing
msg.sender. -
Sepolia evaluation. Reports a full prototype measurement: client-side proof generation under 200 ms (184 ms total measured) and 240,512 gas for on-chain verification, while rejecting proof reuse by a different caller.
Main Findings
- Very small circuit. The
AgeCheckcircuit — covering age predicate, salt integration, andmsg.senderbinding — compiles to 14 total constraints (8 non-linear), with 3 public inputs and 2 private inputs. The authors state this suggests sender binding adds minimal arithmetic overhead. - Sub-second browser proving. Witness generation took 42 ms and Groth16 proof construction took 142 ms, for total client latency of 184 ms, measured with snarkjs compiled to WebAssembly in Chrome on a MacBook Air with an Apple M2 processor and 16GB RAM.
- Verification cost. The initial authorization grant on the deployed
AgeGuardRegistrycontract on Sepolia cost 240,512 gas, including sender anchoring, BN128 pairing verification, and storage of theAccessRecord. Because Groth16 is used, verification cost stays constant-size with respect to the identity predicate. - Sender binding works against front-running. In simulated proof-reuse tests, an adversarial wallet observed a valid
grantAccesstransaction and resubmitted the captured proof from another address; in all tests the contract rejected the transaction because the bound public signal did not matchmsg.sender. - Cheap circuit, real state cost. Storing authorization state on-chain increases gas consumption but makes authorization explicit, auditable, and user-revocable — the design trade-off the authors accept.
- Revocation is user-driven but incomplete. Users can call
revokeAccess()without contacting the original issuer, deleting theAccessRecord; the paper explicitly notes that the prototype does not stop self-replay of an unexpired proof after revocation.
Methodology in Plain English
The authors first describe the problem in the language of formal cryptography: they define what a "context" is (who is calling, which chain, which contract), spell out what an attacker can do in a public mempool (observe pending transactions, relay proofs to other chains or dApps, generate proofs if they hold the witness), and then write two security games that a scheme must win.
They then build a concrete example around a single compliance predicate: proving you are over 18. The user keeps their birth year and a random salt private; the current year, the required threshold (18), and their wallet address are public inputs. The circuit computes age = current year − birth year and checks it is at least the threshold, squares the salt to widen the witness space, and squares the public address so the circuit actually consumes it. Because the address sits in the public input vector and the smart contract checks that input against msg.sender before verifying the proof, an attacker replaying someone else's proof from a different wallet is rejected immediately.
Finally, they implemented this end to end: a Circom 2.1 circuit, a browser prover, and a Solidity registry contract deployed to the Sepolia testnet, then measured constraints, proving time, and gas, and ran a simulated proof-reuse attack.
Why This Matters
For research, the paper shifts attention from "can ZKPs hide attributes?" to "what happens between proof generation and on-chain inclusion?" — a gap that standard knowledge-soundness definitions do not cover. Framing authorization as a context-bound, revocable state transition gives a reusable security model for anyone building compliance tooling on public chains.
Real-world applications:
- Age-gated services and content on-chain, where a user proves an age threshold once without publishing a birth date.
- Regulated DeFi and tokenized assets, where eligibility (residency, investor status) must be checked before a state transition without building a centralized identity repository.
- Auditor access grants, since the prototype's
AccessRecordmaps a user and auditor pair to an expiration timestamp and validity flag, supporting time-bounded disclosure. - User-controlled credential revocation for self-sovereign identity deployments, where the user — not the issuer — withdraws a dApp's access.
Industry relevance: the design deliberately avoids trusted hardware and attribute-based encryption, relying instead on lightweight zk-SNARK verification and explicit context binding, which keeps it compatible with ordinary Ethereum smart contracts and browser wallets.
Future Directions
- Full context binding. The prototype only binds
msg.sender; addingblock.chainidandaddress(this)as public inputs would close the cross-chain and cross-contract replay vectors that the SDAS model already describes. - Stateful nullifiers. The authors propose using a SNARK-friendly hash such as Poseidon to prevent stale proofs from reactivating access after revocation, which the current delete-based revocation does not stop.
- Freshness enforcement in practice. The formal model specifies a proof freshness window checked against the block timestamp (e.g., 900 seconds), but the prototype evaluation does not report on deploying it.
- Deployment-scale evaluation. The evaluation covers a single 14-constraint predicate measured on one machine; broader sets of compliance predicates and production traffic patterns remain untested.
Target Audience
Researchers and practitioners in applied cryptography, blockchain security, and privacy engineering — particularly those working on zero-knowledge identity, decentralized identity/verifiable credentials, and on-chain compliance infrastructure. It is also useful for smart contract developers who need to understand why a proof alone is not an authorization, and for compliance architects evaluating whether ZK-based eligibility checks can replace centralized identity providers. Readers without a cryptography background will follow the motivation and results but will need to work through the security games and constraint layout carefully.
Authors’ abstract
Public distributed ledgers enforce integrity through radical transparency, creating tension with data minimization principles required for regulatory compliance. While Zero-Knowledge Proofs (ZKPs) offer a theoretical privacy solution, existing constructions often overlook adversarial constraints in smart contract environments. Specifically, the asynchronous decoupling of off-chain proof generation from on-chain submission introduces front-running and proof-reuse risks in…
The full abstract on arXiv