DocsDocumentation

• A trading terminal for coins launched on our own bonding curve, on Arc.
• Non-custodial: quotes and transactions build in your browser, your wallet signs. No deposits.
• Reading is public and anonymous - no account needed until you trade.
• Every number derives from indexed on-chain events. Nothing is shown optimistically.

• OHLCV on 1m / 1h / 4h / 1d, your own fills marked.
• Curve bars and post-graduation pool bars are ONE series - same asset, same price.
• Plus: trade tape, holder list (venues broken out), per-wallet totals, 5m/1h/6h/24h rollups.
• FDV = price x TOTAL supply - most of it never bought on a bonding coin. Not money in.
• Curve progress = ethReserve / bondingTarget - how full the raise is, not how far price moved.

• One widget, both sides. Quoted by the contracts: quoteBuyFor/quoteSell on the curve, V4Quoter once graduated. Fees and impact included.
• Slippage is a HARD bound - the transaction reverts rather than filling worse. Persists locally.
• Presets fill the field, never submit: buys in USDC, sells in % of position.
• Buy = 1 transaction. First sell of a graduated coin can need up to 2 approvals, then none.
• No limit orders, no stops, no margin. Fills appear when the indexer confirms them.

• Three live lanes: new / bonding / graduated. Stage is a position, not a badge.
• Each lane sorts + filters independently (age, volume, FDV, holders, progress, top-10, dev-sold).
• Starring adds to your watchlist - and gets that coin's full tape instead of the sampled stream.
• Ranking is not for sale: organic signals key on unique buyers, volume, wallet age.

• Per-wallet, per-coin PnL in USDC. Moving-average cost basis.
• Realised locks in at each sell and is never restated. Unrealised = value now minus basis.
• Curve coins are valued at the real exit quote (price impact included); graduated coins at last price x balance.
• Only curve trades are counted: airdropped/transferred-in tokens read as zero-basis profit.
• Holdings and PnL are public per address - the chain keeps no secrets.

• Token launchpad + trading terminal on Arc.
• Non-custodial: your wallet signs everything. The platform never holds keys or funds.
• A coin's quote is USDC or a platform-approved ERC-20 (a tokenized stock). There is no platform token.
• Open trading - humans and bots, no permits, no transfer lock.
• A filled curve graduates into a permanently locked Uniswap v4 pool. See Locked liquidity.
• Creators pick the coin's economics from contract-enforced menus. See Launch strategies.

• Fixed 1,000,000,000 supply. No mint function, ever.
• 77.8% sells on the bonding curve; 22.2% is reserved for the graduation pool.
• Price rises as the curve fills - it opens at 36.7% of the raise as FDV, graduates at 12.25x the floor.
• The token is a plain ERC-20 from day one - no transfer lock, and the pool still cannot be front-run.
• Hit the target and the coin graduates automatically, inside that same buy.

• Beyond name + raise, the creator picks the coin's economics from CONTRACT-enforced menus.
• Off-menu = revert, not rounding. Snapshotted at launch, carried into the pool at graduation.

• Every dial only ever moves DOWN or OFF afterwards: the creator can lower the pool fee (lowerFee).
• The creator's share is the PIE: compounding commit + burn commitment are percentages of it, never of the whole fee, and together never exceed it; the rest stays the creator's. Burn 100% with compounding off = burn everything.
• Only exceptions, same direction: raiseCompoundCommit and raiseBurnShare deepen a commitment later, eating the creator's own remainder. Never down.
• A coin keeps the menu of the release it launched on, forever. Read the COIN, not this table.

• While the platform's sniper window is set (at most 30s, snapshotted per coin), a non-exempt buy on a fresh curve pays a 99% fee decaying linearly to the base fee. Sells never pay it.
• The clock starts when the sale OPENS - the launch, or a gated launch's reserved first buy - so it cannot be run down while only the creator may buy.
• Exempt: the creator, the dev-buy wallet, and up to 30 wallets named at launch (sniperExempt). Fixed at launch, logged - a bundle lists its wallets or pays.
• What it collects is an ordinary trade fee: the coin's pot, the live split.
• Quotes are per wallet: quoteBuyFor(token, buyer, gross). Quote the wallet that will sign - an anonymous quote is the worst case.

