How StonkFun works on Raydium LaunchLab, what its first day of data shows, and how to stream it with the Bitquery API.

StonkFun is a Solana launchpad where a new coin is paired with a tokenized stock, a pre-IPO token, a crypto asset or SOL instead of the usual SOL or USDC pair. Over the weekend of 5 and 6 September 2026 it moved new launches onto Raydium LaunchLab, and by Sunday its bonding curves were clearing more than half a million trades a day. The numbers below were pulled on Monday 7 September, and every query is one you can run yourself.

What is StonkFun?

StonkFun (stonkfun.xyz) lets anyone launch a coin and choose what it trades against. The menu includes xStocks, the tokenized stocks issued by Backed Finance such as SPYx (S&P 500), NVDAx and QQQx; PreStocks, which are pre-IPO exposure tokens such as OPENAI and ANTHROPIC; crypto assets such as ZEC, WBTC, HYPE, TAO and even xSOL, which I compared with looping jitoSOL in May; and plain SOL.

A coin called “SPDR” paired with SPYx is priced in units of an S&P 500 token, so its chart moves with both the meme and the index. Tokenized stocks are no longer a launchpad curiosity either. In July I reviewed Arcus, the dYdX team’s 24/7 stock-token exchange.

The platform token is STONK. StonkFun sends trading fees into a program it calls Burn & Earn, which buys STONK and the platform’s largest coins and burns them. STONK’s own pool is a Raydium CLMM pool against SPYx, but most of its volume this week went through SOL pools on Orca and Meteora.

For anyone who works with on-chain data, StonkFun is awkward in two ways. The quote assets are unusual, so trackers built around SOL and USDC pairs tend to skip them. And since this weekend there are two launch paths running side by side, which means watching three Raydium programs to see everything.

How a StonkFun launch works on-chain

The bonding-curve path (Raydium LaunchLab)

Every new StonkFun launch is one initialize_with_token_2022 instruction on the Raydium LaunchLab program LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj. StonkFun registered two platform configs with LaunchLab, and both carry the name "StonkFun" in their on-chain data. Reward launches go through 6BwHHDg3u1854jC8PDLXvR4spTcLNaoBxLJNGC4nTESt and mint the coin as a Token-2022 token with a 1% or 3% transfer fee on every transfer, which feeds StonkFun's reward payouts. Standard launches go through 4E876qZTE9FJMrBzgVtBrSrzz2TLivB5Y5QXPjB4gZL7 with no transfer fee. Everything else is the same on both.

Each launch mints 1,000,000,000 tokens with 6 decimals and sells 793,100,000 of them (79.31%) on a constant-product curve. Every curve trade pays a 1% fee in the quote asset. Raydium’s 0.25% protocol share for RAY buybacks comes out of that 1% rather than on top of it, and the rest goes to StonkFun’s fee wallet 5CEbueQnq1Ym2uSSx2xXds3jQAqT1BDnkA59RZobSPAG. Creators get nothing from curve trades.

The graduation target lives in the launch arguments as total_quote_fund_raising. StonkFun sets it in the quote asset at launch time from a fixed dollar figure, so a SOL launch targets 85 SOL, a WBTC launch about 0.112 WBTC and a SPYx launch about 11.5 SPYx. Each of those was worth roughly $8,500 to $10,000 on 7 September. Because the conversion happens per launch, two SPYx coins launched an hour apart will show slightly different targets. Do not hard-code the number.

When the curve fills, LaunchLab runs migrate_to_cpswap. The remaining 206,900,000 tokens and the raised quote asset seed a Raydium CPMM pool on the 0.25% fee tier, and the entire LP position is locked to the platform. Raydium's docs describe a burn or a creator share as options. StonkFun chose neither, which is how it keeps earning fees from graduated pools and, according to the platform, feeds them back into buybacks. StonkFun also says deployment now costs 0.03 SOL, down from 0.29 SOL on the old path, and that the bonding curve reduces sniper risk. What sniping is and how launchpads fight it is covered in my earlier piece on token sniping.

