Skip documentation navigation

Verify a token or pool

Resolve a token or Uniswap v4 pool to one Router record and cross-check it at a single canonical block.

Bind to the canonical Router

Read the stable discovery document, follow its manifestUrl and use the launchStampRouter entry from the live manifest.

Network
Ethereum mainnet · chainId 1
Live range
25717612 to open
Runtime code hash
0x40e27ecf201761d5eb66bc4f2d5c6124831ef078d7baf458ca5f41b1a8108546
ABI SHA-256
sha256:bb4e728e9f9c850eb01f928e8a798ac206a82e241a8d93b3b3c686635c88ed86

Download the hosted Router ABI, hash its exact bytes and match the published digest. From that same ABI, derive and match every published getter selector. For every published event, derive and match its full signature, topic0 and indexed input names and order. Derive and match the sole payable atomic signature launchAndStampV1((uint256,address,address,uint8,bytes32,bytes32,bytes32,bytes32,uint64,uint64,uint256),(bytes32,address,bytes32,(address,address,uint24,int24,address),bytes32,(uint8,address,bytes32,uint8,uint8)[]),bytes,bytes) and selector 0xe5f6b8cd from that ABI too. If the digest or any derived descriptor disagrees, return INDETERMINATE. At the selected block, verify the Router runtime and every immutable binding from the manifest.

  1. Require status: live, or retired only for a historical read inside the published block range. Require complete activation data from the manifest: deployment evidence, finalized canary evidence, getter descriptors and event descriptors.
  2. At the same canonical block, call CHAIN_ID() and all six immutable binding getters below. Match every returned value to the manifest.
  3. At that block, call eth_getCode for the permit authority, Graph Factory and PoolManager. Hash each runtime with EVM Keccak-256 and require the exact manifest runtime hash.
  • CHAIN_ID()Router chain ID
  • PERMIT_AUTHORITY()Permit authority
  • PERMIT_AUTHORITY_RUNTIME_CODE_HASH()Permit authority runtime
  • GRAPH_FACTORY()Graph Factory
  • GRAPH_FACTORY_RUNTIME_CODE_HASH()Graph Factory runtime
  • POOL_MANAGER()PoolManager
  • POOL_MANAGER_RUNTIME_CODE_HASH()PoolManager runtime

Use one canonical block

Resolve one finalized block before the first contract read. Use that same block for the Router runtime, bindings, lookup, stamp record and proof.

  • Use HTTPS for every remote Ethereum RPC. Allow plaintext HTTP only for loopback development endpoints.
  • Prefer the provider's finalized block tag.
  • For an explicit block, require at least 64 confirmations.
  • Use EIP-1898 reads with requireCanonical: true when the provider supports them.
  • Otherwise bind every read to the resolved block number. After the last call, fetch that height again and require the same block hash before returning STAMPED or NOT_STAMPED.
  • Require the block to fall inside the Router's published live range.

Resolve the launch ID

Start from the identity your product already has. A successful zero lookup is the only direct NOT_STAMPED result.

From a token address

  1. Call launchIdByToken(address).
  2. If the canonical call returns zero, complete the closing block hash check when required, then return NOT_STAMPED.
  3. For a nonzero launch ID, continue with the complete record and token proof checks below.

From a Uniswap v4 pool

  1. Require the supplied PoolManager to equal the immutable binding 0x000000000004444c5dc75cB358380D2e3dE08A90.
  2. Call launchIdByPool(address,bytes32) with that bound PoolManager and the pool ID.
  3. If the canonical call returns zero, complete the closing block hash check when required, then return NOT_STAMPED.
  4. For a nonzero launch ID, continue with the complete record and pool identity checks below.

Cross-check the stamp

A nonzero lookup is only a candidate. Complete every check below at the same canonical block before returning STAMPED.

  1. Read launchStamp(bytes32) with the nonzero launch ID and require a supported, nonzero launch kind.
  2. Require valid launchWallet, token, hook, poolManager and routeLauncher address fields.
  3. Require nonzero poolId, poolKeyHash, componentSetHash, routePayloadHash, routeLauncherRuntimeCodeHash, expectedResultHash, permitDigest and stampHash commitments.
  4. For every token, pool or exclusive-component query, require record.poolManager == 0x000000000004444c5dc75cB358380D2e3dE08A90. Also require the queried token or exact PoolManager and pool ID to match the record.
  5. For a token or exclusive component, require stampProof(address) to return the same launch ID and record.stampHash. Also require componentRuntimeCodeHash(address) for the queried address to return a nonzero recorded runtime hash.
  6. For LaunchKindV1.CustomGraph, require record.routeLauncher and record.routeLauncherRuntimeCodeHash to equal the immutable Graph Factory address and runtime hash. For Classic, retain the permit-bound values in the record; there is no Classic launcher immutable.
  7. Complete the closing block-hash check for number-bound reads, then classify only from record.kind.

Names, tickers, logos, creator metadata, factory lookalikes and shared hook addresses are not provenance.

1
Programmable CustomLaunchKindV1.CustomGraph
2
Programmable ClassicLaunchKindV1.Classic

Exclusive components

For a component used by only one launch, call launchIdByComponent(address), stampProof(address) and componentRuntimeCodeHash(address). Require the same nonzero launch ID and stamp hash, plus a nonzero recorded runtime hash. You may compare the runtime returned by eth_getCode at the canonical block with that recorded hash. Report a mismatch as code drift. It does not change the historical Router-provenance result.

Return one of four results

STAMPED
Every canonical binding, lookup, record, identity, commitment, route and proof check succeeds, including the closing block-hash check when required.
NOT_STAMPED
The canonical token, pool or exclusive-component lookup succeeds, returns zero and passes the closing block-hash check when required.
UNAVAILABLE
The Router is not live for the requested block, the chain is inactive or required activation data is incomplete.
INDETERMINATE
RPC, ABI, runtime, block, decoding or cross-check evidence is incomplete or inconsistent.

Test with the finalized PCAN vector

This CustomGraph launch is the published end-to-end integration vector.

Transaction
0xc07b4e70233534a1d4f435ffc9a636ed5f542f4aedcde35052c58224f378b612
Block
25717953
Launch ID
0x5a52180427785716bff0a36218dde89f0459db265d0c2bdfcfde81a8fe733c92
Stamp hash
0x06cb71b38d9b8b1dd1ffcdb00f31c774be36f5473979c3831d5fd0c96cdaa579
Token
0x9DEeB39D2590b0cAD5fc473F755C5F97Dcc8f7cE
Hook
0xEBa46f25DfF528141dE5317109Acb5A989296044
Initializer
0x87B108848B444bC44A01734D62C7be4a2fA64983
PoolManager
0x000000000004444c5dc75cB358380D2e3dE08A90
Pool ID
0x5c5a3ebee6840640642ba2bea526621a4962d2c89c388c36a2edb4725802a229
Launch kind
1 · Programmable Custom

The token, pool and exclusive components must resolve to the same launch ID and stamp hash.

Do not turn missing evidence into a negative result

  • A timeout, pruned block, malformed response or chain mismatch is INDETERMINATE.
  • An unavailable finalized block or inconsistent nonzero response is INDETERMINATE.
  • ORPHANED describes an event observation after a reorg. It is not a point-verification result.