Tokens fight for one pool.How that works, and how to build on it.

ARCWAR is a launchpad where tokens compete for liquidity instead of each receiving their own. Up to six tokens enter a four-hour auction together — a battle opens with as few as two. The one that raises the most opens a Uniswap v4 pool. The money raised behind the others is not refunded and not burned — it is spent buying the winner in that pool, and the winner’s token is what their backers claim.

That single rule is what the rest of this document explains. It is also the only thing about ARCWAR that is unusual; everything else is an ordinary auction and an ordinary Uniswap pool.

1. 01

   Enter the queue

   A creator pays 1 USDC and their token joins the queue. The whole supply is held by the orchestrator until a battle claims it. There is no way back out: an entry is a commitment to the next battle, so nobody can hold the queue's clock by registering and leaving.

2. 02

   The queue fills, then holds

   Once enough tokens are waiting, a thirty-minute countdown starts — and every new entrant pushes it out again. Nobody can open a battle out from under a creator who is still telling people about it. A full cohort of six skips the wait and opens at once.

3. 03

   Open

   Every entrant’s auction is deployed in the same transaction, so they share one window and no entrant gets a head start. The window is 27,923 blocks — four hours at Arc’s block rate.

4. 04

   Bid

   The auction releases its supply over the window and fills bids block by block at that block’s clearing price, which only ever rises. Money that arrives early buys cheaper; thirty percent of the supply clears in the final block, so the closing price stays close to what the money paid rather than a multiple of it. A bid the clearing price passes is refunded rather than filled at a price its owner did not agree to.

5. 05

   Resolve

   After the window closes anyone can settle it — the keeper is expected to, but the function is permissionless so a battle cannot be stranded by one wallet going quiet. The biggest raise wins.

6. 06

   Finalise and claim

   A second transaction opens the winner’s pool and spends the losing side’s raise buying into it. Backers then claim: the winner’s own backers claim the token they bid on, everyone else claims their share of what their money bought.

A launch needs a name, a ticker, a picture and one dollar. There is no allocation to negotiate and no vesting schedule to sign: the supply is fixed at a billion, half of it is auctioned, and the half that does not sell becomes the pool’s liquidity if the token wins.

Entry fee

1 USDC, non-refundable

Total supply

1,000,000,000, fixed at mint

Auctioned

500,000,000 — half

Target to graduate

5,000 USDC raised by the battle, not by each token

Window

Four hours, shared with every other entrant

Picture

Up to 12,000 bytes, stored on chain

Description

Up to 500 bytes

A creator may also skip the auction entirely and launch instantly, which is a different thing in almost every respect and has its own section below.

The queue exists so six tokens can be drawn against each other. A creator who does not want the contest can leave it: launchInstant opens the pool in the same transaction, and the token never enters a battle. About a third of the tokens on this chain arrived this way.

What goes into the pool is the whole supply, not half. A battle sells 500,000,000 through its auction and puts the unsold half into the winner’s pool; an instant launch has nothing to sell, so all 1,000,000,000 become liquidity at once.

Cost

The same $1 queue fee, and nothing else

Into the pool

1,000,000,000

Opening price

$0.000001

Opening valuation

$1,000

Currency in the pool at open

$0

The pool is the same pool a battle winner gets, on the same terms: liquidity nobody can withdraw, a 1% fee on every trade, and that fee swept each hour into AW for the accounts whose trading produced it. What an instant launch does not get is the evidence. A token that won a battle has shown that people put real money behind it against five alternatives; a token that launched instantly has shown that somebody paid a dollar. Both open with permanent liquidity, and only one of them has been argued for.

A bid names an amount and a ceiling: the most it is willing to pay per token. It fills at the clearing price, not at the ceiling, so bidding above the market costs nothing extra — the ceiling only decides at what point the bid stops buying.

The auction is continuous: supply is issued over the window on a schedule that starts slow and rises, with thirty percent held for the final block, and every block clears at one price for everyone bidding in it. The price only rises, so earlier money fills cheaper and the last block — the largest — settles close to the average. The pool opens at that closing price.

This is the part that differs from every other launchpad, so it is worth being precise about.

A token that was funded but lost does not refund its backers. Its raise is spent buying the winner’s token in the pool that has just opened, and that token is what its backers claim. They came for one launch and leave holding the one that worked. The ratio is fixed at settlement; what moves afterwards is the price when they sell.

A token that raised almost nothing is not a separate case, and this is the part that changed. The target belongs to the battle: what the entrants raise between them is what is measured, and the ruling that comes back is the same for all of them. So a token that pulled in forty dollars inside a battle that cleared five thousand is funded, and its backers hold tokens rather than a refund — carried by the rest of the field.

Refunds happen when the battle falls short, not when a token does. Then nobody graduates, including whichever token raised the most.