The direct-pool path (Raydium CLMM)

Before September, every StonkFun launch minted the token and opened a one-sided Raydium CLMM pool in a single transaction signed by the launcher wallet, with no curve and no migration. That path has not gone away. In the first twelve hours of 7 September the launcher wallet opened ten CLMM pools while LaunchLab handled 1,113 launches. The signal for it is a create_customizable_pool instruction on the CLMM program CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK, signed by the launcher wallet.

So a complete StonkFun tracker follows three programs: LaunchLab for curves, CPMM for graduated coins and CLMM for direct launches and for STONK itself. If you have read my guides to the pump.fun API, the Pons launchpad on Robinhood Chain or Four.meme on BNB Chain, the shape will look familiar. One instruction stream for launches, one for graduations, and the Trading API for prices.

StonkFun by the numbers (7 September 2026)

All figures below come from Bitquery queries run on 7 September 2026 around 12:30 UTC, so treat them as a snapshot of the first full day after the LaunchLab move.

Between 00:25 and 12:12 UTC, the two StonkFun platform configs produced 1,113 LaunchLab launches, about 94 an hour. Roughly 70% were reward launches with a transfer fee and 30% were standard launches.

Creators used 98 different quote mints in those twelve hours. xStocks took 42% of launches, crypto assets and other tokens 41%, SOL 10.5% and PreStocks 6.6%. The single most popular non-SOL quote was ZEC with 98 launches, followed by SPYx (70), NVDAx (41), SPCXx (40), MCDx (40), QQQx (36), WBTC (32) and OPENAI (30).

What surprised me was how few curves graduate, and how fast the ones that do get there. In the same twelve hours only 29 curves graduated, about 2.6% of launches. For the 21 graduations whose launch fell inside the sample, the median time from launch to graduation was 19.5 minutes. The fastest took 24 seconds. The slowest took 3.2 hours.

In the 24 hours to 12:25 UTC, pools quoted in xStocks on the three Raydium programs turned over $29 million: $11.6 million on 479 CLMM pools, $8.8 million on 1,984 LaunchLab curves and $8.6 million on 54 graduated CPMM pools. Across LaunchLab and CPMM, the quote assets with the most volume were TAO ($10.2 million), ZEC ($9.4 million), wXRP ($8.4 million), OPENAI ($5.0 million) and STONK itself ($3.8 million).

LaunchLab curves quoted in anything other than SOL, USDC or RAY handled 43,000 trades on 5 September, then 576,000 trades and $17.2 million on 6 September, then 222,000 trades and $6.2 million in the first half of 7 September. Almost all of that is StonkFun, since before 5 September LaunchLab curves quoted in other assets did fewer than 5,000 trades a day.

STONK closed the 7-day window at $0.097, up from $0.021 a week earlier, with a 24-hour range of $0.095 to $0.214 and $98 million of 24-hour volume across all its pools. Supply stands at 874.4 million after burns, down from the original 1 billion. Burn & Earn burned STONK 145 times in the last 24 hours, 1.36 million tokens in total, plus one-off burns of 24 other tokens.

How to get StonkFun data with the Bitquery API

Bitquery indexes Solana instructions, pool states and trades, and exposes them over GraphQL and WebSocket. The same query runs as a one-off query or as a subscription that pushes every new row. For StonkFun you need four streams: launches, curve progress, graduations and trades. Below are the versions I ran on 7 September. The full set, including candles, holders, liquidity, buyback tracking and historical queries, is on the StonkFun API docs page.

You can paste any of these into the Bitquery IDE without a key. Outside the IDE you need an OAuth token in the Authorization header.

1. Stream new StonkFun launches

Filter LaunchLab initialize instructions by the two platform configs. AccountNames labels every account, so you do not have to remember positions, and Arguments gives you the decoded mint name, symbol, curve target and transfer fee setting.

