How ArcLauncher works.

ArcLauncher is a token launchpad on Arc (chain ID 5042), Circle’s stablecoin-native L1 where gas is paid in USDC. One transaction deploys a fixed-supply ERC-20, opens a TOKEN / USDC Uniswap v4 pool, puts the entire supply in it and locks the liquidity position for 2, 5 or 10 years.

There is no bonding curve, no migration and no graduation step: the token trades on Uniswap from its first block, against native USDC, with a price quoted in dollars. The creator earns 85% of the pool’s trading fees for the life of the lock; the other 15% goes to the protocol, and its USDC part is paid out to $ARCL holders.

ArcLauncher runs only on Arc mainnet. Arc is EVM-compatible, so any wallet that supports custom networks works. The one difference is that the native gas token is USDC instead of ETH.

Chain ID

5042

Native token

USDC

18 decimals as msg.value, like ETH

Finality

Sub-second

Deterministic, no reorgs to wait for

Min base fee

20 gwei

≈ $0.00002 per 1,000 gas

Public RPC

rpc.mainnet.arc.io

Explorers

explorer.arc.io · arc.etherscan.io

USDC (ERC-20 view)

0x3600…0000

Same balance, 6 decimals

From Create, fill in a name, ticker, description and logo, choose a starting market cap and a lock duration, optionally add a first buy, and sign once. The app calls launch() on the Launchpad contract, which does all of this atomically:

1. 01
   Deploys a full token contract via CREATE2 and mints the whole 1,000,000,000 supply to the Launchpad in its constructor.
2. 02
   Initialises a Uniswap v4 pool TOKEN / native USDC, 1% fee, tick spacing 200, no hook, at the price that matches your starting market cap.
3. 03
   Mints a single-sided position holding 100% of the supply, from the starting price upward, so no USDC is needed to seed it.
4. 04
   If you attached USDC, runs your first buy on the fresh pool and sends the tokens to your wallet. Nobody can buy before you: it is the same transaction.
5. 05
   Transfers the LP position NFT to the LP locker with your lock date and fees recipient, refunds any rounding dust, records the launch and emits Launched.

Launch fee

None

You only pay gas: about 1.6M gas, ≈ $0.03

Supply

1,000,000,000

Fixed, all of it in the pool

Pool

Uniswap v4 · 1% · spacing 200

hooks = address(0)

Lock

2, 5 or 10 years

Chosen at launch, cannot be shortened

First buy

Optional, in USDC

Keep about 0.1 USDC aside for gas

Fees recipient

Your wallet by default

Any address, fixed for the life of the lock

Name / ticker

≤ 32 chars / 1–8 [A-Z0-9]

Description ≤ 256 chars

With a fixed 1B supply, price and market cap are the same number read differently: a $5,000 start means one token costs $0.000005. The pool’s starting tick is the multiple of 200 closest to that price, so the real figure lands within a percent of the preset.

// token = currency1, native USDC = currency0 (both 18 decimals)
tokensPerUsdc(tick) = 1.0001 ^ tick
startTick           = round(log(supply / marketCapUsd) / log(1.0001) / 200) * 200
marketCap(tick)     = supply / 1.0001 ^ tick
marketCap(sqrtP)    = supply / (sqrtPriceX96 / 2^96)^2

How the price moves

The whole supply sits in one range that starts at the launch price and extends to the top of Uniswap’s price scale. Buys add USDC to the pool and push the price up along that range; sells take USDC out and bring it back down.

Every launch deploys the same token contract (GoParabolicToken on the explorer): an OpenZeppelin ERC-20 whose supply is minted once, in its constructor. It is a real contract at the token address, not a minimal-proxy clone, so explorers show its own source and bytecode scanners find nothing that can mint.

Standard

ERC-20 (OpenZeppelin)

18 decimals

Mint

No

Supply created in the constructor only

Tax or fees on transfer

No

Transfers move exactly what you send

Blacklist or pause

No

