Everything about Wonk, in one place.

Getting started

Wonk runs on Arc mainnet. Everything here moves real funds, and a submitted transaction cannot be recalled.

Add Arc to your wallet

The app offers to add the network for you on first connect, so these values are here for wallets that add a chain by hand and for backend services.

Fund a wallet

Bring USDC on Arc. It is the chain's native coin, so it pays gas and it is also what most coins are priced in. There is no faucet: this is mainnet.

A launch itself costs no protocol fee, only gas, so the practical minimum is gas plus whatever you want the launch to open with.

Try it end to end

Connect a wallet on wonk.fun and run through the full loop: create a coin, buy and sell on its curve, and watch it climb toward graduation.

Overview

Wonk is a fair-launch memecoin platform on Arc. Anyone can create a coin, and every coin trades on the same curve shape against one of the whitelisted base assets.

Wonk never holds your funds. Every launch and trade is a transaction your wallet asks you to approve.

Key facts

• Live on mainnet. Tokens and trading activity carry real value and real loss.
• Names and symbols can be copied. Always check the contract address.
• Prices come from each token's own Uniswap v4 pool, not a fixed rate.
• Launches can be volatile, illiquid, or lose all value.
• Deployed contracts are immutable. Nothing here can be paused or rolled back for you.

How launches work

Creating a launch deploys the coin and opens its market in a single transaction: WonkLauncherFactory.launch deploys the token, creates its config, opens the Uniswap v4 pool, locks the tail band, and optionally buys for the creator. The creator sets the name, symbol, image, description, and links at creation.

There is no separate curve contract and no later migration. The pool a coin graduates into is the pool it was born in.

1. 01

   Create

   The whole supply is minted once and split between two ranges of one Uniswap v4 pool: the main band, which is what trades, and the tail band, which is locked immediately and forever.

2. 02

   Trade

   Buys and sells move price through the main band. Every trade reports its own progress toward graduation as progressBps.

3. 03

   Graduate

   Once the main band has taken in its fill amount, it is withdrawn and redeployed as a permanently locked position in the same pool.

Trading and pricing

Every coin trades in its own Uniswap v4 pool against one base asset chosen at launch. The price you see is that pool's live price, and it moves with each trade. Slippage sets how much movement you accept.

A coin priced in one base is still buyable with another: the bases are paired with each other on Arc's Uniswap deployment, so the app routes a buy through the pool in between and the trade settles in one transaction.

Graduation

A launch graduates once its main band has taken in its configured fill amount of the base asset. Progress toward that amount is what "Closing in" tracks on the Explore page, and what progressBps reports on every CurveBuy and CurveSell.

There is no migration step, and no second pool. A launch is a Uniswap v4 pool from the moment it is created, because WonkHook is part of its pool key. On the swap that crosses the fill target, the hook withdraws the main band whole inside afterSwap and redeploys the proceeds as a locked position held by WonkLauncherLocker. The pool id never changes, so an integration that indexed the pool before graduation keeps working after it.

Graduation only confirms the threshold was reached. It is not a quality signal and does not guarantee future liquidity, price, or an exit.

Fees and royalties

Trading generates a swap fee. The creator keeps almost all of it, the protocol keeps a small share, and a creator may also have set a separate tax at launch.

The split is settled at claim time rather than at swap time, so feePolicy() on the hook is the live value and the numbers above are what is deployed today.

How creators claim their royalty

From the coin's page on the app, which calls WonkHook.claimFees(poolId, minOut). Two things are worth knowing:

• The claim is not permissionless. Only the pool's creator or one of the hook's operators may call it.
• A pool accrues fees in both currencies, and token-denominated fees are sold into the base asset inside the claim. That sale is what minOut bounds, which is why a claim can revert with SlippageExceeded.

A creator can hand the payout over without moving the coin: transferCreator for an immediate transfer, or proposeCreatorTransfer and executeCreatorTransfer for a two-step one.

What the protocol share funds

It is paid to the Treasury contract listed under Contracts, which is where every protocol-side fee accrues. There is no buyback or burn mechanism in the deployed contracts.

Community takeovers

When a coin's original creator steps away, the community can request a takeover. A takeover transfers the social presence and, where applicable, the creator royalty payout to an active community.

Onchain, this is the creator handover described under Fees and royalties: transferCreator, or the two-step proposeCreatorTransfer and executeCreatorTransfer on WonkHook. Only the current creator or a hook operator can move it.

To request one, reach the team on any of the channels under Support.

The coin, its pool, and its locked liquidity are unaffected. Only the creator payout wallet and creator-facing surfaces change. Never share a private key or seed phrase; Wonk will never ask you to send funds to process a request.

Risk disclosures

• This is mainnet. Funds are real, and a submitted transaction is irreversible.
• Prices can move quickly and liquidity can be thin.
• A creator's opening buy is uncapped and happens in the launch transaction. Read the launch before trading a new coin.
• Similar names and images can represent unrelated tokens. The contract address is the only identity that matters.
• Smart contracts, wallets, RPCs, and indexers can fail.
• Displayed values are estimates, not execution guarantees.
• Deployed contracts are immutable. There is no admin who can reverse a trade or recover a mistaken transfer.

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