subscription StonkFunLaunchLabLaunches {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Address: { is: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj" }
            Method: { in: ["initialize_v2", "initialize_with_token_2022"] }
          }
          Accounts: {
            includes: {
              Address: {
                in: [
                  "6BwHHDg3u1854jC8PDLXvR4spTcLNaoBxLJNGC4nTESt"
                  "4E876qZTE9FJMrBzgVtBrSrzz2TLivB5Y5QXPjB4gZL7"
                ]
              }
            }
          }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block { Time }
      Transaction { Signature Signer }
      Instruction {
        Program {
          Method
          AccountNames
          Arguments {
            Name
            Value {
              ... on Solana_ABI_Json_Value_Arg { json }
              ... on Solana_ABI_String_Value_Arg { string }
              ... on Solana_ABI_Integer_Value_Arg { integer }
            }
          }
        }
        Accounts { Address Token { Mint ProgramId } }
      }
    }
  }
}

In each message, account index 5 is the bonding-curve pool, index 6 is the new token and index 7 is the quote asset. The curve_param argument holds total_quote_fund_raising, the graduation target for that launch. During my 45-second test this stream delivered four launches.

2. Stream trades with USD prices across all three programs

The Trading API returns one clean row per swap with the USD price, market cap and trader on it, and it attributes Jupiter router hops to the pool they hit. Filter by the three Raydium programs and by quote token. Market.Protocol tells you the stage of the coin: raydium_launchpad on the curve, raydium_cp_swap after graduation, amm_v3 for a direct-pool launch.

subscription StonkFunTradesSPYx {
  Trading {
    Trades(
      where: {
        Pair: {
          Market: {
            Network: { is: "Solana" }
            Program: {
              in: [
                "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"
                "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C"
                "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"
              ]
            }
          }
          QuoteToken: { Address: { is: "XsoCS1TfEyfFhfvj8EtZ528L3CaKBDBRqRapnBbDF2W" } }
        }
      }
    ) {
      Block { Time }
      Side
      PriceInUsd
      AmountsInUsd { Base Quote }
      Supply { MarketCap }
      Trader { Address }
      Pair {
        Token { Symbol Address }
        QuoteToken { Symbol }
        Market { Address Protocol }
      }
    }
  }
}

Swap the quote address for NVDAx, OPENAI, ZEC or STONK to follow another segment, or drop the quote filter and keep the program filter to watch everything. In a 30-second test this stream delivered 13 SPYx-quoted trades.

3. Stream graduations

A graduation is a migrate_to_cpswap instruction that references a StonkFun platform config. Account index 5 is the new CPMM pool and index 17 is the curve that just closed, so one message gives you the mapping from the old market to the new one.