If no token in a battle reaches the target, there is no winner and no pool. The battle is recorded as abandoned, every entrant’s supply goes back to its creator, and every bid is refunded in full by the auction itself.

The winner’s pool position is owned by PoolVault, and that contract has no function that reduces liquidity. Not a locked one, not a time-delayed one — the code to withdraw does not exist. The only modifyLiquidity call in it passes a delta of zero, which is how Uniswap v4 says “settle my fees and change nothing”.

It is also the one contract in the system that is not upgradeable. The orchestrator and the migrator sit behind proxies so their settlement logic can be fixed; the positions were moved somewhere a change of code cannot reach, or “the liquidity is permanent” would have quietly meant “until whoever holds the upgrade key decides otherwise”.

Trading fees collected from every pool on the platform fund an epoch. Your share of that epoch is your share of the volume you drove during it.

There is no premine, no allocation and no reserve. The entire supply was minted to the treasury and put into a pool; the only way AW reaches anyone is the treasury buying it back out with fees that were actually collected. It is the protocol’s own token and it does not compete for a pool with anyone.

Not everything a buy-back returns is handed out. 9% of it is burned in the same transaction as the buy, sent to the dead address before any root could name it; the rest is what the epoch divides. The burn is why a crowd that claims and sells everything it is given still leaves the price somewhere above where it found it: what they sell back is less than what the treasury took out. It is a setting on the treasury, capped at half, and the figure here is what it holds now.

To enter the queue

1 USDC, once, non-refundable

Taken from the raise

1% of what a battle raised, once, at settlement

Trading fees

1% of every trade, swept hourly

To claim

Gas only

The battle cut is charged on the whole raise — the winner’s and the losing side’s together — and goes to the treasury in USDC. It is a real cost to the losing bidders: the buy-back that funds their claim is 1% smaller than their raise. A battle that falls short is refunded in full; the cut is only ever taken from money that graduated.

Buyback

80%

Social contributors

18%

Ctrl88 Lab

2%

Of each buy, burned

9%

Everything the treasury collects — the battle cuts and the hourly sweeps — is divided the same way. The buyback is the share that reaches traders: it is spent buying the protocol’s token, 9% of what comes back is burned, and the rest is handed to the accounts whose trading produced the fees. The other two are paid in USDC rather than in the token, which is deliberate: a recipient paid in the asset whose supply it helps decide has an interest nobody can audit away. Each is paid into a vault of its own — a contract that holds it and whose admin may move it — so what has been paid is a balance anyone can read. The split is a setting on the treasury, capped at 25% for the two paid shares together, and the figures above are what it holds now.

A creator who switched the creator fee on at launch is owed 20% of every sum the protocol takes for their token: of the battle cut, in USDC, and of each sweep of their pool — in USDC and in the token, in whatever mix the trades paid. Of the 1% a trade pays, that is 0.2% to the creator and 0.8% to the treasury; a creator who left the fee off sends the whole 1% to the treasury. The share is not sent: it is set aside in the migrator, and the creator collects it from their portfolio whenever they choose — claimCreatorFees sweeps the pool on the way, so one transaction pays everything owed, the hour’s takings included. The treasury’s share leaves on every sweep as before.

Before Arc mainnet opens, a spot on the ARCWAR whitelist is claimed at quest.arcwar.gg: four tasks on X — follow, like, repost, reply — and one wallet to receive it. Spots are recorded in the order they arrive, and the list closes the moment mainnet opens, on 16 September.

Every spot comes with a sealed pack of five traits — background, TV, face, outfit and an effect — drawn by the server the moment the spot is taken. The pack rolls its rarity first (Common 69%, Rare 25%, Epic 5%, Legendary 1%), one of the four ranked traits carries it, and the other three roll at or under it (the backgrounds have no Epic tier, so an Epic never lands there); the effect is a flourish and carries none. The pack opens on the page; the NFT it shows is minted to that wallet once mainnet is live, with exactly the traits shown.

Chain

Arc testnet

Chain ID

5042002

Native currency

USDC — gas is paid in it

Block time

~0.516s

RPC

https://rpc.testnet.arc.io

First indexed block

59976263

The auction layer is Uniswap’s Continuous Clearing Auction, vendored and forked. We neither fork nor deploy a DEX — the pool is Uniswap’s v4, at the address above, passed to the migrator as a constructor argument.

The fork adds one thing: exitPartiallyFilledAndClaimBatch, which settles every bid a caller holds in one auction and pays out in a single transfer. Without it a position of three bids was six transactions. You can check which factory you are talking to without opening a battle:

cast code 0x12d2eFc32F13389c23E952cB26C75413a19Ca3f7 \
  --rpc-url https://rpc.testnet.arc.io | grep -c ffe12763
