Send to anyone. Burn the trail.
Every payment lands in a fresh one-time burner only the receiver can open. They sweep it, the burner burns, and the chain is left holding ash that points nowhere. No pool. No contract. No custody. Just math with a lighter.
Three steps. One burner per payment.
Ed25519 math, the same curve every Solana wallet already signs with. The stealth address idea from Ethereum, carried over to Solana and set on fire at the end.
Publish a burner tag
Sign one message and get a burner tag. Put it in your bio, on an invoice, on a sticker on your laptop. It never changes and it never receives a single lamport itself.
Light a fresh burner
The sender's browser mixes fresh randomness with your tag and gets an address nobody has ever seen. The SOL goes there, with a short public note that only means something to you.
Sweep it, burn it
Your browser checks every note with a private view key. Matches are yours to sweep into any wallet, and the emptied burner is closed for good. Its rent comes back to you. The address does not.
A name instead of a key
Claim a short name by burning $BURNER and share burnerprotocol/@name. People pay a word, you still get a brand-new burner every single time. Check a name.
A message only they can read
Attach up to 120 bytes to a payment. It is encrypted with the payment's shared secret, which is plenty for "rent, March" and not enough for anybody else to learn a thing.
A fresh burner per withdrawal
Exchanges cannot attach notes, so your inbox derives withdrawal burners itself. Use a new one every time and sweep them all from one place. The exchange never meets your main wallet.
Get paid without a paper trail
Payment links, invoices and a pay button for your site. Every customer pays their own burner, so nobody who pays you can scroll through what everyone else paid you. Make a link.
Any SPL token burns the same
Get paid in SOL, USDC, USDT or any standard SPL token. A pinch of SOL rides along with token payments so you can sweep into a wallet that has never held anything, and you get it back when the burner closes.
What the chain keeps
A transfer to an address that existed for one payment, a 33-byte note and a closed account. That is the whole story the chain gets to tell. We call it ash, because there is nothing left to read in it.
Light one yourself.
The whole flow, running in this tab: derive keys, pay a tag, scan the inbox, sweep and burn. Nothing here touches a wallet and nothing leaves this browser.
Get your burner tag
One signature turns into a spend key and a view key. The tag built from them is the only thing you ever share.
Your wallet signs a fixed message. This tab turns the signature into two keys and keeps them in memory only.
Paste this into the exchange instead of your wallet. Next time, use a new one.
Burner Protocol v1 Derive my burner keys. This signature never leaves this browser. Only sign this on burnerprotocol.
- Spend key
- —
- View key
- —
A view key finds your incoming burners but can never move a lamport. Hand it to an accountant and they see every payment, and that is all they can do with it.
Send privately
Pay a burner tag or an @handle. The money lands in a brand-new address with no history and nothing that points at the receiver.
Made in this browser from fresh randomness and the receiver's tag. A new one every time you touch the amount.
- A transfer to an address that never existed before
- A memo with a random point R and a 1-byte tag
- Nothing that names the receiver
- Nothing that links this to the last payment
Your private inbox
This tab reads every public announcement and tries your view key on each one. Matches are yours. Everything else is somebody else's ash.
Derive your keys on the Receive tab first. The inbox needs your view key to know which burners are yours.
Sweeping into your main wallet links that payment to it. Sweep into a wallet that has never touched anything and keep it that way.
- Scanning runs on your device
- The server only ever serves public announcements
- Only a scan cursor is saved, never keys or matches
- Every sweep closes the burner and returns its rent
Claim your @handle
Pick a short name and share it as your pay link. Payments to it still land in fresh burners, exactly like your tag. Claiming burns $BURNER, which is the only fire on this site that costs anything.
Mainnet claims start once the $BURNER contract is published. Until then you can check names and prices, and claim one here in the sandbox to try the whole flow.
| 3 characters | 50,000 |
| 4 characters | 20,000 |
| 5 characters | 8,000 |
| 6–8 characters | 2,000 |
| 9–15 characters | 500 |
- First valid claim wins
- No expiry, no renewal
- Burned tokens are destroyed, nobody receives them
Every announcement, in the open
The indexer reads every transfer that carries a br1: memo. All of it is public. None of it names a receiver.
| # | When (UTC) | Amount | One-time burner | Memo | Receiver | State |
|---|
Privacy without a pool.
Mixing pools hide links by holding everyone's money in one contract and hoping it holds. Burners never hold anything for longer than it takes you to sweep: each payment is an ordinary transfer to a new address.
| Property | Burner Protocol | Mixing pool | Normal transfer |
|---|---|---|---|
| Who holds the funds | Only the receiver, from the first block | A pool contract, until withdrawal | The receiver |
| Pool or contract risk | None: there is no contract | Contract bugs, relayers, admin keys | None |
| Sender ↔ receiver link on-chain | No: funds land at an unlinked burner | Hidden in the crowd, timing can leak it | Yes, directly |
| Needs an on-chain program | No: a system transfer plus a memo | Yes | No |
| Can be frozen by an operator | No: there is nothing to freeze | If the contract has admin controls | No |
| What is left afterwards | Ash: a closed account with no future | A withdrawal everyone can try to time | Your whole history, forever |
The whole trick fits on one screen.
Every format is written down in the docs, so any wallet or app can send to a burner tag and sweep one.
// receiver, once s, v = derive(sign("Burner Protocol v1")) S, V = s·G, v·G tag = "br:sol:" + b58(S ‖ V) // sender, every payment r = random() R = r·G shared = H(r·V) burner = S + shared·G memo = "br1:" + b58(R) + view_tag(shared) // receiver, scanning shared = H(v·R) // same secret, from the other side key = s + shared // signs for the burner sweep(burner → fresh) ; close(burner) // ash
- Public: the burner, the amount, the memo, the time
- Public: the sender's wallet, unless they pay from a burner too
- Private: who the burner belongs to
- Private: that two burners share an owner
- Private: the note, to anyone without the view key
Sweep into the same wallet every time and you have built the trail back yourself. Fresh wallet, every time. That part is on you.
$BURNER
Contract address. It feeds the handles, and every handle claim burns some of it.