subscription StonkFunGraduations {
  Solana {
    Instructions(
      where: {
        Instruction: {
          Program: {
            Address: { is: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj" }
            Method: { is: "migrate_to_cpswap" }
          }
          Accounts: {
            includes: {
              Address: {
                in: [
                  "6BwHHDg3u1854jC8PDLXvR4spTcLNaoBxLJNGC4nTESt"
                  "4E876qZTE9FJMrBzgVtBrSrzz2TLivB5Y5QXPjB4gZL7"
                ]
              }
            }
          }
        }
        Transaction: { Result: { Success: true } }
      }
    ) {
      Block { Time }
      Transaction { Signature }
      Instruction {
        Program { AccountNames }
        Accounts { Address Token { Mint } }
      }
    }
  }
}

4. Bonding-curve progress without knowing the quote asset

Every StonkFun curve sells 793,100,000 of 1,000,000,000 tokens, so progress can be read from the base reserve alone. Subscribe to DEXPools for the curve pool and apply:

progress % = 100 - ((Base.PostAmount - 206,900,000) * 100 / 793,100,000)

A SPYx-quoted curve I checked at 12:06 UTC held 913.8 million tokens, which puts it at 10.9% of the way to graduation. If you prefer the quote side, divide Quote.PostAmount by the launch's total_quote_fund_raising after adjusting for decimals.

5. Historical data

The Trading API keeps about 30 days of history with candles at intervals from one second to one hour, which covers the whole LaunchLab era so far. For anything older, the DEXTradeByTokens cube on the combined dataset gives daily volume and hourly OHLC per pool. Always filter by pool address there; a token-level sum double counts aggregator hops and pools where the coin is the quote side.

What you can build with it

The obvious one is a launch feed. Stream 1 plus a filter on curve_param gives you every new coin by quote asset, with the transfer fee setting attached, so you can skip or flag reward tokens before anyone trades them.

Join stream 1 and stream 3 on the pool address and you have a graduation tracker that measures time to graduate per quote asset. That is where the 19.5-minute median above came from. Group stream 2 by QuoteToken instead and you get a stock pair dashboard showing which stocks and pre-IPO tokens attract volume hour by hour.

Buybacks are one more subscription. TokenSupplyUpdates filtered on the launcher wallet as signer shows every Burn & Earn burn as it happens, across all the coins the program buys.

If you run trading bots, the interesting part is what is visible before the first trade. The transfer fee flag, the curve target and the locked LP graduation are all in the launch instruction, and that is the moment a bot should decide whether to touch a coin. They are the same kind of checks I wired into a 24/7 Solana memecoin sniper built with Claude Code.

Caveats

Most StonkFun coins are meme tokens with a few thousand dollars of liquidity, and 97% of the curves in my sample had not graduated. Reward tokens carry a 1% or 3% transfer fee on every move, which changes what “price” means for a holder. xStocks and PreStocks give exposure to a stock or a private company without shareholder rights, and their on-chain liquidity is thinner than the underlying market. Nothing here is investment advice, and I do not hold STONK or any StonkFun coin.

The data side has its own limits. Bitquery’s Solana Instructions cube is real-time only with a short history window, so launch counts for past weeks have to be reconstructed from the first trade of each pool. The Trading API's total supply for STONK lagged the on-chain figure on the day I checked, so I took supply from the token mint directly.

Disclosure: I work at Bitquery, which provides the API used in this post. The queries are free to run in the IDE, and the docs page linked above has the full set.

Sources: The Block, “STONK surges 250% as stock-paired Solana launchpad StonkFun pulls volume to Raydium and Jupiter” (6 September 2026); crypto.news, “Raydium LaunchLab adds support for any token pair on Solana” (7 September 2026); Raydium LaunchLab documentation; on-chain platform config and pool accounts read through a public Solana RPC; Bitquery API queries listed above.

StonkFun API: Track Stock-Paired Solana Launches in Real Time was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

124,016 tokens launched, 1,362 graduated, and a quarter of the volume priced in tokenized stocks. How the Pons launchpad works at the contract level, and the queries that produce those numbers.

Robinhood Chain opened to the public on 1 July 2026. A month later, close to one transaction in ten on the whole chain was coming out of a single application: in the last 24 hours, 922,540 of 9,559,806 transactions carried a Pons launch or bonding-curve trade.

That application is the Pons launchpad. Anyone can deploy a fixed-supply memecoin on it in about thirty seconds, with no code, and trade it from the first block. On 30 August 2026 it minted 22,581 new tokens in a single day.

If you’re building a trading terminal, a sniper bot, a token screener or a research dashboard on Robinhood Chain, that’s the feed you have to handle. This article covers what Pons actually does at the contract level, then the GraphQL queries that turn it into structured data you can use.

Every figure below was measured against live chain data on 31 August 2026 using Bitquery.

How the Pons launch factory works

Pons is a bonding-curve launchpad. Broadly the same design as Pump.fun on Solana or Flaunch on Base, rebuilt on top of Uniswap v4.

A token goes through four stages.

Launch. A creator calls the Pons launch factory at 0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e, or its router at 0xe33e9e479df8802cb0866d5d05258bec4cf62948. The factory deploys a fresh ERC-20 with a fixed supply of one billion, deploys a bonding-curve contract dedicated to that token, and emits TokenLaunched.

Curve trading. Buyers and sellers trade against the curve rather than a pool. Every fill emits CurveBuy or CurveSell from that token's own curve contract. Early buys get hit with a decaying snipe tax, which shows up as SnipeTaxCharged.

Graduation. Once cumulative quote-token deposits cross the token’s graduationThreshold, the curve gets drained (LaunchSwept), a slice of supply is locked permanently (GraduationTokensPermanentlyLocked), and the proceeds seed a real Uniswap v4 pool (PoolGraduated).

Open-market trading. The graduated token then trades in a Uniswap v4 pool sitting behind a custom hook at 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044, which registers the pool and collects protocol fees.

One detail trips almost everybody up on the first pass. The graduation threshold is denominated in whatever pair asset the creator picked, and creators pick different ones. Three consecutive launches on 31 August carried thresholds of 4200000000000000000, 8090000000 and 369000000000000000000. Those aren't comparable. The first is 4.2 ETH, because its pairToken is 0x000…000, the native asset. The second is 8,090 USDG, which is Global Dollar and has six decimals. Read pairToken first or your threshold column is meaningless.

What 124,016 launches actually look like

New tokens per day on the Pons launch factory, Robinhood Chain, 3–30 August 2026. Source: Bitquery.

Lifetime, counting from the factory’s first launch on 3 August 2026:

• Tokens launched: 124,016
• Tokens graduated to Uniswap v4: 1,362
• Graduation rate: 1.10%

Over the last seven days (25 to 31 August 2026):

• Tokens launched: 83,962
• Graduations: 1,064, a rate of 1.27%
• Bonding-curve trades: 3,058,412
• Curve volume: roughly $259M
• Distinct traders: 140,247
• Distinct tokens traded: 65,219

Daily launches sat between 700 and 3,300 for most of the month, then went vertical in the last week: 2,758 on 24 August, then 5,495, 8,137, 12,642, 11,496, 15,957, and 22,581 on the 30th. Two thirds of every token Pons has ever launched appeared in the final seven days of August.

Pons launches vs graduations to Uniswap v4, all history to 31 August 2026. Source: Bitquery.

That graduation rate is the number most people get wrong. Roughly 99 tokens in 100 die on the curve and never reach a pool at all.

Volume is flatter than you’d guess, too. CHIT, the largest bonding-curve token of the week, did $323,744. The nine largest together did about $2.43M, under 1% of the $259M that moved through the curves. No runaway winner, just a very long tail of very small bets. Across 3,058,412 trades the average fill was $85.

A quarter of Pons volume is priced in tokenized stocks

Pons bonding-curve volume by quote asset, 25–31 August 2026. Source: Bitquery.

Group the same week of curve trades by quote asset and Pons stops looking like a normal memecoin launchpad.

• ETH: $168.2M across 2,016,883 trades (64.8%)
• USDG: $24.6M (9.5%)
• NVDA: $13.9M (5.4%)
• SPCX: $8.6M (3.3%)
• SPY: $7.2M (2.8%)
• GME: $4.7M (1.8%)
• DJT: $3.5M, RDDT $3.1M, TSLA $3.1M, GLD $2.9M, then TTWO, AMZN, QQQ, AAPL, MSFT, COIN, MSTR, GOOGL, PLTR, META and more

Twenty-six of the quote assets aren’t crypto at all. They’re tokenized equities and ETFs, and together they carry $65.5M, or 25.2% of all Pons curve volume. Tokenized Nvidia alone moved more money through Pons curves than any individual memecoin on the platform did.

That is a Robinhood Chain-specific behaviour with no equivalent on Solana or Base. A trader can buy a dogcoin denominated in SPY, and about a quarter of them do. If you’re pricing Pons tokens, you cannot assume an ETH or stablecoin quote leg. You have to read pairToken per token and carry the right decimals, or every USD figure downstream is wrong.

Ten wallets minted a quarter of the tokens

Launch concentration on the Pons launch factory, 25–31 August 2026. Source: Bitquery.

Over the same seven days, 34,229 distinct wallets launched tokens through the factory. The ten busiest launched 20,122 of them, about 24% of the week’s total. The single busiest wallet, 0x5be0405dc84593fddbeccb80abb9d8cb0df75519, deployed 5,524 tokens, roughly one every 110 seconds without pause for a week.

Median activity is the opposite: most wallets launched once or twice. The launchpad is a small number of industrial minters sitting on top of a very wide amateur base, and any “new tokens per day” chart that doesn’t separate the two is measuring bot throughput, not adoption.

Querying Pons launchpad data

Bitquery indexes Robinhood Chain and serves it as GraphQL at https://streaming.bitquery.io/graphql. Two cubes matter here:

EVM(network: robinhood) gives you raw and decoded events, calls, transfers and holders. Trading gives you normalised trades, USD prices and OHLCV candles, with curve trades tagged Protocol: "pons_v2" and graduated pools tagged "uniswap_v4".

Everything below runs as written. Grab a free key from the Bitquery IDE and send it as a bearer token.

Detect every new launch

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 25}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
        Log: {Signature: {Name: {is: "TokenLaunched"}}}
      }
    ) {
      Block { Time Number }
      Transaction { Hash From }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg { address }
          ... on EVM_ABI_BigInt_Value_Arg { bigInteger }
        }
      }
    }
  }
}

