Docs

Overview

ArcLaunch is a place to launch and trade tokens on Circle's Arc network. Browse launches, open any token for details, and trade straight from your wallet. Everything is priced in USDC — on Arc, USDC is both the gas token and the quote asset, so you only ever need one asset.

ArcLaunch never holds your funds. Every launch and trade is a transaction your wallet approves. User principal always sits in pools running official Uniswap V3 bytecode; ArcLaunch's own contracts only ever touch the fee stream.

How launches work

Creating a launch deploys the token, creates its USDC pool, seeds the whole supply as single-sided liquidity and locks the LP position in the FeeLocker forever (there is no unlock function). The creator sets the name, symbol, image, description, links and fee wallet.

Every token trades against USDC in its own pool. There is no bonding curve and no migration later. Buys and sells happen in that same pool from the moment it launches.

Launch protection

Buys from the pool are protected for the first 20 blocks after launch (Arc produces a block every 0.5s, so roughly 10 seconds). On the launch block itself only the creator's initial buy can execute. For the rest of the window each wallet can hold at most 5% of supply and buy at most 5.5% per transaction.

Selling and wallet-to-wallet transfers are never restricted, and all limits end once the window closes.

Trading and pricing

The price you see is the live pool price, and it moves with each trade. The amount you actually receive can differ slightly from the quote. Slippage sets how much of that movement you accept.

Graduation

A launch graduates once the USDC paired in its locked pool reaches the threshold (currently $10.0K). The progress line tracks how close a launch is.

Graduation only confirms the threshold was reached. It is not a quality signal and does not guarantee future liquidity, price, or an exit. Trading continues in the same pool after graduation. Nothing moves or migrates; fees and the creator split are unchanged.

Fees and payouts

Trading generates a 1% pool fee. The protocol keeps 25% and the creator keeps 75%. The split is snapshotted for each token when it launches and never changes afterward — before and after graduation alike.

Standard tokens

Standard is the default option on the launch page: a plain ERC-20 with no extra logic. What you send is what arrives — the contract never deducts, adds or blocks. The only trading cost is the Uniswap V3 1% pool fee, and the creator's income comes solely from their share of that fee.

Tax mode

At launch a creator may choose "tax mode": on top of the 1% pool fee, every buy and sell pays a creator-set tax (up to 10% each; the cap is a contract constant). Rates and allocation are immutable fields on the token contract — nobody, including the platform admin, can change them after launch. Standard tokens have zero tax and never touch transfer amounts.

Protocol revenue

Every trade's 1% pool fee is split: project / creator 75%, ARCL buyback & burn 5%, reserve 19%, dev team 1%. The creator's 0.75% is paid straight to the creator's wallet by the FeeLocker; the other 0.25% flows into the automatic settlement contract that settles every 7 days (anyone can call execute(); the keeper triggers it on schedule): 0.19% to the reserve multisig, 0.01% to the dev team wallet, 0.05% into the buyback reserve, then spent in slices buying $ARCL and sending it to the 0x…dEaD burn address (Arc forbids transfers to the zero address). Each slice moves the price at most 1.5%, slices are 10 minutes apart, and every fill must be within 10% of the pool's 10-minute TWAP — MEV protection enforced by the contract. Until the platform token is configured the buyback part accrues in the contract. Creation fees go straight to the reserve multisig. The platform keeps no fund pool: every dollar ends up in the multisig, the dev wallet or the burn address. The ratios, the 7-day cadence and both payout addresses are immutable.

Burning does not guarantee a higher price.

Admin powers

Contracts are not upgradeable. What the admin (a multisig later) can and cannot do is fully public:

Risk disclosures

Tokens launched through ArcLaunch are user-created and experimental. Review the token address, creator, liquidity, holder concentration, and transaction preview before signing.

ArcLaunch is an interface, not investment advice or a representation of token quality.

Integration

Everything reads directly off the contracts. Index factory and pool events for a trust-minimized onchain source of truth.

Network

Contracts

Onchain events

