Search
Search for projects and tokens by name or address
Umbra CashUmbra Cash
About
A stealth-address payment protocol for an existing wallet: the user registers once, and anyone can pay them at a fresh address.
About
A stealth-address payment protocol for an existing wallet: the user registers once, and anyone can pay them at a fresh address.
Umbra Cash is a stealth-address protocol that lets anyone pay the user at a fresh address, so the payment does not identify them as its recipient. The user registers once, and payers find their keys in a public registry. Payer, amount and token stay public, and so does where the funds go next.
Users trust ScopeLift, which hosts the app, runs its indexer and relays token withdrawals. The contracts are immutable, and their owner can only set a fee on new payments. Leaving needs no one: ETH lands at the stealth address itself, and any account can relay a token withdrawal.
Flow
- Register. The app derives a spending and a viewing key from a wallet signature and publishes the public keys in the StealthKeyRegistry.
- Pay. The payer’s app derives a fresh stealth address from those keys and pays through the Umbra contract. ETH goes straight to the address, tokens wait in the contract. An event publishes the address with a secret only the viewing key decrypts.
- Scan. The recipient’s app fetches every payment since registration and decrypts each locally.
- Withdraw. ETH leaves in a plain transfer that pays its own gasA virtual fuel used to execute smart contracts on a rollup. The EVM (or other VM within the rollup) uses an accounting mechanism to correspond the consumption of gas to the consumption of computing resources, and to limit the consumption of computing resources.. Tokens leave through a relayer, which pays the gas for a fee against the recipient’s signature.
App
The app at app.umbra.cash is built from public source, while its indexer and relayer API are closed. It finds payments through the indexer, relays token withdrawals through the API and checks every address it handles with its mainnet RPC, Alchemy. The app warns before withdrawals to registered, named or otherwise known addresses. A local build can leave the indexer out and read the chain from the user’s own nodeA software client that participates in the network.. It still asks Cloudflare for the ENS name of the user’s wallet, and building it needs a WalletConnect project id and L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. subgraph URLs. The privacy policy keeps IP logs for up to 90 days.
Compliance
Screening runs in the app only. It refuses wallets, recipients and withdrawal addresses on its blocklist or Chainalysis’s sanctions oracle, and hides payments from or to listed addresses.
Fees
Each payment through the Umbra contract pays the owner’s ETH toll, 0 ETH today. Token withdrawals through the relayer pay its fee in the withdrawn token, and ETH withdrawals pay only gas.
What the protocol promises: Hides which registered recipient a stealth payment is for. The payer knows; sender, asset, amount and where the funds go next are public.
Ethereum is public by default. Each protocol is rated on its main privacy promise, like hiding who paid, who received, how much, or which deposit became which withdrawal. Against each adversary, the colour says whether it holds for a careful user with the app's own settings: green yes, yellow only with significant extra work, red no. Fields marked at risk stay private only under the condition in their note.
Each payment goes to a fresh stealth address, and only the recipient’s viewing key shows whose it is. The registry lists every recipient who could be behind it, with their key history.
Advice: Withdraw to a fresh address that is not registered and has no public link to the user.
Any of the 11,983 registered recipients could be behind a stealth address. Registrations are rare and public, so a payment that lands minutes after one points to that registrant. Several payments withdrawn to one address share a recipient.
Advice: Register long before anyone pays the user, and withdraw each payment to its own address. Exit through a relayer for tokens, so none of the user's wallets pay gas for the receiving address.
The hosted app checks the payee’s address with its Alchemy RPC seconds before each payment, so timing ties the payee to the payment. The same RPC gets the payee’s wallet on connect, the sender of every matched payment on each scan, and the withdrawal address. The wallet’s own RPC receives the wallet address together with the matched stealth addresses. On connect, the wallet library also sends the wallet address to Cloudflare’s RPC to look up its ENS name.
Advice: Pay and withdraw from a local build with all RPC URLs and the user's wallet pointed at their own node, and block cloudflare-eth.com.
The hosted app gives the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. the user’s wallet address on every scan and withdrawal address in the same session. Token withdrawals also hand its relayer the stealth address. The operator serves the app and can change it at any time. The contracts are immutable, and only the user holds their viewing key.
Advice: Run an inspected local build of the client instead of the hosted frontend. Leave its indexer URL empty, so it reads payments from the user's node.
Whoever breaks elliptic-curve cryptography matches every past payment to its registered recipient from chain data alone. The registry holds each recipient’s public keys, and each announcement the payer’s one-time key and the encrypted secret. Recovering the private keys decrypts the secret and confirms the stealth address.
30 day historic anonymity set
How many unique registrants you could have blended in with if you received a stealth address transfer on a particular day after registering keys during the previous 30 days. This metric is a proxy for the historic anonymity set and shows how it developed over time.
The metric looks backwards: it counts key registrations that already happened, and a registered address has not necessarily received any transfers. Your real anonymity also depends on registrations made after yours, which cannot be known in advance.
Estimated anonymity set by waiting time
An estimate of how many unique registrants you blend in with, depending on how long you wait between registering keys and receiving a stealth address transfer. It is based on historic data of past registrations: each point counts registrants from the preceding period, so waiting for up to 30 days effectively means blending in with everyone who registered during the last 30 days.
Asset | Deposits 7D | Deposits 30D | Deposits Total |
|---|---|---|---|
 DAI | 1 $12.00 K | 1 $12.00 K | 174 $816.10 K |
 ETH | 7 $20.28 | 296 $8.96 M | 23.74 K $118.68 M |
 USDC | 1 $6.99 | 13 $200.86 K | 717 $4.75 M |
 USDT | 9 $88.94 K | 40 $583.88 K | 686 $7.08 M |
 WBTC | 0 $0.00 | 0 $0.00 | 162 $11.22 M |