You get token, curve, deployer, pairToken, launchConfigId and graduationThreshold back as named fields. Hold onto curve. It's unique per token and it's what the next queries key off.

Pull the name, symbol, logo and socials

TokenLaunched hands you addresses, not metadata. The readable fields live in the calldata of the launch call, so read the call instead of the event:

{
  EVM(network: robinhood) {
    Calls(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {
        Call: {
          To: {in: [
            "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
            "0xe33e9e479df8802cb0866d5d05258bec4cf62948"
          ]}
          Input: {startsWith: ["0xf35abbcf", "0xa72101af", "0xf85f8e41"]}
          Success: true
        }
      }
    ) {
      Block { Time Number }
      Transaction { Hash From }
      Call { To Value Input Output }
    }
  }
}

Decode the input and you have name, symbol, an IPFS logo URI, a description, a socials struct covering X, Telegram, Discord, website and Farcaster, plus the creator's fee recipient and their chosen creatorTaxBps. The output carries the two addresses:

const o = call.Output.replace(/^0x/, '');
const token = '0x' + o.slice(24, 64);
const curve = '0x' + o.slice(88, 128);

That’s a complete launch card from one call, with no off-chain metadata service in the loop.

Follow the bonding curve

Every fill on every curve comes down to two event names, so the whole network fits in one query:

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 50}
      orderBy: {descending: Block_Time}
      where: {
        Log: {Signature: {Name: {in: ["CurveBuy", "CurveSell"]}}}
      }
    ) {
      Block { Time }
      Transaction { Hash From }
      LogHeader { Address }
      Log { Signature { Name } }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg { address }
          ... on EVM_ABI_BigInt_Value_Arg { bigInteger }
        }
      }
    }
  }
}

