developers

overview

YAYA Launchpad runs on TON and Solana. Every token trades on a bonding curve from its first second and moves to a DEX pool when it graduates. This page is for trading bots, aggregators and dashboards that want to list those tokens, including before graduation.

• There is no API key and nothing to sign up for. All endpoints below are public, read-only HTTP.
• Trading is non-custodial: your users sign their own transactions against the contracts. Nothing here asks for or accepts a private key.
• Base URL: https://launchpad.yayaton.org. Amounts are decimal strings in base units unless named …Usd.

rate limits & caching

Requests are limited per IP address. A 429 means slow down and retry after a few seconds. Responses are cached for 10–60 seconds, so polling faster than every 5–10 seconds gains nothing.

Call the API from your server. Always re-read chain state before building a trade: the API is a snapshot, the chain is the source of truth.

GET /api/ton-launches

Every live TON curve, newest first. Returns { version, master, savedAt, curves: [...] }. One entry:

{
  "curve":     "EQDQ_mgnd…",   // trade here
  "minter":    "EQDYtLpW…",   // token jetton minter (9 decimals)
  "creator":   "EQA0JBNd…",
  "release":   "xstock",      // "xstock" = pair curve, "holder" | "legacy" = GRAM curve
  "quote":     { "minter": "EQAmbXji…", "symbol": "YAYA", "decimals": 9 },  // pair curves only
  "state":     1,
  "virtual":   "124688279301745635",
  "raised":    "291700401685450",
  "inventory": "997666022971217982",
  "dexSupply": "100000000000000000",
  "threshold": "311720698254364089",
  "feeBps":    300,
  "launchedAt": 1790407019,
  "name": "AYAY", "symbol": "AYAY", "image": "https://…",
  "stats": { "priceUsd": 0.0000049, "marketCapUsd": 4935.7, "volume24hUsd": 152.6, "trades24h": 8 }
}

other TON endpoints

In stats, marketCapUsd counts the coins that exist and fdvUsd the full supply. They differ only for a token minted over time (ORE: 21,000,000 cap, minted as players claim).

factories & discovery

Each launch deploys a curve contract and a standard TEP-74 jetton minter. Two curve families are live:

• GRAM curves: the quote asset is GRAM, TON's native coin. Buy by sending coins to the curve.
• Pair curves: the quote asset is a jetton (YAYA, USDT, STON, xStocks such as SPYx…). Buy by transferring the quote jetton to the curve.

Every factory above is live and its curves trade with the same messages. The master field of /api/ton-launches lists all factory addresses the index follows, older ones included.

Older factories exist for earlier launches; /api/ton-launches lists every live curve whatever its factory. To watch the chain instead, read the factory's external-out messages: the destination is the event op, and the body is:

creator : MsgAddress
salt    : uint64
curve   : MsgAddress
minter  : MsgAddress
tail    : Coins (GRAM factories) | uint16 (pair factories)

reading a curve

Graduation. Current GRAM curves graduate once 2,000 GRAM is raised; current pair curves once the curve holds $3,000 of liquidity (get_xcurve_usd). The DeDust pool keeps the launch's trade fee and its liquidity is locked for good.

quote math

Constant product on a virtual reserve, all values in base units:

x = virtual + raised          // quote-side reserve
y = inventory                 // token-side reserve
f = feeBps                    // 100–300 (ORE: 400)

// buy: spend `in` of the quote asset
net = in - in * f / 10000
out = y - x * y / (x + net)
require(y - out >= dexSupply)

// sell: send `in` tokens
// The curve refuses a sale that would take its reserve down to the virtual
// part (it returns the tokens): the most it takes in one sale is
maxIn = x * y / (virtual + 1) - y
require(in <= maxIn)
out = x - x * y / (y + in) - x * in * f / ((y + in) * 10000)
require(out <= raised)

minOut = out * (10000 - slippageBps) / 10000

Launch window. For the first ~3 seconds after launchedAt the buy fee starts at 99% and halves down to feeBps (anti-snipe; the creator is exempt). Do not quote buys before launchedAt + 4.

Minimum buy on GRAM curves: 0.01 GRAM. Our interface uses 0.5% slippage and treats a quote older than 30 seconds as stale.

GRAM curve: buy & sell

Buy

A bounceable message to the curve. If a check fails (not trading, a buy settling, output below min_out) the coins bounce back minus gas.

to     : curve
value  : in + 0.05 GRAM          // unused gas is returned
body   : op uint32 = 0xa0a0a011
         query_id uint64
         min_out Coins           // minimum tokens

Sell