Network

Wonk runs on Arc mainnet. Each coin lives in its own Uniswap v4 pool from launch through graduation.

Contracts

Deployed addresses on Arc (5042). Every one carries code, and the Wonk contracts reference each other in both directions.

Wonk

Uniswap v4 on Arc

Base assets and curves

A launch is priced in exactly one base asset, chosen at creation from what the registry whitelists. Read the live list from WonkConfigRegistry.getEnabledBases() rather than hardcoding it: the owner can add or drop an entry at any time, and a launch against a base that is not enabled reverts with BaseNotAllowed.

Two are enabled on mainnet today.

Each base carries its own curve on the registry, read as baseCurve(base) returning (startAmount, fillAmount). startAmount is the valuation a launch opens at and fillAmount is what the main band must take in to graduate, both denominated in that base.

Onchain events

For a trust-minimized integration, index WonkLauncherFactory for new coins and WonkHook for curve activity and graduation. The pool id is stable from launch, so you can register a coin's pool once and index PoolManager swaps for it from then on.

Reading token and curve state

A pool id is derived, not looked up. It is keccak256(abi.encode(PoolKey)), and the two currencies have to be sorted by address rather than written base first: native USDC sorts below every launched token, but a base that sorts above one gives a mirrored pool, and an unsorted key produces an id that matches no pool at all. launches() then returns zeroes and the coin reads as "not a launch" instead of failing loudly.

// Arc mainnet client
import { createPublicClient, http, keccak256, encodeAbiParameters, zeroAddress } from "viem";

const arc = {
  id: 5042,
  name: "Arc",
  nativeCurrency: { name: "USD Coin", symbol: "USDC", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.mainnet.arc.io"] } },
  contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } },
};

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

const HOOK     = "0x21bdc377265e2A26ba336F24381E67e768253044";
const REGISTRY = "0xA94601CB7AFC7Ae6a31ab1bB1ccBD1ffc6f4Be9A";

// Pool key is fixed by the factory: dynamic fee flag, tick spacing 60, WonkHook.
const DYNAMIC_FEE_FLAG = 0x800000;
const TICK_SPACING = 60;

// Sorted by address, not base first. This is the one step that silently
// returns a wrong-but-valid id if you skip it.
function poolIdOf(token, base = zeroAddress) {
  const [currency0, currency1] =
    BigInt(base) < BigInt(token) ? [base, token] : [token, base];
  return keccak256(
    encodeAbiParameters(
      [{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }],
      [currency0, currency1, DYNAMIC_FEE_FLAG, TICK_SPACING, HOOK]
    )
  );
}

With the id in hand, everything else is a view call. The functions below are the ones the app itself reads.

Indexer API

If you do not want to index the chain yourself, Wonk's own indexer answers GraphQL over HTTP, and a WebSocket per token for live market and discussion updates. It is the same API the app uses.

Every paged response carries a checkpoint { blockNumber timestamp }. Check it before trusting a figure: it tells you how far behind the chain the answer is, and it is the fastest way to tell an indexer that is merely lagging from one following the wrong chain.

// The newest launches, the same query the home page runs
const r = await fetch("https://api.wonk.fun/graphql", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    query: `query { discoverLaunches(order: NEW, first: 5) {
      nodes { token { address symbol } market { poolId } bondingProgressBps }
      endCursor hasNextPage
    } }`,
  }),
});

Reference token

A graduated coin is the most useful thing to validate an indexer against, because it exercises the whole path: launch, curve trades, the crossing swap, and post-graduation swaps in the same pool.

A second graduated coin, priced in WONK rather than in the native coin, is the one to check a mirrored pool key against:

Recompute both ids with poolIdOf from Reading token state and check them against the poolId the indexer reports. If they match, your key, your sort order and your hook address are all correct, which is where integrations usually go wrong.

Support

For integration questions, technical support, and partnership requests:

• X: @wonk_fun
• Telegram: t.me/wonkdotfun

Versioning means new addresses, not upgrades. Deployed contracts are immutable, so a new version ships as a new factory and a new hook, and because the hook is part of every pool key, every pool id changes with it. Coins from an older deployment stay tradeable at their own addresses but are invisible to the new one. Always pin the addresses under Contracts for the version you integrated against.

Terms and attribution

Onchain data is public and free to read. You are responsible for how you use it. Wonk is provided as is, without warranties, and the team is not liable for losses arising from integrations, interfaces, RPCs, or indexers.

• When you reference Wonk, write the name as "Wonk" or "wonk.fun" and link back to the app.
• Do not present third-party services as operated by Wonk.
• Do not imply a partnership, endorsement, or official status without a written agreement.
• Availability of interfaces and public infrastructure is not guaranteed.

The full terms and the privacy policy live on the app: wonk.fun/terms and wonk.fun/privacy.