Each row gives you buyer, recipient, quoteIn, tokensOut, fee and tax, and LogHeader.Address tells you which curve it came from. That's every bonding-curve trade on the network, all three million a week of them.

To watch one token instead, add its curve address as a filter:

where: {
  LogHeader: {Address: {is: "0x6295b9bee3d8eafe3614a63ed96b0a5ce06dad85"}}
  Log: {Signature: {Name: {in: ["CurveBuy", "CurveSell"]}}}
}

Take that address from the curve field of the token's TokenLaunched event rather than copying one from an article. Curves are deployed per token and most of them go quiet within hours, so a hardcoded address returns an empty result more often than not.

If you’d rather have USD prices and candles than raw integers, go through the Trading cube:

{
  Trading {
    Trades(
      limit: {count: 50}
      orderBy: {descending: Block_Time}
      where: {
        Pair: {Market: {Protocol: {is: "pons_v2"}, Network: {is: "Robinhood"}}}
      }
    ) {
      Block { Time }
      Side
      PriceInUsd
      Amounts { Base Quote }
      AmountsInUsd { Base Quote }
      Trader { Address }
      Pair { Token { Address Symbol } QuoteToken { Symbol } }
    }
  }
}

Protocol: "pons_v2" has to be exact. Pass the wrong string and you get zero rows and no error.

