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, and they can withdraw and take all of it back right up until a battle claims it. An entry nobody has claimed in about a day (167,000 blocks) goes stale, and anyone may then send it back to its creator, so a quiet market cannot drag an abandoned entry into a battle.

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.

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

   Bids fill at one clearing price for everyone. Arriving a block earlier buys nothing, and 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 0.25% 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 rather than first-come. Everyone who fills, fills at the same price, and the price only moves when demand exceeds the supply being issued. There is no curve to snipe and no advantage to being early in a block.

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.

To enter the queue

1 USDC, once, non-refundable

Taken from the raise

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

Trading fees

0.25% 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 0.25% smaller than their raise. A battle that falls short is refunded in full; the cut is only ever taken from money that graduated.

Buyback, to traders

80%

Social contributors

18%

Ctrl88 Lab

2%

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, and the tokens bought are 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. 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 paid first, out of every sum the protocol takes for their token: 0.05% of the battle cut, and 0.05% of each hourly sweep of their pool. Small by design, and stated so nobody reads it as a mistake.

Before Arc mainnet opens, a spot on the ARCWAR whitelist is claimed at quest.arcwar.gg: three tasks on X — follow, like, 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 style, face, outfit, accessories — drawn by the server the moment the spot is taken, each at one of four rarities. 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 and every fill settles at one clearing price, so a fully subscribed auction has raised = price × 500e6, and the pool it opens is priced at that same clearing price across the whole billion.

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

0.100001 USDC per token — about 100,000,000 USDC FDV; the app bids at it, so a bid fills at whatever the clearing price becomes

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. Two doors exist instead: the indexer’s public API, which derives every price from the pool’s own swap events and answers over HTTPS; and PoolLens, a stateless contract that runs the same slot arithmetic the pool manager does and reports what a position is owed — the read a keeper needs before deciding what is worth sweeping.

const base = "https://testnet.arcwar.gg/idx";
const t = await fetch(`${base}/tokens/${token}`).then((r) => r.json());

// sqrtPriceX96 is tokens per unit of currency, so it runs backwards to value.
const r = Number(BigInt(t.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 0.25% 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.

EntryStillFresh

Only the creator can withdraw an entry younger than 167,000 blocks.