How Arcopad works

Arcopad 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 80 % of the pool’s trading fees for the life of the lock; the other 20 % goes to the protocol, and its USDC part is streamed to $ARCO stakers.

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

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 ArcopadLaunchpad.launch(), which does all of this atomically:

1. 1Deploys a full ArcopadToken contract via CREATE2 and mints the whole 1,000,000,000 supply to the launchpad in its constructor.
2. 2Initialises a Uniswap v4 pool TOKEN / native USDC, 1 % fee, tick spacing 200, no hook, at the price that matches your starting market cap.
3. 3Mints a single-sided position holding 100 % of the supply, from the starting price upward, so no USDC is needed to seed it.
4. 4If 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. 5Transfers the LP position NFT to the ArcopadLpLocker with your lock date and fees recipient, refunds any rounding dust, records the launch and emits Launched.

The starting market cap sets the pool’s opening price. 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 contract, ArcopadToken: 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.

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. 1Approve the token for Permit2, once per token.
2. 2Allow the UniversalRouter inside Permit2. The app grants it for 30 days, then asks again.
3. 3Sell. Every later sell is a single transaction until the Permit2 allowance expires.

The only fee on Arcopad 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  (80 %) =  80 USDC   → fees recipient
          stakers  (20 %) =  20 USDC   → ArcopadStaking, streamed over 7 days

Sells → fee 1 % = 100 USDC worth of the token
          creator  (80 %) =  80 USDC worth of tokens → fees recipient
          treasury (20 %) =  20 USDC worth of tokens → Arcopad treasury

• Fees are collected with ArcopadLpLocker.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 ArcopadLpLocker, which records three things: the owner (the creator), the fees recipient, and the unlock date.

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

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

Arcopad has no backend database and no IPFS pinning service. Each launch stores its metadata on-chain, 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.

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

Arcopad

Uniswap v4 & infrastructure on Arc

What each contract lets anyone, including the Arcopad team, do. Nothing here is hidden behind a proxy.

What the locker administrator can do

• Set where the protocol’s 20 % goes (setTreasury, setStakingPool). The creator’s 80 % is hard-coded and untouchable.
• Move locked positions through an emergency path (emergencyWithdrawMany, emergencyWithdrawManyInOne), meant for migrating to a new Uniswap deployment or rescuing positions if Uniswap on Arc ever breaks.

Everything an explorer, a bot or an aggregator needs is on-chain. No API key, no indexer: the launchpad keeps a registry you can page through, and every pool is a standard Uniswap v4 pool.

1 · List 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 not an Arcopad launch)
// one creator's tokens:   launchesByCreator(creator) → address[]

struct Launch {
  address token;
  bytes32 poolId;         // Uniswap v4 pool id
  uint256 nftId;          // LP position, held by ArcopadLpLocker
  address creator;
  address feesRecipient;  // receives 80 % 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
}

2 · Watch 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
);

3 · Price 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

4 · Swap

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

5 · Lock and fees