Introduction

Arco is a launchpad on Uniswap v4. A token created here is a real Uniswap pool from its first block, with its whole supply on the curve and its liquidity locked forever — and that pool keeps its own price history onchain, so anyone can settle a market against the token without asking us, or anyone else, for a price.

There is no bonding-curve contract to graduate out of, no migration for anyone to perform. The market is an ordinary Uniswap market, which is why aggregators route it on day one.

How a launch works

One transaction deploys the token, creates the pool and deposits the entire supply as a single-sided range position. Buyers walking the price up through that range is the bonding curve — it just happens to be an ordinary Uniswap position rather than a contract you have to trust.

• The whole supply goes on the curve. No team allocation, no holdback, no reserve.
• Liquidity is locked forever. The position NFT goes into a locker with no withdrawal path. Fees can be collected; the liquidity cannot.
• The token mints once. Fixed supply, minting gated to the factory, never callable again.
• Snipers are handled by the transaction, not by a fee. A creator’s opening buy is bundled into the same transaction that opens the pool, so there is no block in which anyone can get in ahead of them.
• Gasless when the launch moves no money. You sign it and Arco pays the gas. A creation fee or an opening buy is your own stake, so that part comes from your wallet — Arco pays the gas and never the money.

Supported networks

A launch lives on one chain and is priced against one asset: that chain’s native coin, USDC, EURC, or a tokenized stock. Its market never moves; the coin itself can travel to other chains, as described under Every chain.

Money moves instead. A buyer or seller on another chain pays or receives USDC over Circle’s CCTP while the market stays where it was opened, so a token is buyable from any chain without a bridged copy of it existing anywhere.

Arc is the first mainnet. Launches there are priced in USDC, which is also the coin Arc charges gas in.

One coin, every chain

Coming next: a coin launched on Base will also live on BNB Chain, Monad, Robinhood Chain and Arc. It stays one coin: one supply of one billion, one market on its home chain, one price. The other chains hold a copy that is created only against coins locked at home, through Chainlink’s cross-chain token standard (CCT) and its CCIP network.

• Same address on every other chain. The copy sits at one address on BNB, Monad, Robinhood and Arc, fixed before it exists.
• No second market to keep in line. Nobody has to run a bot to pull prices together across chains, because there is only one price.
• Chosen at launch, or opened later by anyone. A creator picks chains in the launch form and pays Chainlink’s message fee for each. Any other chain can be opened afterwards by whoever wants it there.

Moving, buying and selling

Every coin page has an Every chain panel. It does three things, each in one transaction on the chain you start from.

• Move. Send coins from home to another chain or back. Chainlink locks them at home and creates the copy there, or burns the copy and releases the coins. It takes a few minutes, because Chainlink waits for the sending chain to finalize.
• Buy for another chain. The buy happens in the home market and the coins are delivered to your chain. From BNB, Monad or Robinhood you can also pay with that chain’s own coin: Relay’s solvers bring the money to the home chain, and if the buy cannot happen you are refunded where you paid.
• Sell from another chain. Send the copies home with a sell order attached. They are sold in the home market and the dollars are paid to you on the home chain. If the price moved too far on the way, the coins arrive instead, so a sale that cannot fill never disappears.

What keeps the supply whole

A bridge is only as safe as whoever can create coins on the far side. Arco keeps that list as short as it can be.

• The home coin never gains a mint. Coins leaving home are locked, not burned, so the one billion stays provable on the home chain itself.
• Only Chainlink’s own pool mints a copy. The copy is set up once, to answer to exactly one home pool. Nothing can change that afterwards.
• Nobody can withdraw locked coins. The contracts that own the pools expose none of the pool’s owner controls, and a chain once opened can never be removed.
• New chains wait a week. Adding a chain is the one thing Arco can do, and it only takes effect seven days after it is proposed, in public.
• Every lane is capped. At most 5% of the supply can cross between home and one chain per hour, so even a failure on another chain can only reach a small part of what is locked before it can be stopped.

