The core idea, in one picture
You pay someone. The chain keeps a record that proves the payment was valid without publicly revealing who paid whom or how much.
Neptune Cash keeps payments private and proves them valid with post-quantum zero-knowledge proofs. This page explains how, in plain terms. The documentation and whitepaper linked at the bottom go deeper.
You pay someone. The chain keeps a record that proves the payment was valid without publicly revealing who paid whom or how much.
The same steps the cards below explain in detail, in the order they happen:
How a payment sits on a public ledger without naming its sender, its receiver, or its amount.
Spends cannot be linked to the coin they consume, and double-spending is still caught.
Every spendable coin on the chain is a UTXO (unspent transaction output). The mutator set is the structure that holds them, and the foundation of Neptune's transaction privacy: transactions do not name the coins they touch.
A coin they create arrives as an addition record: a commitment, meaning a sealed, tamper-proof envelope that pins the coin down without revealing it. A coin they consume leaves as a removal record: a scatter of marks on a big shared checklist. Unlike an addition record, it never identifies the coin: the marks are provably tied to some sealed envelope in the set, without revealing which.
What the mutator set achieves is unlinkability: a spend cannot be connected to the coin it consumes, or to the transaction that created that coin, and double-spending is still caught. An observer sees entries added and entries consumed, and cannot determine which entry a spend touched, whose it was, or what it held. What a removal record does reveal is roughly when the spent entry was created, so each spend hides among the entries created around the same time: a creation window the protocol picks for you.
Payments find their recipient without putting either of you on the chain.
How your wallet discovers it was paid, given that transactions name no addresses. A payment carries an announcement: a public note with a receiver identifier on the outside and a sealed message inside. The sealed part holds the coin's full description and the sender randomness, the sender's half of the secret the commitment was sealed with. The other half is baked into the recipient's address. The recipient needs the announcement's half, together with keys only they hold, to recognize the payment and later spend it.
Both halves together are the deliberate exception to the mutator set's unlinkability, and they open different doors. The recipient, who also holds the private key behind the address, can connect the coin to its entry in the set and produce the removal record that spends it.
The sender can watch the coin confirm, but without that key cannot recognize the removal record, so they cannot even tell whether the coin has since been spent.
The commitment is the payment and nobody can read it; the announcement is the notice about it, and with the strongest address format exactly one person can. The addresses card covers the formats that widen that circle.
The identifier on the outside is a deliberate trade-off. It lets your wallet spot payments meant for it instead of trial-decrypting every announcement on the chain. The cost: two payments to the same address carry the same identifier and can be linked to each other, which is the mechanism behind the advice to use a fresh address per payment, or to notify the recipient directly off-chain instead.
Three formats let you choose the trade-off: the strongest post-quantum privacy, a compact address, or one whose incoming payments anyone holding it can see.
Neptune has three shareable address formats because different situations call for different trade-offs: address length, post-quantum strength, and what the holder gets to see.
Generation is the strongest, the enormous one, and the format a wallet gives you by default: it encodes a lattice-based public key, built on mathematics resistant to quantum attacks, and that key is what a sender uses to encrypt the announcement from the previous card. The length is the price of post-quantum privacy.
EC hybrid is the compact option. Its key exchange uses an elliptic curve, the one piece here a quantum computer could break. Even a successful attack would require the address itself, which never appears on the chain, and would only reveal what that address received; spending would remain out of reach. The developers' documentation advises sharing an EC hybrid address only with the person paying you.
A viewing address is a receiving address with no secrets from whoever holds it: anyone with it can see each payment sent to that address and its amount, though not whether it was later spent, and cannot spend anything.
That is useful when one other party should see what you receive: an accountant or an auditor can verify incoming payments with no power to move them. Publish it, on a donation page for example, and everyone sees every payment to it, which is why the developers' documentation (opens in new tab) says to share one with a single party only.
| Format | Prefix | Length |
|---|---|---|
| Generation | nolgam1 | 3,482 chars |
| EC hybrid | nechm1 | 168 chars |
| Viewing | nviewm1 | 116 chars |
m in each prefix marks mainnet.Rules are programs: running one yields a proof that anyone can check, and one proof covers a whole block.
Ownership and money rules are enforced by proofs rather than policy.
Neptune's rules are small programs attached to coins, and they come in two kinds. They run in Triton VM and are proven with STARKs, the next two cards. This is what "programmable" concretely means here.
A lock script decides who may spend a UTXO. Usually it checks knowledge of a secret key, but it can be arbitrarily complex: shared ownership, quorums, or conditions unrelated to keys entirely. Today the scripts in use are the protocol's own, such as the standard key check and the mining-reward timelock; a way for anyone to write and deploy their own is still to come.
A type script decides how a kind of coin may behave: the native currency type script is what enforces that a transaction's inputs cover its outputs plus its fee, so no coins appear from thin air. The three-year timelock on half of every mining reward is a type script too: the rule lives on the coins themselves, not in anyone's policy.
Nodes agree the ledger changed correctly by checking a proof, without re-running the work or seeing the private data behind it.
Think of Triton VM as the computer Neptune's transaction rules run on: a simulated machine that every node can run identically. The interesting part is what it is used for.
Most chains use their VM to replicate state, so every node re-executes everything and ends up holding the same data. Neptune uses Triton VM to validate updates to a state commitment instead: one sealed fingerprint of the whole ledger, a chain-sized sibling of the per-coin commitments in the last section. Nodes agree on that fingerprint, and that it changed correctly, without needing to see the private data behind the change.
Verifying proofs instead of replaying data is what lets a chain be both verifiable and private. Programs for it are written in its own low-level language, tasm.
A proof shows a program ran correctly without revealing what it ran on: expensive to make, cheap to check.
The proof system Triton VM ships with. The zk stands for zero-knowledge: a proof that convinces you a program ran correctly without showing you what it ran on. The rest of the acronym, Scalable Transparent ARgument of Knowledge, matters here for two reasons: transparent means there is no trusted setup ceremony to take on faith, and the proofs are built out of hash functions, the next card's subject, not out of math a quantum computer can break. Validating a Neptune transaction largely means verifying such proofs.
The cost is asymmetric by design: proving is expensive, verifying is cheap. That asymmetry is why composing a block needs serious hardware while checking one does not: the node's own documentation asks for plenty of cores and around 128 GB of memory to compose. It is also why STARKs sit at the center of the design: the network verifies private computation without ever seeing it. Who does that expensive proving, the last card in this section explains.
One quantum-resistant hash sits behind the commitments, the proofs, and the mining race.
A hash function turns any data into a short fingerprint that cannot feasibly be run backwards. Tip5 is Triton VM's built-in hash, co-designed by one of Neptune's founders for recursive STARK machines like this one: cheap to reason about inside the VM rather than merely fast on a CPU. It seals the commitments in the hiding half of this page, and it is the hash the mining race is run with.
Each block carries one transaction and one proof, so every node verifies it cheaply however many payments it holds.
A block does not carry a bundle of separate transactions. The composer merges the block's payments into one aggregate transaction, inputs, outputs, and announcements shuffled together, and produces one proof for all of it. The merge is packaging, not a mixer: every record survives it unchanged, and the payments circulated separately in the mempool first. Hiding stays the mutator set's job.
That merge is the kind of expensive proving the zk-STARKs card describes, and it is not the first proof in a payment's life. The sender's own node proves the payment valid when it creates it, in a lighter form an ordinary computer can manage. A powerful node then upgrades that proof into the compact form a block needs, for a share of the fee, and combines it with others before a composer builds the block. That is why a payment with a very low fee can wait.
Appending the block needs no proving at all. A proof-of-work lottery of Tip5 hashes decides which guesser, the role most people call the miner, earns the right, and every node then verifies the block's one proof rather than re-running everyone's payments. Mining splits exactly along the proof system's asymmetry: composing is the heavy proving, guessing is hash after hash.
The composer never opens anyone's payment to do its job: it merges sealed transactions by verifying and combining their proofs, learning no more about them than any other observer. And that is how private payments become a chain everyone can trust.
Two headline claims come with details worth knowing before you repeat them.
Spending is hash-based and holds against a quantum computer. One optional address format uses breakable encryption, but a break there could never be used to spend.
Spending is hash-based. Lock scripts and the key derivation behind them, how your seed phrase becomes spending keys, run on Tip5. Authority over your coins rests on hash functions, which a quantum computer does not meaningfully weaken. That is the heart of Neptune's post-quantum claim, and it holds.
Encryption is not all hash-based. A generation address carries a lattice-based public key, used to encrypt the announcement, the payment notice, for its recipient. An EC hybrid address uses secp256k1, an elliptic curve, for that key exchange instead.
Elliptic curves are exactly what a large quantum computer is expected to break; lattices, like hashes, are believed to resist one. So the curve appears in one optional address format, for confidentiality rather than custody: a break there would let an attacker read what you received, but only if they also hold the address, which never appears on the chain, and it would still not let anyone spend it.
| Component | Built on | Post-quantum? |
|---|---|---|
| Spending and ownership | Hash functions (Tip5) | Yes |
| Proofs (zk-STARKs) | Hash functions | Yes |
| Generation address encryption | Lattices | Yes |
| EC hybrid address encryption | secp256k1 curve | No: a break plus the address risks reading, never spending |
Each block proves the one before it, so the newest proof covers the chain back to block 62,500. No node syncs from it yet.
The mechanism is recursive block validation: every block carries a STARK proof, the same kind built in the section above, that the block before it was valid, proof included. Checking the newest proof therefore checks the chain behind it, and that is the same small amount of work however long the chain grows.
The update to the mutator set is proved too. A proof the composer builds alongside the rest shows that the block's spends were applied correctly, and its result lets a node rebuild the mutator set without reading the slices of the shared checklist that spends bring along, which the developers call chunks.
Those slices still travel in the block, which limits how many spends fit in one, and by the developers' own account the proof does not yet vouch for the copies. A hard fork planned for block 70,000 (opens in new tab) drops them and closes that gap.
Two things stay outside. The proofs start at block 62,500, so a node that skipped replay would need some other way to accept what came before, the way today's node already takes blocks up to 54,999 on faith through a checkpoint. And that node does not exist yet, so today's node still downloads and checks every block. The developers plan to get there in steps, starting with a node that no longer needs every old block.
The whole system at a glance: each row pairs a part with its job and its payoff, and links back to its card above.
| Component | What it does | What you get |
|---|---|---|
| Mutator set | Holds every coin as an indistinguishable commitment and takes spends without naming the coin | Spends that cannot be linked to the coin they consume or the transaction that created it |
| Announcements | Carry an encrypted notice that leads the recipient's wallet to its payment | Private payments that still arrive |
| Addresses | Three shareable formats trading length, post-quantum strength, and visibility | Privacy you can match to the situation |
| Lock and type scripts | Small programs setting the conditions to spend and how coins behave | Rules enforced by code, and programmability |
| Triton VM | Executes the transaction rules so the execution itself can be proven | Rules verified while your data stays with you |
| zk-STARKs | Prove a program ran correctly without revealing anything else | Proof the rules were followed, verifiable by anyone |
| Tip5 | Seals the commitments and powers the mining race | One quantum-resistant hash behind commitments, proofs, and mining |
| Block pipeline | Merges a block's payments into one transaction covered by one proof | Cheap verification for every node regardless of how many payments a block holds |