Developer docs

Introduction

Fair-launch meme platform on Robinhood Chain. Create Classic V3 / Tax V4 Instant launches, or Bonding on-curve launches (V3 or V4 graduate), trade through the matching router / aggregator, earn creator fees, and graduate when progress hits ~4.2 ETH.

Product names in the UI: Instant / Bonding first, then Classic launch (V3), Tax launch (V4), or Narrative (Hot elsewhere → prefilled Tax Instant or Tax Bonding — same factories, no separate Narrative stack). On-chain: Instant PeepsFactory / PeepsV4Factory, bonding PeepsBondingV3Router / PeepsBondingV4Router. Prefer @peeps/shared helpers (getPeepsV3Addresses, getPeepsV4Addresses, getPeepsBondingV3Addresses, getPeepsBondingV4Addresses) over hardcoding.

• Non-custodial — every action is signed by the user's wallet.
• Fair launches — no presale; Instant locks full supply as LP at create; Bonding sells into a curve then migrates LP at graduation.
• Classic V3 — Uniswap V3 Instant pool with locked LP via PeepsLocker; 1% pool fee; 70% creator / 30% protocol of LP fees.
• Tax V4 — Uniswap V4 Instant pool with a 1% LP fee (70% creator / 30% protocol of LP fees) plus a separate creator-configured buy/sell tax (1–10%).
• Bonding — trade on a bonding curve until ~4.2 ETH, then migrate to Uni V3 (bonding V3) or the Instant V4 graduate sink (bonding V4).
• Aggregator — PeepsAggregatorRouter for Peeps Instant and multi-venue swaps (0.25% Peeps fee when it applies). Bonding on-curve uses the bonding routers; post-grad bonding V4 uses the graduate aggregator.

Network

Deployed contracts

Mainnet (chain 4663). Source of truth: packages/contracts/deployments/4663.json and @peeps/shared getDeployment(4663).

How it works

Launch Classic V3: call PeepsFactory.launchToken with launch fee 0.00025 ETH (plus optional initial buy ETH). Factory deploys the ERC-20 with a 1% Uniswap V3 pool fee tier and locked LP in PeepsLocker. Emits TokenLaunched.

Launch Tax V4: call PeepsV4Factory.createTokenV4 with the same launch fee pattern, 1% LP fee (70/30), tax config (1–10% buy/sell — separate from the LP fee; 100% split across treasury / burn / dividend / liquidity), and optional seed buy. Liquidity and tax live on Uniswap V4.

Launch Bonding: call PeepsBondingV3Router.createToken or PeepsBondingV4Router.createToken. Trading stays on the bonding curve until ~4.2 ETH, then the migrator seeds Uni V3 (bonding V3) or the Instant V4 graduate sink (bonding V4 — separate from Instant create factories).

Trade: Instant Classic / Tax routes through PeepsAggregatorRouter (buy / sell, buyV4 / sellV4). Bonding on-curve uses the bonding routers; bonding V4 after graduation uses the graduate aggregator. Peeps may take 0.25% on supported aggregator routes.

Graduate: when progress hits ~4.2 ETH, Instant launches enter the locked pool phase; Bonding migrates curve liquidity into Uni. Charts and Discover status update; creator LP participation continues on eligible Instant volume (70/30 of the 1% pool fee on Classic V3).

Setup

Examples use ethers v6 (npm i ethers). Prefer resolving addresses from @peeps/shared in production.

import { ethers } from "ethers";

const RPC = "https://rpc.mainnet.chain.robinhood.com";
const provider = new ethers.JsonRpcProvider(RPC, 4663);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

