Sol TopUps vs. Sol Funding vs. Transfers — what is the difference?
A worked guide to SOL top-ups, native SOL funding and token transfers, with real transactions, queries and results.
Education · Solana wallets
Three families of tables answer the question "who paid this wallet?". They record different things. Pick the wrong one and your query runs fine but tells you the wrong story. This page shows what each table stores, with queries you can copy.
17 Nov 2026 · 12 min read · Beginner
The short version
- Top-ups.
sol_top_upsgets a row when a SOL balance goes from zero to above zero. Use it to find fresh wallets. - Fundings.
indexer3_sol_fundingsgets a row when one wallet loses SOL and another gains it, whatever the balances were before. Small amounts are left out. - Token transfers.
token_transfersgets a row when a token (USDC, wSOL, any mint) moves from one owner to another.
The same wallet, seen three ways
All three tables are built from successful transactions only. A failed transaction changes nothing, so it leaves no row.
The difference is easiest to see on one wallet over time. In the chart below the wallet is paid three times, trades once, and is emptied once. Only some of these events become rows.
- Top-up row + funding row
- Funding row only
- No row
Two servers, two history depths
The tables live on two servers. Tables without a prefix are on the main server and keep about one month. Tables that start with indexer3_ are on a second server and keep much more history. This query prints the current first day of each one:
SQLhistory_depth.sql
-- How far back each table goes today.
SELECT *
FROM
(
SELECT 'sol_top_ups' AS table_name, min(block_date_utc) AS first_day,
toTimeZone(max(block_time), 'UTC') AS last_row_utc
FROM sol_top_ups
UNION ALL
SELECT 'token_transfers', min(block_date_utc), toTimeZone(max(block_time), 'UTC')
FROM token_transfers
UNION ALL
SELECT 'indexer3_sol_top_ups', min(block_date_utc), toTimeZone(max(block_time), 'UTC')
FROM indexer3_sol_top_ups
UNION ALL
SELECT 'indexer3_sol_fundings', min(block_date_utc), toTimeZone(max(block_time), 'UTC')
FROM indexer3_sol_fundings
UNION ALL
SELECT 'indexer3_token_transfers', min(block_date_utc), toTimeZone(max(block_time), 'UTC')
FROM indexer3_token_transfers
)
ORDER BY first_day DESC, table_name
Result · 5 rows · this code ran on 2026-11-18 01:10 UTC
table_name | first_day | last_row_utc |
|---|---|---|
| sol_top_ups | 2026-10-18 | 2026-11-18 01:10:02 |
| token_transfers | 2026-10-18 | 2026-11-18 01:10:02 |
| indexer3_sol_top_ups | 2026-08-20 | 2026-11-18 01:10:05 |
| indexer3_sol_fundings | 2026-08-01 | 2026-11-18 01:10:05 |
| indexer3_token_transfers | 2026-08-01 | 2026-11-18 01:10:05 |
You query all of them through the same connection. Two things are different for the indexer3_ tables:
- Joins are slower. The data has to travel between servers. Filter the
indexer3_table by wallet, slot or date first, then join. - Use
GLOBAL INfor subqueries. If you filter anindexer3_table with a list that comes from a main-server table, writeGLOBAL IN (SELECT ...). A plainINis sent to the second server as it is, and that server does not have the main tables. Keep that list simple: build it with a join, not with another subquery inside it. A nested subquery there can silently return nothing.
About times
block_time is shown in the time zone of the main server, which is US Pacific time, not UTC. The examples on this page wrap it in toTimeZone(block_time, 'UTC') so every time you see here is UTC.
| Top-ups | Fundings | Token transfers | |
|---|---|---|---|
| A row means | A SOL balance went from 0 to above 0 | One wallet lost SOL and another gained SOL in the same transaction | A token moved from one owner to another |
| Smallest amount | Any | More than 0.09 SOL, on both sides | Any |
| Sender column | Each signer of the transaction | Each wallet that lost SOL | Owner of the source token account |
| Signature | Yes | No. Use slot and tx_idx | Yes in token_transfers, no in indexer3_token_transfers |
| Kept for | 31 days. 180 days in indexer3_sol_top_ups | No expiry so far | 31 days. No expiry so far in indexer3_token_transfers |
| Program accounts | Included as receivers | Left out | In token_transfers only |
Top-ups: from zero to above zero
sol_top_ups has one simple rule. After every successful transaction we compare each account's SOL balance before and after. If it was exactly zero before and is above zero after, we write a row. Token accounts are skipped.
Here is a good transaction to learn from. One wallet pays five others with five plain transfers: open it on Solscan and look at the balance changes.
SQLtop_ups_one_tx.sql
-- One transaction that pays five wallets with five System Program transfers.
-- sol_top_ups keeps only the wallets whose balance was zero before.
SELECT
dst_wallet,
amount,
src_wallet,
JSONLength(top_level_transfers_json) AS transfers_in_tx,
signature
FROM sol_top_ups
WHERE block_date_utc = '2026-11-17'
AND signature = 'KfjE2rhYq66UuMjZhbgwB7rxXkwnbfH8dvPmNY1dxjv3Ngw2bgC4mHrLXdeX6BBoz82mcQtK9NyeXWKLwPRmACb'
Result · 3 rows · this code ran on 2026-11-18 01:10 UTC
dst_wallet | amount | src_wallet | transfers_in_tx | signature |
|---|---|---|---|---|
CfmG…699S | 3,500,000 | 2BJb…mzWj | 5 | KfjE2r…mACb |
6oK1…Xs4d | 3,500,000 | 2BJb…mzWj | 5 | KfjE2r…mACb |
GX2L…NUAE | 3,500,000 | 2BJb…mzWj | 5 | KfjE2r…mACb |
Five transfers, but only three rows. The three wallets in the result had a zero balance before the transaction. The other two receivers, Asgard3A…6Bh6 and 71DDZTmG…1vKu, already held SOL, so for this table nothing happened to them.
Three details matter when you read these rows:
amountis the balance after the transaction. Because the balance before was zero, this is also what the wallet received.src_walletis a signer of the transaction. It is the wallet that signed, which is usually the wallet that paid, but not always. A transaction with two signers gives two rows for the same receiver.dst_walletis any account that came to life. Most are wallets. Some are accounts created by programs, such as a Pump.fun bonding curve or a stake account. Join with your own list of wallets when you need wallets only.
A wallet can be topped up many times
The name suggests a top-up happens once. It does not. Every time a wallet is drained to zero and paid again, it gets a new row. The wallet below collects profits for an arbitrage bot. Its owner empties it after each payout, so each payout starts from zero again:
SQLtop_ups_many_times.sql
-- A top-up is not a once-in-a-lifetime event. This wallet is emptied and
-- refilled all day, and every refill from zero is a new row.
SELECT
toTimeZone(block_time, 'UTC') AS block_time_utc,
amount / 1e9 AS sol,
src_wallet,
signature
FROM sol_top_ups
WHERE block_date_utc = '2026-11-17'
AND dst_wallet = '6gnVbP38GXVgseLGRTN52rhzfHsyfKzzSK1Z5SuykuQZ'
ORDER BY slot, tx_idx
Result · 7 rows · this code ran on 2026-11-18 01:10 UTC
block_time_utc | sol | src_wallet | signature |
|---|---|---|---|
| 2026-11-17 16:13:25 | 0.5394 | 3WWd…aTLZ | 5wBzYL…G2kY |
| 2026-11-17 16:52:13 | 3.4674 | 3zMJ…y6vi | 21uCJU…Q9cZ |
| 2026-11-17 16:52:13 | 3.4674 | EbsU…KnE7 | 21uCJU…Q9cZ |
| 2026-11-17 23:18:47 | 0.1861 | 3WWd…aTLZ | 2vrtWc…JqJK |
| 2026-11-17 23:25:25 | 0.211 | 3WWd…aTLZ | 5drtNH…bhsb |
| 2026-11-17 23:28:58 | 0.1981 | 3WWd…aTLZ | 4GwYi7…vR8G |
| 2026-11-17 23:34:12 | 0.1983 | 3WWd…aTLZ | 3ovXx2…CAVj |
Two of the rows share a time and an amount but show different senders. That is one transaction with two signers.
If you want the first top-up of a wallet, take the earliest row. Keep the 31-day window in mind: a wallet that was first paid two months ago has its first top-up in indexer3_sol_top_ups, not here.
What top-ups are good for: fresh wallets
A wallet that was empty a few minutes before it does something important is a fresh wallet. Fresh wallets are how people hide who they are. So "when was this wallet last filled from zero?" is a strong signal, and sol_top_ups answers it with one lookup.
The query below takes the last 1,000 Pump.fun launches that trade against SOL. For each launch it finds two numbers: how long before the launch the creator's wallet was topped up, and how many different wallets bought in the first minute. Then it counts launches in each combination.
SQLcreator_top_up_heatmap.sql
-- Last 1,000 Pump.fun launches quoted in SOL.
-- x: how long before the launch the creator wallet was last topped up from zero.
-- y: how many different wallets bought in the first minute.
WITH
launches AS
(
SELECT
trim(BOTH '\0' FROM toString(mint)) AS mint,
trim(BOTH '\0' FROM toString(creator)) AS creator,
block_time AS launched_at
FROM pumpfun_token_creation
WHERE quote_coin = '11111111111111111111111111111111' -- SOL
AND block_time < now() - INTERVAL 2 MINUTE
ORDER BY slot DESC, tx_idx DESC
LIMIT 1000
),
top_ups AS
(
SELECT dst_wallet, block_time
FROM sol_top_ups
WHERE dst_wallet IN (SELECT creator FROM launches)
),
buys AS
(
SELECT base_coin, signing_wallet, block_time
FROM pumpfun_v2_swaps
WHERE block_date_utc >= (SELECT toDate(min(launched_at)) FROM launches)
AND failed = 0
AND direction = 'buy'
AND base_coin IN (SELECT mint FROM launches)
),
per_launch AS
(
SELECT
l.mint AS mint,
dateDiff(
'second',
maxIf(t.block_time, t.block_time <= l.launched_at),
any(l.launched_at)
) AS top_up_age,
uniqExactIf(
b.signing_wallet,
b.block_time < l.launched_at + INTERVAL 1 MINUTE
) AS buyers
FROM launches AS l
LEFT JOIN top_ups AS t ON t.dst_wallet = l.creator
LEFT JOIN buys AS b ON b.base_coin = l.mint
GROUP BY l.mint
)
SELECT
-- no top-up found means the last one is older than the table (31 days)
multiIf(top_up_age < 60, 1, top_up_age < 600, 2, top_up_age < 3600, 3,
top_up_age < 21600, 4, top_up_age < 86400, 5,
top_up_age < 31 * 86400, 6, 7) AS age_bucket,
['<1 min', '1-10 min', '10-60 min', '1-6 h', '6-24 h', '1-31 d', 'older'][age_bucket]
AS topped_up_before_launch,
multiIf(buyers <= 1, 1, buyers <= 3, 2, buyers <= 7, 3,
buyers <= 15, 4, buyers <= 31, 5, 6) AS buyers_bucket,
['0-1', '2-3', '4-7', '8-15', '16-31', '32+'][buyers_bucket]
AS buyers_in_first_minute,
count() AS launches
FROM per_launch
GROUP BY age_bucket, buyers_bucket
ORDER BY age_bucket, buyers_bucket
Result · 42 rows · this code ran on 2026-11-18 01:10 UTC
Read it from left to right. The left columns are creators whose wallet was filled from zero minutes before the launch. The right column, "older", holds creators with no top-up in the table at all: their wallet has not been empty for at least a month. Each column then shows how much attention those launches got in their first minute.
Fundings: every balance change above the dust line
indexer3_sol_fundings looks at the same balances but asks a wider question. It does not care if the receiver was empty. For each successful transaction it collects the wallets that lost SOL and the wallets that gained SOL, and writes a row for each sender and receiver pair. src_decrease is what the sender lost, dst_increase is what the receiver gained, and src_pre_balance and dst_pre_balance are the balances before.
Let us look at the slot that holds the five-transfer transaction from above. It was transaction 292 in slot 470716085.
SQLfundings_one_slot.sql
-- Every funding row of the slot that holds the transaction above (tx_idx 292).
SELECT
tx_idx,
src_wallet,
dst_wallet,
src_decrease,
dst_increase,
src_pre_balance,
dst_pre_balance
FROM indexer3_sol_fundings
WHERE slot = 470716085
ORDER BY tx_idx
Result · 1 row · this code ran on 2026-11-18 01:10 UTC
tx_idx | src_wallet | dst_wallet | src_decrease | dst_increase | src_pre_balance | dst_pre_balance |
|---|---|---|---|---|---|---|
| 0 | FEvc…MBfd | HWzn…DYmk | 817,900,000 | 817,889,961 | 827,900,000 | 23,009,089,925,144 |
Transaction 292 is not there. It paid 0.0035 SOL to each wallet, and that is too small.
Fundings do not record dust
A wallet counts only if its SOL balance changed by more than 0.09 SOL (90,000,000 lamports) inside one transaction. A change of exactly 0.09 SOL or less is ignored, whether it goes up or down.
The full rule, applied to every successful transaction:
- Take each account whose SOL balance changed by more than 0.09 SOL.
- Drop token accounts and addresses that are not ordinary wallets (addresses derived by programs).
- If at least one wallet is left that lost SOL and at least one that gained SOL, write a row for every pair. Otherwise write nothing.
What this means in practice:
- a 0.05 SOL payment never appears;
- a wallet that pays 0.05 SOL to each of ten wallets loses 0.5 SOL, but no receiver passes the line, so there is no row at all;
- transaction fees, tips and rent for new accounts are almost always below the line and leave no rows.
If you need small payments into empty wallets, use sol_top_ups. It has no minimum.
You can see the line in the data itself:
SQLdust_line.sql
-- The smallest balance changes recorded yesterday.
-- Both sit just above the line of 90,000,000 lamports.
SELECT
min(src_decrease) AS smallest_loss,
min(dst_increase) AS smallest_gain,
count() AS funding_rows
FROM indexer3_sol_fundings
WHERE block_date_utc = today() - 1
Result · 1 row · this code ran on 2026-11-18 01:10 UTC
smallest_loss | smallest_gain | funding_rows |
|---|---|---|
| 90,002,858 | 90,000,001 | 2,609,250 |
The table also has no signature column. A transaction is identified by slot and tx_idx. When you need the signature, join a table that has it on those two columns. A trading table works well, as the next example shows.
We record what happened, not how it was done
This is the most important thing to understand about top-ups and fundings. We do not look for "transfer" instructions. We compare balances before and after. If a wallet ends a transaction with more SOL, we see it, no matter which program moved the SOL or how many steps it took.
Here is a transaction where 9.65 SOL goes from one wallet to another and no instruction transfers SOL between them:
SQLhidden_transfer.sql
-- 9.65 SOL moves from one wallet to another, yet no instruction says
-- "transfer SOL to that wallet". The only top-level transfer goes elsewhere.
SELECT
src_wallet,
dst_wallet,
src_decrease / 1e9 AS sol_lost,
dst_increase / 1e9 AS sol_gained,
JSONExtractString(top_level_transfers_json, 1, 'to') AS only_transfer_goes_to
FROM indexer3_sol_fundings
WHERE slot = 470716000
AND tx_idx = 241
Result · 1 row · this code ran on 2026-11-18 01:10 UTC
The only top-level SOL transfer in that transaction goes to a third address. That address is the sender's own wrapped SOL account. So how did the SOL reach the receiver? The PumpSwap table shows it:
SQLhidden_transfer_swaps.sql
-- The same transaction in the PumpSwap table. Slot and tx_idx identify it,
-- and this table has the signature. In this pool wSOL is the base token.
SELECT
signing_wallet,
if(direction = 'S', 'pays SOL into the pool', 'takes SOL out of the pool') AS what_it_does,
base_token_amount / 1e9 AS sol,
signature
FROM pumpswap_all_swaps
WHERE slot = 470716000
AND tx_idx = 241
AND base_token = 'So11111111111111111111111111111111111111112'
ORDER BY direction DESC
Result · 2 rows · this code ran on 2026-11-18 01:10 UTC
signing_wallet | what_it_does | sol | signature |
|---|---|---|---|
BiEH…py1r | pays SOL into the pool | 9.6782 | 4oGMUQ…c3Ec |
CV4g…ZPR9 | takes SOL out of the pool | 9.65 | 4oGMUQ…c3Ec |
The first wallet buys a token from a PumpSwap pool. In the same transaction the second wallet sells the same token to the same pool. SOL goes in from one side and comes out on the other. Both wallets sign. An explorer shows two swaps. The funding table shows what it really was: about 9.65 SOL moved from wallet A to wallet B, and the pool kept the fees. See the transaction on Solscan.
The same idea covers wrapped SOL. Closing a wSOL account pays its SOL to a wallet. That is how the receiver above got paid, and it is recorded like any other payment.
The other side of this
Because we only see results, we cannot tell you which instruction moved the SOL. When that matters, take the slot and transaction index and open the transaction.
Many senders, many receivers
Balances tell us who lost SOL and who gained SOL. They do not tell us who paid whom. With one sender and one receiver that is not a problem. With several of each, we cannot split the amounts, so we do not try. We write one row for every sender and receiver pair. Each row carries the full loss of its sender and the full gain of its receiver. n_src and n_dst say how many senders and receivers the transaction had.
SQLmany_to_many.sql
-- One transaction where three wallets lost SOL and two gained it.
-- The table pairs every sender with every receiver: 3 x 2 = 6 rows.
SELECT
src_wallet,
dst_wallet,
src_decrease,
dst_increase,
n_src,
n_dst
FROM indexer3_sol_fundings
WHERE slot = 470678384
AND tx_idx = 709
ORDER BY dst_wallet, src_wallet
Result · 6 rows · this code ran on 2026-11-18 01:10 UTC
src_wallet | dst_wallet | src_decrease | dst_increase | n_src | n_dst |
|---|---|---|---|---|---|
3DBD…GAiA | 9LGq…zaqQ | 1,157,831,911 | 1,003,462,243 | 3 | 2 |
6dwo…rmFR | 9LGq…zaqQ | 1,003,482,062 | 1,003,462,243 | 3 | 2 |
Ft8d…mtaa | 9LGq…zaqQ | 1,597,976,808 | 1,003,462,243 | 3 | 2 |
3DBD…GAiA | wYKb…sano | 1,157,831,911 | 1,026,864,789 | 3 | 2 |
6dwo…rmFR | wYKb…sano | 1,003,482,062 | 1,026,864,789 | 3 | 2 |
Ft8d…mtaa | wYKb…sano | 1,597,976,808 | 1,026,864,789 | 3 | 2 |
Three senders and two receivers give six rows. Look at the amounts: the first receiver gained about 1.00 SOL, and that same number is repeated on all three of its rows.
This example is on purpose a hard one. The transaction merges eight pairs of stake accounts, and each merge moves SOL only inside its own pair. Five of those sixteen accounts have ordinary wallet-style addresses, so we see them: three that lost SOL and two that gained it. Their real partners are program addresses, which this table leaves out. So in this transaction none of the six rows is a real payment. Check it on Solscan.
Two rules keep you safe:
- For exact pairs, add
n_src = 1 AND n_dst = 1. Then each row is one sender, one receiver, and the amounts are real. - Never sum
dst_increaseover rows withn_srcabove 1. The same gain is repeated once per sender.
Three things you can do with these tables
1. Find wallets filled by the same tool
Someone who launches many tokens often funds each creator wallet from a different source, so the wallets look unrelated. But the funding transactions are usually built by the same script. The script leaves marks: the same compute-unit limit, the same priority fee, the compute-budget instructions at the same positions.
This query takes wallets that created a Pump.fun token in the last 24 hours. It groups their top-ups by those settings, by hour, and by amount (each group holds amounts within 5% of each other). It keeps groups where every wallet was paid by a different sender.
SQLsame_builder_top_ups.sql
-- Pump.fun creators of the last 24 hours whose wallets were topped up
-- by different senders, yet with the same transaction settings, amounts
-- within 5% of each other, and inside the same hour.
WITH
creators AS
(
SELECT DISTINCT trim(BOTH '\0' FROM toString(creator)) AS wallet
FROM pumpfun_token_creation
WHERE block_time >= now() - INTERVAL 1 DAY
)
SELECT
toTimeZone(toStartOfHour(block_time), 'UTC') AS hour_utc,
provided_gas_limit,
provided_gas_fee,
cu_limit_ix_index,
cu_price_ix_index,
round(min(amount) / 1e9, 4) AS min_sol,
round(max(amount) / 1e9, 4) AS max_sol,
uniqExact(dst_wallet) AS creators,
uniqExact(src_wallet) AS senders,
groupUniqArray(3)(dst_wallet) AS sample_creators
FROM sol_top_ups
WHERE block_date_utc >= today() - 1
AND num_signatures = 1
AND provided_gas_limit > 0
AND dst_wallet IN (SELECT wallet FROM creators)
GROUP BY
hour_utc,
provided_gas_limit,
provided_gas_fee,
cu_limit_ix_index,
cu_price_ix_index,
floor(log(amount) / log(1.05)) -- one bucket = amounts within 5%
HAVING creators >= 4 AND senders = creators
ORDER BY creators DESC
LIMIT 10
Result · 10 rows · this code ran on 2026-11-18 01:12 UTC
hour_utc | provided_gas_limit | provided_gas_fee | cu_limit_ix_index | cu_price_ix_index | min_sol | max_sol | creators | senders | sample_creators |
|---|---|---|---|---|---|---|---|---|---|
| 2026-11-17 11:00:00 | 1,450 | 0 | 0 | -1 | 0.1766 | 0.1776 | 9 | 9 | 35e3…uzZG, 8scr…zwt5, EJWt…kz38 |
| 2026-11-17 01:00:00 | 50,000 | 200,000 | 0 | 1 | 0.5 | 0.5001 | 9 | 9 | 5pti…Mokf, 6qVH…sCTD, DF1b…BWUj |
| 2026-11-17 04:00:00 | 1,450 | 20,000 | 0 | 1 | 65.5537 | 66.7569 | 9 | 9 | GUqZ…AUyM, Feee…iKrT, 8yXX…QyCU |
| 2026-11-17 08:00:00 | 50,000 | 200,000 | 0 | 1 | 0.5 | 0.5001 | 8 | 8 | 6swS…GqXu, Aqkr…XchF, 2sQh…PLpd |
| 2026-11-18 00:00:00 | 50,000 | 200,000 | 0 | 1 | 0.5 | 0.5001 | 8 | 8 | HJgr…JCKn, 7JoD…LvoK, B4ge…RRKZ |
| 2026-11-17 02:00:00 | 1,450 | 0 | 0 | -1 | 0.113 | 0.118 | 7 | 7 | 35e3…uzZG, ADtJ…ueP1, HH2t…qDWZ |
| 2026-11-17 13:00:00 | 1,450 | 20,000 | 0 | 1 | 74.5178 | 75.972 | 6 | 6 | Baoa…wsHQ, 4gVW…SpiL, 4Hrg…ahHq |
| 2026-11-17 15:00:00 | 1,450 | 20,000 | 0 | 1 | 79.0057 | 80.0851 | 6 | 6 | 13dB…QEj2, 8MPY…Hryc, FWbn…Q992 |
| 2026-11-17 19:00:00 | 200,000 | 0 | -1 | -1 | 0.0069 | 0.0069 | 5 | 5 | 3kHx…45vh, 6D4b…fBwA, 95d2…9urn |
| 2026-11-17 21:00:00 | 562 | 133,333,334 | 1 | 0 | 2.5594 | 2.6725 | 5 | 5 | Hp5f…Zitw, 99DY…Ha1f, Azhh…XQcH |
Each row is a cluster: several creator wallets, each paid by a different sender, in the same hour, with nearly the same amount and identical transaction settings. Common settings from popular wallet apps will also show up, so treat a cluster as a lead and check a few of its wallets by hand.
2. Follow a pipe of pass-through wallets
To hide where money comes from, people send it through a chain of new wallets. Each wallet receives SOL and passes all of it to the next. In the funding table such a hop has a clear shape:
dst_pre_balance = 0: the receiver was empty;- the sender kept almost nothing:
src_pre_balance - src_decreaseis close to zero; n_src = 1 AND n_dst = 1: one sender, one receiver.
This script starts at the creator of a Pump.fun token and walks backwards, one hop at a time, until the shape breaks or it has made 12 hops. The connection code is in a small helper file, so the script shows only the logic.
Pythonfunding_pipe.py
"""Walk SOL backwards from a Pump.fun creator through pass-through wallets."""
from ocd import query, show
CREATOR = "2x7XsuzUzWPsTHeoUgEtSbFXNVcKiPTu3mfqX4Kqx3sZ" # launched a token on 2026-11-18
# One hop back: who filled this wallet when it was empty,
# and sent nearly everything they had?
HOP = """
SELECT
slot,
toTimeZone(block_time, 'UTC') AS block_time_utc,
src_wallet,
dst_wallet,
dst_increase / 1e9 AS sol
FROM indexer3_sol_fundings
WHERE dst_wallet = %(wallet)s
AND slot < %(before_slot)s
AND dst_pre_balance = 0 -- receiver was empty
AND src_pre_balance - src_decrease < 3000000 -- sender kept under 0.003 SOL
AND n_src = 1 AND n_dst = 1 -- one sender, one receiver
ORDER BY slot DESC
LIMIT 1
"""
wallet, before_slot, hops = CREATOR, 470_740_000, []
while len(hops) < 12:
rows = query(HOP, {"wallet": wallet, "before_slot": before_slot})
if not rows:
break
hops.append({"hop": len(hops) + 1, **rows[0]})
wallet, before_slot = rows[0]["src_wallet"], rows[0]["slot"]
show(hops)
Result · 12 rows · this code ran on 2026-11-18 01:10 UTC
5i7v…PtbRearliest wallet reached- 13.125 SOL11-17 23:57 UTC
3aA2…Dm8Cempty before, passes it all on - 13.125 SOL11-17 23:57 UTC
BQYX…L6Ykempty before, passes it all on - 13.125 SOL11-17 23:59 UTC
CuWu…SvmJempty before, passes it all on - 13.124 SOL11-17 23:59 UTC
6Me3…zMvPempty before, passes it all on - 17.321 SOL11-18 00:02 UTC
7RCz…A6AUempty before, passes it all on - 17.321 SOL11-18 00:02 UTC
2qGH…tcYvempty before, passes it all on - 21.225 SOL11-18 00:04 UTC
AYS8…KRYUempty before, passes it all on - 21.225 SOL11-18 00:04 UTC
ChZT…PvfYempty before, passes it all on - 13.873 SOL11-18 00:26 UTC
H2Du…XEKvempty before, passes it all on - 13.873 SOL11-18 00:26 UTC
B94a…wVQKempty before, passes it all on - 13.873 SOL11-18 00:27 UTC
CgWB…6eowempty before, passes it all on - 13.873 SOL11-18 00:27 UTC
2x7X…x3sZthe token creator
hop | slot | block_time_utc | src_wallet | dst_wallet | sol |
|---|---|---|---|---|---|
| 1 | 470734043 | 2026-11-18 00:27:08 | CgWB…6eow | 2x7X…x3sZ | 13.8733 |
| 2 | 470734037 | 2026-11-18 00:27:06 | B94a…wVQK | CgWB…6eow | 13.8734 |
| 3 | 470733953 | 2026-11-18 00:26:48 | H2Du…XEKv | B94a…wVQK | 13.8734 |
| 4 | 470733946 | 2026-11-18 00:26:46 | ChZT…PvfY | H2Du…XEKv | 13.8734 |
| 5 | 470727696 | 2026-11-18 00:04:20 | AYS8…KRYU | ChZT…PvfY | 21.2254 |
| 6 | 470727687 | 2026-11-18 00:04:18 | 2qGH…tcYv | AYS8…KRYU | 21.2254 |
| 7 | 470727227 | 2026-11-18 00:02:38 | 7RCz…A6AU | 2qGH…tcYv | 17.3208 |
| 8 | 470727220 | 2026-11-18 00:02:37 | 6Me3…zMvP | 7RCz…A6AU | 17.3208 |
| 9 | 470726298 | 2026-11-17 23:59:20 | CuWu…SvmJ | 6Me3…zMvP | 13.1245 |
| 10 | 470726290 | 2026-11-17 23:59:18 | BQYX…L6Yk | CuWu…SvmJ | 13.1245 |
| 11 | 470725760 | 2026-11-17 23:57:24 | 3aA2…Dm8C | BQYX…L6Yk | 13.1245 |
| 12 | 470725752 | 2026-11-17 23:57:23 | 5i7v…PtbR | 3aA2…Dm8C | 13.1245 |
Each hop loses a few thousand lamports, which is the transaction fee. Where the amount jumps between two hops, that wallet did something else before passing the SOL on. In this chain those wallets launched Pump.fun tokens of their own, so this is one operator moving the same money from launch to launch. If the walk ends before 12 hops, it has reached a wallet that does not fit the shape: one that already held SOL, kept some, or was paid with less than 0.09 SOL. That wallet is where you start looking by hand.
3. Find the sink that early buyers pay into
When one person controls the first buyers of a token, the profits have to come together somewhere. This query takes tokens launched in the last day and the wallets behind their first 10 trades. Then it looks for a wallet that receives SOL from early traders of more than one launch.
SQLcommon_sink.sql
-- Wallets that collect SOL from the early traders of several launches.
-- "Early" = behind one of the first 10 trades of a token launched in the last day.
WITH
launches AS
(
SELECT trim(BOTH '\0' FROM toString(mint)) AS mint
FROM pumpfun_token_creation
WHERE block_time >= now() - INTERVAL 1 DAY
),
early AS
(
SELECT s.base_coin AS mint, s.signing_wallet AS wallet, s.block_time AS traded_at
FROM pumpfun_v2_swaps AS s
INNER JOIN launches AS l ON l.mint = s.base_coin
WHERE s.block_date_utc >= today() - 1
AND s.failed = 0
ORDER BY s.slot, s.tx_idx, s.ix_idx
LIMIT 10 BY mint
),
payouts AS
(
SELECT src_wallet, dst_wallet, block_time, dst_increase
FROM indexer3_sol_fundings
WHERE block_date_utc >= today() - 1
AND n_src = 1 AND n_dst = 1
AND src_wallet GLOBAL IN (SELECT wallet FROM early)
)
SELECT
p.dst_wallet AS sink,
uniqExact(e.mint) AS launches,
uniqExact(e.wallet) AS early_wallets,
round(sum(p.dst_increase) / 1e9, 1) AS sol_received,
groupUniqArray(2)(e.mint) AS sample_tokens
FROM early AS e
INNER JOIN payouts AS p ON p.src_wallet = e.wallet
WHERE p.block_time >= e.traded_at
AND p.dst_wallet NOT IN (SELECT wallet FROM early)
GROUP BY sink
HAVING launches >= 3 AND early_wallets >= 5
ORDER BY early_wallets DESC
LIMIT 10
Result · 10 rows · this code ran on 2026-11-18 01:11 UTC
sink | launches | early_wallets | sol_received | sample_tokens |
|---|---|---|---|---|
GPcP…ECkm | 150 | 146 | 667.3 | GyLe…pump, 8vhy…pump |
2abw…TJVn | 49 | 142 | 3,653.8 | E9QZ…pump, CyZB…pump |
GAiN…LmVZ | 127 | 127 | 383.3 | DnCk…pump, 2a3k…pump |
Fz2U…LWec | 15 | 100 | 222.2 | AqYq…pump, F2Fc…pump |
HS23…jnWF | 10 | 89 | 71.1 | 9YqP…pump, Hz3s…pump |
Cfh3…9i77 | 82 | 80 | 67.9 | 85M6…5qAw, A7ov…RWz6 |
EYXK…1Qcs | 30 | 79 | 1,180.5 | 8MHD…pump, FfaR…pump |
D3Je…Lfaz | 10 | 68 | 515.4 | B2La…pump, 4HEc…pump |
7RVA…co5q | 64 | 64 | 789.6 | 9kTB…pump, BnpL…pump |
C2fv…fhjR | 8 | 64 | 102.6 | Fbc7…pump, HRky…pump |
A wallet at the top of this list collects SOL from the first buyers of several launches. Some of them are exchange deposit addresses or trading-bot fee wallets, so open a few before you draw conclusions. Note the GLOBAL IN: the list of early wallets comes from the main server, and the funding table lives on the second one.
Token transfers
Token transfers are the simplest of the three. A row means a token moved from one owner to another. The columns are mint, src_wallet, dst_wallet and amount. The wallets are the owners of the token accounts, not the token accounts themselves. amount is in the token's smallest unit.
SQLtoken_transfers_recent.sql
-- The five largest USDC transfers of the last hour.
SELECT
toTimeZone(block_time, 'UTC') AS block_time_utc,
src_wallet,
dst_wallet,
amount / 1e6 AS usdc,
flavour,
signature
FROM token_transfers
WHERE block_date_utc >= today() - 1
AND block_time >= now() - INTERVAL 1 HOUR
AND mint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' -- USDC
AND src_wallet != dst_wallet
ORDER BY amount DESC
LIMIT 5
Result · 5 rows · this code ran on 2026-11-18 01:11 UTC
block_time_utc | src_wallet | dst_wallet | usdc | flavour | signature |
|---|---|---|---|---|---|
| 2026-11-18 00:34:52 | Bc5b…nXHf | 81w9…ytUj | 31,548,281.3145 | 1 | 6785SK…K8iz |
| 2026-11-18 00:15:23 | 5g7y…aBWs | EWWf…39Us | 6,666,680.006 | 1 | rKFUPh…g2iu |
| 2026-11-18 00:15:22 | 5g7y…aBWs | EWWf…39Us | 6,666,660.006 | 1 | 4BwqLs…9n56 |
| 2026-11-18 00:15:22 | 5g7y…aBWs | 3NZu…5hhJ | 6,666,660.006 | 1 | 3qe6GE…rKgt |
| 2026-11-18 00:15:23 | 5g7y…aBWs | EWWf…39Us | 6,666,660.006 | 1 | uVpwN5…ghfK |
There are two tables, and they differ in more than history:
token_transferskeeps 31 days and has the signature. It records transfers written directly in the transaction. Transfers that a program makes on your behalf are not in it. A swap, for example, is not a row here.indexer3_token_transfershas the long history and also records transfers made inside programs. It addssrc_pre_amountanddst_pre_amount, the token balances before the transfer. It keeps a transfer only when both owners are ordinary wallets. It has no signature, so useslotandtx_idx.
Both tables cover the classic Token program and Token-2022, including mints that use extensions such as transfer fees. The flavour column tells you how the transfer was made: 0 is a plain transfer, 1 a checked transfer, 2 a transfer with a fee, 3 a change of the token account's owner. Add 16 for Token-2022. We index more of the token programs than most people expect, and we will keep the finer details to ourselves for now.
A few things are not token transfers and are not here: minting, burning, and closing a token account.
What about wrapped SOL?
wSOL is a token, so moving wSOL between owners is a row in the token tables with the mint So11111111111111111111111111111111111111112. Wrapping and unwrapping are different. They are not token transfers. Unwrapping closes the wSOL account and pays plain SOL to a wallet. That shows up on the SOL side: as a top-up if the wallet was empty, and as a funding if more than 0.09 SOL arrived and another wallet lost SOL in the same transaction. The PumpSwap example above is exactly that case.
What these tables do not see
Wallets controlled by programs. A multisig vault, such as a Squads vault, is not an ordinary wallet. Its address is derived by a program and has no private key. indexer3_sol_fundings and indexer3_token_transfers only keep ordinary wallets, so money that goes into or out of such a vault is not there. token_transfers misses them for a different reason: a vault always moves tokens through its program, and that table only records transfers written directly in the transaction. sol_top_ups is the one exception. It shows a vault as a receiver the first time it is paid, but the sender is the signer of the transaction, not the vault's owner.
Small SOL amounts between wallets that already hold SOL. Too small for fundings, and not a top-up.
The instruction. Top-ups and fundings tell you that SOL moved, not which program moved it.
Summary
Key takeaways
- Top-ups are for fresh wallets. A row means a balance went from zero to above zero. Any amount counts, and it can happen to the same wallet many times.
- Fundings are for following money. They cover every wallet-to-wallet change above 0.09 SOL, with balances before, and go back much further. They have no signature and no dust.
- Both record results, not instructions. SOL that moves through a pool or a wSOL account is still seen.
- Check n_src and n_dst. With several senders or receivers, every pair gets a row and the amounts repeat.
- Token transfers follow tokens. Use token_transfers for recent rows with signatures, and indexer3_token_transfers for history and transfers made inside programs.
Keep reading
- Solana Table Reference. Column types, partition keys and retention.