Documentation

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_ups gets a row when a SOL balance goes from zero to above zero. Use it to find fresh wallets.
  • Fundings. indexer3_sol_fundings gets a row when one wallet loses SOL and another gains it, whatever the balances were before. Small amounts are left out.
  • Token transfers. token_transfers gets 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.

What makes a row in each table
Illustration.
Top-ups
sol_top_ups
A SOL balance goes from zero to above zero.
SignerEmpty wallet0 → 0.0035 SOLany amount
Fundings
indexer3_sol_fundings
One wallet loses SOL and another gains it, whatever the balance was.
Wallet AWallet Bevery change above 0.09 SOLbalance before can be anything
Token transfers
token_transfers
A token moves from one owner to another.
Owner AOwner BUSDC, wSOL, any mintToken and Token-2022
Fig. 1Top-ups look for a balance that starts at zero. Fundings look for any large SOL change between wallets. Token transfers follow tokens, not SOL.

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.

One wallet, six balance changes
SOL balance. Illustration.
  • Top-up row + funding row
  • Funding row only
  • No row
0.00.51.01.52.0Day 02468101214Top-up: 0 → 2.00+0.50+0.05, dust−1.95, wallet emptiedTop-up again: 0 → 1.00
0.00.51.01.52.0Day 024681012140 → 2.00+0.50+0.05−1.95 to zeroagain: 0 → 1.00
Fig. 2The first payment and the payment after the wallet was emptied are top-ups, because the balance started at zero. The 0.50 SOL payment is only a funding. The 0.05 SOL payment and the token purchase are in neither table. Hover or tap for details.
Hover, tap or tab to a balance change for details.

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_namefirst_daylast_row_utc
sol_top_ups2026-10-182026-11-18 01:10:02
token_transfers2026-10-182026-11-18 01:10:02
indexer3_sol_top_ups2026-08-202026-11-18 01:10:05
indexer3_sol_fundings2026-08-012026-11-18 01:10:05
indexer3_token_transfers2026-08-012026-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 IN for subqueries. If you filter an indexer3_ table with a list that comes from a main-server table, write GLOBAL IN (SELECT ...). A plain IN is 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.
NOTE

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-upsFundingsToken transfers
A row meansA SOL balance went from 0 to above 0One wallet lost SOL and another gained SOL in the same transactionA token moved from one owner to another
Smallest amountAnyMore than 0.09 SOL, on both sidesAny
Sender columnEach signer of the transactionEach wallet that lost SOLOwner of the source token account
SignatureYesNo. Use slot and tx_idxYes in token_transfers, no in indexer3_token_transfers
Kept for31 days. 180 days in indexer3_sol_top_upsNo expiry so far31 days. No expiry so far in indexer3_token_transfers
Program accountsIncluded as receiversLeft outIn 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_walletamountsrc_wallettransfers_in_txsignature
CfmG…699S3,500,0002BJb…mzWj5KfjE2r…mACb
6oK1…Xs4d3,500,0002BJb…mzWj5KfjE2r…mACb
GX2L…NUAE3,500,0002BJb…mzWj5KfjE2r…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:

  • amount is the balance after the transaction. Because the balance before was zero, this is also what the wallet received.
  • src_wallet is 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_wallet is 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_utcsolsrc_walletsignature
2026-11-17 16:13:250.53943WWd…aTLZ5wBzYL…G2kY
2026-11-17 16:52:133.46743zMJ…y6vi21uCJU…Q9cZ
2026-11-17 16:52:133.4674EbsU…KnE721uCJU…Q9cZ
2026-11-17 23:18:470.18613WWd…aTLZ2vrtWc…JqJK
2026-11-17 23:25:250.2113WWd…aTLZ5drtNH…bhsb
2026-11-17 23:28:580.19813WWd…aTLZ4GwYi7…vR8G
2026-11-17 23:34:120.19833WWd…aTLZ3ovXx2…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

↑ Wallets buying in the first minute
32+
18
8
4
5
6
16
29
16-31
5
14
7
5
11
65
38
8-15
4
24
17
5
19
90
61
4-7
2
15
14
3
20
124
61
2-3
3
8
10
10
17
103
56
0-1
21
3
10
7
3
35
24
<1 min
1-10 min
10-60 min
1-6 h
6-24 h
1-31 d
older
Creator wallet topped up before launch →0 124 launches per cell · 1000 in total

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_idxsrc_walletdst_walletsrc_decreasedst_increasesrc_pre_balancedst_pre_balance
0FEvc…MBfdHWzn…DYmk817,900,000817,889,961827,900,00023,009,089,925,144

Transaction 292 is not there. It paid 0.0035 SOL to each wallet, and that is too small.

WARNING

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:

  1. Take each account whose SOL balance changed by more than 0.09 SOL.
  2. Drop token accounts and addresses that are not ordinary wallets (addresses derived by programs).
  3. 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_losssmallest_gainfunding_rows
90,002,85890,000,0012,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

src_walletdst_walletsol_lostsol_gainedonly_transfer_goes_to
BiEH…py1rCV4g…ZPR99.67839.654FpY…Au2Z

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_walletwhat_it_doessolsignature
BiEH…py1rpays SOL into the pool9.67824oGMUQ…c3Ec
CV4g…ZPR9takes SOL out of the pool9.654oGMUQ…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.

NOTE

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

