zerotracedocs

Glossary

Short definitions of the terms used across the ZeroTrace documentation, with links to where each is explained.

Admin

A role on the vault (DEFAULT_ADMIN_ROLE). It grants and revokes every role, its own included, to and from any address. The deployer holds it at launch. → Trust model

Bonding curve

The Pons contract ZERO trades on from launch until graduation. It sells ZERO for ETH and buys it back, at a price set by its reserves. → The market and the router

Commitment

The hash stored in the tree for a note: cm = H(1, stub, shares). It reveals neither the owner nor the amount. → Notes

Creator fee

The part of every Pons trade fee paid to ZERO's creator fee recipient, the fee harvester: the standard fee minus Pons' 30% share, plus the creator tax if there is one (ZERO has none), so 0.7% of each trade. Paid in ETH. Half goes to the team, half to private holders. → Fees

Creator tax

An optional fee a Pons launch can add to every trade on top of the standard fee, set at launch and frozen. ZERO launches with none (0%), so a trade pays only Pons' 1%. → Fees

CRS

The common reference string: public parameters the prover loads before proving. The app serves its own copy so that proving contacts no third party. → The circuit

Dummy note

A zero-value input or output that fills an unused slot, since every transaction has exactly two inputs and two outputs. It looks like any other note on-chain. → Notes

EIP-712

The Ethereum standard for signing typed data. The wallet signs Spend(bytes32 transaction) under the vault's EIP-712 domain for every private transaction, and the circuit checks that signature. → Keys

EntryPoint

The ERC-4337 contract (v0.8) that bundlers call. It asks the vault to validate a private transaction, pays the gas from the vault's deposit, then runs the execution step. → Gas

ERC-4337

The account abstraction standard. The vault is itself an ERC-4337 account, so a private transaction travels as a UserOperation sent by a bundler, and the user's address never signs or pays for it. → Gas

ExtData

The public part of a private transaction that the proof does not compute but is bound to: recipient, allowed caller, gas fee, caller data and the two note ciphertexts. Its hash is a public input, so nobody can change it after the wallet signs. → Contracts

Fee harvester

FeeHarvesterV3, the vault's harvester and ZERO's Pons creator fee recipient: it receives ZERO's creator fees in ETH and splits them in half. The team's half goes to the team's recipient; with the holders' half, harvest keeps the vault's gas deposit funded and buys ZERO, which it donates to the vault. Its owner can hand the fee recipient to another contract at once (handOver). → Contracts

Gas deposit

The vault's ETH balance in the EntryPoint, which pays bundlers for private transactions. The harvester tops it up to 0.1 ETH from the holders' half of the creator fees. → Gas

Gas fee

See network fee.

Graduation

The moment ZERO moves from its bonding curve to its Uniswap v4 pool, once the curve has collected 4.2 ETH. It takes two permissionless calls on the Pons factory, graduate and createGraduatedPool. → The market and the router

Guardian

A role on the vault (GUARDIAN_ROLE). It can pause and resume every spend of a note (pause, unpause), with no time limit; pause and resume new entries (shield, and so private buys); pause and resume exits handed to a target contract (private sales through the router); and set the operation cost between 0.00005 and 0.001 ETH. Its functions never move a note or ZERO. The deployer holds it at launch. → Contracts

Harvest

A call to harvest() on the harvester. Anyone may make it, and the caller gets back the gas of a call that put ETH to work (at most 0.5% of that ETH). It claims the creator fees, sets the team's half aside, tops up the gas deposit, and makes at most one buy of ZERO for the vault per L1 block, sized to move the price by at most 0.5% and getting at least 85% of the ZERO the price average gives. → The vault

Indexer

An optional service that stores every vault event and serves it to all wallets alike. Wallets check its data against the on-chain root and fall back to the chain. → The note tree

Network fee

The fee of a private transaction, paid in shares out of the spent notes (ext.gasFee). It is a flat amount of ZERO worth the operation cost at the price average, reset at most once an hour; the previous amount stays accepted until the next reset. The operation cost is 0.0002 ETH at the start, and the guardian can set it between 0.00005 and 0.001 ETH. Its shares are burned and its ZERO stays in the vault, a donation to every note. → Fees

Note

A private piece of value: a number of vault shares owned by one key. On-chain it is only a commitment and an encrypted payload that only the owner can read. → Notes

Nullifier

The value published when a note is spent: nf = H(2, nk, cm, index). Only the owner can compute it, it cannot be linked back to the note, and the contract refuses the same nullifier twice. → Notes

Nullifier key