| Total | 18 $100.97 K | 350 $9.76 M | 25.48 K $142.56 M |
Funds can be lost if
- an unsupported ERC-20, such as a fee-on-transfer or rebasing token, causes the Umbra contract’s internal accounting to diverge from its token balance.
Use can be stopped if
- the Umbra owner raises the toll on payments through the contract, which has no cap.
Privacy can be lost if
- the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. links the user’s wallet to their stealth addresses, since the hosted app sends it both in one session (see privileged insider).
- Alchemy, the hosted app’s RPC, receives the payee’s address seconds before each payment, so timing ties the payee to it (see networkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. observer).
- elliptic-curve cryptography is broken, which matches every past payment to its registered recipient (see future adversary).
The Umbra and StealthKeyRegistry contracts are immutable. The Umbra owner sets the ETH toll on every payment through the contract and the addresses that collect it, instantly and without a cap. A high toll stops new payments. ScopeLift changes the hosted app, its indexer and its relayer at will.
2026 October 09, 07:23 UTC1changeAdded UmbraBatchSend, which the app uses for batch payments. Moved Umbra and StealthKeyRegistry from config overrides into templates, with no value changes.
Added UmbraBatchSend, which the app uses for batch payments. Moved Umbra and StealthKeyRegistry from config overrides into templates, with no value changes.
New and verified contracts
| + | Status: CREATED |
| contract UmbraBatchSend (eth:0xDbD0f5EBAdA6632Dde7d47713ea200a7C2ff91EB) [umbra/UmbraBatchSend] | |
| +++ description: Helper the app uses to send several stealth payments in one transaction. It pulls the tokens from the sender and calls the Umbra contract once per payment, so each payment emits its own Announcement. It holds no funds between transactions. | |
2026 August 17, 09:44 UTCHigh severity3changes7702 delegation.
7702 delegation.
| EOA (eth:0xb4435399AB53D6136C9AEEBb77a0120620b117F9) { | |
| +++ description: None | |
| proxyType: | |
| - | "EOA" |
| + | "EIP7702 EOA" |
| sourceHashes: | |
| + | ["0x1f44812af62d28f019e30e8eb2af596fb36c7db9d34576972c0405e110a6ef45"] |
| values: | |
| + | {"$implementation":"eth:0x63c0c19a282a1B52b07dD5a65b58948A07DAE32B","delegationManager":"eth:0xdb9B1e94B5b69Df7e401DDbedE43491141047dB3","DOMAIN_VERSION":"1","eip712Domain":{"fields":"0x0f","name":"EIP7702StatelessDeleGator","version":"1","chainId":1,"verifyingContract":"eth:0xb4435399AB53D6136C9AEEBb77a0120620b117F9","salt":"0x0000000000000000000000000000000000000000000000000000000000000000","extensions":[]},"entryPoint":"eth:0x0000000071727De22E5E9d8BAf0edAc6f37da032","getDeposit":0,"getDomainHash":"0x9962d46a78b1e6906da83f5bd75621a608112e6b851709d6504888d73d532e1c","getNonce":0,"NAME":"EIP7702StatelessDeleGator","PACKED_USER_OP_TYPEHASH":"0xbc37962d8bd1d319c95199bdfda6d3f92baa8903a61b32d5f4ec1f4b36a3bc18","VERSION":"1.3.0"} |
| } | |
2026 July 31, 11:57 UTC2changesInitial discovery of Umbra contracts
Initial discovery of Umbra contracts
Initial discovery
| + | Status: CREATED |
| contract StealthKeyRegistry (eth:0x31fe56609C65Cd0C510E7125f051D440424D38f3) [N/A] | |
| +++ description: Public registry that maps an Ethereum address to its two secp256k1 stealth public keys: a spending key used to derive a fresh stealth address, and a viewing key used to encrypt the transfer metadata for the recipient. | |
| + | Status: CREATED |
| contract Umbra (eth:0xFb2dc580Eed955B528407b4d36FfaFe3da685401) [N/A] | |
| +++ description: Main entry point of the Umbra protocol, routing all ETH and ERC-20 stealth payments. On send, it emits an Announcement event that the recipient scans to detect the payment. ETH is forwarded directly to a fresh stealth address, ERC-20s are escrowed in this smart contract. | |
Ethereum
Actors:
- Can interact with Umbra
- set an arbitrary ETH toll that must be paid on every transfer routed through the Umbra contract
- Can interact with UmbraBatchSend
- approve new tokens so that batch sends can route them to the Umbra contract
Ethereum
Public registry that maps an Ethereum address to its two secp256k1 stealth public keys: a spending key used to derive a fresh stealth address, and a viewing key used to encrypt the transfer metadata for the recipient.
Helper the app uses to send several stealth payments in one transaction. It pulls the tokens from the sender and calls the Umbra contract once per payment, so each payment emits its own Announcement. It holds no funds between transactions.
- Roles:
- owner: EOA 2
Main entry point of the Umbra protocol, routing all ETH and ERC-20 stealth payments. On send, it emits an Announcement event that the recipient scans to detect the payment. ETH is forwarded directly to a fresh stealth address, ERC-20s are escrowed in this smart contract.
- Roles:
- owner: EOA 1