How Hushel works

Pay your team without publishing their salaries. Addresses stay public; amounts and assets are encrypted.

This page is also served at /documentation. The map reads any Solana address from public chain data today.

What Hushel is

Hushel is a payouts app for crypto teams on Solana. A team pays contributors, staff, grant recipients and vendors in USDC or USDT, one asset a batch, and the amount and the asset are encrypted on chain. The recipient's address stays public. It runs on Helius Privacy Rings, the default ring: addresses public, amounts and assets encrypted, deposits and withdrawals public.

It is not a mixer. It never hides who paid whom, never routes through hop wallets, and does not use the anonymous ring.

Around each payment: an auditor key that reads the payout history and cannot move money, a signed receipt a recipient can show without the amount, and the map, which shows what public chain data already says about any address.

Status on this server. The payout app opens at launch. Hushel's own program: reading its state from chain.

Hidden and visible

What a stranger can read about one payout, from public chain data:

On chainWith a plain USDC transferWith Hushel
Recipient addressVisibleVisible
Sender addressVisibleVisible
TimeVisibleVisible
AmountVisibleHidden
AssetVisibleHidden
Deposit into a private balanceNot usedVisible
Withdrawal to a public accountNot usedVisible

Five ways amounts leak

Encryption hides the amount inside a private transfer. Public money still has to enter and leave, and people still get paid on a rhythm. These five can give an amount away:

  1. A public deposit can reveal a batch total. Money enters a private balance with a public deposit. If you deposit exactly what a batch pays, the deposit shows the total, and with one recipient it shows their amount. Fund ahead, on another day, with another amount. The app warns when a recent deposit is within 1% of the batch and when a batch has a single recipient. Funds also plans the deposits for a payday: 2 to 4 deposits on different days before it, in round amounts that together cover the batch with a margin, none of them and no sum of them within 1% of the total or of any row. It only plans; you deposit each line on its day.

  2. Withdrawing exactly what arrived shows what arrived. A withdrawal to a public account is public. The withdraw screen says so before you sign.

  3. Regular timing shows the relationship. Addresses are public by design, so a payment on the same day every month says that you pay that person. Only the amount is hidden.

  4. Earlier public payments hint at the new ones. If you paid someone in plain USDC before, those amounts stay public forever. The app runs the same read as the map on your paying wallet and flags those recipients.

  5. Withdrawing the leftover balance shows the total paid out. Public deposits in minus public withdrawals out equals what left privately. The withdraw screen warns about it.

How keys work

Your wallet makes its private keys by signing one fixed message: the Solana off-chain message (version 0) of TSPP/derive/v1, with the application domain sha256("TSPP/derive/v1"), defined by the Privacy Rings protocol. The signature is expanded with HKDF into a nullifier key and an X25519 viewing key. Ed25519 signatures are deterministic, so the same wallet gives the same keys on any device that signs the same bytes.

Those keys read and decrypt. They cannot move money: every spend also needs your wallet's own transaction signature, which the Privacy Rings program checks. Hushel never holds a key and never stores an amount in plain text.

The message is the same on every site, because the protocol accepts only these exact bytes. Anyone who gets that one signature can read your private history, so sign it only in an app you trust. Signing in to Hushel uses a separate message that names this site; the two are never the same request.

Phantom does not sign this message: it reads every Solana off-chain message as a transaction and refuses it (checked on Nov 20, 2026). For Phantom, Hushel makes the keys from its own plain message instead, which names the address and the version hushel/derive/v1; the app shows it in full before you sign, and the first time it asks twice to check that the wallet gives the same signature again. Keys made this way work in Hushel; another Privacy Rings app reads them only if it supports the same message, and once the address registers, the registry keeps its keys for good. Other wallets: the keys window can check yours with a harmless test message in the Privacy Rings format, which makes no keys. A Ledger-only account cannot hold these keys, because the device cannot run the key agreement.

Recipients register once

