Skip to main content
A join-split can create an output for any public key, not only your own. That is all a payment inside the pool needs. You spend a note you own, you address one of the new notes to someone else’s key, and the value never crosses the pool boundary: no tokens move, and the chain carries nothing but the transaction’s three commitments, their ciphertexts and its input nullifiers. A private transfer therefore has extAmount = 0, and so publicAmount = 0. The recipient never has to touch the chain: no gas to pay and no prior on-chain history to have.

Shielded address

The recipient hands out a shielded address, serialized as pp-addr: followed by two hex fields:
The first is the Poseidon spend public key that goes into the note’s commitment. The second is an x25519 public key, derived deterministically from the same spend key, that the note’s ciphertext is encrypted to. Both come out of one SDK call:
Because the encryption key is derived from the spend key rather than stored, there is nothing extra to back up: the one secret reproduces the address, decrypts every note sent to it and spends them. Parsing refuses anything that is not two well-formed hex fields with a public key inside the field. How a wallet signature becomes that spend key is on Keys and view keys. An address is not an account. Paying one twice creates two unrelated commitments, and nothing on-chain groups them.

Ciphertext per output

A commitment alone is useless to its new owner: they cannot guess the blinding. So every one of the three outputs ships a ciphertext of its opening, (amount, blinding, asset), encrypted to the owner’s x25519 key:
Every blob is exactly 168 bytes: 32 for the ephemeral key, 24 for the nonce, 16 for the authentication tag and 32 each for the amount, blinding and asset. The pool rejects any other length, so a ciphertext’s size says nothing about the note inside it. A one-unit transfer and a million-unit transfer look identical. The three ciphertexts are fields of ExtData, so they are inside extDataHash and bound into the proof. Nobody between you and the chain can swap, drop or re-encrypt one: a relayer that tampered with a ciphertext would invalidate the proof it was paid to submit. That is what makes delivery safe over an untrusted path. See Notes and proofs for the binding itself.

What is on-chain and what is not

A transfer names no token, so its three new leaves join the anonymity set of every listed token at once (Many tokens, one pool). Nor does the payload distinguish a payment from mere self-shuffling: a transfer that pays nobody but yourself produces exactly the same shape.

Scanning as recovery

The recipient finds the note by trying to decrypt it. The SDK’s scanShieldedNotes walks every commitment the pool ever emitted, attempts an authenticated decryption of each ciphertext with your encryption secret, and keeps the ones that open:
Authenticated decryption is the filter: another user’s blob fails its tag check and is skipped. A blob that does open is checked again before it is believed: the opening must be canonical, re-hashing it under your own public key must reproduce the commitment that was published, and the asset must be one the pool lists. The commitment hashes the asset, so a ciphertext claiming the wrong token is discarded, and a transfer that kept its token private on-chain is still recovered as the right token. Each note’s spent status comes from its nullifier, which your key can compute. This is why scanning doubles as note recovery. One secret key, plus chain data, reconstructs every note you own (payments received, your own deposits, every piece of change, of every token) with no server, no backup file and no note strings to keep. A view key does the same read-only. Pass a view key instead of the spend key and the notes come back without a private key: visible, countable, not spendable. Scanning is a full history walk, so clients read the commitment events in chunked block ranges, and may use an indexer to avoid rescanning everything on every refresh. The indexer’s answer is accepted only if the tree rebuilt from it matches the pool’s own root, leaf count and nullifier count at one pinned block, and is otherwise thrown away for a plain RPC scan. Keys, notes and scanning covers the SDK side.

Relayed or sent from your own wallet

Submit the transfer yourself and your wallet is the public sender of a pool transaction (nothing more: no amount, no token, no recipient); submit it through the hosted relayer, which pays the gas in exchange for a fee note, and the public sender is the relayer instead. See Fees and referrals and What stays public.