The ARCO token

ARCO is Arco’s official token and the first one ever launched here. It went out the same way every other launch does: one transaction on Arc, priced in USDC, the whole supply in an open market from its first block, no presale, no team allocation, no unlock schedule.

Name

Arco (ARCO)

Network

Arc (chain id 5042)

Contract

0xC0830B375406A46F98A58C2A69B41C29f2EB672c

Supply

1,000,000,000, fixed, minted once

Priced in

USDC

Trade ARCO or open its token page.

This is the only official Arco token. Check the contract address before you buy — any other token using the name, on Arc or on any other chain, is not ours.

Why v4 has no oracle

Uniswap v3 made every pool a price oracle for free — each one carried an observations array, and anything could read a time-weighted average out of it. v4 removed that. A v4 pool knows its price now and nothing about then.

In v4 an oracle is a hook: a contract the pool calls on the events it is given permission to see. And a hook is part of a pool’s identity, fixed at the moment the pool is created.

A hook can never be added to a pool that already exists. Every token already launched on a launchpad that shipped without one is permanently unsettleable. That is not a head start — it is a door that closed behind them.

How Arco records price

Every Arco launch pool opens with ArcoOracleHook. It keeps one observation per pool, in a single storage slot: a running sum of tick × seconds, the tick the pool was last left at, and when. Each swap advances that sum by the tick that held before it, then records the tick the swap left behind.

Read it twice and the difference, divided by the seconds between, is an exact time-weighted average price over that window. There is no observation buffer to bootstrap and no cardinality to pay for.

observe(poolId) → (tickCumulative, tick)

averageTick = (cum₁ − cum₀) / (t₁ − t₀)
price       = 1.0001 ^ averageTick

No feed, no reporter, no committee, no key. Nobody can switch it off, pause it, or be persuaded to change it. It is a number the pool computes about itself.

It never touches a trade

A v4 hook can be given the power to change what a swap pays out. This one is not. It declares afterInitialize and afterSwap and nothing else: no delta permission, no dynamic fee.

That is enforced by Uniswap’s own core, not promised by us — a hook without the delta flag has its return value ignored outright. The price you are quoted is the price you get, and because the hook stays inside Uniswap’s automatic routing rules, aggregators route an Arco pool like any other.

Permissions

afterInitialize, afterSwap

Can change your amounts

No — no delta permission

Can change the fee

No — the fee is static

Added cost per swap

~16,000 gas — a fraction of a cent

Can it fail a swap

No — it has no revert path

That last row is the one that matters most. An afterSwap which reverts takes the swap down with it, and the hook is fixed into every pool that names it — so its arithmetic is written to wrap rather than to throw, including across the timestamp rollover in 2106.

The cost of lying to it

A push inside a single block contributes nothing, because no time elapses between the swap and the record. Moving the average means holding a displaced price across blocks — against every arbitrageur and every seller — and paying the pool’s depth for every second you hold it.

The cost of a displacement grows exponentially in ticks while the accumulator grows only linearly in time. Buying the average with a spike is therefore orders of magnitude more expensive than buying it with a long, patient hold. That is why anything settling against an Arco token should read an average over a window rather than a price at a block.

Build on it

Anything that needs a price for an Arco token can read one, with no permission from us: no API key, no allowlist, no signature, no relationship.

• Prediction markets and betting games that settle on a real number
• Lending against a launch as collateral
• Options and structured payoffs
• Vesting that unlocks on a price rather than on a date
• A treasury that pays out when a milestone is genuinely hit

The hook is a public good that happens to live at our pools’ addresses. Battles, below, is simply the first thing we built on it.

Coin vs coin

My coin versus your coin. Two Arco launches, one clock, and whichever climbed further takes the pot. It is a game rather than a prediction market, and that is deliberate: tribalism is the most reliable energy in memecoins, and nobody has packaged it head to head.

