Integration guide

This guide is for trading terminals, aggregators, and bots that want to list, trade, or launch stbl.meme bonding-curve tokens from their own product.

The integration is fully on-chain — there is no partner API. You interact directly with the BondingCurve singleton contract: quote via its viewfunctions, trade and create by sending transactions from your users' wallets, and discover tokens by indexing its events from your own RPC node. No API keys, no auth, no off-chain dependencies.

stbl.meme runs on Stable Mainnet (chain id 988, native currency USDT0, ~700 ms blocks).

Live launchpad parameters:

Create a launch by calling the curve directly:

// simple create (USDT0 pool; msg.value = creationFee)
createPool(CreateParams params) payable returns (address token)

// create + creator first-buy, locked in the TokenLock vault
// msg.value = creationFee + first-buy amount
createAndLockFirstBuy(CreateParams params, uint256 lockDuration,
                      uint256 deadline) payable returns (address token)

struct CreateParams {
  string  name;
  string  symbol;
  string  uri;                  // token metadata URI (you host it)
  address quoteToken;           // USDT0 (the only whitelisted quote today)
  DexTarget dexTarget;          // 0 = UniswapV3 (only value; immutable)
  uint256 graduationThreshold;  // 0 = default (4200 USDT0), else 1000-10000 USDT0 (raw units)
}

• msg.value must cover the 1 USDT0 creation fee (plus the first buy when using createAndLockFirstBuy); any excess is refunded in the same transaction.
• uriis the token's metadata pointer (logo, description, socials) — host the JSON yourself, e.g. on IPFS or your CDN.
• lockDurationlocks the creator's first buy in the TokenLock vault (up to 10 years) — a visible rug-safety signal shown on token pages.
• The new token address is returned by the call and emitted in the TokenCreated event. Total supply is fixed at 1B (18 decimals), fully minted to the curve — 800M sellable on the curve, the rest reserved for the graduation LP.

The curve is a constant-product AMM on virtual reserves. Quote with the view functions (they match execution exactly, fee included), then trade:

// quotes (view)
estimateBuyExactInTokens(address token, uint256 quoteAmountIn)
  returns (uint256 tokenOut)
estimateSellTokens(address token, uint256 tokenAmountIn)
  returns (uint256 quoteOut)
getPool(address token) returns (Pool)   // reserves, threshold,
                                        // creatorFeePercent, isCompleted, ...

// trades (USDT0 pools take native USDT0 on buys)
buyExactIn(address token, uint256 amountOutMin, uint256 deadline)
  payable returns (uint256 tokenOut)
sellExactIn(address token, uint256 tokenAmountIn, uint256 amountOutMin,
  uint256 deadline) returns (uint256 quoteOut)

• Slippage & deadline are yours to set: compute amountOutMinfrom the estimate functions and your user's tolerance; the curve reverts with SlippageExceeded past it.
• Approvals: buys attach native USDT0 — no approval. Sells require a one-time ERC20.approve(curve, amount) on the token.
• The 1% trade fee is taken inside the curve on every buy and sell — no extra fee for integrators to add or skim.
• Spot price = virtualQuoteReserves / virtualTokenReserves (from getPool or the reserves on each TradeEvent).
• After graduationthe curve rejects trades — route to the token's V3 pool (Uniswap V3, per its dexTarget, 1% fee tier) with standard routers. The pool address is in the V3PoolCreated event.

Watch the bonding-curve contract from your own node — these four events are the same stream our indexer consumes:

TokenCreated(token, creator, quoteToken, name, symbol, uri,
  virtualQuoteReserves, virtualTokenReserves, quoteDecimals,
  timestamp, dexTarget, graduationThreshold)   // new launch

TradeEvent(token, trader, quoteToken, isBuy, amountIn, amountOut, fee,
  virtualQuoteReserves, virtualTokenReserves,
  realQuoteReserves, realTokenReserves, timestamp)
  // every curve trade - carries post-trade reserves, so you can
  // derive price, volume, and graduation progress without extra reads

PoolCompleted(token, realQuoteReserves, timestamp)   // threshold hit

V3PoolCreated(token, v3Pool, quoteToken, tokenId, amountToken,
  amountQuote, sqrtPriceX96, timestamp, dexTarget)   // graduated -
  // v3Pool is where trading continues

• Graduation progress = realQuoteReserves vs the pool's graduationThreshold (both on every TradeEvent / getPool read).
• Useful public mappings for state reads: pools(token), positionIds(token) (V3 LP NFT id; 0 = not graduated), creatorClaimable(token), pendingQuoteFees(token).
• Fee-related events: FeesDistributed, CreatorClaimed, PlatformWithdrawn, CreationFeeCharged; config changes emit ConfigUpdated / QuoteGraduationThresholdsUpdated.

• A token graduateswhen its 800M sellable supply is fully bought — exactly when net quote raised equals the pool's threshold (default 4200 USDT0).
• Migration is atomic inside the completing buy: a full-range V3 position is seeded at the final curve price on the token's dexTarget (Uniswap V3, 1% fee tier) and the LP NFT is locked in the curve contract forever — liquidity can never be pulled. If a migration ever fails mid-buy, migrateToUniswapV3(token, deadline) is permissionless after a 5-minute grace period.
• The 1% trade fee applies in both phases (curve fee before, 1% V3 fee tier after). Per token it splits 50% to the creator and 50% to the platform.
• Fee plumbing is permissionless: anyone may call distributeFees(token) to fold pending curve + LP fees into escrow; creators pull with claim(token); check balances via creatorClaimable(token) / pendingQuoteFees(token).
• Token locks — the TokenLock vault holds creator first-buys:

lockTokens(address token, address owner, uint256 amount,
  uint256 duration) returns (uint256 lockId)   // max 3650 days
extendLock(uint256 lockId, uint256 newUnlockTime)   // owner only
unlock(uint256 lockId)                              // owner, after unlockTime
getLock(uint256 lockId) returns (Lock)  // { token, owner, amount, unlockTime }

// events: TokensLocked(lockId, token, owner, amount, unlockTime),
//         LockExtended(lockId, newUnlockTime),
//         TokensUnlocked(lockId, owner, amount)