API

// fomopad.ts: launch a coin for a fomo trader, buy and sell one. Node 18+.
//   npm i viem
//   PRIVATE_KEY=0x… npx tsx fomopad.ts launch unipcs ./logo.png
//   PRIVATE_KEY=0x… npx tsx fomopad.ts buy <token> 0.01
//   PRIVATE_KEY=0x… npx tsx fomopad.ts sell <token> 1000000
import { readFileSync } from 'node:fs'
import { createPublicClient, createWalletClient, defineChain, http, type Hex } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'

const API = 'https://api.fomopad.pro'
const robinhood = defineChain({
  id: 4663,
  name: 'Robinhood Chain',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: ['https://rpc.mainnet.chain.robinhood.com'] } },
})
// The key stays on this machine; the API never sees it. Use a dedicated hot wallet.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex)
const transport = http(process.env.RPC_URL ?? robinhood.rpcUrls.default.http[0])
const wallet = createWalletClient({ account, chain: robinhood, transport })
const client = createPublicClient({ chain: robinhood, transport })

type EvmTx = { to: Hex; data: Hex; value: string; gas?: string; label: string }
type Quote = {
  inAmount: string
  outAmount: string
  minOut: string
  feeQuote: string
  priceImpactPct: number | null
  route: 'curve' | 'v4'
  snipeTaxBps?: number
  final?: boolean // fills the curve: the rest of the ETH is refunded and the coin graduates
}

async function api<T>(path: string, body?: unknown): Promise<T> {
  const res = await fetch(`${API}${path}`, {
    method: body === undefined ? 'GET' : 'POST',
    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
    body: body === undefined ? undefined : JSON.stringify(body),
  })
  const json: unknown = await res.json()
  if (!res.ok) {
    const e = json as { error?: string; details?: unknown }
    throw new Error(`${res.status} ${e.error ?? 'error'} ${e.details ? JSON.stringify(e.details) : ''}`)
  }
  return json as T
}

/** Send each transaction in order, waiting for its receipt before the next (an approval lands before the sell). */
async function sendAll(txs: EvmTx[]): Promise<Hex[]> {
  const hashes: Hex[] = []
  for (const tx of txs) {
    const hash = await wallet.sendTransaction({
      to: tx.to,
      data: tx.data,
      value: BigInt(tx.value),
      gas: tx.gas ? BigInt(tx.gas) : undefined, // set when estimation is unsafe (a buy that may finish the curve)
    })
    const receipt = await client.waitForTransactionReceipt({ hash })
    if (receipt.status !== 'success') throw new Error(`${tx.label} reverted: ${hash}`)
    console.log(tx.label, hash)
    hashes.push(hash)
  }
  return hashes
}

async function launch(handle: string, imagePath: string): Promise<void> {
  // 1. Pin the image. The server reads the bytes; the declared type is ignored.
  const image = `data:image/png;base64,${readFileSync(imagePath).toString('base64')}`
  const { imageUrl, imageMime } = await api<{ imageUrl: string; imageMime: string }>('/launch/image', { image })

  // 2. Build. `match` is the fomo handle; the server checks it on fomo.family, sets the coin's
  //    website to its fomopad page and returns one transaction plus the coin's (predicted) address.
  const built = await api<{ token: Hex; curve: Hex; tx: EvmTx; website?: string; firstBuy?: Quote }>('/launch/build', {
    creator: account.address,
    match: handle,
    name: 'Cat Coin', // <= 32 bytes
    symbol: 'CAT', // <= 10, letters and digits
    description: 'Launched from a script',
    twitter: 'https://x.com/example', // optional, https only
    imageUrl,
    imageMime,
    firstBuy: { amount: '0.01', slippageBps: 500 }, // optional, ETH, in the same transaction
  })
  console.log('token', built.token, 'curve', built.curve, 'first buy', built.firstBuy?.outAmount ?? 'none')

  // 3. Send it from the creator wallet and wait for the receipt.
  await sendAll([built.tx])
  console.log(`https://fomopad.pro/token/${built.token.toLowerCase()}`)
}