A private payment goes to the recipient's own private keys, so a recipient registers once before the first one. They connect their wallet, sign the derivation message to make their keys, and sign one transaction that writes those keys to the Privacy Rings user registry. The registry is on chain and only that address can write its record. Records are never replaced.

For invited recipients Hushel can pay the network fee and rent of that one transaction, so the recipient needs no SOL. It does this once per wallet, only for addresses invited by an organisation with a signed profile, and within limits: an organisation that has not recorded a payout here yet covers 3 recipients, and all such organisations share 50 a day; an organisation that has recorded one covers 50 a month; 200 a day in all. The recipient signs in first (one signature, no funds move) so the site knows whose fee it pays. Past a limit, for an address no organisation invited, or when this server has no sponsor set up, the recipient can pay that small fee themselves, about 0.0012 SOL.

Until a recipient registers, their row in the organisation's batch says waiting for recipient, and they get a link to register. No money is locked anywhere while it waits. If an address already registered through another app, Hushel pays those same keys and never makes a second identity for it.

Why not pay first and let the recipient claim later: a claim escrow for unregistered addresses needs circuits and a trusted setup of its own. A setup run by one team alone would let its holder forge claims, so Hushel does not ship one. It is listed under Next.

How a payout moves

  1. Fund ahead. The organisation moves USDC into its private balance with a public deposit, ideally days before payday and in a round amount unrelated to any batch.

  2. Paste the batch. Address, amount, memo, as CSV or typed rows. Each row is checked: address format, duplicates, the OFAC list, registry status and your private balance. The leak warnings above show here.

  3. Prove. The default ring pays up to 15 recipients of one asset in one private transaction. The proof is made remotely, as described under Remote proving.

  4. Send. A batch of N rows is N divided by 15, rounded up, private transactions sent one after another. A transaction that does not confirm is rebuilt only after its blockhash has expired, so a late landing cannot pay twice.

  5. Sign one statement. After the batch lands, your wallet signs one statement naming the batch root and its transfers. Every receipt in the batch carries it. Then it signs one transaction that commits the batch root to Hushel's program, with its row and transfer counts, stamped by the chain clock (about 0.0011 SOL of rent per batch, plus 0.0014 SOL once for the organisation's account). If that is declined or fails, the payouts and receipts stand, and the commitment is written with the next batch or from History.

Every organisation can pay 5 recipients a month free. Each recipient past that is a seat at 0.50 USDC for that month, bought on chain from the review screen when a batch needs it: paid from the paying wallet's public USDC, or first moved there from the private balance (a public withdrawal of that amount). Locking $HSHL for the month gives a tier of recipients instead. The program's state is on /program. The confirm line shows the count before you sign.

Remote proving

A private transfer needs a zero-knowledge proof, and making it needs the plain transaction (amounts included) and the nullifier secret. The Privacy Rings SDK does not offer proving in the browser today, so the proof is made by Helius's prover inside an AWS Nitro enclave.

Before it sends anything, the browser checks the enclave's attestation against a policy signed by Helius and encrypts the request to the enclave's key. The request travels through this site's relay, which adds the Helius key server side, forwards the ciphertext, never logs request bodies and stores nothing. Checked on mainnet on Nov 18, 2026: the attestation came back from AWS Nitro with the GPU verified, in 1.1 s.

So the amounts are readable inside Helius's attested enclave while the proof is made, and nowhere else on the way. The relay and its operator see only ciphertext.

Step counts: to see where people get stuck, this site counts per day how often each page is opened and each step is reached (wallet connected, keys made, signed in, registered, deposited, batch sent), with the wallet app's name for wallet steps. A count holds no address, no IP and no amount.

Receipts and proof

Each row has its own 256-bit secret, derived from the organisation's secret with HKDF over the batch number and row number. A receipt carries a commitment to the amount and to the asset made with that secret, plus a Merkle proof that the row is in the signed batch. The row secret is sealed to the recipient's registered viewing key. Hushel stores the sealed box and never the secret.