• On the curve: buy / sell on the curve contract. Quote first with quoteBuyFor / quoteSell - never hand-roll the price.
• Every trade has a slippage bound; it reverts instead of filling past it.
• Graduated: swaps go through the Universal Router on Uniswap v4; V4Quoter quotes with the fee already included.
• Buys are one transaction. A wallet's first sell can need up to two approvals, then none.

• Happens automatically inside the buy that completes the curve - nobody triggers it.
• One atomic transaction: token ownership renounced, the coin's migration fee (deployed at 0) skimmed off the raise, pool seeded at the curve's exact closing price.
• The liquidity is locked forever - see Locked liquidity for the proof.
• The seed is balanced: the whole raise and the whole reserved supply go in. Nothing is burned but rounding dust - 100% of supply is tradeable.

• Nobody can withdraw a graduated coin's liquidity. Not the creator, not the platform, not the owner key. Ever.
• How: the graduation position is a Uniswap PositionManager NFT owned by the burn address 0x...dEaD. Only the NFT's owner can touch the position, and nobody holds that key. No owner = no rug.
• Check it yourself - the migrator names the NFT, Uniswap says who owns it and that it IS the pool:

# 1. The burned position NFT behind the pool (the migrator's own record).
cast call 0x7c8dE42426A058B778DCe8530537cd62eF0178C4 \
  'positionTokenIds(bytes32)(uint256)' <POOL_ID> \
  --rpc-url https://rpc.mainnet.arc.io

# 2. The pool's TOTAL liquidity (StateView is Uniswap's own lens, not our code).
cast call 0xF3334192D15450CdD385c8B70e03f9A6bD9E673b \
  'getLiquidity(bytes32)(uint128)' <POOL_ID> \
  --rpc-url https://rpc.mainnet.arc.io

# 3. That NFT's position: owner = the PositionManager, full range (-887200 to 887200), salt = the tokenId (as bytes32).
cast call 0xF3334192D15450CdD385c8B70e03f9A6bD9E673b \
  'getPositionInfo(bytes32,address,int24,int24,bytes32)(uint128,uint256,uint256)' \
  <POOL_ID> 0x6049c9a0e26405C0985f9E3685C87d0aE917f82B -- -887200 887200 \
  $(cast to-uint256 <TOKEN_ID>) \
  --rpc-url https://rpc.mainnet.arc.io

# 4. Who owns that NFT - the burn address, so nobody can ever modify the position.
cast call 0x6049c9a0e26405C0985f9E3685C87d0aE917f82B \
  'ownerOf(uint256)(address)' <TOKEN_ID> \
  --rpc-url https://rpc.mainnet.arc.io

# The first number of (3) equals (2), and (4) is 0x000000000000000000000000000000000000dEaD: 100% of the liquidity
# sits in a burned position.

LP-lock checker sites read this as LP burned - the shape they already recognize. The reads above are the proof.

• Three fees: a flat launch fee, a trade fee in the coin's quote asset (the sniper tax is this fee at a higher rate), and a migration skim at graduation (off the deposit, never the price; deployed at 0).
• All owner-tunable - read them live off the curve (launchFee(), feeBps(), migrationFeeBps()), never trust a printed number.
• Graduated pools: LP fee is 0; the LaunchpadHook charges a base fee in the pool's quote asset, split creator / treasury at the LIVE platform dial. The hard 40% floor bounds the creator's GROSS share; a compounding commit then slices inside it.
• The base rate is the floor, and one optional mechanism rides on top of it, documented in its own section below: a platform-level graduation-block surcharge.
• Fees can be redirected rather than paid out: compounding locks them into the pool, a fee-burn commitment buys and burns with them.
• No rent, no listing fee, anywhere. Ranking is never for sale.

Read live from the curve just now, this deployment charges $0.001 to launch, 1% per trade, and 0% at migration. Read live from the chain just now, that split is 70% creator (gross - a compounding commit slices inside it) / 30% treasury.

• Pool LP fee is 0. The hook charges the real fee in the pool's quote asset, both directions.
• The base rate is the CREATOR's pick from a fixed menu: 0.3% / 0.5% / 1% / 1.5% / 2% / 2.5% / 3% / 4% / 5% / 7.5% / 10%. 0 means "hook default", not "no fee".
• Bytecode ceiling: MAX_FEE_BPS = 10%. Nothing on this stack can exceed it.
• lowerFee accepts strictly lower menu values only. No code path raises a fee.
• Read the live rate off quoteFees (base + any active window), not the menu.

