Developer Docs

// The launch params tuple. tax.projectWallet receives the creator's sell fee.
function launch(
  (string name, string symbol, address dev,
   (uint16 buyBps, uint16 sellBps, uint16 walletBps,
    uint16 floorBps, uint16 burnBps, address projectWallet) tax) p
) payable returns (address token, address curve, address pool)

function tokenCount() view returns (uint256)
function allTokens(uint256 index) view returns (address)
function recordOf(address token) view returns (address token, address curve, address dev, uint256 at)

event Launched(address indexed token, address indexed curve, address indexed pool, address dev, uint256 devBought)

function buy(address token, uint256 minOut) payable returns (uint256 tokensOut)
function sell(address token, uint256 amountIn, uint256 minOutEth) returns (uint256 ethOut)

// reads
function configOf(address token) view returns (
  (address pool, address curve, address projectWallet,
   uint16 buyBps, uint16 sellBps, uint16 walletBps,
   uint16 floorBps, uint16 burnBps, bool set) )
function devEscrow(address token) view returns (uint256)   // creator's uncollected sell fees (wei)
function bondOf(address token) view returns (address)

// creator-only fee controls (projectWallet)
function withdrawDev(address token)   // collect escrowed sell fees to the wallet
function burnDev(address token)       // buy + burn with them instead

event Bought(address indexed token, address indexed buyer, uint256 ethIn, uint256 fee, uint256 tokensOut)
event Sold(address indexed token, address indexed seller, uint256 tokensIn, uint256 fee, uint256 ethOut)
event FeeSplit(address indexed token, uint256 platform, uint256 deferred, uint256 platformCut, uint256 dev, uint256 floor, uint256 burn)

function pool() view returns (address)     // the Uniswap v3 pool
function dev() view returns (address)
function bond() view returns (address)     // zero until graduated
function seeded() view returns (bool)
function graduated() view returns (bool)
function ready() view returns (bool)       // true only at the full ceiling
function seedTime() view returns (uint64)

// geometry - ticks along the curve (price rises left→right)
function startTick() view returns (int24)      // curve start (~$3.4k FDV)
function gradTick() view returns (int24)       // ceiling - the ONLY graduation point (~4.2 ETH)

function graduate()                        // permissionless once ready()

event Seeded(int24 curveLo, int24 curveHi, uint128 liquidity)
event Graduated(address indexed bond, uint256 raisedWeth, uint256 leftoverToken)

function poke()   // permissionless: compound Sherwood LP fees back into the floor

event Posted(uint128 sherwoodL, uint128 bountyL, uint128 ambushL)
event Poked(int24 tick, uint128 bountyL, uint128 ambushL, uint256 sherwoodFees0, uint256 sherwoodFees1)

// legacy overrides - spread into EVERY write (buy/sell/launch/graduate)
async function legacy(provider){ const { gasPrice } = await provider.getFeeData(); return { type: 0, gasPrice }; }

// 1) WATCH new launches - one event on the factory
const factory = new ethers.Contract(FACTORY, [
  "event Launched(address indexed token,address indexed curve,address indexed pool,address dev,uint256 devBought)",
], provider);
factory.on("Launched", (token, curve, pool, dev) => {
  // ...decide whether to snipe it, inside the same block the dev opens
});

// 2) BUY - native ETH in, no approval
const value = ethers.parseEther("0.1");
const q = await router.buy.staticCall(token, 0n, { value });
await (await router.buy(token, q * 99n / 100n, { value, ...(await legacy(signer.provider)) })).wait();

// 3) SELL - one exact-amount approval, then sell
await (await erc20.approve(ROUTER, amountIn, await legacy(signer.provider))).wait();
await (await router.sell(token, amountIn, minOutEth, await legacy(signer.provider))).wait();

import { ethers } from "ethers";

