Devnet beta · test money

What our server knows.

BLACKOUT's private balance is a zero-knowledge pool on Solana. Nobody sees who pays whom in it, us included. Our server only helps your payment reach the chain. Here is what it can't see, what it can, and what it keeps. Nothing is left out to look better.

01 · The private pool

What we can't see.

This holds for the private balance: the app's one balance. The reason in each line is how the pool is built, not a promise to look away.

  1. Hidden

    Who sent a private payment to whom

    A private payment reaches us as a proof and two sealed notes. The proof says the payment is valid. It doesn't say who sent it or who receives it.

    solana/zk/relayer/relayer.mjs · makeJob
  2. Hidden

    How much was sent

    The amount is sealed inside the notes. We see which coin it is (SOL or USDC) and the relayer's fee. So does everyone, on chain.

    solana/zk/js/lib.mjs · parseTransactData
  3. Hidden

    Your balance and your history

    Your device downloads the pool's whole public list and opens only its own notes, on the device. We can't tell which notes are yours.

    solana/zk/relayer/leaf-index.mjs · solana/zk/js/lib.mjs · NoteScanner
  4. Never sent

    Your keys

    Your spending key, your viewing key and your backup line are made on your device and stay there. Our server holds no user's viewing key, so it has nothing to open notes with.

    blackout/app/zk.js
  5. Can't change

    Where a payment goes

    The proof fixes the receiver and the fee. We can delay a payment or refuse it. We can't send it somewhere else.

    solana/zk/relayer/relayer.mjs · solana/zk/program/src/lib.rs

Two things give us more than this, and each is your choice: an offline allowance, and a claim link you ask us to text. They are under where we see more. The Emergency lane for basic phones is a separate balance, and we see all of it.

02 · The honest list

What we can see.

Seeing is not keeping. What we write down, and for how long, is in the next part.

APublic on Solana, to everyone

  • Deposits. The wallet, the amount and the time.
  • Withdrawals. The receiving address, the amount and the time.
  • That a private payment happened. Its time, its coin and its fee. Nothing else.

BBecause your device talks to us

  • Your IP address and the time of every request. Our web server writes both to its log.
  • The wallet you deposit from. Before the pool takes a deposit, we check the wallet against sanctions lists. We see the wallet, the coin and the amount. A wallet we refuse is written to our log. solana/zk/relayer/screener.mjs
  • The payments we relay. The same proof and sealed notes that go on chain, a moment earlier, and the time they reached us. By that time we could match an IP address to a transaction, while the web log lasts. solana/zk/relayer/relayer.mjs
  • Who you look up. Before you pay a @name, a phone number or a wallet, your device asks us for its private address. We see the question and your IP address. We don't write it down, but in that moment we could guess who you are about to pay. solana/src/names.js · solana/src/zk-bridge.js
  • Your wallet address. Balance checks and your own deposit pass through our window on the chain, so we see your wallet next to your IP address. solana/src/zk-bridge.js · toChain

CBecause you chose to publish it

  • A private receiving address for your wallet. Anyone can look it up: that is its job. Knowing it doesn't show the payments it gets.
  • A @name. The name, its private address and the wallet that claimed it.
  • A linked phone number. Your wallet and your number. We store a keyed hash and an encrypted copy. We hold the key, so we can read the number. solana/src/phone.js

DWhere we see more

Each of these is a choice. The private balance works without them.

  • Offline allowance. A phone with no internet can pay with a short signed code from an allowance you set aside. We hold the key to that allowance. For these payments we see your wallet, the amount and the receiver. Your daily limit is the cap. A payment your phone proves in full (the QR code, or the long code) is not like this: we see no more of it than of any private payment. solana/zk/relayer/offline.mjs
  • A claim link we text for you. Paying a number that has no account makes a claim link. The link is the money until it is claimed. If you ask us to text it, we see the link, your wallet and the receiver's number. Send the link yourself and we see none of that. solana/src/zk-bridge.js · claimText
  • Payments sent by SMS. A text arrives from your number, so we see your number and the code, and so does the phone network.
  • The agent. What you type to the agent is read by an outside AI model when the agent is on. solana/src/agent.js
  • Swaps and exits to other chains. A swap's coins and amounts are public on chain. For an exit, we and the exit provider see the address on the other chain and the amount.
  • The web app itself. Its code comes from our server on each visit. You trust us to deliver the code this page describes.
03 · When the smartphones are dead

The Emergency lane.

The fallback for a real blackout. Power is out, the internet is down, smartphones have died. A basic phone with days of battery can still pay by text, with a printed card of one-time codes. It can't make a proof, so this lane works differently from the private pool, and we say so.

On the public chainHidden

