How it works

Every row shows two prices: a commodity futures settlement, and a token. How much those two have to do with each other depends on how the token was launched, and there are two answers.

Named pairs

A launch on Argus trades against USDC. Its ticker is a label somebody typed. Nothing reads the settlement, nothing settles against it, and the matching ticker is a coincidence of text — no backing, no claim.

Reference pairs

A reference coin is one unit of the commodity — a pound of copper, an ounce of gold — fully backed by USDC. Mint one by paying what a pound costs; redeem it for what a pound costs. The reserve always covers every coin outstanding, the issuer can never withdraw it, and coins launched against a reference coin are priced in pounds of copper rather than in dollars.

The price follows Pyth, with one rule: a rise only takes effect if the reserve already covers it. A reference coin that cannot afford the new price keeps the old one and says so. That is a coin which has stopped tracking — still fully backed, and visible on its page — rather than a coin that owes more than it holds.

What a coin costs to mint is not what it redeems for. A mint is charged the higher of two figures: what the commodity costs according to the oracle, and what the reserve already stands behind each coin. Both halves matter. The stored price only moves when somebody syncs it, so selling at it would mean selling a pound of copper for less than a pound costs. And a coin’s real claim is a share of the reserve, so selling below that share would hand a new coin part of a buffer the existing holders funded. Paying the backing is exactly non-dilutive: the ratio a mint joins is the ratio it leaves. Where the two figures differ, a coin’s page shows both.

Launching against a commodity

A coin priced in copper does not launch on Argus. It cannot: an Argus launch is quoted in the Portal’s asset, which is USDC. So the reference-pair factory opens its own Uniswap v4 pool on Arc, with the reference coin as the other side of the pair — an ordinary pool, no hook, no tax, no allocation, because everything exotic already lives in the quote asset.

Deploying the token, opening the pool and placing the opening liquidity all happen in one transaction. Splitting them was wrong twice over: a pool with no liquidity has a price anyone can move to anywhere for nothing, and a pool key anybody can open first is a pool key anybody can take. The opening liquidity is one-sided — all token, no commodity — so a launcher supplies nothing but their own supply, and there is no code path that removes it. The trading fees go to the launcher.

These launches appear on Live pairs in their own section, and each one resolves at the same address URL as an Argus launch, because a link handed around should not have to know which kind it is.

The curve, and the migration

A launch opens with most of its supply in a bounded range above the opening price. That range is the curve: buyers walk up it paying more as it empties, and the copper they pay in stays in the position, below the price, as the bid. It is placed in the same transaction as the pool and there is no code path that removes it.

When the range is gone the launch has no offer left at any price, and anyone can migrate it. That pairs the proceeds with a tranche held back at launch and opens a position across every price instead — which is the difference between a curve that has finished and a market. The bar on a launch’s page counts tokens sold rather than how far the price has moved, because price travels through a range unevenly and a price bar would sit still and then leap.

Trading is straight to the pool through Uniswap’s router: no tax, no intermediary, and the fee goes to the pool with the launcher able to collect it. A first trade also approves the token to Permit2, which is how that router takes payment; it is one transaction and never needs repeating.

What a launch page can and cannot show

The price chart and the trade list are built from the pool’s own Swap logs, and Arc prunes its ranged log index at about four days. So a launch page shows the history that still exists and says which boundary it hit — “no trades yet” and “no trades in the last four days” are different facts and are never printed as the same one.

For the same reason there is no holder ranking. Ranking a set means enumerating it, enumerating it means the whole transfer history, and for any launch older than that window the history has been deleted. What the page shows instead is the supply split, which is exact and needs no logs at all — and for these tokens it is the more useful number anyway, since the whole supply is minted at launch and most of it sits in the pool. The addresses listed beneath it are whoever traded recently, labelled as that and nothing more.

Keeping the price honest

Pyth on Arc is pull-based: a price only exists on chain after somebody submits a signed update. Nothing calls the reference coin’s syncPrice on its own either, so between syncs its price is the last answer somebody happened to cause rather than the current one — and that figure is exactly what a holder is owed.

A keeper closes both gaps on a schedule, pushing a signed update and syncing in a single transaction. Every function it touches is permissionless, so the key it runs on holds no privilege and no money. Whether it is running is on the status page, read live rather than asserted.

The reference price

Each of the 27 entries names one exchange-traded contract: venue, delivery month, unit and contract size. Prices come from a public quote feed, cached for a few minutes. When the feed does not answer, the row shows the snapshot pinned in this repository and says so.

Nothing on Arc reads these numbers. They are not an oracle, no contract consumes them, and no launch settles against them.

The pair price

The token trades in a Uniswap v4 pool on Arc, launched through Argus. Every figure comes from that launch’s own contracts: price from its pool, tax from its hook, split from its splitter.

Anyone can launch a token under any symbol. A matching ticker is a coincidence of text: no backing, no redemption right, no relationship.

Reading Argus correctly

Every launch has its own hook, and the Portal that created a launch is the only authority for it. This site queries all 7 Portals on every lookup.

• “No record” and “did not resolve” are different answers. The pair pages name which one they got.
• Bonding is read from hook.bonded(), never from the tick. A retreat does not clear it.
• Displayed fees do not predict execution. They exclude router and service fees, gas and the opening surcharge.

What this site is pinned to

Addresses, record shapes and ABIs come from the Argus bundle pinned at reference/argus-v4.json, version 3. Its hash does not match the digest the Argus docs print for that filename. Integrate has both digests.

New launches go to Portal #7. Every address this site uses is printed on the page that uses it.

Where to go next

• Fees & rewards — the tax, the split, what a claim pays.
• Glossary — the labels used across the pair pages.
• Integrate — reading these launches yourself.
• The Argus documentation — the launchpad’s own reference.