Skip to content
stipldevnet

Technical walkthrough

Everything that happens between “someone opens your link” and “the money is in a wallet you choose”, with the exact maths and what each party can see.

Built onSolanaEd25519 · SHA-512 · Memo program

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.

Payment flowYou publish two public keys through stipl. The payer's browser derives a one-time address and pays it with a memo. Your browser scans every memo, recognises yours, and the one-time address signs its own withdrawal.Payer's browserstipl serverSolana (public)Your browsername, S, Vsigned with s, no walletpay page: S, Vpublic keys onlyR = rG, P = S + H(rV)Gr is random, never sentSOL to P + memo (R, tag)one plain transfertx signatureserver re-reads the memo on chainevery memo, unfilteredthe server cannot tell whose is whosetag ok → P = S + H(vR)Gonly v can do thisP signs its own withdrawalone transaction per address
The two lime arrows are the only transactions. Everything else is computed in a browser or passes through stipl as public data.

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)
ℓ is the order of the Ed25519 group, G its base point. Every hash carries its own label so outputs can never be confused.

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 address
r·V and v·R are the same point because r·(v·G) = v·(r·G). That is a Diffie-Hellman exchange with no round trip.

P 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)
Base58 of the 32-byte point R, then one hex byte.

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 yours
The one-byte tag rejects about 255 out of 256 foreign payments with a single hash, before the more expensive point maths.

Matching 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 ℓ)
The nonce k is derived from p and the message: the same message always gets the same nonce, and two different messages never share one.

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

ToolHidesStill visibleFunds held by
stiplWho receives, and that payments share a recipientSender, amounts, timingYou, address by address
Mixer / privacy poolThe link between deposit and withdrawalThat you used the pool, amounts in and outA shared contract
Confidential transfersAmounts and balancesSender and receiverYou, in a token account
Fresh wallet by handThe same as stipl, onceEverything, as soon as you reuse itYou

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?