Check the liquidity lock

Every Pons graduation permanently locks part of the supply. The amount is emitted as an event, so you can verify it yourself rather than trusting the docs:

{
  EVM(network: robinhood, dataset: combined) {
    Events(
      limit: {count: 25}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
        Topics: {includes: [{Hash: {is: "a0a18f5bf205becee8b268d7cf69addab8548ae8ef361791464cf0e0e17c1361"}}]}
      }
    ) {
      Block { Time Number }
      Transaction { Hash }
      Topics { Hash }
      LogHeader { Data }
    }
  }
}

The token address is the second topic, left-padded. The amount is the data field. Decode a recent one and you get 81,632,653.06 tokens, which is exactly 4/49 of the one-billion supply, or 8.163%. That figure was identical across the locks checked, and the locked balance sits at the launch locker, 0x267444d099b10fb5ed7c3cc7b7c767adca574952. Exclude that address from holder queries or your top-holder list will be wrong on every graduated token.

Counting the same events across all history: 1,363 sweeps, 1,363 locks and 1,362 PoolGraduated events. The off-by-one is a graduation that was mid-flight when the snapshot was taken.

Catch graduations

The cleanest graduation signal is PoolRegistered on the meme hook, which fires when the Uniswap v4 pool is created:

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 50}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}
        Topics: {includes: [{Hash: {is: "01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573"}}]}
      }
    ) {
      Block { Time Number }
      Transaction { Hash }
      LogHeader { Data }
    }
  }
}

The payload is three left-padded addresses:

const d = log.Data;
const memecoin   = '0x' + d.slice(24, 64);
const quoteToken = '0x' + d.slice(88, 128);   // 0x000…000 = native ETH
const creator    = '0x' + d.slice(152, 192);

On the factory side the full sequence reads TokenLaunched, then LaunchSwept, then GraduationTokensPermanentlyLocked, then PoolGraduated.

Stream it live

Any query above becomes a WebSocket subscription: change query to subscription, drop limit and orderBy, and connect to wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN. Three subscriptions covering launches, curve trades and graduations give you the whole launchpad in real time.

Three things that will cost you a day

SignatureHash filters silently force the realtime dataset. Filtering on or selecting Log { Signature { SignatureHash } } limits the query to a rolling two-to-three-day window. For anything historical, filter on Topics: {includes: [{Hash: {is: "…"}}]} instead. Same topic0, archive-safe.

Decoded event names only go back to 14 August 2026. Before that date, Log: {Signature: {Name: {is: "TokenLaunched"}}} returns nothing on the archive dataset. Use the topic hash for full history, and dataset: combined when you want archive plus the realtime tail in one response.

Validate USD figures on both legs. The Trading cube exposes AmountsInUsd { Base Quote }. Sum both and compare. If they disagree by more than a few percent, one side has bad pricing somewhere. Pons curve trades over the last seven days came out at $261.4M base-side and $259.2M quote-side, a spread of 0.9%, which is why the $259M above is safe to quote.

Is the Pons launchpad on Base?

No. Pons runs on Robinhood Chain, chain ID 4663. It isn’t deployed on Base, Solana or Ethereum mainnet, and every contract address in this article is a Robinhood Chain address. Anything advertising “Pons on Base” is a different project trading on the name.

Pons also isn’t the only launchpad on the chain. pools.trade, built by Uniswap Labs, opened publicly on 5 August 2026 on the same network. It has no bonding curve at all: tokens open as a Uniswap v4 pool from block one, with no graduation event to wait for. If you’re building a screener for Robinhood Chain you need both feeds, and they need different code.

