I spent a weekend tracing token launches on Solana, and the most useful thing I
learned was not about clustering wallets. It was that the logs are easy to read
in a way that produces the opposite of the truth.
Here is the transaction that taught me.
What the log looked like
A single transaction contained seven pump.fun instructions. Counting them gave
an obvious headline: seven tokens created in one transaction. That claim
circulated in a draft before I checked it properly.
It was wrong. Those seven instructions were SweepCreatorFee, not CreateV2.
The transaction swept the creator fees of seven existing tokens. Zero tokens
were created in it.
The difference matters because creator fees can only be collected by the token's
creator. So the correct claim is not weaker than the wrong one — it is stronger.
Seven tokens swept in one transaction means one wallet controls the creator-fee
rights of all seven. That is not a behavioural inference. It is the ownership
record itself.
Why the naive reading fails
Two traps, and they compound.
1. Inner instructions are nested.
A pump.fun CreateV2 calls Token-2022, which logs its own
Instruction: InitializeMint2. If you count InitializeMint2 occurrences you
report two creations per launch. If you count pump.fun instructions you miss
that the nested call happened at all.
The fix is to reconstruct the invoke / success stack from the program logs
and attribute every inner instruction to the program that actually invoked it.
Positional matching breaks as soon as calls nest more than one level deep.
2. Program log: lines carry no program id.
Solana's log stream interleaves messages from every program in the call chain.
A line reading Program log: Instruction: InitializeMint2 tells you that some
program emitted it. Without the invoke stack, you cannot say which.
What the correct output looks like
$ launchforensics tx <signature>
pump ops SweepCreatorFee x7, CollectCreatorFeeV2
creates 0
mints 7 referenced
Compare that with a real creation:
$ launchforensics scan <wallet> --limit 400
wallet ...
scanned 400 transactions
creations 27
window 39m 11s
Both are readable in a terminal, and every line carries the signature that
produced it.
The pattern that only shows up across transactions
One more thing worth checking, because a single-transaction view returns zero.
A splitter usually pays one destination per transaction. So if you want to know
whether payouts repeat an exact size, you have to look across signatures and
aggregate by counterparty and amount.
In one case that meant nine separate transactions, each paying exactly
486,609,148 lamports (0.486609148 SOL) to a different fresh wallet. Not
"about 0.48". The same lamport count, nine times.
Real traders sell in different sizes. Scripts round to one number.
The tool
I packaged this as solana-launch-forensics: a read-only CLI with no
dependencies outside the Python standard library, no API key, and no wallet
connection.
-
scan <wallet>— mints created, time window, density -
tx <signature>— instruction-level breakdown -
flows <wallet> --across-tx— repeated equal-size payouts
https://github.com/tdkrHuang/solana-launch-forensics
It is MIT licensed. It reports what the chain records and does not label intent;
repeated payouts and batched creations are patterns, not proof of wrongdoing.
The takeaway
If you are reading Solana transaction logs, the number that goes wrong most
often is the one you get by counting instructions. Attribute them first, then
count. The two operations produce very different numbers, and only one of them
survives review.
Top comments (0)