The protocol
Zcash Agora runs isoloir, an open protocol for anonymous polls with passport eligibility. This page names the parties, walks through a vote, and says what each party can learn. The normative text is the specification; the threat model is the design note; the files of this deployment are in the repository.
1. The parties
Eight parties take part. Four are ours or chosen by us. Four are outside Zcash. No party alone can read a ballot before the close or tie a ballot to a person.
The voter has a passport with a chip, a phone with NFC and a browser. The phone runs the ZKPassport app, which reads the chip and proves facts about it. The browser runs the voting page, holds the voter secret, builds ballots and verifies the log.
The issuing state signed the passport chip and keeps a record of every passport it issued. ZKPassport maintains the app and the open circuits that check the state's signature on the phone. We trust it for correct circuits, which are public, and for nothing secret.
The OPRF network gives each passport a salted identifier. A plain hash of the chip data would let the state recompute it. The salted one mixes in a key held by the TACEO network: by its launch note the key is shared 2-of-3 between independent operators, ZKPassport among them, and never put back together. The servers answer only blinded queries and learn neither input nor output. ZKPassport requires a face match for this mode.
The relays are public Nostr relays run by others; this ledger names three. Voters send nothing to a server of ours. A relay sees the sender's address and the bytes, and keeps a copy for anyone who asks.
The ledger is our one server, the ingest. It reads the relays, checks each message and appends it to one signed log, accepted or refused with the reason. It holds the log's signing key and no other. The log is published as files in a public git repository, the mirror.
drand is a public randomness beacon run by the League of Entropy: Cloudflare, EPFL, Kudelski, Protocol Labs and others. Every three seconds its nodes sign the round number with a threshold key. A future round's signature does not exist before its time, and time-lock encryption uses it as the decryption key. The League does not know this poll exists.
Bitcoin dates the log. Each checkpoint is stamped with OpenTimestamps. No coins move.
The authority opens the ballots after the close and posts the count. It holds no key: it fetches the drand round and opens each ballot with it. Anyone can run one, and two correct authorities post the same entry. The auditor recomputes everything from the log and the relays. Your browser is one (parties).
2. The vote, step by step
2.1 Setup and the voter secret
Three documents define a deployment, and they are the first entries of the log. The ledger entry names the origin, the signing key and the relays. The registry is the eligibility rule: any passport ZKPassport verifies, unexpired, with the salted identifier under a pinned OPRF key. The poll names its registry, the question, the options, the dates, the drand round of the close and the hash of the ballot circuit (registries, polls, this deployment's files).
The browser makes one secret per registry, from a passkey through the WebAuthn PRF extension when the platform offers it, otherwise from twelve BIP39 words. The secret stays on the device. Everything the voter publishes derives from it by one-way functions (voter secret).
2.2 Registration
Registration adds one leaf to the registry tree: a commitment to the voter secret.
- The browser draws a one-time key and sends the phone a request bound to it.
- The phone reads the chip, checks the state's signature chain, does the face match, gets the salt from the OPRF network and makes a proof. The proof discloses three things: the document is valid and unexpired, the one-time key, and the salted identifier. Nothing else leaves the phone.
- The browser derives the leaf from the secret, signs the registration with the one-time key and posts it to a relay.
- The ingest verifies the proof with ZKPassport's open verifier, refuses an identifier the log already holds, and appends the leaf.
The identifier is public in the log, so anyone can check that no passport registered twice. Section 3.4 says what it reveals (registration).
2.3 The ballot and its seal
A ballot proves two facts in one zero-knowledge proof: a registered voter made it, and that voter made no other. The proof is written in Noir and made with UltraHonk in the browser. Its public values are a recent root of the registry tree, the poll, a pseudonym, a commitment to the choice and the hash of the sealed choice. The pseudonym derives from the secret and the poll, so it is constant for one voter in one poll and unlinkable across polls. The ingest accepts one ballot per pseudonym (statement, checks). UltraHonk needs no ceremony, and anyone can rebuild the circuit with the generator and compare the key hash the poll pins.
The choice is sealed under a fresh symmetric key, and that key is time-locked to the drand round of the close. Before that round no one can open a ballot, us included. The circuit does not verify the encryption, which would cost too much inside a proof; the opening checks it instead. A blob that does not open to its commitment makes the ballot void: listed, not counted (encryption).
2.4 Transport and receipts
The browser posts registrations and ballots as signed events under one-time keys. It ranks the relays by a value derived from the secret, sends the registration to the first and the ballots to the second, so one relay does not see both. The ingest answers each message with a signed acknowledgement that names the checkpoint that will hold it, on the same relay. The browser keeps the receipt and checks the checkpoint later. A dropped message is a complaint anyone can judge from the relay's copy and the ingest's signature (acknowledgements, receipts).
2.5 The log, the mirror, the stamps
The log is an RFC 6962 Merkle tree. In each minute in which it grew, the ingest signs a checkpoint in the C2SP signed-note format: the log's size and root, each registry's size and root, the mirror commit. Each checkpoint is stamped with OpenTimestamps until it carries a Bitcoin attestation. Browsers read the mirror by commit, and the mirror cannot serve a key or a result the log does not hold (the log, the mirror).
2.6 The close and the opening
At the first checkpoint after the closing time, the ingest logs a close entry, and no ballot is accepted after it. When the drand round arrives, the authority verifies the beacon, opens each ballot, checks it against its commitment and posts the tally: the totals, the count, the void list, the beacon. The ingest repeats each opening before it logs the entry. The beacon is public, so anyone can repeat the computation and get the same tally (tally, close).
2.7 The audit
The audit replays the ledger's judgment: every checkpoint signature and the consistency between checkpoints, the stamps against Bitcoin headers, every registration proof and identifier, every ballot proof and pseudonym, every refusal's reason, the beacon and every opening. With the relays, it checks that each message they hold was judged. A check that cannot run is a failure. It runs in the browser and from one script (the audit).
3. Privacy
3.1 The three links
- Passport to leaf. The registration proof discloses only the salted identifier. The link holds as long as the identifier cannot be recomputed.
- Leaf to ballot. Hidden by the ballot's membership proof, under the assumptions of UltraHonk on BN254.
- Ballot to choice. Hidden until the drand round by the time-lock. Public afterwards, under the pseudonym.
At the close every ballot opens under its pseudonym, and the pseudonym names no one. The protocol reveals choices without persons. A voter who gives up the secret can prove which ballot is theirs.
3.2 What each party sees
Everyone honest. "Identifier" is the salted passport identifier. "Every ballot" means each ballot's choice and pseudonym, at the round and after.
| Party | Passport to leaf | Leaf to ballot | Choice | Network address |
|---|---|---|---|---|
| Public, the log | the identifier | no | every ballot | no |
| Ledger, us | the identifier | no | every ballot | no |
| A relay | the identifier | no | every ballot | of each post it carries, with the time |
| OPRF servers | a blinded value | no | no | of the phone, at registration |
| Issuing state | no | no | no | no |
| ZKPassport | no | no | no | of the phone and the browser, through its bridge |
| drand | no | no | every ballot | no |
| Mirror host | the identifier | no | every ballot | of each reader |
Two addresses are exposed: the phone's, to the OPRF servers and ZKPassport's bridge at registration, and the browser's, to the relay of each post. Tor or a VPN on a device removes that device's exposure (what each party learns).
3.3 What a corrupted party can do
- The ledger can refuse service, or keep two signed histories and show different readers different ones. A fork is detectable: two conflicting checkpoints prove it (fork detection).
- A relay can pair an address with each post it carries: an identifier for a registration, a pseudonym and its choice for a ballot. Two relays together can pair an identifier with a choice through an address.
- The OPRF servers, at the threshold, hold the key. With a passport's chip data from elsewhere, they can recompute its identifier.
- drand, at the threshold, can sign a round early and read every ballot before the close, under pseudonyms.
- ZKPassport can, through a flaw in its circuits, admit an invalid passport. The circuits are public and pinned by hash.
- An issuing state can sign passports for people who do not exist, and each one registers as a voter. The proof hides the nationality, so the log does not show which state did it. A person can also lend a passport to someone else. One passport is one vote; it is not proof of one willing person.
- The voter's device, seized or compromised, gives the secret and with it every ballot of the voter. The twelve words give the same.
3.4 What the issuing state can learn
The state knows the chip data of each passport it issued and can read the public log. With a plain identifier it could recompute each one and read off which of its citizens registered; we do not use that mode. With the salted identifier and an honest OPRF network, it learns nothing. If the OPRF threshold is corrupted and works with the state, they can together recompute each identifier and learn who registered. In every case the state learns at most participation, never a choice. A state that also watches its citizens' networks can pair an address with a choice at the close; Tor or a VPN closes that path.
3.5 Limits
- Ballots open in clear at the round, under pseudonyms. Hence one ballot per voter and no correction (the matrix).
- A fork of the log is detectable, not prevented. Pinning one history on a chain is designed, not deployed (design).
- Network metadata is the one exposure the protocol does not close by itself.
- Passports only, with a chip and an NFC phone, and a face match.
- Not post-quantum. The time-lock is pairing-based and the proofs are on BN254.
- Scale: about a hundred thousand voters with the current software (limits).
4. This deployment
- Origin
zcash-agora: the name of the log and of its signing key, pinned in the voting page- Relays
wss://relay.damus.io,wss://nos.lol,wss://relay.primal.net- Registry 2
- ZKPassport; any passport, unexpired; salted identifier under ZKPassport's OPRF key 1; domain
nikkolasg.github.io, scopeagora/registry/2; tree depth 20. Registry 1 (domainzcash-agora) stays on the log empty: the ZKPassport app accepts a request only from the page whose hostname is the domain, andzcash-agorais not one. - Poll 3
- "Zcash Shielded Assets (ZSAs): do you want them in the Zcash protocol?", two options and a blank, on registry 2; opens 2026-11-10 00:00 UTC, closes 2026-11-20 12:00 UTC. Polls 1 and 2 ask the same question on registry 1 (1: 2026-11-16 to 2026-12-14; 2: 2026-11-06 to 2026-11-20) and nobody can register there; the site shows poll 3.
- Time-lock
- drand quicknet, round 34124212, the first round at or after the close
- Circuit
choice4_tlock_linked_d20, verification key hash0x33147e49…c229; nargo 1.0.0-beta.22, bb 5.0.0- Checkpoints
- at most one a minute, each stamped in Bitcoin
- Setups
- ledger/, checked offline with
isoloir check
5. Code
- isoloir: the protocol. SPEC.md, DESIGN.md, circuits/, crates/server (ingest, authority), js/ (register, vote, audit in the browser).
- zcash-agora: this deployment. ledger/ (setups), site/ (this site and the voting page), deploy/ (how the ingest runs), zip/ (a draft ZIP).
- zcash-agora-mirror: the public log, as files.
- ZKPassport, tlock, drand, OpenTimestamps.
Audit the vote · Compared with the coinholder stack · The short version