TopBlast bonding curve — integration guide

Each launch deploys one BondingCurve contract and one TEP-74 jetton master. The full supply of 1,000,000,000 tokens (6 decimals) is minted once to the curve and the minter immediately renounces its admin rights — the jetton can never be re-minted, frozen or upgraded.

Tokens trade against a whitelisted quote jetton (USDT, USDe, XAUt0 gold, SP500 or one of nine xStocks) on a constant-product curve with virtual reserves. When the raise reaches the per-pair cap, the curve migrates: up to 25% of total supply, priced at the final curve price, paired with the full raise seeds a DeDust CPMM v2 volatile pool, tradeable from the first block.

A curve address is deterministic from (master, creator, quote_master, salt), so it can be computed before the deploy transaction lands:

state_init = { code: curve_code, data:
  begin_cell()
    .store_address(master)
    .store_address(creator)
    .store_address(quote_master)
    .store_uint(salt, 64)
  .end_cell() }
curve = address_of(state_init)

No contract can protect you against a hijacked domain or a tampered front end. Both values below are fixed and public — before approving a launch or a trade, check that the destination shown by your wallet is the master address here, and that the curve code hash matches. If either differs, the page you are on is not TopBlast.

Constant product over virtual reserves. Virtual reserves start at cap ÷ 2 quote units and 1,125,000,000 meme tokens, so the curve sells exactly 750,000,000 tokens (75% of supply) by the cap and the remaining 250,000,000 seed the DeDust pool:

reserve_quote = virt_quote + raised
reserve_meme  = virt_meme  - sold

buy:  swap_in  = amount_in - amount_in * 1%
      amount_out = swap_in * reserve_meme / (reserve_quote + swap_in)

sell: gross_out = amount_in * reserve_quote / (reserve_meme + amount_in)
      amount_out = gross_out - gross_out * 1%

The fee is always taken in the quote asset — buyers pay it on the way in, sellers on the way out. Traders never pay fees in the meme token.

Both directions are a standard TEP-74 transfer#0f8a7ea5 to the curve with a forward payload. Never send jettons without a payload — an empty forward payload is treated as a donation and is not swapped.

forward_payload#_ op:uint32 query_id:uint64 min_out:Coins = TradePayload;

// buy 100 USDT with 1% slippage tolerance
transfer(
  amount:            100_000000,
  destination:       curve,
  response_destination: sender,
  forward_ton_amount: 0.2 TON,
  forward_payload:   begin_cell()
      .store_uint(0x42555921, 32)
      .store_uint(query_id, 64)
      .store_coins(min_out)
    .end_cell()
)

Attach at least 0.25 TON of forward amount and 0.35 TON total message value. If min_out is not met — or the curve has graduated, or the cap is already reached — the curve refunds your exact input in the same asset instead of throwing, because a failing notification cannot undo a jetton transfer.

Right after launch the curve sends a TEP-89 discovery request to learn its own quote wallet address. Any trade notification that arrives before that reply is treated as a donation and kept by the curve; do not send trades immediately after a launch until the token appears in the indexer and the UI enables trading.

Every buy and sell pays a 1% trading fee, always denominated in the quote asset. Buyers pay it on the way in, sellers on the way out. Traders never pay fees in the meme token.

The master emits an external-out log for every launch. Subscribe to outgoing external messages from the master address:

launch_created#4c4e4344
  query_id:uint64
  curve:MsgAddress
  creator:MsgAddress
  quote_master:MsgAddress
  salt:uint64
  metadata:^Cell   // TEP-64 onchain content

Poll get_curve_data() for live progress; the raise percentage is raised / cap. Graduation is signalled by the graduated flag flipping to true and the curve rejecting trades.

For platforms that want to list and track TopBlast launches without decoding contracts themselves, we expose a public read-only JSON API. No authentication, no API key — just cache responsibly (responses carry a short Cache-Control window).

curl https://topblastv2.lol/api/public/tokens

