Overview

Private payments on Robinhood Chain.

Cloakr holds ETH and USDG in shielded pools. Inside a pool, balances and transfers are private: an observer sees that the pool was used, not who paid whom or how much. You shield from your wallet, send or swap privately, and withdraw to any address. Proofs are made in your browser and a relayer submits them, so your wallet never signs the private part.

How it works

Every balance in Cloakr is a set of notes. A note is an amount owned by a spending key, stored on chain only as a commitment: a Poseidon hash of the amount and a hiding value built from your public key and a random blinding factor. The pool keeps every commitment in a Merkle tree of depth 20 (about a million notes) and remembers its last 100 roots.

1. Shield. You deposit ETH or USDG. The pool computes the commitment on chain from the amount it received and the hiding value you sent, and appends it to the tree. The note itself is encrypted to your key and published alongside, so any of your devices can find it again.
2. Prove. To spend, your browser builds a Groth16 proof that you own up to two notes in the tree, that the outputs add up, and which nullifiers they burn. A nullifier is a hash only the owner can compute; publishing it marks a note spent without saying which one.
3. Relay. The proof and the encrypted outputs go to the relayer, which submits the transaction from its own address and takes a small fee from the notes. The fee, recipient and outputs are sealed into the proof, so the relayer cannot change them.
4. Settle. The pool checks the proof, burns the nullifiers, adds the new notes to the tree and, for a withdrawal, pays the recipient. Change comes back to you as a fresh note.

A shielded swap spends notes in one pool, routes the proceeds through the ETH/USDG pool on Uniswap V3, and lands the output in the other pool as a new note for you. The swap target, minimum output and your new note are bound into the proof, so nobody in between can redirect it.

Using the app

Open the app, connect an EVM wallet on Robinhood Chain and sign one message to unlock your private balance. The signature never leaves your browser; it is turned into your keys there.

Payment links

A payment link is money you can send as a message. Cloakr makes a fresh one-off account in your browser, moves the funds to it privately, and puts its 32-byte secret in the link after the #. Browsers never send that part of a URL to a server, so the secret goes only where you paste it.

• Claiming needs nothing. The recipient opens the link and picks a 0x address or their own private balance. Their browser makes the proof and the relayer submits it and pays the gas, so a brand new wallet with no ETH can receive.
• Fees. Funding a link is one private transfer (relayer fee only). The link also holds one relayer fee for the claim, so the recipient gets close to the full amount. A claim to a 0x address pays the 0.3% withdrawal fee; a claim into a private balance does not.
• Taking it back. Your links are listed under Payment links on the device that made them. Until someone claims one, Take back returns its funds to your private balance.
• Treat it like cash. Whoever holds the link can claim it, once. Send it privately to one person. The optional note travels inside the link only and is never written on chain.

Payroll and requests

Payroll takes one payment per line: address, amount, label. Paste from a spreadsheet or upload a CSV of up to 100 rows. Cloakr checks every address first, shows the total with fees, and then pays each row as a separate relayed transfer. Shielded and registered recipients are paid inside the pool; plain 0x addresses get a payout from the pool, minus 0.3%.

Progress is saved in your browser after every row. If the tab closes mid-run, finished rows stay paid, and the row that was in flight is marked check so you can confirm it in History before paying it again. When the batch is done, download the results with a transaction link per row.

Payment requests are links you make under Receive: your shielded address, an asset, and optionally an amount and a note. Opening one starts a private send with everything filled in, so the payer only checks and confirms. A request link holds no money and reveals nothing beyond the address you chose to share.

Fees and limits

Getting the most privacy

• Leave time between shielding and spending. A deposit followed seconds later by a payout of the same amount is easy to pair up.
• Shield round amounts and spend different ones.
• Withdraw to a fresh address rather than the wallet you shielded from.
• Pay registered 0x addresses or ck1 addresses when you can: those payments never leave the pool.
• Use the relayer. If it is offline the app can submit from your wallet, which hides amounts and recipients of private transfers but shows that your wallet used Cloakr.

Keys and recovery

Your shielded account comes from one signature of a fixed message by your wallet. The same wallet always produces the same keys, so there is nothing extra to back up: open the app on another device with the same wallet and your notes are found again from chain data. Wallets that sign differently every time (some smart contract accounts) cannot hold a Cloakr balance.

Viewing keys

A viewing key contains your public key, your nullifying key and your note decryption key. With it, anyone can scan the pools, open every note you received and compute whether each one is spent. That is enough for a statement of what came in, what went out and what is left, and nothing more: it cannot make a proof, so it cannot move funds.

Share it with an accountant, an auditor or a compliance team the way you would share a bank statement. Everyone else keeps seeing only commitments.

SDK quickstart

The SDK is a plain ES module served from this site. It works with any EIP-1193 wallet and uses the same code as the app.

import { Cloakr } from 'https://cloakr.tech/sdk/cloakr.js';

// wallet access, Robinhood Chain, one signature that derives the shielded keys
const cloakr = await Cloakr.connect(window.ethereum);

await cloakr.shield({ asset: 'ETH', amount: '0.05' });
await cloakr.send({ asset: 'USDG', amount: '25', to: '0x9f2c...41d7' });  // private payout
await cloakr.swap({ from: 'ETH', to: 'USDG', amount: '0.02' });          // stays in the pool

console.log(await cloakr.balances());   // { ETH: '0.0299', USDG: '...' }
console.log(cloakr.address);            // ck1... to get paid privately

const link = await cloakr.createLink({ asset: 'USDG', amount: '20', note: 'Lunch' });
// send link.url to anyone; they claim it with no wallet:
await Cloakr.claimLink(link.url, { to: '0x5e1a...c0de' });

Every action accepts { onStep }, called with { step, detail } as it loads the prover, proves, relays and confirms, so you can show progress.

SDK reference

Relayer API

The SDK talks to the relayer for you. If you build your own client:

Security

• Circuit. One 2-in, 2-out transaction circuit over BN254 with Poseidon hashing, about 29,000 constraints. It range-checks every amount to 248 bits, forbids spending the same note twice in one proof and binds the public data hash into the proof.
• Trusted setup. Phase one is the public Perpetual Powers of Tau ceremony (80 contributions). Phase two had one Cloakr contribution from fresh randomness followed by a random beacon.
• Contracts. The factory creates one pool per asset. The admin can pause new deposits, change deposit limits, the treasury, and the withdrawal fee up to its 1% cap. Nothing can pause, block or redirect a withdrawal, and nobody can spend a note without its key. Source is verified on Sourcify.
• Hashing on chain. The pools use the Poseidon contract already deployed on Robinhood Chain at its standard address, and the deploy script checks its output against the circuit before anything is sent.
• Status. The contracts and circuit are new and have not had an external audit yet. Deposits are capped per transaction for that reason. Use amounts you are comfortable with.