// fresh-wallet funding tracer

A fresh wallet remembers who funded it.

Mainnet live · checking… Status: Ticker (placeholder, no token exists):
// the working app

Trace a wallet's roots

Paste the "fresh" address you want to keep separate. Optionally list the wallets it must not be linked to. Originveil reads mainnet and follows the money backwards.

Trace settings

Each hop reads one address's signature history (newest → oldest) and its earliest transactions.

Waiting for an address.

What an observer learns

Filled in from the actual trace — not generic advice.

Run a trace to see what the funding trail gives away.

Funding trail

Heuristics from public mainnet data, not proof of ownership.

No trace yet.
// how it works

Digging, one hop at a time

  1. Walk back. getSignaturesForAddress pages backwards (1,000 per call, using before) until the start of the address's history — or until the depth you chose runs out.
  2. Read the oldest. Up to three of the earliest successful transactions are fetched with getTransaction (jsonParsed), oldest first, stopping as soon as funding is found.
  3. Find the funding. The first incoming SOL transfer (System transfer, transferWithSeed, or createAccount of a wallet), including transfers made inside other programs. If lamports arrived without a plain transfer (e.g. through a program), the balance change is used and the fee payer is shown as the likely funder — labelled as such.
  4. Follow the funder. Repeat for the funder, up to three hops. The trail stops at an address whose history is longer than the depth limit — usually an exchange, bridge, bot or service — because its true origin can't be reached within limits.
  5. Compare locally. Every address on the trail is checked, in this tab, against the wallets you listed. One getMultipleAccounts call shows each node's current balance and owner program.
Fund through a crowd.Funding from a high-traffic source (where your withdrawal is one of thousands) gives more cover than a direct send from your main — but that source itself knows who you are.
Don't round-trip.One transfer back to your main wallet links the two forever, no matter how clean the funding was.
Mind the amount and time.Withdrawing a unique amount and funding the new wallet with the same amount minutes later is a link of its own.
// privacy model

Who sees what

Kept private

  • Your list of "my other wallets": compared in your browser, never sent anywhere, gone when you close the tab
  • Which wallet you traced: the server relays allowlisted read calls and keeps no log of them; no account, no analytics
  • The result: computed in this page, never uploaded

Still visible

  • The trail itself — it's public. Anyone can run the same reads; this page just shows you first
  • The RPC operator (this proxy and the upstream mainnet RPC) sees your IP, the time, and which addresses' histories were requested — including each hop
  • Explorer links open a third-party site that sees what you click
  • Nothing here can unlink wallets that are already linked on-chain

Originveil helps you reduce linkability by showing it. It does not provide anonymity.

Known limitations — please read

  • "No link found" is not "unlinked". Originveil follows one path — the first funding — for at most three hops. Later deposits, token transfers, shared counterparties, timing and amounts can all link wallets. See the direct-contact check, and treat silence as "not found here", nothing more.
  • Depth limits. Addresses with more history than the depth you picked end the trail; their "earliest" transaction can't be reached. The page says so instead of guessing.
  • First funding only. If a wallet was first funded with a token or by a program (e.g. an exchange withdrawal through a program), the fee payer is shown as the likely funder and marked as an inference.
  • No identity labels. Originveil never names exchanges or people. "High-activity" only means many signatures.
  • Pruned history. Some RPC nodes don't serve very old transactions; a missing transaction is reported as unreadable, not invented.
  • Public RPC limits. Reads are throttled with retry on rate limits and may be slow. Results are heuristics from public data, not proof. Experimental and unaudited.