arc-depth

Which of an Arc token's Uniswap v4 pools can you actually trade through, and what does a buy-then-sell round trip really cost?

Read-only. No wallet, no signing, no transactions — every number on this page is an eth_call your browser makes directly to Arc.

Same token. Eight pools. One block.

These are the pools recorded in the on-chain registry, all for one Arc token. Your browser reads each key from the contract, then quotes a full round trip through every pool at a single pinned block. Nothing here is precomputed and nothing is served by a backend.

Check any registered pool

A v4 pool id is a one-way hash, so an id alone tells you nothing. Paste one and the registry answers with the key behind it.

Why this matters

On Arc the same token can be bought through pools that differ by more than ninety percentage points in cost. No rug, no honeypot, no malice — just the wrong pool. Nothing published on Arc tells a buyer which one is usable.

The existing Arc scanners cannot answer it and say so. From Smithii's Arc rug checker: "token scanners rely on third-party providers that simulate buys and sells to catch honeypots, and those providers don't cover Arc yet." Their honeypot, tax and holder checks return Unknown, and their suggested workaround is to buy a tiny amount and try to sell it. That is what this does — as a quote, so it costs nothing and risks nothing.

How common is it, measured

From an index of 216,632 Initialize events — every v4 pool on Arc. Across the whole population the answer is boring: 97.1% of tokens have exactly one pool. But most of those are dead launches, and a token nobody trades has no routing problem. Sampling 151 tokens by 24h volume:

One in five actively traded Arc tokens has five or more pools — thirty times the base rate. The problem is concentrated exactly where the volume is. From the same index, 16,004 pools charge 50% or more, 6,280 of them over 90%, and 4,631 use a dynamic fee no one can quote in advance.

The missing primitive

A v4 pool id is keccak256(abi.encode(PoolKey)). A hash is one-way, so the id tells you nothing about the pool it names — not the currencies, the fee, the tick spacing or the hook. The only record of a key is the Initialize event emitted once at creation.

Off-chain that is expensive: Arc rejects wide eth_getLogs ranges, so a key has to be recovered by binary-searching block timestamps and scanning a narrow window — tens of seconds per token. For a contract it is impossible: the EVM cannot read a past event, so on-chain logic holding a pool id is stuck with an opaque 32 bytes.

PoolKeyRegistry fixes that. It derives the id from the key rather than accepting a caller-supplied pair, so a wrong entry is impossible by construction — planting one would take a keccak collision, not gas. No owner, no admin function, no upgrade path. Wired into the service as a lookup tier it measures 65–76 ms against the log scan's tens of seconds.

One program, 160,569 addresses

Arc's 216,632 pools reference 160,569 distinct hook addresses — nearly one per pool. Hashing their bytecode suggests 160,000 different programs, but that is an artifact: Solidity bakes immutables into deployed code, so identical contracts hash differently.

Code size sees through it. Of 150 hooks sampled from the long tail: 150 distinct hashes, but only 3 distinct code sizes, and 148 of 150 are exactly 5,175 bytes. Its selectors are poolManager(), beforeInitialize, afterSwap and treasury().

That shape — a hook running after every swap, holding a treasury — looks like a launchpad taking a cut, which would mean a pool's stated fee understates its cost. So it was tested rather than asserted. Measured at 5 USDC on pools that carry volume, the hooked cohort's excess over twice the stated fee is 0.39%, stable across runs of 10 and 12 pools, far below the 1% fee itself. The hypothesis failed. Finding a function in bytecode shows it exists, not that it is used at scale.

What this does not claim

• A failed call is not a verdict. Quote failures are reported as unmeasured, never as "cannot sell". Treating a network error as a honeypot stamps healthy pools as traps.
• Uniswap v4 only. Arc also has about 10,000 v3 pools; the v4 quoter cannot price them and they are not covered.
• Dynamic-fee pools are flagged, not priced. The hook sets the fee at swap time, so no fixed percentage would be honest.
• One block is a measurement, not a guarantee. Hook behaviour and liquidity can change in the next one.
• The registry is partial. 225 pools of 216,839 are registered — the ones that actually trade, written after the cost was measured rather than estimated. Filling it costs about 0.0014 USDC per key and is incremental, not a bulk load.
• The public Arc RPC is rate limited. Measured end to end, this service has a median latency of 4.3 s and a p90 of 40 s. Serving real traffic needs a dedicated endpoint.

Run it yourself

Every number above comes from a script in the repository, so it can be re-derived rather than believed. Clone it, then:

npm install
npm run check            # service self-checks, against mainnet
npm run contract:check   # compiled + deployed contract, no key needed