3DBD…GAiA−1.1578 SOL6dwo…rmFR−1.0035 SOLFt8d…mtaa−1.598 SOL9LGq…zaqQ+1.0035 SOLwYKb…sano+1.0269 SOL
src_walletdst_walletsrc_decreasedst_increasen_srcn_dst
3DBD…GAiA9LGq…zaqQ1,157,831,9111,003,462,24332
6dwo…rmFR9LGq…zaqQ1,003,482,0621,003,462,24332
Ft8d…mtaa9LGq…zaqQ1,597,976,8081,003,462,24332
3DBD…GAiAwYKb…sano1,157,831,9111,026,864,78932
6dwo…rmFRwYKb…sano1,003,482,0621,026,864,78932
Ft8d…mtaawYKb…sano1,597,976,8081,026,864,78932

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_increase over rows with n_src above 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_utcprovided_gas_limitprovided_gas_feecu_limit_ix_indexcu_price_ix_indexmin_solmax_solcreatorssenderssample_creators
2026-11-17 11:00:001,45000-10.17660.17769935e3…uzZG, 8scr…zwt5, EJWt…kz38
2026-11-17 01:00:0050,000200,000010.50.5001995pti…Mokf, 6qVH…sCTD, DF1b…BWUj
2026-11-17 04:00:001,45020,0000165.553766.756999GUqZ…AUyM, Feee…iKrT, 8yXX…QyCU
2026-11-17 08:00:0050,000200,000010.50.5001886swS…GqXu, Aqkr…XchF, 2sQh…PLpd
2026-11-18 00:00:0050,000200,000010.50.500188HJgr…JCKn, 7JoD…LvoK, B4ge…RRKZ
2026-11-17 02:00:001,45000-10.1130.1187735e3…uzZG, ADtJ…ueP1, HH2t…qDWZ
2026-11-17 13:00:001,45020,0000174.517875.97266Baoa…wsHQ, 4gVW…SpiL, 4Hrg…ahHq
2026-11-17 15:00:001,45020,0000179.005780.08516613dB…QEj2, 8MPY…Hryc, FWbn…Q992
2026-11-17 19:00:00200,0000-1-10.00690.0069553kHx…45vh, 6D4b…fBwA, 95d2…9urn
2026-11-17 21:00:00562133,333,334102.55942.672555Hp5f…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_decrease is 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

  1. 5i7v…PtbRearliest wallet reached
  2. 13.125 SOL11-17 23:57 UTC
    3aA2…Dm8Cempty before, passes it all on
  3. 13.125 SOL11-17 23:57 UTC
    BQYX…L6Ykempty before, passes it all on
  4. 13.125 SOL11-17 23:59 UTC
    CuWu…SvmJempty before, passes it all on
  5. 13.124 SOL11-17 23:59 UTC
    6Me3…zMvPempty before, passes it all on
  6. 17.321 SOL11-18 00:02 UTC
    7RCz…A6AUempty before, passes it all on
  7. 17.321 SOL11-18 00:02 UTC
    2qGH…tcYvempty before, passes it all on
  8. 21.225 SOL11-18 00:04 UTC
    AYS8…KRYUempty before, passes it all on
  9. 21.225 SOL11-18 00:04 UTC
    ChZT…PvfYempty before, passes it all on
  10. 13.873 SOL11-18 00:26 UTC
    H2Du…XEKvempty before, passes it all on
  11. 13.873 SOL11-18 00:26 UTC
    B94a…wVQKempty before, passes it all on
  12. 13.873 SOL11-18 00:27 UTC
    CgWB…6eowempty before, passes it all on
  13. 13.873 SOL11-18 00:27 UTC
    2x7X…x3sZthe token creator
hopslotblock_time_utcsrc_walletdst_walletsol
14707340432026-11-18 00:27:08CgWB…6eow2x7X…x3sZ13.8733
24707340372026-11-18 00:27:06B94a…wVQKCgWB…6eow13.8734
34707339532026-11-18 00:26:48H2Du…XEKvB94a…wVQK13.8734
44707339462026-11-18 00:26:46ChZT…PvfYH2Du…XEKv13.8734
54707276962026-11-18 00:04:20AYS8…KRYUChZT…PvfY21.2254
64707276872026-11-18 00:04:182qGH…tcYvAYS8…KRYU21.2254
74707272272026-11-18 00:02:387RCz…A6AU2qGH…tcYv17.3208
84707272202026-11-18 00:02:376Me3…zMvP7RCz…A6AU17.3208
94707262982026-11-17 23:59:20CuWu…SvmJ6Me3…zMvP13.1245
104707262902026-11-17 23:59:18BQYX…L6YkCuWu…SvmJ13.1245
114707257602026-11-17 23:57:243aA2…Dm8CBQYX…L6Yk13.1245
124707257522026-11-17 23:57:235i7v…PtbR3aA2…Dm8C13.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

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_utcsrc_walletdst_walletusdcflavoursignature
2026-11-18 00:34:52Bc5b…nXHf81w9…ytUj31,548,281.314516785SK…K8iz
2026-11-18 00:15:235g7y…aBWsEWWf…39Us6,666,680.0061rKFUPh…g2iu
2026-11-18 00:15:225g7y…aBWsEWWf…39Us6,666,660.00614BwqLs…9n56
2026-11-18 00:15:225g7y…aBWs3NZu…5hhJ6,666,660.00613qe6GE…rKgt
2026-11-18 00:15:235g7y…aBWsEWWf…39Us6,666,660.0061uVpwN5…ghfK

There are two tables, and they differ in more than history:

  • token_transfers keeps 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_transfers has the long history and also records transfers made inside programs. It adds src_pre_amount and dst_pre_amount, the token balances before the transfer. It keeps a transfer only when both owners are ordinary wallets. It has no signature, so use slot and tx_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