nk, the secret derived from the activation signature that proves ownership of a note inside the proof and derives its nullifier. → Keys

Operation cost

opCostWei, read through maxOpCostWei(): what the network fee is worth in ETH, and the most a private operation may cost the gas deposit. The two are equal on purpose, so an operation never costs the deposit more than it pays. → Gas

Owner key

opk = H(nk, wallet key), the public key registered on-chain. Notes are made out to it, and spending needs both nk and a signature from the wallet key it binds. → Keys

Placeholder proof

Random bytes of a real proof's size, used to estimate a UserOperation's gas. The vault reports it as a failed signature, which bundlers accept while estimating, so the wallet signs and proves only once. → Gas

Pause

The guardian's stop of every spend of a note (pause), until it calls unpause. While the vault is paused no note can be sent, sold, unshielded or claimed from a payment link; shields, donations and key registration still work. The app closes its wallet screens meanwhile. → Contracts

Pons

Pons V2, the launchpad on Robinhood Chain that created ZERO. It runs ZERO's bonding curve and graduated pool and collects the trade fees. → Trust model

Price average

The vault's moving average of ZERO's market price (tokensPerEthEma), read from the curve or the Pons pool and used to set the network fee and bound harvester buys. Each block's price (the last one poked in it) enters clamped to ±10% of the average with weight 1/8, so the average moves at most 1.25% per L1 block. → The market and the router

Privacy set

The notes a spend hides among. A proof shows that the spent notes are somewhere in the note tree without saying which, so the more notes the tree holds, the better every user is protected. → Key concepts

Public ZERO

ZERO held at an address like any ERC-20 balance: visible to everyone and not earning the holder yield. ZERO bought anywhere but through the router, and ZERO taken out of the vault, is public until shielded. → Public balances

Refund

The refund of every note that was unspent in the earlier vault at its last state, block 86632173: NoteRefund pays each note what it was worth then into a note of the vault, once. The app claims it automatically. → Refund of the earlier vault

Registration

Publishing your owner key and viewing key on the vault (register). After it, others can send you private notes. It does not change ZERO held publicly at your address. Each vault has its own key registry; the app registers you when you turn privacy on. → Get started

Root history

The last 64 roots of the note tree, all accepted by the contract, so a proof made against a slightly older root still works. Final roots of full trees stay valid forever. → The note tree

Sale escrow

Where the ZERO of an ERC-4337 exit waits between validation and execution (pendingSales). Execution hands it to the exit target the proof names: for a sale, the router, which sells it for ETH. If that fails, the ZERO goes to the recipient. → Sell

Seed shares

The shares of the ZERO the deployer bought with 0.001 ETH at deployment and locked in a note nobody can spend. They keep the first holders from being diluted by the vault's virtual shares or by fees donated before them. → ZERO on Pons

Share

The unit a note holds. One share is worth ZERO in the vault / total shares, and donated fees raise that value without adding shares. → The vault

Shield

Moving public ZERO into the vault as a private note (approve the vault, then shield). A purchase through the router is shielded in the same transaction. → Public balances

SIWE

Sign-In with Ethereum (EIP-4361). The message your wallet signs to activate privacy is in this form and names the app's domain, so wallets warn if another site asks for it. → Keys

Stub

H(opk, rho, r): a note without its amount. A buyer picks the stub, and the contract completes it with the share amount known only on-chain. → Notes

Unshield

Moving ZERO out of the vault to an address as public ZERO. The amount becomes visible and stops earning. → Unshield

Upgrader

A role on the vault (UPGRADER_ROLE). It can replace the vault's implementation (upgradeToAndCall), and with it the vault's rules, with no timelock. Notes, the note tree, registered keys and the gas deposit stay in the proxy through an upgrade. The deployer holds it at launch, and the vault's admin (DEFAULT_ADMIN_ROLE) grants and revokes it. → Trust model

UserOperation

An ERC-4337 transaction request. A private transaction's UserOperation carries the transaction and its proof as its signature, and the vault as its sender. → Gas

Vault

PrivateVault, the contract that holds the ZERO behind all notes (totalBacking) with the total number of shares (totalShares). Harvested fees and network fees are donated to it. It runs behind an ERC-1967 proxy, so its address stays the same when its implementation is upgraded. → The vault

Viewing key

The X25519 key pair that encrypts and finds your notes. Anyone with the private part can see your notes but cannot spend them. → Keys

Wallet key

The secp256k1 public key of the wallet that activated privacy, bound into the owner key. Every spend needs a signature by it. → Keys

On this page