LAUNCHPADS, DEPLOYED BY ANYONE.

npm i @zpad/sdk

import { ZPAD } from '@zpad/sdk'

export const pad = new ZPAD({
  pad: 'yourpad',              // the slug you picked at deploy
  key: process.env.ZPAD_KEY,  // zp_live_… — server side only
})

// who am I talking to?
const info = await pad.get()
console.log(info.name, info.fees.tradeBps, info.stats.tokens)
// → MoonWorks 100 61

curl https://api.zpad.fun/v1/pads/yourpad \
  -H "Authorization: Bearer zp_live_8f2c19ad4b7e"

curl "https://api.zpad.fun/v1/pads/yourpad/tokens?limit=25&cursor=eyJvIjoxNzU2NDgzMjAwfQ" \
  -H "Authorization: Bearer $ZPAD_KEY" -i

HTTP/1.1 200 OK
ZPAD-Version: 2026-08-01
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 57
X-RateLimit-Reset: 1756483260

{
  "data": [ /* … 25 items … */ ],
  "page": {
    "hasMore": true,
    "cursor": "eyJvIjoxNzU2NDc5NjAwfQ",
    "limit": 25
  }
}

{
  "slug": "yourpad",
  "name": "MoonWorks",
  "address": "0x8f3C1b9a44Ee02c7B1d5aA90fE31c7742Bd41d17",
  "chainId": 4663,
  "owner": "0x7bF3c410aD9e2255Ef01a7cC94f0b8E4d31c9A21",
  "curve": "classic",
  "quote": {
    "symbol": "USDG",
    "address": "0x51aB6f8cB2e7419b0dA3E8Cc2FbD1904Ee7803F7",
    "decimals": 6
  },
  "fees": {
    "tradeBps": 100,        // what a trader pays: 1.00%
    "creatorBps": 90,       // → your wallet, inside the same tx
    "protocolBps": 10,      // → ZPAD. always 10. never rises.
    "launchFeeWei": "500000000000000"
  },
  "graduation": { "reserveUsd": 12000, "lpBurned": true },
  "stats": {
    "tokens": 61,
    "graduated": 9,
    "volumeUsd24h": 38210.44,
    "volumeUsdTotal": 412703.18,
    "creatorFeesUsd": 3714.32
  },
  "createdAt": "2026-08-09T11:24:03Z"
}

{
  "data": [
    {
      "address": "0x91b2e7Ac03d5F1882bB4fD0a7cE6109a54cB4cE1",
      "name": "Hood Cat",
      "ticker": "HOODCAT",
      "image": "ipfs://bafkreihq2s7x…",
      "creator": "0x4a1d90Ff23cB8e07A1502dEc7719b6Aa3C0f88b0",
      "status": "bonding",
      "curve": {
        "progress": 0.343,             // 34.3% of the way to graduation
        "reserveUsd": 4120.55,
        "priceUsd": 0.00000412,
        "supply": "1000000000000000000000000000"
      },
      "marketCapUsd": 8134.90,
      "volumeUsd24h": 3210.40,
      "holders": 212,
      "createdAt": "2026-08-28T09:02:11Z"
    }
  ],
  "page": { "hasMore": true, "cursor": "eyJvIjoxNzU2Mzc4…", "limit": 25 }
}

// walk the whole board without touching cursors yourself
for await (const token of pad.tokens.paginate({ status: 'bonding' })) {
  if (token.curve.progress > 0.9) {
    await alertTelegram(`${token.ticker} is about to graduate`)
  }
}

{
  "name": "Hood Cat",
  "ticker": "HOODCAT",
  "description": "the cat that bought the dip",
  "image": "ipfs://bafkreihq2s7x…",
  "creator": "0x4a1d90Ff23cB8e07A1502dEc7719b6Aa3C0f88b0",
  "devBuy": { "amount": "100000000", "currency": "USDG" },
  "links": { "x": "https://x.com/hoodcat" }
}

{
  "token": {
    "predictedAddress": "0x91b2e7Ac03d5F1882bB4fD0a7cE6109a54cB4cE1",
    "ticker": "HOODCAT"
  },
  "transaction": {
    "chainId": 4663,
    "to": "0x8f3C1b9a44Ee02c7B1d5aA90fE31c7742Bd41d17",
    "data": "0x1f2a3b4c000000000000000000000000…",
    "value": "500000000000000",       // your launch fee, in wei
    "gasLimit": "2450000"
  },
  "requires": [
    {
      "type": "erc20-approval",
      "token": "0x51aB6f8cB2e7419b0dA3E8Cc2FbD1904Ee7803F7",
      "spender": "0x8f3C1b9a44Ee02c7B1d5aA90fE31c7742Bd41d17",
      "amount": "100000000"
    }
  ],
  "expiresAt": "2026-08-30T12:04:00Z"
}

import { createWalletClient, custom, erc20Abi } from 'viem'

const wallet = createWalletClient({ transport: custom(window.ethereum) })
const [account] = await wallet.getAddresses()

const res = await pad.tokens.create({ name: 'Hood Cat', ticker: 'HOODCAT' })

// 1. clear everything the API says must happen first
for (const req of res.requires) {
  if (req.type === 'erc20-approval') {
    await wallet.writeContract({
      account, abi: erc20Abi, address: req.token,
      functionName: 'approve',
      args: [req.spender, BigInt(req.amount)],
    })
  }
}

