The short version
You publish two public keys under a name. Whoever pays you uses them, in their own browser, to compute a Solana address that has never existed before and that only you can control. The payment goes there, with a tiny note attached. Your browser reads every note, recognises the ones meant for you, and can then sign from those addresses.
Nothing is pooled and nobody holds your funds: each payment sits in its own ordinary address until you move it. The technique is called stealth addresses. stipl implements it on Ed25519, the curve Solana addresses already live on.
Two keys from one signature
When you unlock stipl, your wallet signs a fixed message. Ed25519 signatures as defined in RFC 8032 are deterministic: the same wallet signing the same message always produces the same 64 bytes. stipl hashes that signature into two private scalars, so the same wallet gives the same keys on any device and there is no extra seed phrase.
seed = SHA-512("stipl/keys/v1" ‖ wallet_signature)
s = SHA-512("stipl/spend/v1" ‖ seed) mod ℓ spend key (private)
v = SHA-512("stipl/view/v1" ‖ seed) mod ℓ view key (private)
S = s·G spend key (public)
V = v·G view key (public)S and V are what your link publishes. To claim a name, your browser signs stipl:claim:name:V:label with s, and the server checks that signature against S. Ownership is proven by the stealth key itself, so the server never needs, and never receives, your wallet address.
The private keys exist only in the memory of the tab. Close it and they are gone; sign again next time to get them back.
A fresh address per payment
When someone opens your stipl link, their browser fetches your S and V, picks a random number r and computes a shared secret that only the two of you can reach: the payer through r, you through v.
r = random 512 bits mod ℓ
R = r·G published
shared = r·V (= v·R) never published
h = SHA-512("stipl/shared/v1" ‖ shared) mod ℓ
P = S + h·G the one-time addressP is a valid Ed25519 public key, which is exactly what a Solana address is. To the network it is an ordinary system account. Because r is new every time, two payments to the same link land on two addresses with no visible relation, to each other or to S.
A brand-new Solana account must hold at least the rent-exempt minimum, a little under 0.001 SOL, so the pay page refuses smaller amounts.
The note on chain
You still need a way to learn that P exists. The payment transaction carries a second instruction to the Solana Memo program (MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr) with this text:
stipl:1:<R>:<tag>
tag = first byte of SHA-256("stipl/tag/v1" ‖ shared)R is a random-looking point and the tag is one byte. Neither says who the payment is for. After the payment confirms, the pay page sends only the transaction signature to stipl; the server reads the memo back from the chain itself and stores R and the tag. It never trusts a copy sent by the browser.
Because the memos are on chain, stipl's index is a convenience, not the source of truth. Anyone can rebuild it by reading Memo program transactions that start with stipl:1:.
Finding your payments
Your browser downloads every announcement, unfiltered. The server is never asked “what belongs to this name?”, so it cannot answer that question for anyone else either. For each announcement:
shared' = v·R
if first byte of SHA-256("stipl/tag/v1" ‖ shared') ≠ tag: skip
h' = SHA-512("stipl/shared/v1" ‖ shared') mod ℓ
P' = S + h'·G
if P' = P: this payment is yoursMatching addresses are then looked up on Solana to show their balances. The sum you see in the app is computed on your device and exists nowhere else.
The view key v is enough to find payments but not to spend them. That split is what would allow a watch-only mode, or an accountant who can see your income without being able to move it.
Spending without a seed
The private key of P follows from the same algebra:
p = s + h mod ℓ then p·G = s·G + h·G = S + h·G = P
Normal Ed25519 keys are derived from a 32-byte seed, and wallets sign from that seed. p has no seed, so stipl signs directly from the scalar. The signature it produces is a standard Ed25519 signature; Solana validators verify it like any other.
prefix = SHA-512("stipl/nonce/v1" ‖ p)
k = SHA-512(prefix ‖ message) mod ℓ
R' = k·G
e = SHA-512(R' ‖ P ‖ message) mod ℓ
sig = R' ‖ (k + e·p mod ℓ)Each one-time address withdraws in its own transaction and pays its own network fee (5,000 lamports), so no relayer is needed for SOL and two of your payments never appear side by side in one transaction. When a treasury is configured, 0.5% of the withdrawn amount goes to it in the same transaction.
stipl has a test that builds a real Solana transaction this way and checks it with web3.js's own signature verification.
What the stipl server sees
Stored
- Your name, your public keys S and V, the optional label.
- For each payment: transaction signature, R and the tag. No name attached.
Never received
- Your wallet address.
- Your private keys s, v or any p.
- Which payment belongs to which name.
- Your balance or what you withdraw.
Like any website, the server sees the IP address of each request. If the link between your connection and your use of stipl matters, use a VPN or Tor.
Threat model and limits
- Amounts are public. Each payment is a normal SOL transfer, so its size is visible. Hiding amounts needs Solana's confidential transfers, which stipl does not use yet.
- The payer is public. stipl hides who receives, not who sends.
- Timing and sweeping can relink. Withdrawing many addresses into one wallet, or withdrawing a minute after being paid, gives an observer an easy guess. Withdraw to fresh wallets, at different times.
- The payer knows the one address they paid. They can watch what happens to it. They cannot find your other payments.
- Your RPC provider sees what you check. To show balances, your browser asks a Solana RPC node about your one-time addresses. That node could group them. Point the app at an RPC you trust, or run your own.
- You trust the code stipl serves. The maths runs in your browser, but the browser runs what stipl sends, as with any web wallet.
- Not audited, devnet only. This build has not had a security audit. Use test SOL.
- Your keys depend on your wallet's signature. Wallets that sign Ed25519 the standard, deterministic way always give back the same keys. A wallet that signs differently each time would give you different keys, and you would not find past payments with it.
Compared with other tools
| Tool | Hides | Still visible | Funds held by |
|---|---|---|---|
| stipl | Who receives, and that payments share a recipient | Sender, amounts, timing | You, address by address |
| Mixer / privacy pool | The link between deposit and withdrawal | That you used the pool, amounts in and out | A shared contract |
| Confidential transfers | Amounts and balances | Sender and receiver | You, in a token account |
| Fresh wallet by hand | The same as stipl, once | Everything, as soon as you reuse it | You |
stipl and confidential transfers solve different halves of the problem, which is why combining them is the next step: fresh recipients and hidden amounts.
Questions
- Can stipl take my money?
- No. Spending needs s, which only exists in your tab. The server has your public keys, which let it compute nothing it could sign with.
- What if stipl goes offline?
- Your money stays in addresses only your keys control, and the notes that point to them are on chain. Recovering without stipl means rescanning Memo program history with your keys. A standalone recovery tool is planned, not built yet.
- Does the person paying me need stipl?
- They need a Solana wallet and your pay page, which does the maths in their browser. They do not create an account.
- Why SOL only?
- A one-time address can pay its own fee in SOL. Tokens like USDC need a token account and someone to pay the fee for an address that holds no SOL, which means a relayer. That is on the list.
- Which wallets work?
- Any Solana wallet that can sign messages, such as Phantom, Solflare or Backpack. The unlock step needs that message signature.
Ready to try it on devnet?