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 transfer1,279 bytes, about 140,000 compute units
A program instruction with its own proof plus the pool call240,029 to 249,723 compute units, under 1,400 bytes
Transaction size limit (v1 messages)4,096 bytes
Tree fee5,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:

InstructionCompute unitsTransaction size
open251,6611,695 bytes
pay255,8871,756 bytes
settle249,0881,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 Programring1GaLCuJnkUMVkX2JeZLTTX17wKsV4fZmPVzXANW
User Registryregy3WAeRXMYuMYxr5iK3Bf9Arr3PcxGxyzAddbiqDQ
State tree777pvSGe5LaBd9nCczvE2FXEauiwtfGJ5XRpjKyniGor

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.

Loading the index