A wallet on Solana created 108 tokens in one 9-hour window and collected the creator fee on 88 of them. Every one of those 88 collections is a signed transaction. Not a heuristic, not a pattern match — a signature you can open in an explorer and read.
This is a write-up of one cluster from a public dataset, plus the two lines of reasoning that make it checkable by someone who does not trust the tool.
TL;DR:
- 117 mints link to a single wallet
- 108 have a creation inside the scanned window
- 88 have a creator-fee collection, each with its own signature
- All of it inside 8.9 hours
- Reproducible in a browser with no install: demo
The mistake almost every "dev wallet" list makes
pump.fun emits two events that look alike in a transaction log and mean completely different things:
| Event | Log line | What it means |
|---|---|---|
| creation | Instruction: Create / CreateV2 | this wallet paid for the transaction that created the mint |
| fee collection | SweepCreatorFee / CollectCreatorFee / CollectCreatorFeeV2 | this wallet is the creator and took its fee |
The second one is the interesting one.
Only a mint's creator can collect its creator fee. That is enforced by the program, not by convention. So a fee collection is not evidence about behaviour — it is proof of control, signed by the account that holds it.
Most of the "who is the dev" tooling I see counts creations and stops there. That has two problems:
- Creations under-count control. A creator who launched a mint before your scan window still controls it, and a sweep will say so when a creation cannot.
- Creations over-count activity. Any wallet can pay to create a mint. Paying is cheap. Collecting requires being the creator.
There is a third, subtler problem: attribution of Program log: lines. Those lines carry no program id, so if you count InitializeMint2 as a launch, you will report the token program's own instruction as a pump.fun creation. I hit this while writing the parser and the fix is to walk the invoke/success stack:
Program 6EF8…F6P invoke [1] stack: [pump] Program log: Instruction: Create -> pump ✓ Program Tokenkeg… invoke [2] stack: [pump, token] Program log: Instruction: InitializeMint2 -> token (not a launch) Without the stack walk, one launch becomes two.
The cluster
Seed wallet: 6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc
{ "cluster_id": "ce26f719c0cdc", "seed_wallet": "6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc", "wallets": ["6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc"], "mint_count": 117, "links": { "swept": 88, "created": 108 }, "confidence": "high", "first_block_time": 1795153520, "last_block_time": 1795185436, "window_seconds": 31916, "scanned_transactions": 250, "scan_limit": 250, "tool_version": "0.2.1" } 31,916 seconds is 8.9 hours. 250 transactions is the sample size — that is the whole scan. No archive node, no indexer, no API key.
Note the 117 versus 108: nine mints in the cluster appear only as fee collections, because their creation is older than the last 250 transactions of that wallet. That gap is the point made above — sweeps see control that creations miss. If you only counted creations, those nine mints would quietly drop out of the picture.
A later rescan of the same wallet (250 transactions again, a few hours later) produced 118 mints, 110 creations and 87 sweeps. The counts move with the window; the identity does not. That is why every record stores window_seconds and scanned_transactions next to the findings.
How fast the money comes back
For the 78 mints where both events fell inside the window, the gap from creation to first fee collection was:
| Statistic | Value |
|---|---|
| median | 8 minutes |
| 25th–75th percentile | 3 – 19 minutes |
| under one hour | 71 of 78 |
| slowest | 1.8 hours |
One of those mints, 8mnJZnxaNLqVwkaWWGH7dKmoEzyYzGJx5pHaCp7spump, was created at 1795171599 and its fee was collected at 1795173264 — 27.8 minutes later. A public alert account flagged that same mint on 20 November as "dev sold via side wallet".
I want to be precise about what that juxtaposition means. The cluster does not say who sold, or why, or whether the sale was the "side wallet". It says something narrower and more useful: there is one address behind 117 launches, and 88 signed fee collections prove control of them. If you are trying to work out what happened to a token, that is the first question, not the last.
What this does not tell you
Every number above is a fact about transactions. None of them is a fact about a person, and none of them is a fact about intent.
- It does not tell you who sold. A seller is a swap instruction from some token account; the cluster maps creation and control, not disposal.
- It does not tell you why. A creator can launch 108 tokens in nine hours and still be unremarkable; launchpads exist for exactly this.
- It does not cover the wallet's lifetime. 250 transactions is a sample. Older launches are invisible, and the dataset says
window_secondsso you can see how much history you are looking at. - It does not identify a human. No social account is asserted. The claim is about addresses.
-
highconfidence means control is proven, not that anything is wrong. Only a mint's creator can collect its fee; that is the entire content of the label.
The honest summary of a cluster is: these mints share an owner, and here are the signatures. Anything else is an inference, and should be labelled as one.
Reproduce it in about a minute
In a browser
https://tdkrhuang.github.io/solana-launch-forensics/demo/
Paste the wallet, press Scan. The page reads the last N transactions through a public RPC and draws one node per mint around the wallet. Blue means created only, green means swept only, purple means both. Click a mint and you get the two signatures, linked to Solscan.
No install, no API key, no wallet connection. The page is a static file; it talks to a public RPC and nothing else.
On the command line
pip install solana-launch-forensics launchforensics cluster 6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc --limit 250 You get the same edges, with a signature on each line. --json emits the whole structure if you want to diff it against the dataset.
Against the dataset
The record above is committed at datasets/clusters.jsonl, along with 110 others:
| Dataset | Value |
|---|---|
| clusters | 111 |
| mints | 2,872 |
| wallets | 230 |
| confidence | high 78 / medium 33 |
| largest cluster | 157 mints |
| median cluster | 16 mints |
Schema and grading rules are in datasets/SCHEMA.md. Three points from it are worth repeating:
- A cluster needs at least two mints. One creation says nothing, and printing it would make a control wallet look suspicious.
-
fundededges are links, not proof. Exchanges and faucets fund thousands of unrelated wallets, so a cluster joined only by funding is gradedlowand dropped. - Seeds come from a pool feed, not a trade log. Sampling pump.fun program activity yielded 3 creators from 2,000 transactions; the GeckoTerminal new-pools feed yielded 61 creators from 10 pages. The feed is the cheaper source.
Why this is worth publishing rather than selling
The analysis is cheap to run and the tool is MIT. What is not cheap is doing it carefully: reading instruction names instead of counting invocations, keeping the window visible, refusing to grade intent, and putting a signature on every line so a reader does not have to trust me.
If you need that for a specific wallet — creator, funding chain, where the SOL went, in a form you can hand to someone else — that is what I do for a living, and the sample report shows the format:
Corrections are welcome and useful. If a number here does not match what you see on chain, open an issue — the whole point of keeping the signatures is that the claim is checkable, including by me being wrong.