const FACTORY = "0x8aa92d5297fEC45cbC7F16A32F4aed5D3AC58074";
const abi = [
  "function launch((string name,string symbol,address dev,(uint16 buyBps,uint16 sellBps,uint16 walletBps,uint16 floorBps,uint16 burnBps,address projectWallet) tax) p) payable returns (address token,address curve,address pool)",
];
const signer = await new ethers.BrowserProvider(window.ethereum).getSigner();
const factory = new ethers.Contract(FACTORY, abi, signer);

const me = await signer.getAddress();
const params = {
  name: "Sherwood", symbol: "WOOD", dev: me,
  tax: {
    buyBps: 100,   // 1% buy  → platform (min)
    sellBps: 100,  // 1% sell → you, the creator (min)
    walletBps: 0, floorBps: 0, burnBps: 0, // split of any ABOVE-1% fee
    projectWallet: me,                 // where your sell fee lands
  },
};

// staticCall first to get addresses without spending gas, then send.
const [token] = await factory.launch.staticCall(params, { value: 0n });
const tx = await factory.launch(params, { value: ethers.parseEther("0.02") }); // opening buy
await tx.wait();
console.log("launched", token);

const ROUTER = "0xA6BaAB820809C7fC8350311776627298f91F07eC";
const rAbi = [
  "function buy(address token,uint256 minOut) payable returns (uint256)",
  "function sell(address token,uint256 amountIn,uint256 minOutEth) returns (uint256)",
];
const router = new ethers.Contract(ROUTER, rAbi, signer);

// legacy() = { type:0, gasPrice } - REQUIRED on every write (no EIP-1559 on Robinhood Chain)
async function legacy(p){ const { gasPrice } = await p.getFeeData(); return { type: 0, gasPrice }; }

// BUY - native ETH in, no approval. Quote first, then apply slippage.
const value = ethers.parseEther("0.1");
const quoted = await router.buy.staticCall(token, 0n, { value });
const minOut = quoted * 99n / 100n; // 1% slippage
await (await router.buy(token, minOut, { value, ...(await legacy(signer.provider)) })).wait();

// SELL - one EXACT-amount approval to the router, then sell.
const erc20 = new ethers.Contract(token, ["function approve(address,uint256) returns (bool)"], signer);
await (await erc20.approve(ROUTER, amountIn, await legacy(signer.provider))).wait();
await (await router.sell(token, amountIn, minOutEth, await legacy(signer.provider))).wait();

const curve = new ethers.Contract(curveAddr, [
  "function pool() view returns (address)",
  "function startTick() view returns (int24)",
  "function gradTick() view returns (int24)",
  "function graduated() view returns (bool)",
], provider);
const [poolAddr, start, ceil] = await Promise.all([curve.pool(), curve.startTick(), curve.gradTick()]);

const pool = new ethers.Contract(poolAddr, [
  "function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16,uint16,uint16,uint8,bool)",
], provider);
const { tick } = await pool.slot0();

const span = Math.abs(Number(ceil) - Number(start)) || 1;
const progress = Math.min(1, Math.abs(Number(tick) - Number(start)) / span); // 0 … 1

const curve = new ethers.Contract(curveAddr, [
  "function ready() view returns (bool)",
  "function graduate()",
], signer);

// ready() is true ONLY at the full ceiling (~4.2 ETH). Anyone can graduate once
// ready() - this is the "Graduate" button / a keeper bot. No early path, no timeout.
if (await curve.ready()) await (await curve.graduate()).wait();

// Creator only: collect your escrowed sell fees - or buy + burn with them.
const router = new ethers.Contract(ROUTER, [
  "function withdrawDev(address)", "function burnDev(address)",
], signer);
await (await router.withdrawDev(token)).wait();

# sort: new | trending | top | graduated   filter: all | live | graduated
GET /api/coins?sort=trending&filter=live&q=wood&limit=60

# each coin includes:
{ token, curve, pool, dev, name, symbol, launchTs, devBought,
  graduated, raisedWeth, bond,
  progress, mcapEth, lastPriceEth,           # live snapshot - no chain read needed
  tradesAll, trades24h, volAllEth, vol24hEth,
  startTick, gradTick }