Concepts
Solana Privacy Rings underneath
What Remit takes from Solana Privacy Rings: private balances, program-owned balances with data, a program's own proof, and encryption to each reader.
Remit is a Solana program on top of Solana Privacy Rings, the shielded pools Helius runs natively on Solana. Rings holds the money and encrypts it. Remit decides who may move it and on what terms. Remits and holds live in the Default Ring, which is live on mainnet and devnet.
Private balances
A private balance is not a token account. It is a set of UTXOs: commitments in a Merkle tree that the Solana Privacy Rings program keeps on chain. Each commitment is a hash over an owner, a mint, an amount and a blinding value, and the values themselves travel encrypted beside it. Spending a UTXO publishes its nullifier, which marks it spent without saying which commitment it was.
A wallet's private balance in a mint is the sum of its unspent UTXOs of that mint. Money enters with a deposit and leaves with a withdrawal, both public transfers. Rings carries SOL, SPL tokens and Token-2022 tokens, which is why a remit's mint is open.
What the Default Ring shows
In the Default Ring the sender and the recipient of a transaction are public, and the asset and the amount are encrypted. Remit adds its own data to that encrypted part: the terms of a remit, and the request hash and deadline of a hold. What the chain shows lists the result for each instruction.
Keys from one signature
A wallet's private keys are derived from its signature over one fixed message, the Solana off-chain message with the payload TSPP/derive/v1. From that signature come a nullifier key, used when the wallet spends, and an X25519 viewing key, which decrypts. The wallet's own Ed25519 key keeps signing transactions as before.
The public halves are published once in the User Registry, in a record under the wallet's address. That record is how one party finds another's private address from an ordinary Solana address: an agent paying a payee, a payee's hold being encrypted to it, a refund finding the owner.
Whoever holds the derivation signature can read that wallet's private history, so it is treated as a secret.
Balances a program owns
Rings lets a program own a UTXO through a program address, and attach its own data to it. This is the property Remit is built on.
- A remit is a UTXO owned by the remit authority of its owner: the address derived from the seeds
"remit_authority"and the owner's wallet. Its data is the terms. - A hold is a UTXO owned by the hold authority of its payee: the address derived from
"hold_authority"and the payee's wallet. Its data is the request hash, the deadline and the owner to refund.
The data is hashed into the UTXO's commitment, so the terms are part of what the pool stores. No wallet holds a key that spends these UTXOs. Only the Remit program can sign for its authorities, and it signs in one place: after it has verified a proof.
A program's own proof
Each instruction that moves a remit or a hold (open, pay, settle, refund, revoke) has its own circuit. The instruction verifies a Groth16 proof of that circuit, checks the public conditions the proof depends on (the signer, the clock, the configured fee), and then calls the pool's transact with its authority signing.
The proof is bound to the exact pool transaction it was made for: its public input includes the hash of the transaction's inputs and outputs, so a valid proof cannot be attached to different outputs. The pool then checks its own rules as for any private transfer: the inputs exist and are unspent, and no value is created.
The circuits are written in Rust with Xark and proven with Groth16 over BN254. A proof is 128 bytes with one public input, verified on chain through Solana's alt_bn128 syscalls. The program builds against the spr-program 0.10.0 crates and Xark 0.3.1.
Viewing keys
A UTXO's values are encrypted to the viewing key of whoever needs to read it. Remit chooses that reader per output: a new remit is encrypted to the agent, every later state of it to the owner, a hold to its payee, a settlement to the payee and the fee recipient, a refund to the owner. Each reads its own with its own key and nothing else.
Showing one payment to someone outside it needs no key at all. The party hands over the values behind that one hold, and the reader checks them against the commitment on chain: Receipts and disclosure.
Size and cost
Figures from Helius's documentation and its example programs:
| A confidential transfer | 1,279 bytes, about 140,000 compute units |
| A program instruction with its own proof plus the pool call | 240,029 to 249,723 compute units, under 1,400 bytes |
| Transaction size limit (v1 messages) | 4,096 bytes |
| Tree fee | 5,000 lamports for each state tree an instruction updates, on top of the Solana transaction fee |
Remit's own instructions, measured on a local Rings network. Each is one transaction that verifies its proof and calls the pool:
| Instruction | Compute units | Transaction size |
|---|---|---|
open | 251,661 | 1,695 bytes |
pay | 255,887 | 1,756 bytes |
settle | 249,088 | 1,265 bytes |
Over HTTP a paid call is 1 round trip more than an unpaid one. From the first request to the response it took 12 seconds on a local network, proving included, with the payee's settlement following the response.
Addresses
The same on mainnet and devnet.
| Solana Privacy Program | ring1GaLCuJnkUMVkX2JeZLTTX17wKsV4fZmPVzXANW |
| User Registry | regy3WAeRXMYuMYxr5iK3Bf9Arr3PcxGxyzAddbiqDQ |
| State tree | 777pvSGe5LaBd9nCczvE2FXEauiwtfGJ5XRpjKyniGor |
Remit's own program address is in The program.
Audits and setup
The Solana Privacy Program has published audit reports from zkSecurity (August 2026) and Certora (October 2026), and its trusted setup was completed on 2 November 2026. Helius's security page links the reports.