A lane payment is a move in our ledger. Nothing about it appears on Solana. A top-up, and a payout to a Solana address, are public.

To our gatewayVisible

We hold the lane's balance and its ledger: your wallet, your number, each sender, receiver and amount.

Limits1 SOL held

At most 1 SOL and 100 USDC in a lane, 0.5 SOL and 50 USDC a day by text. More is sent back.

  • Separate from your private balance. The lane holds only what you put in it. It can't reach your shielded notes, and the app pays from the lane nowhere but back to your own wallet.
  • What "no internet" means here. The paying phone needs none. The text needs a cell signal. Our gateway and the chain need internet.
  • Who it is for. Phones that can't run the app. Everyone else uses the private pool, where we see none of this.
  • What a text reveals. Your number, the receiver's number or address, and the amount, to us and to the phone network.
solana/src/phone.js · solana/src/engine.js · SOL_BASIC_CAP_BALANCE_*, SOL_BASIC_CAP_DAY_*
04 · Written down

What we keep, and how long.

Numbers with a dot beside them are read from the running server.

WhatWhat is in itHow long
Web server log IP address, time, the page or route asked for (never what was asked, never a token), size and duration. 3 days, then deleted.
The app's own log No IP addresses. A line for each relayed payment (a job number and its result), each offline-allowance payment (which allowed phone, the amount, a shortened receiver), each refused deposit wallet, and each text sent (masked number). A new file each day or at 10MB; 7 files kept, so about a week.
The relayer's queue A payment waiting to go out: its proof and when it reached us. Once it is sent, only what is on chain anyway stays: the public receiver if it was a withdrawal, the fee, the transaction. The arrival time is dropped the moment a payment is sent. The rest goes after 24 hours.
Receiving addresses and @names What you published: wallet, private address, name. Until you remove or release it.
Linked phone numbers Your wallet, the number as a keyed hash and an encrypted copy, a masked form. Until you unlink it.
Offline allowances Each phone you allowed, your wallet, its limits; and each code used, with its amount. Phones: kept. Used codes: until the code expires, 30 days at most.
Emergency lane ledger Lane only: each payment with sender, receiver and amount; top-ups; the code card as hashes; an operator log. Payments and top-ups 45 days, signed originals 30. Operator log 30 days. Payments waiting for a number: not deleted yet.
Swaps and exits A finished swap's public details. For exits, only the one-time deposit addresses we were quoted. Swaps 24 hours. Exit addresses 30 days.
Backups When backups are on: a nightly copy of the database, the relayer's queue, the offline allowances and the phone-number key. 14 copies. So a deleted record can live up to 14 days longer.
In memory only Request counts per IP address for rate limits, and codes for linking a number. Also the crowd meter's count: the pool's deposits, withdrawals and swaps of the last 7 days as the chain shows them to anyone (time, coin, amount), rebuilt every minute, with nothing about who asks. Minutes to 24 hours. Gone on a restart.
05 · Don't take our word

Check it yourself.

The server answers one public question: what do you store? It reads the answer from its real database and files each time. It gives names and shapes, never anyone's data.

Asking the server… Raw answer

What this proves, and what it doesn't

  • It is the server describing itself. A web page can't prove which code a server runs. The report can't drift from the storage by accident, because nobody writes it by hand. It could still be faked on purpose.
  • The code is not public yet. Opening it comes before mainnet. Until then the file names on this page are pointers you can't follow. When the code is open, the report's commit says which version to read.
  • No outside audit yet. Three AI audit passes have been run on the code. An outside audit comes before mainnet.
  • What you can check today. Everything under A is on the public chain. Your device, not our server, builds the proof: watch what it sends in your browser's network tab.
06 · Your move

Show us less.

Now
  • Send claim links yourself. Then we never see the link or the number.
  • Pay offline with a full proof. The QR code or the long code keeps the payment sealed. The allowance doesn't.
  • Keep the Emergency lane for emergencies. We see every lane payment. A phone that runs the app should use the private pool.
  • Don't link a number, don't publish. Share your private address directly and there is nothing to look up.
  • Withdraw with the next wave. It goes out together with others, in random order, so its time on chain says less about when you asked.
  • Pick another relayer. In the app, "Who sees what" lets a relayer run by someone else send your spends, or a random one each time. Then we don't see them arrive.
  • Read the chain somewhere else. The same screen points the app at the network's public RPC or your own, so we don't see your wallet's reads. With both changed, no single server sees both.
  • Hide your IP address. A VPN or Tor Browser works with the site today. We have no Tor address of our own yet.
Coming
  • A Tor address. So the server never learns an IP address at all.
  • Open code. So every line on this page can be checked.