/** amount: ETH for a buy, coins for a sell. A sell may come back as [approve, sell]. */
async function trade(side: 'BUY' | 'SELL', mint: string, amount: string): Promise<void> {
  // owner on the quote includes this wallet's snipe tax (a coin's first ~3 seconds).
  const params = { mint, side, amount, slippageBps: '300', owner: account.address }
  console.log('quote', await api<Quote>(`/trade/quote?${new URLSearchParams(params)}`))
  const built = await api<{ txs: EvmTx[]; quote: Quote }>('/trade/build', { ...params, slippageBps: 300 })
  await sendAll(built.txs)
}

const [cmd, a, b] = process.argv.slice(2)
const run =
  cmd === 'launch' && a && b ? launch(a, b) : (cmd === 'buy' || cmd === 'sell') && a && b ? trade(cmd === 'buy' ? 'BUY' : 'SELL', a, b) : null
if (!run) console.log('usage: launch <fomo handle> <image> | buy <token> <eth> | sell <token> <amount>')
run?.catch((err: unknown) => {
  console.error(err instanceof Error ? err.message : err)
  process.exit(1)
})

# Live launchpad parameters (fee split, buyback token, graduation threshold)
curl -s https://api.fomopad.pro/config

# Coins still on the curve, by 24h volume
curl -s 'https://api.fomopad.pro/tokens?sort=volume&status=CURVE&limit=10'

# Every coin made for one fomo trader, and their page
curl -s 'https://api.fomopad.pro/tokens?match=unipcs'
curl -s https://api.fomopad.pro/fomo/users/unipcs

# One coin, its last 20 trades, 1h candles and fee history
curl -s https://api.fomopad.pro/tokens/<token>
curl -s 'https://api.fomopad.pro/tokens/<token>/trades?limit=20'
curl -s 'https://api.fomopad.pro/tokens/<token>/candles?tf=1h&limit=200'
curl -s https://api.fomopad.pro/tokens/<token>/fees

# Quote a 0.01 ETH buy (read-only, nothing is built or signed)
curl -s 'https://api.fomopad.pro/trade/quote?mint=<token>&side=BUY&amount=0.01&slippageBps=300'

{ "token": "0x…", "curve": "0x…",
  "tx": { "to": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "data": "0x…", "value": "10500000000000000",
          "gas": "2500000", "label": "Launch $CAT" } }

curl -s https://api.fomopad.pro/rpc -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["<tx hash>"]}'

// Browsers, Node 22+ (global WebSocket), or the `ws` package on older Node.
const ws = new WebSocket('wss://api.fomopad.pro/ws')
ws.onopen = () => {
  ws.send(JSON.stringify({ op: 'subscribe', topics: ['trades', 'tokens', `token:${token}`] }))
  setInterval(() => ws.send(JSON.stringify({ op: 'ping' })), 25_000)
}
ws.onmessage = (m) => {
  const msg = JSON.parse(String(m.data))
  if (msg.op !== 'event') return // 'pong' | 'error'
  const e = msg.event
  if (e.type === 'trade') console.log(e.trade.side, e.trade.quoteAmount, 'ETH', e.trade.symbol)
  if (e.type === 'token:new') console.log('new coin', e.token.mint, 'for', e.token.match?.handle)
  if (e.type === 'buyback') console.log('bought back', e.buybackQuote, 'ETH for', e.handle, 'from', e.mint)
}

// 400: validation (details lists each field)
{ "error": "invalid request", "details": [{ "path": "symbol", "message": "symbol is letters and digits only" }] }

// 404: the fomo handle does not exist
{ "error": "fomo.family has no user @someone" }

// 409: the curve is full and the Uniswap v4 pool is not created yet
{ "error": "this coin is graduating; trading reopens on its Uniswap v4 pool in a moment" }