• A creator COMMIT picked at launch: none, or 10% / 20% / 30% / 40% / 50% of the creator's own fee share is locked back into the pool as liquidity, forever. Same pie as the burn commitment - the two never exceed the share together.
• Multiplicative split: creator-gross / treasury at the LIVE platform dial (hard 40% gross floor), the commit slicing inside the gross. At the 70/30 deploy dial a 20% commit = 56% creator / 14% compounding / 30% treasury.
• Deploys as single-sided quote asset in a band just under price - a standing bid. No swap executes, so there is no execution price to attack.
• Triggers inline in the swap that crosses the settle threshold. No keeper, no oracle.
• Bands ladder upward as price climbs; old ones stay as deeper crash protection. No removal verb.
• raiseCompoundCommit deepens the commit post-launch, 0 to any stop included. There is no verb back down, by design.

• Flat 20% on any swap, EITHER direction, landing in the block the pool initialized in.
• That block contains no organic humans by construction - only pre-computed key sprays, back-run bundles, and atomic complete-then-buy contracts.
• Also covers the graduation-block DUMP on coins that chose no sell window.
• Platform-level, not creator-cancellable - there are no real buyers in that block to protect.
• A live operator toggle. OFF lowers immediately; ON can only bind on pools that have not graduated yet, so it can never raise a live coin's fee.