• Anyone opens a battle. Name two Arco tokens and a duration, and put up a seed. Both pools are snapshotted at that moment.
• Back a corner. Your stake buys shares in one side. The share price is the crowd’s opinion of the odds, and it moves as money arrives.
• Cash out early, or hold. Shares are sellable back while the clock runs, so a position is not a one-way door.
• Every failure refunds. A dead heat, a corner nobody backed, a pool that will not answer — all of them return the pot. No admin can seize it and no funds can be trapped.

How a battle settles

After the clock runs out, anyone can settle it. One call reads both pools through the hook, compares each coin’s time-weighted move since the battle opened, and pays the winning side. The caller is paid a bounty out of the fees, so settling is a race rather than a favour — nobody benefits from stalling until the average drifts somewhere convenient.

Two markets live inside a battle and they are never confused:

The odds

The crowd betting against each other. Moving them decides nothing.

The pools

The coins’ real Uniswap markets. Read, never traded by the battle.

Nothing you do inside a battle can touch its own result — which is exactly what a market settled against a feed somebody can buy cannot say.

The fairness rules

Three constraints, and each one closes a specific way the fight could be rigged.

• Only Arco launches can be named. This is the one that makes open creation safe. The usual attack on a design like this is to open a battle against a coin whose market you control and simply buy the result. An Arco launch is not such a market: it carries the oracle by construction, its entire supply is locked forever with no withdrawal path, and its depth is readable before the battle opens.
• Both corners share a quote asset. A battle compares two price moves, and those moves are measured in whatever the coin is priced against. Put a USDC-priced coin against a native-priced one and a move in the native coin decides the battle rather than either contender.
• A depth floor. A market too thin to be an honest price cannot host a battle at all.

Contracts

Source, fork tests and the indexer all live in the Arco repository. Addresses are per chain, and Arc is the first mainnet: its factory is 0xE998A15234aF788152254E8F75e04009e945F569.

ArcoLaunch

The factory and registry. Creates the token, the pool and the locked position in one call.

ArcoLaunchLocker

Holds every position forever. Collects and splits fees; cannot withdraw.

ArcoOracleHook

The price history. One observation per pool, one deployment per chain.

ArcoBattle

Coin vs coin, settled against the hook. Ships with ArcoOutcomeToken.

ArcoCrossBuy / ArcoCrossSell

Circle CCTP rails. Buy from any chain, sell to any chain. Ownerless.

ArcoCctHub

Home chain. Registers a coin with Chainlink, owns its lock-and-release pool, and opens it on other chains. Launches with chains in one call.

ArcoCctRemote

Every other chain, one address. Opens a coin’s copy and its burn-and-mint pool when the hub asks. No owner.

ArcoIntentDesk

Home chain. Buys for any chain, and sells copies sent home. Holds no user money.

ArcoTwinToken

The copy on another chain. Minted and burned only by its Chainlink pool.

ArcoForwarder

Carries a signed, gasless launch to the factory.

Reading the oracle

Snapshot at the start of your window, read again at the end, and divide the difference by the seconds between. The accumulator is allowed to wrap, so take the difference inside an unchecked block — that is what makes it exact rather than merely usually right.

// at open
(int56 cum0, int24 tick0) = oracle.observe(poolId);
uint64 t0 = uint64(block.timestamp);

// at settle
(int56 cum1, ) = oracle.observe(poolId);

int256 averageTick;
unchecked {
  averageTick = (int256(cum1) - int256(cum0)) / int256(block.timestamp - t0);
}

A pool’s tick prices currency1 in currency0. Native coin and most stablecoins sort ahead of a launch token, so the token usually sits on the currency1 side — and a token whose price is rising has a falling tick. Sign the result by which side the token is on, or the winner comes out backwards.

observe reverts for a pool the hook never initialized, so a market cannot open against a price source that does not exist. Read it through a try at settlement time and refund on the failure, rather than letting a dead pool trap a pot.

Roadmap

ARCO at 0xC0830B375406A46F98A58C2A69B41C29f2EB672c on Arc is Arco’s only token. Anything else claiming to be one is not ours.