Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 6 min read

One wallet, 108 launches in 9 hours: what a fee sweep actually proves

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 ca

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:

  1. 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.
  2. 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_seconds so 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.
  • high confidence 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:

  1. A cluster needs at least two mints. One creation says nothing, and printing it would make a control wallet look suspicious.
  2. funded edges are links, not proof. Exchanges and faucets fund thousands of unrelated wallets, so a cluster joined only by funding is graded low and dropped.
  3. 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.

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.