const A = {
  factory:           "0xeE6D48e781c1bA547B63a3d65Db87F67305D1531",
  locker:            "0x9d6CDEe7243002bBDe5C1AB7bc664542ae153c93",
  feeRouter:         "0xd72999F9feC33cDC16BcA790ED5C66026Dc81B1D",
  v4Factory:         "0x60796114CF6Ac0759098788e6d4D1F4774556A34",
  aggregator:        "0x7080d248123539d71aacd3BEc50DD0f7c2246054",
  bondingV3Router:   "0x7aFbda8014507beF89385a61B2a81B8874FCE579",
  bondingV4Router:   "0x1d5d916B042e9faF6d41EC155b8E43ed37A0aC2A",
  bondingV3Factory:  "0x84A9Ac2A545B72efed12CD8E8EaB647Af0e3f303",
  bondingV4Factory:  "0xEEb8Ac11e9E70AFb9979204fbD9A0166Ecc28BC9",
  graduateAggregator:"0xE568086a6766351A789b4e87E351Ce312143AF20",
  weth:              "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
};

const LAUNCH_FEE = ethers.parseEther("0.00025");

Launch Classic V3

Call PeepsFactory.launchToken. Send at least 0.00025 ETH; extra msg.value funds an optional initial buy. Anti-snipe defaults on in the peeps.wtf create UI.

const FACTORY_ABI = [
  "function launchToken((string name,string symbol,string logo,string description,(string twitter,string telegram,string discord,string website,string farcaster) socials,address feeWallet,bool antiSnipe) params,uint256 launchConfigId,uint256 dexId,bytes32 salt) payable returns (address token)",
  "function graduationStatus(address token) view returns (uint256 pairedPrincipal,uint256 threshold,bool graduated)",
  "event TokenLaunched(address indexed token,address indexed deployer,address indexed dexFactory,address pairToken,address pool,uint256 dexId,uint256 launchConfigId,uint256 positionId,uint256 restrictionsEndBlock,uint256 initialBuyAmount)",
];

const factory = new ethers.Contract(A.factory, FACTORY_ABI, wallet);
const salt = ethers.hexlify(ethers.randomBytes(32));
const params = {
  name: "My Token",
  symbol: "MTK",
  logo: "ipfs://your-logo",
  description: "Fair launch on Peeps",
  socials: { twitter: "", telegram: "", discord: "", website: "", farcaster: "" },
  feeWallet: ethers.ZeroAddress,
  antiSnipe: true,
};

const tx = await factory.launchToken(
  params,
  0n,
  0n,
  salt,
  { value: LAUNCH_FEE }
);
const rc = await tx.wait();

const ev = rc.logs
  .map((l) => { try { return factory.interface.parseLog(l); } catch { return null; } })
  .find((e) => e && e.name === "TokenLaunched");
console.log("token:", ev.args.token, "pool:", ev.args.pool);

App helpers: buildLaunchTokenV3 in @peeps/chain, constants like PEEPS_INSTANT_LAUNCH_FEE_WEI in @peeps/shared.

Launch Tax V4

Call PeepsV4Factory.createTokenV4. Swaps collect a 1% LP fee (70% creator / 30% protocol of LP fees). Separately, tax buy/sell rate is 1–10% in 0.5% steps; Treasury / Burn / Dividend / Liquidity splits must total 100%. Creator LP share default is 70% (PEEPS_INSTANT_V4_CREATOR_SHARE_BPS = 7000).

const V4_FACTORY_ABI = [
  "function createTokenV4((string name,string symbol,string logo,string description,(string twitter,string telegram,string discord,string website,string farcaster) socials,address feeWallet) params,((uint8 graduationCap,uint16 postGradCreatorShareBps,bool antiSnipe,bool uniformClearing) base,uint16 buyTaxBps,uint16 sellTaxBps,uint16 fundsBps,uint16 burnBps,uint16 dividendBps,uint16 liquidityBps,address taxRecipient,uint16 antiFarmerDays,uint256 minDividendBalance) tax,uint256 seedEthWei,uint16 lpTokenBps,bytes32 specialCodeHash) payable returns (address token,bytes32 poolId)",
  "function graduationStatus(address token) view returns (uint256 pairedPrincipal,uint256 threshold,bool graduated)",
];