// 2. send exactly what you were handed. never rebuild the calldata —
//    the predicted address depends on it byte for byte.
const hash = await wallet.sendTransaction({
  account,
  chainId: res.transaction.chainId,
  to:      res.transaction.to,
  data:    res.transaction.data,
  value:   BigInt(res.transaction.value),
  gas:     BigInt(res.transaction.gasLimit),
})

// 3. the token is indexed the moment the block lands
const token = await pad.tokens.waitFor(hash)   // resolves in ~2s

{
  "token": "0x91b2e7Ac03d5F1882bB4fD0a7cE6109a54cB4cE1",
  "side": "buy",
  "amountIn": "250000000",     // 250 USDG
  "slippageBps": 100
}

{
  "side": "buy",
  "amountIn":  { "currency": "USDG", "raw": "250000000", "usd": 250.00 },
  "amountOut": {
    "ticker": "HOODCAT",
    "raw": "60728155000000000000000000",
    "min": "60120873450000000000000000"   // after your 1% slippage
  },
  "priceImpactBps": 84,
  "fees": {
    "totalUsd": 2.50,       // 1.00% of 250
    "creatorUsd": 2.25,     // 0.90% → the pad owner
    "protocolUsd": 0.25     // 0.10% → ZPAD
  },
  "validUntil": "2026-08-30T12:00:30Z"
}

const ws = new WebSocket(
  'wss://stream.zpad.fun/v1/pads/yourpad?key=zp_pub_3d81c4f0'
)

ws.addEventListener('open', () => {
  ws.send(JSON.stringify({
    subscribe: ['trade', 'token.created', 'token.graduated'],
  }))
})

ws.addEventListener('message', (e) => {
  const ev = JSON.parse(e.data)
  switch (ev.type) {
    case 'trade':           return paintTrade(ev.data)
    case 'token.created':   return prependCard(ev.data)
    case 'token.graduated': return confetti(ev.data)
  }
})

// the server pings every 30s. two missed pings means the socket is
// dead even though readyState still says OPEN — reconnect on that.
let lastPing = Date.now()
ws.addEventListener('ping', () => { lastPing = Date.now() })
setInterval(() => {
  if (Date.now() - lastPing > 70_000) ws.close()
}, 10_000)

Content-Type: application/json
ZPAD-Event: token.graduated
ZPAD-Delivery: dlv_7c1e93f0a244
ZPAD-Signature: t=1756483200,v1=5257a869e7ecebeda32affa62cdca3fa51cad7e77a0e56ff536d0ce8e108d8bd

{
  "id": "evt_2f9a71c4b830",
  "type": "token.graduated",
  "created": 1756483200,
  "pad": "yourpad",
  "data": {
    "token": { "address": "0x91b2…4cE1", "ticker": "HOODCAT" },
    "reserveUsd": 12043.55,
    "pool": "0x77Aa02fD91c4e5B3a0817fEc39d5B2c4406C910F",
    "lpBurned": true,
    "creatorFeesUsd": 109.49
  }
}

import express from 'express'
import { createHmac, timingSafeEqual } from 'node:crypto'

const app = express()

app.post('/hooks/zpad',
  // raw, not json: the signature covers the exact bytes we sent
  express.raw({ type: 'application/json' }),
  (req, res) => {
    const header = req.get('ZPAD-Signature') ?? ''
    const part = Object.fromEntries(
      header.split(',').map(kv => kv.split('='))
    )

    // replay protection: nothing older than five minutes
    const age = Math.abs(Date.now() / 1000 - Number(part.t))
    if (!Number.isFinite(age) || age > 300) return res.sendStatus(400)

    const expected = createHmac('sha256', process.env.ZPAD_WEBHOOK_SECRET)
      .update(`${part.t}.${req.body}`)
      .digest()

    const given = Buffer.from(part.v1 ?? '', 'hex')
    if (given.length !== expected.length || !timingSafeEqual(given, expected)) {
      return res.sendStatus(401)
    }

    const event = JSON.parse(req.body)

    // ack inside 5s or we count it as failed — do the work after.
    // deliveries can repeat, so key your side on event.id.
    res.sendStatus(200)
    queue.add(event.id, event)
  })

{
  "error": {
    "code": "insufficient_reserve",
    "message": "Trade exceeds 2% of the curve's inventory.",
    "param": "amountIn",
    "requestId": "req_9f21a0c4e7",
    "docs": "https://docs.zpad.fun/errors#insufficient_reserve"
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IPadCurve {
    /// @notice Buy along the curve. Reverts if the price moved past `minOut`.
    /// @dev    Creator and protocol fees are transferred inside this call.
    function buy(uint256 amountIn, uint256 minOut, address to)
        external returns (uint256 amountOut);

    function sell(uint256 amountIn, uint256 minOut, address to)
        external returns (uint256 amountOut);

    /// @notice Fixed at deploy. protocolBps is always 10 and has no setter.
    function fees() external view returns (
        uint16 tradeBps, uint16 creatorBps, uint16 protocolBps
    );

    function reserve() external view returns (uint256);
    function quoteToken() external view returns (address);

    /// @notice Callable by anyone once reserve() clears the threshold.
    ///         Pairs the reserve into a DEX pool and burns the LP.
    function graduate() external;

    event Traded(
        address indexed trader,
        bool isBuy,
        uint256 amountIn,
        uint256 amountOut,
        uint256 creatorFee,
        uint256 protocolFee
    );

    event Graduated(address indexed pool, uint256 reserve, uint256 lpBurned);
}