What the chain proves

  • The transaction exists, it is a Privacy Rings transfer, and the organisation's wallet signed it.
  • The recipient's address received an output in that transaction.
  • Once Hushel's program is deployed: the batch root was committed by the organisation, under its sequence number, at a time stamped by the chain clock.
  • The amount, when the recipient discloses their own output (asset, amount, blinding): anyone can recompute that output's hash and compare it with the hash the transaction put on chain. This opens no other row.

What the organisation's signature vouches for

  • That the row belongs to the batch the organisation signed.
  • The amount and asset behind the commitments, when the recipient opens them with the row secret. That proves what the organisation signed, not what the chain holds.

A "Paid by" card shows the organisation, its address, whether its X account is verified, the date and the transaction, and the words Amount private. Organisations without a verified X account are labelled Unverified organization. Anyone can check a receipt on /verify.

Income proof

A recipient can prove what they received through Hushel over a period, for a landlord, a bank or an accountant, without opening anything else. In Receive, they pick the first and last day; the app puts every receipt of that period with its opened amount (and, where it can, the output disclosure above) into one file, totals it per asset, and the recipient's wallet signs a plain-text summary of the period, the count, the totals and a hash of the payments. /verify checks the signature and the totals in the browser and every payment like a single receipt. A changed amount, total or period fails it. It proves at least these payments: it cannot show a payment left out, so its total reads as a floor, never a ceiling.

What the chain enforces

Enforced on chainDone by the Hushel app and server
Amounts and assets of private payouts are encrypted (Privacy Rings program, run by Helius)Free limits and seat counting. Anyone can pay privately with the Helius SDK directly
Config changes (free limit, price) wait 7 days before they applySanctions screening before sending, with the list shown on screen
Only an organisation's payout wallet commits its batchesIssuing receipts (the organisation's wallet signs them)
Each batch sequence number is committed once, stamped by the chain clockComparing a batch commitment with the real transfers, row by row, in the auditor view
Extra recipients are paid in USDC at the configured price, in the same flowLeak warnings before sending and before withdrawing

Only the first row of the left column is live today. The other rules are Hushel's own program, which is built and tested but holds nothing until it is deployed; /program shows its state, its keys and what each key could lose.

A batch commitment is what the organisation says it paid. The auditor view checks it against the decrypted transfers; nothing stops a dishonest organisation from committing something else.

Sanctions screening

Before anything is sent, every recipient and the paying wallet are checked against the Solana addresses on the OFAC SDN list. The list is read from OFAC's own SDN export, with the nightly mirror 0xB10C/ofac-sanctioned-digital-currency-addresses as a fallback. The list's source and date are on the send screen.

Freshness means this server's last successful check, not the list's last change: OFAC publishes irregularly. The server checks again every six hours. If no source has loaded within seven days, or the list comes back empty, nothing sends.

On this server now. Reading the list's status from /api/sanctions.

Auditor keys

An organisation gives its auditor the viewing key of its paying wallet. The auditor view is read-only, lists every batch with its rows decrypted in the auditor's browser, compares them with the signed batch roots, and exports CSV. A viewing key cannot move money.

It reads that wallet's whole private history, past and future, so pay from a wallet used only for payouts and hand the key over knowing it cannot be taken back.

How the map reads an address

The map on the first screen uses public chain data only. For the address you paste, this site's server reads the address itself and its USDC and USDT token accounts, takes their newest transactions (60 on a public RPC, 150 with a Helius key), and keeps every USDC, USDT and SOL transfer into or out of the address. SOL transfers under 0.001 SOL are left out as fees and rent.

  • A block is one counterparty in one asset: every payment between the two addresses.
  • Paid on a schedule (white): three or more payments whose gaps stay close to their median, at least about a day apart.
  • Same amount again (purple with a white edge): a scheduled payment, a repeated amount, or amounts within 10% of each other.
  • Area is the square root of the total, with anything under 400 drawn at the 400 size, so 0.01 and 4,000,000 fit on one screen. Area is not proportional to money.