No admin functions at all

Proxy or upgrade

No

Full contract, immutable

Owner

0x000…000

Ownable, renounced in the constructor

Address

CREATE2 from the Launchpad

The salt mixes in your random entropy

Each token page has a swap panel that routes through Uniswap’s UniversalRouter on Arc and quotes with the V4Quoter. The pool is a regular Uniswap v4 pool, so any v4-aware wallet, aggregator or bot can trade it too.

Buying

Pools are quoted in native USDC, so a buy is one transaction with no approval: the USDC is sent as the transaction value.

Selling

1. 01
   Approve the token for Permit2, once per token.
2. 02
   Allow the UniversalRouter inside Permit2. The app grants it for 30 days, then asks again.
3. 03
   Sell. Every later sell is a single transaction until the Permit2 allowance expires.

Router

UniversalRouter

V4_SWAP, exact-in single hop

Quote

V4Quoter

Read onchain before each swap

Max slippage

1% · 3% · 5%

3% by default, applied to the quote

Pool fee

1%

Taken from the input side of each trade

The only fee on ArcLauncher is the pool’s 1% Uniswap fee. There is no launch fee, no transfer tax and no hidden cut. As in every Uniswap pool, the fee is paid in whatever the trader puts in: buys pay in USDC, sells pay in the token. Fees accumulate on the locked position and are split when collected:

Trading volume on a token: 10,000 USDC of buys, 10,000 USDC worth of sells

Buys  → fee 1% = 100 USDC
          creator  (85%) =  85 USDC   → fees recipient
          protocol (15%) =  15 USDC   → paid out to $ARCL holders

Sells → fee 1% = 100 USDC worth of the token
          creator  (85%) =  85 USDC worth of tokens → fees recipient
          treasury (15%) =  15 USDC worth of tokens → protocol treasury

• Fees are collected with the LP locker’s collectFees(nftId), from the token page or directly. Collecting works at any time, even while the liquidity is locked.
• Anyone may call it: the split is hard-coded, so the caller cannot redirect anything. It just saves the creator a transaction.
• If a recipient cannot receive native USDC (a contract without receive(), for example), its share is parked in pendingNative and withdrawn with claimPending(), so one bad recipient never blocks the others.

The LP position is a Uniswap v4 NFT. The Launchpad never holds it past the launch transaction: it goes straight into the LP locker, which records three things: the owner (the creator), the fees recipient, and the unlock date.

Durations

2 · 5 · 10 years

10 years by default in the form

While locked

Fees collectible

The liquidity itself cannot move

Countdown

On the token page

Read with lockInfoByToken(token)

After unlock

Owner withdraws

withdraw(nftId) returns the NFT to the creator

Extend or shorten

Not possible

The date is set once

$ARCL is ArcLauncher’s platform token, and it launches on ArcLauncher itself, like any other token. Staking it on the Stake page earns the protocol’s 15% share of the USDC fees from every ArcLauncher pool, paid in native USDC, pro rata to your stake.

1. 01
   A fee collect on any ArcLauncher pool sends the protocol’s USDC share to the staking contract.
2. 02
   Each deposit is streamed over 7 days, merged with whatever is still streaming.
3. 03
   Every second, the stream is shared among stakers in proportion to their stake.
4. 04
   You claim whenever you like; exit() unstakes and claims in one call.

Reward

Native USDC

Not inflation, not the staked token

Streaming

7 days per deposit

Synthetix StakingRewards model

Lock-up

None

Unstake at any time

APR

On the Stake page

Live stream rate ÷ value staked

Idle time

Not lost

Rewards streamed while nobody stakes roll into the next stream

ArcLauncher has no backend database and no IPFS pinning service. Each launch stores its metadata onchain, in the launch record, as a small JSON string of at most 2,048 bytes:

{
  "description": "What this token is about",
  "image": "data:image/webp;base64,UklGR…",   // square logo, ≤ 96 px
  "socials": ["https://x.com/yourtoken"],
  "website": "https://yourtoken.xyz"
}