const v4 = new ethers.Contract(A.v4Factory, V4_FACTORY_ABI, wallet);
const tax = {
  base: {
    graduationCap: 2,
    postGradCreatorShareBps: 7000,
    antiSnipe: true,
    uniformClearing: false,
  },
  buyTaxBps: 100,
  sellTaxBps: 100,
  fundsBps: 5000,
  burnBps: 2000,
  dividendBps: 2000,
  liquidityBps: 1000,
  taxRecipient: wallet.address,
  antiFarmerDays: 0,
  minDividendBalance: 10_000n * 10n ** 18n,
};
const meta = {
  name: "Tax Token",
  symbol: "TAX",
  logo: "ipfs://your-logo",
  description: "Tax V4 on Peeps",
  socials: { twitter: "", telegram: "", discord: "", website: "", farcaster: "" },
  feeWallet: ethers.ZeroAddress,
};

const seedEth = 0n;
const tx = await v4.createTokenV4(meta, tax, seedEth, 10_000, ethers.ZeroHash, {
  value: LAUNCH_FEE + seedEth,
});
await tx.wait();

App helpers: buildCreateTokenV4, getPeepsV4Addresses. Prefer PeepsAggregatorRouter.buyV4 / sellV4 for swaps.

Launch Bonding (on-curve)

Bonding creates go through PeepsBondingV3Router or PeepsBondingV4Router (not Instant factories). On-curve buys/sells use the same routers. Graduation threshold is ~4.2 ETH (BONDING_GRADUATION_ETH_WEI / factory graduationEthForCap).

Bonding V3 migrates into Uni V3 via PeepsBondingV3Migrator. Bonding V4 migrates into the graduate Instant V4 sink (0xF68f25bE1861115d81ecD4850f397A9e27126d45) — keep that separate from Instant Tax V4 creates (0x60796114CF6Ac0759098788e6d4D1F4774556A34).

// Prefer @peeps/chain helpers — createToken takes a LaunchConfig tuple + metadata.
import { buildCreateBondingV3, buildCreateBondingV4 } from "@peeps/chain";
import {
  getPeepsBondingV3Addresses,
  getPeepsBondingV4Addresses,
} from "@peeps/shared";

const b3 = getPeepsBondingV3Addresses(4663);
const b4 = getPeepsBondingV4Addresses(4663);

// Classic bonding → Uni V3
const createTx = buildCreateBondingV3({ /* name, symbol, meta, launch, … */ });
// Tax bonding → Instant V4 graduate sink
// const createTx = buildCreateBondingV4({ /* … + tax */ });

const BONDING_TRADE_ABI = [
  "function buy(address token,address recipient,uint256 minTokensOut,uint256 deadline) payable returns (uint256)",
  "function sell(address token,uint256 tokenAmount,address recipient,uint256 minEthOut,uint256 deadline) returns (uint256)",
];
const bonding = new ethers.Contract(b3.router, BONDING_TRADE_ABI, wallet);
// Or: b4.router for bonding V4 on-curve trades

const ethIn = ethers.parseEther("0.05");
const deadline = Math.floor(Date.now() / 1000) + 600;
await (await bonding.buy(token, wallet.address, 0n, deadline, { value: ethIn })).wait();

Addresses: getPeepsBondingV3Addresses, getPeepsBondingV4Addresses, getPeepsBondingV4GraduateAddresses in @peeps/shared.

Buy

Native ETH → tokens via PeepsAggregatorRouter (and after graduation on supported routes).

const AGG_ABI = [
  "function buy(address token,address recipient,uint256 minTokensOut,uint256 deadline) payable returns (uint256)",
  "function buyV4(address token,address recipient,uint256 minTokensOut,uint256 deadline) payable returns (uint256)",
];
const agg = new ethers.Contract(A.aggregator, AGG_ABI, wallet);

const ethIn = ethers.parseEther("0.05");
const deadline = Math.floor(Date.now() / 1000) + 600;

// Classic V3
await (await agg.buy(token, wallet.address, 0n, deadline, { value: ethIn })).wait();