A TEP-74 transfer from the seller's token jetton wallet (get_wallet_address on the minter):

to     : seller's token jetton wallet
value  : 0.35 GRAM
body   : op 0x0f8a7ea5, query_id, amount,
         destination = curve, response_destination = seller,
         custom_payload = null, forward_ton_amount = 0.25 GRAM,
         forward_payload = ^Cell { op 0xa0a0a020, query_id uint64, min_out Coins }

pair curve: buy & sell

Both directions are jetton transfers to the curve. The quote jetton is quote.minter from the API or get_xcurve_quote.

// buy: from the buyer's QUOTE jetton wallet
value  : 0.25 GRAM
body   : op 0x0f8a7ea5, query_id, amount (quote to spend),
         destination = curve, response_destination = buyer,
         forward_ton_amount = 0.15 GRAM,
         forward_payload = ^Cell { op 0xa0a0c011, query_id, min_out }

// sell: from the seller's TOKEN jetton wallet
value  : 0.20 GRAM
body   : same layout, forward_ton_amount = 0.10 GRAM,
         forward_payload = ^Cell { op 0xa0a0a020, query_id, min_out }

A buy needs at least 0.12 GRAM of forward gas; 0.15 is safe. If the order cannot be filled, the curve sends the incoming jettons back.

Trading on a user's behalf

The inner payload of a pair-curve order may carry optional fields after min_out, so a router contract can trade for a user:

target   : MsgAddress    // receives the output and any refund (workchain 0)
fwd_ton  : Coins         // only after target: TON forwarded with the payout, max 1 GRAM
fwd_body : Maybe ^Cell   // forward payload for the payout

reference code

import { beginCell, Address } from '@ton/core';

// GRAM curve buy: send to the curve with value = amountIn + toNano('0.05')
export const gramBuyBody = (minOut: bigint, queryId = BigInt(Date.now())) =>
  beginCell().storeUint(0xa0a0a011, 32).storeUint(queryId, 64).storeCoins(minOut).endCell();

// Jetton transfer into a curve (GRAM sell, pair buy, pair sell)
export function curveTransfer(o: { curve: Address; owner: Address; amount: bigint; minOut: bigint;
  op: number; forwardTon: bigint; queryId?: bigint }) {
  const id = o.queryId ?? BigInt(Date.now());
  const inner = beginCell().storeUint(o.op, 32).storeUint(id, 64).storeCoins(o.minOut).endCell();
  return beginCell().storeUint(0x0f8a7ea5, 32).storeUint(id, 64).storeCoins(o.amount)
    .storeAddress(o.curve).storeAddress(o.owner)
    .storeBit(false).storeCoins(o.forwardTon).storeBit(true).storeRef(inner).endCell();
}
// GRAM sell: op 0xa0a0a020, forwardTon 0.25, message value 0.35
// pair buy:  op 0xa0a0c011, forwardTon 0.15, message value 0.25
// pair sell: op 0xa0a0a020, forwardTon 0.10, message value 0.20

trade events

Curves emit an external-out log for every trade; the op is the log's destination.

trading Solana launches

Solana launches run on Raydium LaunchLab under the YAYA Launchpad platform, so no custom contract is involved. Jupiter routes the curve from the first block, and the pool migrates to a Raydium CPMM pool at graduation. Bots that already support Jupiter or LaunchLab can trade them today.

• Tokens are Token-2022 with 6 decimals, supply 1,000,000,000, no mint or freeze authority.
• Every launch has a 1% or 3% transfer fee (taxBps) that funds holder rewards. It applies to every transfer, so a buy delivers that much less than the curve output.
• Curve fee: 1% platform plus 0.25% Raydium. After graduation: 0.25% trade fee plus a 1% pool creator fee.
• Any pool whose platform config is not the one above is not a YAYA launch.

Solana endpoints

status: 0 = trading on the curve, anything higher = migrating or graduated to Raydium CPMM. progress is the share of the graduation target raised (0–1).

bot checklist

• Find launches with /api/ton-launches and /api/sol-launches, or watch the factories on TON.
• TON: before each trade call get_state and trade on the curve only when it returns 1; for buys also check get_pending_buy is empty.
• TON: skip buys in the first 4 seconds after launchedAt.
• Always pass min_out. The contracts refund an order they cannot fill.
• Cap sells at maxIn (see quote math): selling everything bought from a curve, down to the last unit, is just over it and is refunded.
• When a TON curve reaches state 3, switch the token to its DeDust pool. Solana tokens keep routing through Jupiter.
• Questions or a listing request: Telegram t.me/yayafam.