The logo you upload (up to 5 MB) is cropped to a square in your browser and re-encoded, shrinking size then quality until it fits the remaining bytes. Very detailed images may not fit; a simpler logo always will.

ArcLauncher’s contracts are immutable: no proxies, no upgrade path. Click an address to open it on the Arc explorer, or copy it.

This is what each contract lets anyone do, the ArcLauncher team included. Nothing here is hidden behind a proxy.

Launchpad

No owner

Permissionless, holds nothing between calls

Token contract

No owner

Renounced at deployment, nothing to call

Staking

Owner: sets the staked token once

Cannot move staked tokens or rewards

LP locker

Owner: protocol fee routing only

Cannot touch a lock, its owner, recipient or date

What the locker administrator can do

• Set where the protocol’s 15% goes (setTreasury, setStakingPool). The creator’s 85% is hard-coded and untouchable.
• Nothing else. There is no emergency or admin withdrawal: an LP position leaves the locker only through withdraw, called by the lock’s owner after the unlock date.

Everything an explorer, a bot or an aggregator needs is onchain. The Launchpad keeps a registry you can page through, and every pool is a standard Uniswap v4 pool.

01List launches

import { createPublicClient, http } from "viem";

const client = createPublicClient({ transport: http("https://rpc.mainnet.arc.io") });

const total = await client.readContract({
  address: LAUNCHPAD, abi, functionName: "totalLaunches",
});
const launches = await client.readContract({
  address: LAUNCHPAD, abi, functionName: "getLaunches", args: [0n, total], // [start, stop)
});

// one token:              launchOf(token)            → Launch (reverts if unknown)
// one creator's tokens:   launchesByCreator(creator) → address[]

struct Launch {
  address token;
  bytes32 poolId;         // Uniswap v4 pool id
  uint256 nftId;          // LP position, held by the LP locker
  address creator;
  address feesRecipient;  // receives 85% of fees
  uint64  timestamp;
  uint64  unlockAt;       // lock end, unix seconds
  uint24  fee;            // 10000 = 1%
  int24   initTick;       // start price
  int24   tickSpacing;    // 200
  uint256 supply;         // 18 decimals
  string  name;
  string  symbol;
  string  metadata;       // JSON, see Metadata
}

02Watch new launches

event Launched(
  address indexed creator,
  address indexed token,
  bytes32 poolId,
  uint256 nftId,
  uint256 supply,
  uint24  fee,
  int24   initTick,
  int24   tickSpacing,
  uint64  unlockAt,
  string  name,
  string  symbol
);

03Price and market cap

// PoolKey: native USDC always sorts first
{ currency0: 0x0000…0000, currency1: token,
  fee: 10000, tickSpacing: 200, hooks: 0x0000…0000 }

poolId = keccak256(abi.encode(poolKey))      // also stored in the Launch record

StateView.getSlot0(poolId) → (sqrtPriceX96, tick, protocolFee, lpFee)
tokensPerUsdc = (sqrtPriceX96 / 2^96)^2       // both sides have 18 decimals
priceUsd      = 1 / tokensPerUsdc
marketCapUsd  = supply / tokensPerUsdc

04Swap

Send UniversalRouter.execute(commands, inputs, deadline) with command V4_SWAP (0x10) and actions SWAP_EXACT_IN_SINGLE, SETTLE_ALL, TAKE_ALL.

Buy

zeroForOne = true

msg.value = USDC in, no approval

Sell

zeroForOne = false

Token → Permit2, then Permit2.approve(router)

Quote

V4Quoter.quoteExactInputSingle

Apply your slippage to amountOut

05Lock and fees

Lock info

lockInfoByToken(token)

nftId, owner, feesReceiver, unlock, seconds left

Collect fees

collectFees(nftId)

Anyone can call it, split 85 / 15

Withdraw

withdraw(nftId)

Owner only, after unlock