TonX Launchpad Docs

Deployed contracts

Each launch also deploys a unique BondingCurve and Tonx via CREATE2. Token addresses always end in …TODO.

Architecture

1. Launch — call TonxFactory.createLaunch to deploy curve + token.
2. Bonding curve — users buy/sell on the curve until 3 TON is raised (2% trade fee).
3. Graduation — when the 3 TON target is reached, ~5,860 TON seeds a Uniswap V3 pool whose LP is locked permanently in TonX Vault; the small remainder covers the TonX Vault lock and splits 80% creator / 20% platform.
4. LP fees — the graduation LP is locked in TonX Vault forever, but its Uniswap V3 trading fees never stop accruing and stay claimable for as long as the pool trades (collectFees() has no time gate): token side burned, side split 80% creator / 20% platform on each collect.
5. DEX trading — after graduation, trade the token/ pool on canonical Uniswap V3 (1% tier) or via TonX.

Fees & custody. TonX is non-custodial — every create, buy, sell, and graduation runs on-chain straight from your wallet, and the platform contract never holds your funds. Fees settle directly: the 0.7 TON launch fee and the platform's 1% of the 2% curve trade tax go to the fee wallet, the creator's matching 1% to the creator, and the graduation cut splits per the waterfall above. Because the LP is locked without a time gate, the position itself can never be withdrawn — only its trading fees are ever collected, and those keep flowing 80% creator / 20% platform.

1. Launch a token

Call createLaunch on the launchpad. Pay at least 0.7 TON launch fee; any extra TON in the same tx is used as an optional creator dev-buy.

// TonxFactory.createLaunch
function createLaunch(
  string name,
  string symbol,
  string metadataURI,   // ipfs:// or https:// JSON with name, symbol, image, socials
  uint256 minTokensOut, // slippage guard for optional dev-buy (0 if no dev-buy)
  bytes32 curveSalt,    // CREATE2 salt — curve address must end in TODO
  bytes32 tokenSalt     // CREATE2 salt — token address must end in TODO
) external payable returns (address curve, address token);

// Example (viem / wagmi)
await writeContract({
  address: "EQDDiEsNSz_hxntY4ovh2glivESy1ylBmbP3d5XCvQD5np8b",
  abi: launchpadAbi,
  functionName: "createLaunch",
  args: [name, symbol, metadataURI, 0n, curveSalt, tokenSalt],
  value: parseEther("0.7"), // launch fee only
});

Read launch metadata: launchpad.launches(launchId) or launchpad.curveToLaunchId(curve). Resolve token → curve: Tonx(token).curve().

2. Buy on bonding curve (pre-graduation)

Send TON to the curve's buy function. 2% fee is taken (1% platform TON + 1% creator TON accrued from curve trading).

// BondingCurve.buy — curve must not be graduated
function buy(uint256 minTokensOut) external payable;

await writeContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "buy",
  args: [minTokensOut],
  value: parseEther("0.1"),
});

// Quote before sending
const [tokensOut] = await readContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "quoteBuy",
  args: [parseEther("0.1")],
});

3. Sell on bonding curve (pre-graduation)

Approve the curve to spend tokens, then call sell.

// 1. Approve curve to spend tokens
await writeContract({
  address: tokenAddress,
  abi: erc20Abi,
  functionName: "approve",
  args: [curveAddress, tokenAmount],
});

// 2. Sell
function sell(uint256 tokenAmount, uint256 minEthOut) external;

await writeContract({
  address: curveAddress,
  abi: bondingCurveAbi,
  functionName: "sell",
  args: [tokenAmount, minEthOut],
});

4. Trade after graduation (Uniswap V3)

Once curve.graduated() == true, trade the token/ pool directly on canonical Uniswap V3 (the pool is created at graduation with the 1% fee tier).

// Post-graduation trading is plain canonical Uniswap V3 — pool: token/null, 1% fee tier.
const SWAP_ROUTER = "0xCaf681a66D020601342297493863E78C959E5cb2"; // canonical SwapRouter02

await writeContract({
  address: SWAP_ROUTER,
  abi: swapRouter02Abi,
  functionName: "exactInputSingle",
  args: [{
    tokenIn: WUSDT0, tokenOut: tokenAddress, fee: 10000,
    recipient: me, amountIn, amountOutMinimum, sqrtPriceLimitX96: 0n,
  }],
});

5. Read on-chain state

// BondingCurve views
curve.token()            // Tonx address
curve.creator()          // launch creator
curve.graduated()        // true after migration
curve.uniswapPool()      // V3 pool (zero before grad)
curve.currentPrice()     // spot price in wei per token
curve.tokensRemaining()  // unsold sale inventory (800M cap)
curve.ethCollected()     // net TON in curve
curve.tokensSold()
curve.graduationTarget() // 3 TON target

// Tonx
token.curve()            // bonding curve address

// Creator fees accrue on the CURVE in native TON (1% of every trade) —
curve.claimCreatorFees() // permissionless; pays the accrued fees to the creator

6. Index trades (events)

Pre-graduation trades emit on the curve contract:

event Buy(address indexed buyer, uint256 ethIn, uint256 tokensOut, uint256 newPrice);
event Sell(address indexed seller, uint256 tokensIn, uint256 ethOut, uint256 newPrice);
event DevBuy(address indexed creator, uint256 ethIn, uint256 tokensOut, uint256 newPrice);
event Graduated(address pool, uint256 ethLiquidity, uint256 tokenLiquidity, uint256 ethToDev);

// Launchpad
event LaunchCreated(uint256 indexed launchId, address curve, address token, address creator, string name, string symbol);

Fetch historical logs from the explorer or any RPC eth_getLogs against the curve address.

7. Token supply & curve math

• Total supply: 1,000,000,000 tokens
• Bonding curve sale: 800,000,000 tokens
• Uniswap LP allocation: 200,000,000 tokens (minted to curve, migrated at graduation)
• Virtual reserves: 2047.5 TON + 1,073,000,000 virtual tokens (constant-product AMM)
• Graduation target: 3 TON net collected