Everything about Bull Launch, in one place.

Getting started

Bull Launch runs on Arc Chain Testnet. Nothing here has real value, which makes it the place to try the whole flow.

Add Arc Testnet 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 Chain Testnet. It is the chain's native coin, so it pays gas and it is also what most coins are priced in. Test USDC comes from Circle's faucet at faucet.circle.com.

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 bulllaunch.fun and run through the full loop: create a coin, buy and sell on its curve, and watch it climb toward graduation.

Overview

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

Key facts

• Running on testnet. Balances carry no value, and the contracts may be redeployed.
• 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: the launcher factory's 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.

1. CreateThe 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. TradeBuys and sells move price through the main band. Every trade reports its own progress toward graduation as progressBps.
3. GraduateOnce the main band has taken in its fill amount, it is withdrawn and redeployed as a permanently locked position in the same pool.

The pre-buy is worth understanding before you trade a brand new coin: a creator can take a large share of the main band in the same transaction that creates it. Read the launch transaction, not just the chart.

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.

Spending an ERC-20 takes two permissions, not one. The Universal Router pulls an ERC-20 through Permit2, so the token must allow Permit2 (a transaction) and Permit2 must allow the router (a signature, replayed inside the swap). Selling a coin therefore asks for both the first time. A buy paid in native USDC needs neither.

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 each coin's page tracks, 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 the hook 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 the launcher locker. 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 most of it, the protocol keeps a 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 the hook holds 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 Hook.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. See also the fees page.

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 the hook. Only the current creator or a hook operator can move it. To request one, reach the team through Support.

Risk disclosures

• This is testnet. Balances have no value, and the deployment may be replaced without notice.
• 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.
• Bull Launch is an interface, not investment advice or a representation of token quality.

Network

Bull Launch runs on Arc Chain Testnet. Each coin lives in its own Uniswap v4 pool from launch through graduation.

Contract addresses

Every Bull Launch deployment, with the transaction that created each contract. The Bull Launch contracts reference each other in both directions, so any one of them can be checked against the rest on chain.

Mainnet deployments

None yet. Bull Launch runs on testnet only; this list will name the mainnet contracts once they are live.

Testnet deployments

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 ConfigRegistry.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.

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.

baseFillAmountActual(base) is the figure the hook actually settles against, and it is slightly above fillAmount because the band is priced in ticks and the target lands inside one. Use it when you need the exact raise, and fillAmount when you need the number the protocol advertises.

Onchain events

For a trust-minimized integration, index the launcher factory for new coins and the hook 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.

Every topic0 above is computed from the ABIs this app trades through.

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 Chain Testnet client
import { createPublicClient, http, keccak256, encodeAbiParameters, zeroAddress } from "viem";

const arc = {
  id: 5042002,
  name: "Arc Testnet",
  nativeCurrency: { name: "USD Coin", symbol: "USDC", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.testnet.arc.io"] } },
  contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } },
};
const client = createPublicClient({ chain: arc, transport: http() });

const HOOK     = "0xe332196A3bf409899E990846373cf47255e7b044";
const REGISTRY = "0xaB53045522C110DEB14f46f39322f5bD43956bD1";

// Pool key is fixed by the factory: dynamic fee flag, tick spacing 60, the hook.
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, the indexer behind Bull Launch 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.bulllaunch.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
    } }`,
  }),
});

Support

For integration questions, technical support, and partnership requests, open the support panel. It is also at the bottom of every page.

Terms and attribution

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

• When you reference Bull Launch, write the name as "Bull Launch" or "bulllaunch.fun" and link back to the app.
• Do not present third-party services as operated by Bull Launch.
• 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: Terms and Privacy.