# 1 — exitPartiallyFilledAndClaimBatch is present

cast code 0xe0648174b6c0860C5e8CFB263C3A0B54D28Fe9FD \
  --rpc-url https://rpc.testnet.arc.io | grep -c ffe12763
# 0 — Uniswap's own factory has no such function

A token’s valuation is not a model — it falls out of the auction’s own arithmetic. Half the supply is auctioned; the pool opens at the closing clearing price, and because thirty percent of the supply clears in the final block that price stays close to the average paid — measured on Arc, about one and a half times it, where a flat schedule had produced ten — so a fully subscribed auction has roughly raised ≈ price × 500e6 and the pool is priced at that closing price across the whole billion. The other half of the supply pairs with the raise as full-range liquidity. Whatever the auction did not sell, and whatever the opening price could not pair, is burned — nothing is held back.

Floor price

0.000001 USDC per token

Floor FDV

1,000 USDC

Full subscription at the floor

500 USDC raised

A token that raises 5,000 alone

10,000 USDC FDV at open

Ceiling price

the auction's own maximum; the app bids at it, so a bid fills at whatever the clearing price becomes

Supply schedule

twelve rising steps over the window, then 30% of the auctioned supply in the final block

Unsold supply

burned at finalisation, together with the losers' supply

After the pool opens, the losing side’s raise buys into it, which moves the price up before anyone has traded. The figures above are the opening valuation, not the settled one.

Pool state is not readable through ordinary getters. StateLibrary computes storage slots and reads them through extsload, so there is no getSlot0 to call over JSON-RPC. The chain is still the door: the slot arithmetic is short, and PoolLens — a stateless contract that runs the same arithmetic the pool manager does — reports what a position is owed, the read a keeper needs before deciding what is worth sweeping.

import { createPublicClient, http, encodeAbiParameters, keccak256, hexToBigInt } from "viem";

const pm = "0x5e4b627b99BC77a29c874ba1ccAe65af5d8D1B19"; // Uniswap v4 PoolManager
const client = createPublicClient({ transport: http("https://rpc.testnet.arc.io") });

// The key the migrator opened the pool with — ask it rather than assume.
const key = await client.readContract({ address: MIGRATOR, abi: migratorAbi, functionName: "poolKeyFor", args: [token] });
const poolId = keccak256(encodeAbiParameters(
  [{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }],
  [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));

// StateLibrary: pools live in slot 6; slot0 is the first word of the pool's struct.
const slot = keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }], [poolId, 6n]));
const word = await client.readContract({ address: pm, abi: [{ name: "extsload", type: "function", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "bytes32" }] }], functionName: "extsload", args: [slot] });
const sqrtPriceX96 = hexToBigInt(word) & ((1n << 160n) - 1n);

// sqrtPriceX96 is tokens per unit of currency, so it runs backwards to value.
const r = Number(sqrtPriceX96) / 2 ** 96;
const price = 1 / (r * r);          // USDC per token
const fdv = price * 1_000_000_000;  // supply is fixed at a billion

TokenRegistered

A creator entered the queue. Carries name, symbol, image.

BattleOpened

Auctions deployed. Carries the entrant list and the window.

ClearingPriceUpdated

The live valuation moved. Emitted by each auction.

EntrantSettled

Per token: what it raised, and the battle's verdict — the same for every entrant.

BattleResolved

The winner, its raise, and the losing side's total.

BattleFinalized

The pool is open and the losing raise has been spent. Claims start here.

BattleCutTaken

The 1% taken from the raise, and the creator's slice of it.

EntryWithdrawn

A queued token went back to its creator — withdrawn, or evicted once stale.

BattleAbandoned

The battle raised less than the target between them. Everything is refunded.

InstantLaunched

A pool opened without an auction.

Swap

A trade through a pool. Uniswap's, on the PoolManager.

BidMustBeAboveClearingPrice

The ceiling named is at or below where the auction has already settled.

CannotExitBid

This bid set the clearing price. It leaves through exitPartiallyFilledBid.

BidNotExited

claimTokens was called before the bid was settled.

NotGraduated

The battle fell short, so there is nothing to claim — only to refund.

VerdictPending

The battle has not been resolved yet. Nothing settles until it is; anyone can call resolveBattle once the window closes.

AlreadyExited

This bid has already been settled.

NothingToClaim

Settled, and the payout was zero.

BattleStillRunning

The window has not closed yet.

BattleNotResolved

finalizeBattle was called before resolveBattle.

NotEnoughEntrants

The queue is too short to open a battle.

CountdownRunning

The queue's hold has not expired.

WrongCreationFee

The value sent is not the current creation fee.

ImageTooLarge

The picture is over 12,000 bytes.

DescriptionTooLong

The description is over 500 bytes.