Zcash Agora

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.

Issuing state Phone · passport OPRF servers Browser Relays Ledger Mirror · log drand Bitcoin Authority Auditor signed chip blinded query proof round tally reads stamps shaded: ours. Arrows: who sends what to whom; sections 2.3 to 2.9 give each step.

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.

  1. The browser draws a one-time key and sends the phone a request bound to it.
  2. 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.
  3. The browser derives the leaf from the secret, signs the registration with the one-time key and posts it to a relay.
  4. The ingest verifies the proof with ZKPassport's open verifier, refuses an identifier the log already holds, and appends the leaf.
Issuing state signed the chip Phone · app reads chip · face match · proof OPRF servers see: a blinded value, the phone's address passport blinded query salt Browser one-time key · leaf from the secret proof: valid · key · identifier Relay 1 sees: address, identifier Ledger verifies · rejects duplicates logs identifier + leaf The passport, its number and the face stay on the phone.

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).

Browser secret → pseudonym, proof choice sealed to the round drand public key lock Relay 2 sees: address, pseudonym, sealed blob, time ballot receipt Ledger verifies the proof one ballot per pseudonym ack Log pseudonym, proof, sealed blob Nobody sees the choice before the round. Nobody sees which leaf voted. The registration went to relay 1 (2.3): one relay does not see both.

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).

Ledger Checkpoint signed: size, root, registry roots, mirror commit each minute Mirror (git) OpenTimestamps files hash Readers Bitcoin by commit The mirror host sees who reads. Bitcoin dates each checkpoint. Neither can change the log.

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).

drand round public at the close Authority opens every ballot · counts key Ledger repeats each opening tally Log every ballot, open, under its pseudonym Auditor log, mirror, relays Same inputs, same tally. No key, no permission.

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

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.

PartyPassport to leafLeaf to ballotChoiceNetwork address
Public, the logthe identifiernoevery ballotno
Ledger, usthe identifiernoevery ballotno
A relaythe identifiernoevery ballotof each post it carries, with the time
OPRF serversa blinded valuenonoof the phone, at registration
Issuing statenononono
ZKPassportnononoof the phone and the browser, through its bridge
drandnonoevery ballotno
Mirror hostthe identifiernoevery ballotof 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

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

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, scope agora/registry/2; tree depth 20. Registry 1 (domain zcash-agora) stays on the log empty: the ZKPassport app accepts a request only from the page whose hostname is the domain, and zcash-agora is 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 hash 0x33147e49…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

Audit the vote · Compared with the coinholder stack · The short version