{
  "master": "EQA3QsiH-T6j…",
  "tokens": [
    {
      "curve": "EQ…",            // bonding curve contract
      "name": "Example",
      "symbol": "EXMPL",
      "image": "https://…",
      "creator": "UQ…",
      "createdAt": 1757000000,   // unix seconds
      "quote": {
        "id": "USDT",
        "symbol": "USDT",
        "master": "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
        "decimals": 6
      },
      "category": "stable",
      "cap": { "raw": "2640000000", "amount": "2640" }
    }
  ]
}

// live state (raised, sold, graduated, jetton master) is NOT in this feed —
// call get_curve_data() on the curve, or /api/public/tokens/{curve}

curl https://topblastv2.lol/api/public/tokens/{address}

{
  "token": { /* same shape as above */ },
  "graduation": {
    "graduated": true,
    "pool": "EQ…",               // DeDust CPMM v2 pool, LP locked in the curve
    "lpLockedRaw": "…",
    "lpOwner": "EQ…",            // the curve contract itself
    "reserves": { "memeReserveRaw": "…", "quoteReserveRaw": "…" },
    "price": { "quotePerToken": "0.00000012", "quoteSymbol": "USDT" }
  }
}

Everything these endpoints return is also readable directly on-chain — see Indexing above if you prefer to run your own indexer against the master's launch_created#4c4e4344 logs and curve get-methods.

Everything a trading bot or terminal needs to route an order, in one place. Start from GET /api/public/config — it returns the live master, the whitelisted quote assets with their decimals, caps and category, the curve constants and the exact gas amounts to attach. Never hard-code these: a new master deployment changes caps and the quote whitelist.

curl https://topblastv2.lol/api/public/config

{
  "network": "mainnet",
  "master": "EQ…",
  "dedustFactory": "EQ…",
  "meme": { "decimals": 9, "supply": "1000000000" },
  "curve": {
    "capUsd": 2640,
    "virtualQuoteNum": 1, "virtualQuoteDen": 2,   // virtual quote = cap * 1/2
    "curveAllocationRaw": "1125000000000000000",  // virtual meme reserve
    "maxBuyPerWalletRaw": "20000000000000000",    // 2% lifetime buy cap
    "tradingFeeBps": 100
  },
  "gasNano": {
    "curveTransfer": "380000000", "curveForward": "260000000",
    "dedustTransfer": "350000000", "dedustForward": "250000000"
  },
  "quotes": [
    { "id": "USDT", "symbol": "USDT", "master": "EQ…", "decimals": 6,
      "category": "stable", "capRaw": "2640000000", "holderPool": false }
  ]
}

Discovery & categories

GET /api/public/tokens lists up to the 500 most recent launches across every known master and accepts an optional ?category= filter (comma-separated). Each token also carries its own category field, so a terminal can build tabs without a lookup table.

GET /api/public/tokens?category=stable,stocks

All public endpoints are GET-only, unauthenticated, CORS-open and answer OPTIONS preflight. Respect the Cache-Control window: 60s for the token directory, 30s for a token detail, 300s for config. Poll, do not hammer.

Venue routing

One field decides where an order goes. While graduated is false, trade against the bonding curve at token.curve. Once it flips to true, the curve refuses trades with error 204 and all liquidity lives in the DeDust CPMM v2 pool at token.pool — route there using DeDust's own swap interface (jetton transfer to the asset vault with aswap#e3a0d482 payload). The detail endpoint returns pool reserves and the live quotePerToken price for post-graduation quoting.

Pricing an order on the curve

Quote locally from the constant-product formula in Curve math, or read the curve directly — get_meme_out(quote_in) and get_quote_out(meme_in) already include the 1% fee and are the authoritative quote. Derive min_out from that value and your slippage tolerance, and put it in the trade payload; the curve refunds instead of filling when it cannot be met.

reserve_quote = cap/2 + raised
reserve_meme  = 1_125_000_000e9 - sold

quote_in_net = quote_in * 99 / 100
meme_out     = quote_in_net * reserve_meme / (reserve_quote + quote_in_net)
min_out      = meme_out * (10000 - slippage_bps) / 10000

Outcomes a bot must handle

Trades settle asynchronously: a curve processes messages one at a time, so a burst of orders fills sequentially at moving prices, typically within a few seconds each. Confirm a fill by polling the buyer's jetton wallet balance or the curve's get_curve_data() — never by assuming the transfer succeeded.