// Tax V4
// await (await agg.buyV4(token, wallet.address, 0n, deadline, { value: ethIn })).wait();

During anti-snipe, non-creator wallets may hit early buy caps. Tax V4 anti-bundle can pause sells briefly during the shared clearing window.

Sell

Approve the aggregator, then sell tokens back through the Peeps route for ETH.

const ERC20_ABI = [
  "function approve(address,uint256) returns (bool)",
  "function allowance(address,address) view returns (uint256)",
];
const AGG_ABI = [
  "function sell(address token,uint256 tokenAmount,address recipient,uint256 minEthOut,uint256 deadline) returns (uint256)",
  "function sellV4(address token,uint256 tokenAmount,address recipient,uint256 minEthOut,uint256 deadline) returns (uint256)",
];
const tokenC = new ethers.Contract(token, ERC20_ABI, wallet);
const agg = new ethers.Contract(A.aggregator, AGG_ABI, wallet);

const amountIn = ethers.parseEther("1000000");
if ((await tokenC.allowance(wallet.address, A.aggregator)) < amountIn) {
  await (await tokenC.approve(A.aggregator, ethers.MaxUint256)).wait();
}
const deadline = Math.floor(Date.now() / 1000) + 600;
await (await agg.sell(token, amountIn, wallet.address, 0n, deadline)).wait();

Fees & claims

• Creation: 0.00025 ETH launch fee → protocol.
• Classic V3 pool: 1% on eligible swaps — 70% creator / 30% protocol of LP fees (curve phase and after graduation).
• Tax V4: 1% LP fee (70% creator / 30% protocol of LP fees) plus a separate creator-configured buy/sell tax (1–10%). Holders claim dividends on the token page when eligible.
• Aggregator: 0.25% Peeps fee may apply on supported routes.
• Gas: always ETH on Robinhood Chain — separate from platform fees.

const LOCKER_ABI = [
  "function collectFees(address token) returns (uint256 amount0,uint256 amount1)",
  "function protocolFeeShare() view returns (uint256)",
];
const locker = new ethers.Contract(A.locker, LOCKER_ABI, wallet);
await (await locker.collectFees(token)).wait();

Graduation

Classic V3 / Tax V4 Instant and Bonding all target ~4.2 ETH. Instant graduation is a stage change into the locked pool. Bonding calls the migrator to seed Uni V3 or the Instant V4 graduate sink. Graduation is not a safety seal.

After Instant graduation, keep routing Classic V3 / Tax V4 swaps through PeepsAggregatorRouter. After bonding V4 graduation, use the graduate aggregator (0xE568086a6766351A789b4e87E351Ce312143AF20), not the Instant product aggregator.

Read state

const FACTORY_ABI = [
  "function graduationStatus(address token) view returns (uint256 pairedPrincipal,uint256 threshold,bool graduated)",
];
const factory = new ethers.Contract(A.factory, FACTORY_ABI, provider);
console.log(await factory.graduationStatus(token));

Gotchas

• New Instant creates go through PeepsFactory (Classic V3) or PeepsV4Factory (Tax V4). Bonding creates go through PeepsBondingV3Router / PeepsBondingV4Router.
• Do not confuse Instant Tax V4 creates (0x60796114CF6Ac0759098788e6d4D1F4774556A34) with the bonding V4 graduate sink (0xF68f25bE1861115d81ecD4850f397A9e27126d45).
• Send at least 0.00025 ETH as the Instant launch fee; extra value is for the optional initial buy.
• Classic V3 LP split is 70% / 30% of the 1% pool fee.
• Prefer PeepsAggregatorRouter for Instant buys/sells (including after graduation). Bonding on-curve uses bonding routers; bonding V4 post-grad uses the graduate aggregator.
• Tax V4 has two lines: a 1% LP fee (70/30) and a separate buy/sell tax (1–10%) you set at create. Tax splits must total 100%; dividend holder minimum is product-fixed (~10k tokens).
• Always verify addresses against deployments/4663.json or getDeployment(4663) before mainnet funds move.