Where to go next

The full reference sits in the Pons API documentation: every contract address, every topic0 hash, the complete event ABI list, holder queries, OHLCV candles, and the liquidity and slippage endpoints.

The same GraphQL endpoint covers the rest of the chain too, including trades, transfers, token holders and contract events.

At 22,000 tokens a day, scraping stops being an option fairly early. The events above are the whole surface area of the launchpad, so once you can read them you can build anything on top.

All figures were measured on 31 August 2026 against Robinhood Chain via Bitquery’s GraphQL API. The one-in-ten transaction share counts transactions carrying a decoded TokenLaunched, CurveBuy or CurveSell, so it is a floor rather than a ceiling. The 31 August day count is partial. None of this is financial advice, and a 1.10% graduation rate is closer to a warning than an invitation.

Pons API on Robinhood Chain: How to Track the Pons Launchpad On-Chain was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Man vs. machine might be the rallying cry of our future with AI, but for Meta CEO Mark Zuckerberg, the fight is here now — in more ways than one.

Zuckerberg, who dabbles in mixed martial arts, took on Merab “The Machine” Dvalishvili, a professional fighter and former UFC bantamweight champ, on a padded barge floating on Lake Tahoe.

A video of the sparring match on Facebook and Instagram on Sunday, complete with drone views, showed the shirtless combatants exchanging kicks, punches and take-downs before they both end up in the water.

Zuckerberg’s wife Priscilla Chan rows past in a fancy outrigger canoe at one point to comment on her husband’s bare-chested battle.

“When Merab was winning: real. When Mark was winning: AI,” read one comment on Facebook.

Elsewhere on the water, much farther north, Zuckerberg’s superyacht Launchpad continues to make headlines, 2 1/2 months after the vessel grabbed attention with a stay in Seattle.

The 387-foot, $300 million Launchpad is currently anchored in Auke Bay off Juneau, Alaska, along with its 262-foot support vessel, Wingman, which also spent time in Seattle at the end of May into June.

Last week, Launchpad was linked to a bit of drama at sea when a 21-foot skiff ran out of fuel between Juneau and Petersburg and made a request for assistance. A small cruise ship operating in the area had to make a detour around 10 p.m. on Aug. 3 to tow the stranded boat to safety.

The captain of the UnCruise Adventures ship Wilderness Legacy reportedly announced to passengers that the billionaire tech CEO’s ship was closer but did not answer the radio call for help, drawing boos from those onboard.

A software developer from New York City on the cruise ship detailed the ordeal on Facebook Instagram … Bluesky.

A spokesperson for Zuckerberg said, “Mark and his family were not on board at the time of the incident,” adding that the yacht’s crew was operating on a different radio frequency when the Coast Guard issued the general assistance request. By the time they checked the broadcast, the Wilderness Legacy was already handling the rescue.

Zuckerberg was making more waves Monday morning with the release of a 6,500-word manifesto about his vision for the future of artificial intelligence.

In the post, titled “The Future is for Everyone,” Meta’s founder laid out a defense of “personal superintelligence,” pushing back against AI doom-mongering and warning against centralizing the technology within a few powerful institutions.

Key takeaways from Zuckerberg’s manifesto include:

• Superintelligence for all: Arguing that AI should empower individuals rather than displace them, Zuckerberg advocated for open, widely distributed models over locked-down corporate gatekeeping.
• Everyday AI agents: He envisioned a world where everyone has a 24/7 personal agent managing health, career, and family — noting his own agent monitors his workouts and helps plan weekend baking recipes with his daughter.
• Invention over automation: Rather than treating AI as a tool to automate jobs, he framed it as an “invention superpower” capable of accelerating drug discovery, scientific research, and software creation.
• Accessible compute: Meta plans to maintain free and low-cost access to its models, leveraging dynamic auction mechanisms for compute to ensure broad affordability.