Index the factory's TokenLaunched event, register each emitted pool, and index its Swap events. Onchain events are the authoritative source of truth. There is no migration event; poll graduationStatus(token) for graduation and optionally index token Transfer events for holder balances.

import { createPublicClient, http, parseAbiItem } from "viem";
import { arcTestnet } from "viem/chains";

const client = createPublicClient({ chain: arcTestnet, transport: http() });

const launches = await client.getLogs({
  address: "0x…",
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed deployer, address indexed pool, uint256 positionId, bool isToken0, uint256 restrictionsEndBlock, uint256 graduationThreshold, uint256 initialBuyUsdc, uint256 creationFeePaid)",
  ),
  fromBlock: 0n,
  toBlock: "latest",
});
// The public RPC times out on wide eth_getLogs ranges — backfill in bounded chunks (≤ 2000 blocks).

// isToken0 comes straight from the TokenLaunched event
usdcDelta = isToken0 ? amount1 : amount0   // signed, from the Swap event
side      = usdcDelta > 0 ? "buy" : "sell" // USDC flowing into the pool = buy

Pricing and graduation

Price comes from the pool's slot0. Square sqrtPriceX96 and invert it when the token is not token0 — and mind the decimals: launch tokens are 18dp, USDC is 6dp, so a 10^12 scale applies. pons has 18dp on both sides, so its formula does not carry over.

const [sqrtPriceX96] = await client.readContract({ address: pool, abi: slot0Abi, functionName: "slot0" });

const ratio = Number(sqrtPriceX96) / 2 ** 96;   // sqrt(token1 raw units per token0 raw unit)
const raw   = ratio * ratio;                      // token1 per token0, raw units
// token is 18dp, USDC is 6dp → scale by 1e12
const priceUsdc = isToken0 ? raw * 1e12 : 1e12 / raw;

const supplyTokens = 1e9;
const fdvUsd       = priceUsdc * supplyTokens;
const burned       = Number(await balanceOf(token, "0x000000000000000000000000000000000000dEaD")) / 1e18;
const mcapUsd      = priceUsdc * (supplyTokens - burned);

const [paired, threshold, graduated] = await client.readContract({
  address: factory,
  abi: [parseAbiItem("function graduationStatus(address token) view returns (uint256 paired, uint256 threshold, bool graduated)")],
  functionName: "graduationStatus",
  args: [token],
});
const progress = Number(paired) / Number(threshold); // 0 → 1

// locks(token) → (tokenId, token, quote, pool, creator, payout, creatorShareBps, exists)
const lock = await client.readContract({ address: locker, abi: lockerAbi, functionName: "locks", args: [token] });
const creatorSharePercent = Number(lock[6]) / 100;  // 75
const creatorPayout       = lock[5];                 // may differ from the deployer

Self-describing tokens

const tokenAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function logo() view returns (string)",
  "function description() view returns (string)",
  "function liquidityPool() view returns (address)",
  "function deployer() view returns (address)",
  "function restrictionsEndBlock() view returns (uint256)",
  "function socials() view returns (string website, string twitter, string telegram, string discord, string farcaster)",
  // tax mode (0/0 = standard token); all immutable
  "function taxConfig() view returns (uint16 buyBps, uint16 sellBps, address marketing, address team, uint16 marketingShareBps)",
]);

REST / WebSocket

ArcLaunch's own indexer is public for quick integrations (not authoritative — the chain is):

Versioning and terms

Versioning

Deployed contracts are immutable. New versions ship as new Factory / Locker addresses listed under Contracts; tokens launched on an older version keep trading there and are never moved. Once official Uniswap V4 is live on Arc a new factory may target it, again without touching existing tokens.

Terms

Onchain data is public and free to read; you are responsible for how you use it. ArcLaunch is provided as is, without warranties, and the team is not liable for losses arising from integrations, interfaces, RPCs, or indexers. When referencing ArcLaunch, link back to the app; do not imply a partnership, endorsement, or official status without written agreement, and do not use the ArcLaunch name or marks in a misleading way. ArcLaunch is not an official Arc or Circle product.

Community and support

For integration, indexing, pricing or onchain-state questions, DM us on X: @ArcLaunch_.