• Any creator can hand their pool's fee seat to a contract that buys the coin and burns it.
• BuybackBurner = the whole stream. FeeSplitter = a live percentage ( burnShareBps ) of the creator's WHOLE share (gross, before any compounding slice), rest paid out. A third leg, the holder share, sits beside them - same pie, raise-only (raiseHolderShare): those fees pool per coin and are pushed to holders in verified rounds, daily or when the pot hits the creator's threshold, split by balance held over time.
• Pickable on the launch form: none, or 10% / 20% / 30% / 40% / 50% / 60% / 70% / 80% / 90% / 100%. Two signed txs (launch, then the factory deploy against the predicted pool, which seats the clone as the coin's creator on the curve in the same tx - commitSeat). Committed and locked from that block: no re-point, no handoff, the seat crosses to the hook verbatim at graduation, raiseBurnShare the only move. No pending phase - a coin whose deploy never landed has no burn at all. The sale pays the clone only while creator curve fees are on (an owner switch, shipped off).
• Irreversible by ABSENCE OF CODE: the clone has no proposeCreator, so the seat can never leave again.
• checkpoint() photographs spot price; burn() runs only 30s-15min later and only inside a band around it. minOut comes from the checkpoint, never the caller.
• Burns are sized to live pool depth, so a thin pool burns dust rather than bricking.
• Verify before believing: isFactoryBurner / isFactorySplitter on the factory.

• Tokens here are experimental - volatile, illiquid, possibly worthless. Only risk what you can lose.
• Contracts may have bugs. On-chain transactions are irreversible.
• Anyone can clone a name or ticker - always verify the full contract address.
• Exits are never guaranteed. The launch stack has not yet completed an external audit.

Full terms: Terms of Use and Privacy Policy.

• Creator went quiet? The community can apply to take the coin over (CTO).
• The fee pays for a manual review. Non-refundable, and it buys a decision - never approval.
• States: awaiting-payment to pending to accepted / refused, always with a written reason.
• On acceptance the platform recognises the new creator; the on-chain fee recipient moves in a separate transaction - watch for it.

Curve release	9.0
BondingCurveV4	0x6A62919ccbf0c19e0C4e084F986b582b4492dDA4
UniswapV4Migrator	0x7c8dE42426A058B778DCe8530537cd62eF0178C4
LaunchpadHook	0x47e7936ae9891e61C5123db720593c05dE7120cc
Uniswap v4 PoolManager	0x8366a39CC670B4001A1121B8F6A443A643e40951
Uniswap v4 PositionManager	0x6049c9a0e26405C0985f9E3685C87d0aE917f82B
V4Quoter	0x8Dc178eFB8111BB0973Dd9d722ebeFF267c98F94
StateView	0xF3334192D15450CdD385c8B70e03f9A6bD9E673b
Universal Router	0x4fcA4a51Ab4F23A7447b3284fBd7D73289A89Fb1
Permit2	0x000000000022D473030F116dDEE9F6B43aC78BA3
Payments	0x80560C3384210c09A301b6aB2F5404c9674719A1
BurnerFactory (fee-burn commitments)	0xCEC9C59E1E79908e80a3BCFE7719BfDd469f5f63
HolderDistributorRegistry (holder payouts)	0xfe93F55a669E0048aC608A947dD1EAAbCa4E5C11
HolderDistributor (per-coin pot, clone implementation)	0xAD04f00bc6dCA4D7a8Dc2Dd5f0139266aD55B096

Resolve addresses at runtime (platform API or launch record) - never hardcode them.

Mirror these signatures exactly - a drifted type changes the topic hash and matches nothing.

struct LaunchTerms {
  uint256 bondingTarget; uint16 feeBps; uint16 migrationFeeBps; address migrator; bool active;
  uint16 launchSellFeeBps; uint32 launchSellFeeDecay; uint16 poolFeeBps; bool compounding;
  uint16 launchBuyFeeBps; uint32 launchBuyFeeDecay; uint16 compoundCommitBps; bool creatorCurveFees;
  address quoteToken; uint32 sniperTaxWindow;
}
event Launched(
  address indexed token, address indexed creator, LaunchTerms terms,
  string name, string symbol, string tokenURI
);
event SniperExemptionsSet(address indexed token, address[] wallets);
event Bought(
  address indexed token, address indexed buyer,
  uint256 ethGross, uint256 fee, uint256 tokensOut,
  uint256 ethReserve, uint256 tokenReserve
);
event Sold(
  address indexed token, address indexed seller,
  uint256 tokensIn, uint256 fee, uint256 ethOut,
  uint256 ethReserve, uint256 tokenReserve
);
event Completed(address indexed token, address indexed buyer, uint256 finalRaise);
event Abandoned(address indexed token, address indexed by, uint256 raise);
event Graduated(
  address indexed token, address indexed pool, address migrator,
  address caller, uint256 ethMigrated, uint256 migrationFee, uint256 liquidity
);

• getCoin(token) is the canonical state; quoteBuyFor / quoteSell give exact fills.
• abandoned true = reopened sell-only, buys revert. active false = waiting for the creator's first buy.
• Name, symbol, artwork and description live on the token contract itself, immutable.

import { createPublicClient, http, parseAbi } from 'viem';

const abi = parseAbi([
  'struct Coin { address creator; address devBuyer; address migrator; address quoteToken; uint16 feeBps; uint16 migrationFeeBps; bool complete; bool graduated; bool active; bool abandoned; bool creatorCurveFees; uint16 poolFeeBps; uint16 launchSellFeeBps; uint32 launchSellFeeDecay; uint16 launchBuyFeeBps; uint32 launchBuyFeeDecay; uint16 compoundCommitBps; uint32 sniperTaxWindow; uint64 openedAt; uint64 completedAt; uint256 ethOffset; uint256 ethReserve; uint256 tokenReserve; uint256 bondingTarget; uint256 accrued; }',
  'struct BuyQuote { uint256 tokensOut; uint256 ethUsed; uint256 tradeFee; bool completes; }',
  'function quoteBuyFor(address token, address buyer, uint256 ethGross) view returns (BuyQuote quote)',
  'function getCoin(address token) view returns (Coin coin)',
  'function quoteSell(address token, uint256 tokensIn) view returns (uint256 ethOut, uint256 ethGross, uint256 fee)',
]);

const client = createPublicClient({ transport: http('https://rpc.mainnet.arc.io') });
const curve = '0x6A62919ccbf0c19e0C4e084F986b582b4492dDA4';

// Canonical current state and a quote - both read straight off the contract. The quote names the BUYER: inside a
// coin's sniper-tax window an exempt wallet and a stranger pay different fees, so quote the wallet that will sign.
const coin = await client.readContract({ address: curve, abi, functionName: 'getCoin', args: [token] });
const quote = await client.readContract({
  address: curve, abi, functionName: 'quoteBuyFor', args: [token, buyer, 10n ** 16n], // 0.01 of the quote, gross
});

• Buy: buy(token, quoteIn, minTokensOut), value = quoteIn on a native-quoted coin (approve the curve instead on an ERC-20 quote).
• Sell: approve(curve, tokensIn), then sell(token, tokensIn, minEthOut). No Permit2 on the curve.
• Quote first, always pass a slippage floor; a completing buy graduates the coin inline.

import { createPublicClient, createWalletClient, http, parseAbi } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const abi = parseAbi([
  'struct BuyQuote { uint256 tokensOut; uint256 ethUsed; uint256 tradeFee; bool completes; }',
  'function quoteBuyFor(address token, address buyer, uint256 ethGross) view returns (BuyQuote quote)',
  'function quoteSell(address token, uint256 tokensIn) view returns (uint256 ethOut, uint256 ethGross, uint256 fee)',
  'function buy(address token, uint256 quoteIn, uint256 minTokensOut) payable returns (uint256 tokensOut)',
  'function sell(address token, uint256 tokensIn, uint256 minEthOut) returns (uint256 ethOut)',
  'function approve(address spender, uint256 amount) returns (bool)',
]);

const transport = http('https://rpc.mainnet.arc.io');
const client = createPublicClient({ transport });
const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const wallet = createWalletClient({ account, transport });
const curve = '0x6A62919ccbf0c19e0C4e084F986b582b4492dDA4';
const token = '0x...'; // a coin still on the curve (state curve-trading)

// BUY a coin quoted in the native token: quoteIn and msg.value must be EQUAL (NativeValueMismatch otherwise).
// An ERC-20-quoted coin (getCoin(token).quoteToken != 0) instead approves the curve for quoteIn and sends NO value.
const quoteIn = 10n ** 16n; // 0.01 of the quote, gross (the fee comes off this)
const q = await client.readContract({ address: curve, abi, functionName: 'quoteBuyFor', args: [token, account.address, quoteIn] });
const minTokensOut = (q.tokensOut * 99n) / 100n; // 1% slippage floor
await wallet.writeContract({ address: curve, abi, functionName: 'buy', args: [token, quoteIn, minTokensOut], value: quoteIn });

// SELL on the curve: approve the CURVE itself for exactly tokensIn (no Permit2 while the coin is bonding), then sell.
const tokensIn = 1_000_000n * 10n ** 18n;
const [ethOut] = await client.readContract({ address: curve, abi, functionName: 'quoteSell', args: [token, tokensIn] });
await wallet.writeContract({ address: token, abi, functionName: 'approve', args: [curve, tokensIn] });
await wallet.writeContract({ address: curve, abi, functionName: 'sell', args: [token, tokensIn, (ethOut * 99n) / 100n] });

• Price = (ethOffset + ethReserve) / (TOKEN_OFFSET + tokenReserve). BOTH offsets are required - dropping the token offset overprices by 40%+.
• Progress = ethReserve / bondingTarget.
• For real amounts, trust the on-chain quote over any re-derived spot price.
• Graduated: PoolId = keccak256 of (quote asset and token, sorted by address; fee 0; spacing 200; hook). Price via StateView.getSlot0 (mind which side the quote is on), quotes via V4Quoter.

• Everything is public on-chain state - read it over the RPC, no keys, no account, nothing from us.
• A typed TypeScript SDK wraps the platform API - see the SDK page.
• Bots, programmatic trading, partnerships: hello@faze.fun.

• Every SDK method is a plain HTTP call. Paths are relative to https://faze.fun/api/v1.
• Reads are anonymous; session-scoped ones carry the wallet-link cookie.
• Full schemas: https://faze.fun/openapi.json, generated from the client's own validators. Public surface only - admin and ad-booking routes are deliberately absent.
• Coins by mint, wallets by address, both EIP-55 (any casing accepted).
• Lists are keyset-paginated: pass nextCursor back as ?cursor=. It is opaque and bound to its sort.
• Errors are { "error": "<identifier>" }. Branch on the identifier, never the message. Bad wallet param = 400, unknown mint = 404.

• Questions, bugs, partnerships: hello@faze.fun.
• Attribute Faze data to the platform and link back where practical.
• Contract data is as-is - no warranty. Verify anything you rely on against the chain.