Limits: only the newest slice of a busy address is read; transfers through other tokens, swaps and programs are not counted; nothing is named or labelled, counterparties are addresses. A read is kept for 15 minutes, and each visitor can start a few new reads every 10 minutes.

The first screen opens on one real address the site operator chose, labelled with whose data it is and when it was read. The Hushel view is a what-if over those same public payments: no Hushel payouts are drawn on it.

The house demo

The house demo is an organisation run by the Hushel team, set up to pay 5 recipients 1 to 3 USDC each on mainnet once a month and to publish its viewing key. Once it pays, anyone can open /demo and watch their own browser decrypt each row, next to the same transaction on Solscan, where no amount shows. The same page can then take this site out of the path: it asks a public Solana RPC for the house organisation's own transactions, reads each payout's encrypted outputs from the transaction's bytes, opens them with the published key and compares them row by row with what came through the relay. Demo payouts are labelled House demo and are never counted as usage.

Whether it has paid yet is shown on /demo. After the first funded month, the team tries to recover each demo amount from public data only and publishes what leaked on this page.

Audits and maturity

  • The Privacy Rings SDK is alpha (@heliuslabs/spr 0.9.0-alpha) and its endpoints are Beta. Its program module is marked experimental.
  • Privacy Rings core audits: Certora and zkSecurity are done; the OtterSec report is pending. Its trusted setup ceremony finished on Nov 2, 2026, with 15 contributions per circuit.
  • Hushel's own program is not audited.
  • USDC can be frozen by its issuer, inside a private balance too.
  • Timing, public deposits and public withdrawals can still leak information, as listed above.
  • Private payouts need this server's Helius connection (indexer and prover). When it is not configured, the app stops at that step and says so.

Programs and addresses

Privacy Rings programring1GaLCuJnkUMVkX2JeZLTTX17wKsV4fZmPVzXANW
Privacy Rings user registryregy3WAeRXMYuMYxr5iK3Bf9Arr3PcxGxyzAddbiqDQ
State tree777pvSGe5LaBd9nCczvE2FXEauiwtfGJ5XRpjKyniGor
Hushel programe66fRx6BuK8mZozdHsPHznA8hNnFwCwXgwvWEwDuXpw
USDC mintEPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

Key roles, their addresses and what each key could lose are on /program.

Bounties

An organisation with a signed profile can publish a bounty on the bounty board: a title, the details and a pool in USDC or USDT. Its wallet signs that text, and later the list of winners, at least 2 addresses that cannot change once named. The winners are paid in an ordinary batch, so what each gets is encrypted like any payout; a winner shows as paid once this site holds a receipt from that organisation to that address, made after the winners were named. The board moves no money and allows no links. The pool is the organisation's own word: receipts prove who was paid, not that the whole pool was. Anyone can check both signatures on the bounty's page, in their browser.

Next

  • Claim slots: pay an address that has not registered yet, if an escrow program backed by a public ceremony appears.
  • Multisig organisations: a Squads vault cannot sign the derivation message, so it cannot hold private keys the normal way yet.
  • Proving in the browser, once the Privacy Rings SDK offers it, so amounts never leave the device.

Public API

GET /api/healthSolana slot and RPC latency, the newest Privacy Rings transaction, Helius indexer status, sanctions list date, house demo, program status
GET /api/exposure?address=The map's read of one address, as JSON (/api/exposure/stream sends progress first)
GET /api/sanctionsSource, publish date, last check, count
GET /api/programProgram address, deployment, key roles and what each key can do
GET /api/demoThe house demo's batches and its published viewing key
GET /api/statsOrganisations, batches and payouts recorded, the house demo excluded

/docs and /documentation are the same page.

Read before you pay

The map shows what a stranger can already read about any Solana address. Private payouts open at launch.

Connect

Connecting signs nothing. From any page, the wallet menu opens your own public payouts on the map.