Launch Stamp Router

Scope

Router V1 covers only launches executed and stamped through it. Read the Router directly to resolve a token or Uniswap v4 pool to one frozen record.

Network

Ethereum mainnet, chainId 1

Recognition input

token or (PoolManager, poolId)

Returned identity

A launchId and its StampRecordV1

Trust dependency

An Ethereum provider. A Registry, indexer, Supabase project, Programmable API, or application server is not required.

A valid record establishes Router provenance only. It does not establish safety, tradability, current liquidity or pool state, audit coverage, review status, or third-party terminal support.

Live Ethereum deployment

The deployment below is live on Ethereum. Validate the full binding at the same canonical block as every launch lookup.

Router status: live

chainId

1

version

1

generation

1

address

0x8622DD5bAb44185f2A458ac90384Ac99248f8d56

startBlock

25717612

endBlock

null

runtimeCodeHash

0x40e27ecf201761d5eb66bc4f2d5c6124831ef078d7baf458ca5f41b1a8108546

finalityConfirmations

64

abiUrl

https://developers.programmable.family/abis/ethereum/programmable-launch-stamp-router-v1.json

abiSha256

sha256:bb4e728e9f9c850eb01f928e8a798ac206a82e241a8d93b3b3c686635c88ed86

runtimeCodeHash means EVM Keccak-256 of the deployed runtime bytecode, encoded as a 0x-prefixed bytes32 value. This binding applies at or after startBlock and through endBlock when a retirement boundary is published.

Finalized deployment evidence

verificationStatus

finalized-verified

address

0x8622DD5bAb44185f2A458ac90384Ac99248f8d56

deploymentTransactionHash

0x3bc086661555c10040feb3fceb23d33003e22ca033e65cfae72592119ee8d486

deploymentBlockNumber

25717612

deploymentBlockHash

0x8e4512193217c2171624657717d32dbfe9896455e553cadc192fbfe32d3278bc

finalizedBlockNumber

25717634

finalizedBlockHash

0x4177a280cd7e43da181bf1d73900eb2431c26d5fe933a5ed0e583370064cbd6e

finalityDepth

22

runtimeCodeBytes

23013

runtimeCodeKeccak256

0x40e27ecf201761d5eb66bc4f2d5c6124831ef078d7baf458ca5f41b1a8108546

runtimeCodeSha256

sha256:0b0e89074bff270bd5bf80ca9642f748dca1857d1ab643cbce65f4f663937ec7

getterBundleSha256

sha256:6e6e8a93193bbe2f79f98594a1af32c27bae0746f8297dd13592d9608e2feb20

evidenceSha256

sha256:f9786ebfb74c96a3c225567ad324f0fbecfd8520b8d8addec85ba58cd67e19ff

finalized-verified describes the deployment receipt, runtime, and immutable getter evidence. It is not an Explorer source publication status. The SHA-256 values are supplied handoff digests; this Website repository did not independently download and recompute their source evidence files.

Immutable bindings

permitAuthority

0x755509eA6e3F5Ec1aA2E797bb68f1B87DD8b886b

permitAuthorityRuntimeCodeHash

0xd7d408ebcd99b2b70be43e20253d6d92a8ea8fab29bd3be7f55b10032331fb4c

graphFactory

0xB012e4A8F2c5FC4E8E4faCA9D5Ad6FfF13FBA887

graphFactoryRuntimeCodeHash

0xd23692fae59331592048e71a96d4963e170ee56e449683dc9f7fa3f9470018b8

poolManager

0x000000000004444c5dc75cB358380D2e3dE08A90

poolManagerRuntimeCodeHash

0x785f1014552b7ce7d5fb7d0c970ca60edee94fd00425d7ca21609acac7ce1293

Finalized CustomGraph test case: PCAN

This point-in-time test case covers the CustomGraph route. PCAN is the token symbol in this test case, not a separate trust root or classification. The published evidence does not include a separate Classic onchain canary. Router-stamped Classic launches use the same live Router ABI and become verifiable when their records exist.

finality

finalized

customGraphOnchainCanary

true

classicOnchainCanary

false

transactionHash

0xc07b4e70233534a1d4f435ffc9a636ed5f542f4aedcde35052c58224f378b612

blockNumber

25717953

blockHash

0x97827b6586f0dca00e44801acc529c3961b4c693988dfc9f4b2bb4c3d94632ba

launchId

0x5a52180427785716bff0a36218dde89f0459db265d0c2bdfcfde81a8fe733c92

stampHash

0x06cb71b38d9b8b1dd1ffcdb00f31c774be36f5473979c3831d5fd0c96cdaa579

launchKind

1

sourceRepository

https://github.com/0xprogrammable/programmable

sourceCommit

b3cfed41bb841ae8d6188dbb815eddb5e1440218

commitSubject

Add graph launch stamp canary

evidenceFileSha256

sha256:1325d1333b6df9545cb87048e2b8d1c57a63af5b6790c329c0e95157a0d16d2c

evidenceLineSha256

sha256:615a20b31f454afb020a8fa83653c7685328e3f12ad58d3ac11ddab2d02968b5

Canary source commit b3cfed41bb841ae8d6188dbb815eddb5e1440218 is separate from Router artifact source commit 0a7134bbb912222639627fb9078df2f8dd3a6c38 and does not replace it. The canary SHA-256 fields are supplied handoff digests; this Website repository did not independently download or recompute their evidence files and does not host them.

Canary observations

initializer

0x87B108848B444bC44A01734D62C7be4a2fA64983

token

0x9DEeB39D2590b0cAD5fc473F755C5F97Dcc8f7cE

hook

0xEBa46f25DfF528141dE5317109Acb5A989296044

poolManager

0x000000000004444c5dc75cB358380D2e3dE08A90

poolId

0x5c5a3ebee6840640642ba2bea526621a4962d2c89c388c36a2edb4725802a229

activeLiquidity

31618002430832353916

positionManager

0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e

lpNftTokenId

367610

lpNftOwner

0x2Bb333d48DFAF1596D9036671d2E43168994249E

platformFeePips

1000

platformFeeRecipient

0x4957f49620AFf3Adbbe8195a4f633E49cc93376c

tokenTotalSupply

1000000000000000000000000

Canary component proofs

0x87B108848B444bC44A01734D62C7be4a2fA64983

0x5a52180427785716bff0a36218dde89f0459db265d0c2bdfcfde81a8fe733c92stampHash 0x06cb71b38d9b8b1dd1ffcdb00f31c774be36f5473979c3831d5fd0c96cdaa579

0x9DEeB39D2590b0cAD5fc473F755C5F97Dcc8f7cE

0x5a52180427785716bff0a36218dde89f0459db265d0c2bdfcfde81a8fe733c92stampHash 0x06cb71b38d9b8b1dd1ffcdb00f31c774be36f5473979c3831d5fd0c96cdaa579

0xEBa46f25DfF528141dE5317109Acb5A989296044

0x5a52180427785716bff0a36218dde89f0459db265d0c2bdfcfde81a8fe733c92stampHash 0x06cb71b38d9b8b1dd1ffcdb00f31c774be36f5473979c3831d5fd0c96cdaa579

Launch kinds

Classify a stamped record only from record.kind. The kind is returned metadata; it never selects a different trust root.

0

LaunchKindV1.InvalidNot a valid stamped record kind

1

LaunchKindV1.CustomGraphProgrammable Custom

2

LaunchKindV1.ClassicProgrammable Classic

Map LaunchKindV1.CustomGraph to Programmable Custom and LaunchKindV1.Classic to Programmable Classic.

Token and pool identity

Complete the manifest, canonical block, runtime, ABI, descriptor and immutable-binding gates before resolving a launch identifier. Read the lookup, record and proof from the same Router at the same block.

input := token OR (PoolManager, poolId)

preflight  require HTTPS RPC; HTTP is loopback-only
           require live/retired-in-range manifest with complete
           canary, binding, atomic, getter and event descriptors
           resolve one finalized canonical block → (number, openingHash)
           require eth_chainId, block range and Router runtime
           require ABI byte hash, getters, topics and indexed layouts
           require CHAIN_ID() == manifest.chainId
           require all six immutable bindings to match the manifest
           require permit authority, Graph Factory and PoolManager runtimes

step 1  launchId := input is token
          ? launchIdByToken(token)
          : launchIdByPool(PoolManager, poolId)
        if launchId == bytes32(0) → candidate := NOT_STAMPED; finalize

step 2  record := launchStamp(launchId)
        require supported kind and exact token or pool identity
        require valid address fields and nonzero bytes32 fields
        require record.poolManager == immutable PoolManager
        for token input, require stampProof(token) ==
          (launchId, record.stampHash)
        CustomGraph → require Graph Factory address + runtime binding
        Classic → retain permit-bound recorded launcher + runtime
        candidate := STAMPED(record)

finalize  for number-bound reads, require closingHash == openingHash
return candidate only after every required gate succeeds

Remote RPC URLs must use HTTPS. Plain HTTP is accepted only for loopback development endpoints. Prefer EIP-1898 reads with a concrete block hash and requireCanonical: true. When reads are bound by block number instead, refetch that height and require its closing hash to match the opening hash before returning either result.

Identity checks

Token

Require launchIdByToken(token), record.token == token, and stampProof(token) == (launchId, record.stampHash).

v4 pool

Require launchIdByPool(PoolManager, poolId) and exact equality with record.poolManager and record.poolId. PoolManager must equal the published immutable binding.

Exclusive component

Require launchIdByComponent(component), matching stampProof(component), and a nonzero recorded componentRuntimeCodeHash(component). Compare current runtime separately as a drift signal; equality is not a historical provenance gate.

A Classic hook is shared infrastructure, so its component proof is intentionally (bytes32(0), bytes32(0)) even when its launch is stamped. stampProof(address)corroborates an exclusive component. There is no universal hook getter. A current component-runtime mismatch may require separate consumer action, but it does not erase the Router's historical origin record.

Frozen ABI

Bind the source-exact ABI to the published address, runtime code hash, immutable getters, block range, and finality policy before reading a result.

Contract

ProgrammableLaunchStampRouterV1

Source commit

0a7134bbb912222639627fb9078df2f8dd3a6c38

Source tree

24ffb0c6b04af7993254560b4f03608de8f52231

Forge artifact

out/ProgrammableLaunchStampRouterV1.sol/ProgrammableLaunchStampRouterV1.json

Published ABI

https://developers.programmable.family/abis/ethereum/programmable-launch-stamp-router-v1.json

ABI file SHA-256

sha256:bb4e728e9f9c850eb01f928e8a798ac206a82e241a8d93b3b3c686635c88ed86

GitHub ABI source

Exact published file

Hash the exact downloaded ABI file bytes. Do not normalize or reserialize the JSON before comparing its SHA-256 digest.

Trust-root reads

Router chain ID

CHAIN_ID()selector 0x85e1f4d0 · returns uint256 chainId

Permit authority

PERMIT_AUTHORITY()selector 0xc3a3d03c · returns address permitAuthority

Permit authority runtime

PERMIT_AUTHORITY_RUNTIME_CODE_HASH()selector 0xa497c61c · returns bytes32 runtimeCodeHash

Graph Factory

GRAPH_FACTORY()selector 0x1cc9e5ce · returns address graphFactory

Graph Factory runtime

GRAPH_FACTORY_RUNTIME_CODE_HASH()selector 0x92989a00 · returns bytes32 runtimeCodeHash

PoolManager

POOL_MANAGER()selector 0x62308e85 · returns address poolManager

PoolManager runtime

POOL_MANAGER_RUNTIME_CODE_HASH()selector 0x38d831c4 · returns bytes32 runtimeCodeHash

Primary verification reads

Token to launch ID

launchIdByToken(address)selector 0x1dad847c · returns bytes32 launchId

Market to launch ID

launchIdByPool(address,bytes32)selector 0x361df6f3 · returns bytes32 launchId

Launch ID to record

launchStamp(bytes32)selector 0x4c9e4764 · returns StampRecordV1

Exclusive-component reads

Exclusive-component proof

stampProof(address)selector 0x174b9f9d · returns (bytes32 launchId, bytes32 stampHash)

Exclusive-component lookup

launchIdByComponent(address)selector 0x58c5e373 · returns bytes32 launchId

Recorded component runtime

componentRuntimeCodeHash(address)selector 0xc892d353 · returns bytes32 runtimeCodeHash

Atomic write selector

This is the sole market-bearing state-changing selector. Verification uses the read calls above and does not require a permit service, Registry, or application server.

Stamp record

launchStamp(bytes32) returns StampRecordV1 with fourteen fields in this exact order. Decode the tuple with the frozen ABI rather than a locally reconstructed type.

1. uint8kind
2. addresslaunchWallet
3. addresstoken
4. addresshook
5. addresspoolManager
6. bytes32poolId
7. bytes32poolKeyHash
8. bytes32componentSetHash
9. bytes32routePayloadHash
10. addressrouteLauncher
11. bytes32routeLauncherRuntimeCodeHash
12. bytes32expectedResultHash
13. bytes32permitDigest
14. bytes32stampHash

Every address field must have valid 20-byte address encoding; this does not add a blanket nonzero-address rule. Require nonzero values for poolId, poolKeyHash, componentSetHash, routePayloadHash, routeLauncherRuntimeCodeHash, expectedResultHash, permitDigest, and stampHash.

Identity

launchId is the lookup key. Do not replace it with a name, ticker, creator label, or hook address.

Hook

record.hook is descriptive metadata. The shared Classic hook is not a universal lookup or classification key.

Launch kind

Use record.kind for the public Classic or Custom label. It does not change the Router binding.

Events

Use Router events to discover candidate launch IDs. Accept a result only after reproducing the record with canonical getter reads.

ProgrammableLaunchStampedV1

ProgrammableLaunchStampedV1(bytes32,address,address,address,bytes32,bytes32)topic0 0x6cf479a102f1eebc9244f48f8d68f6aa52b4c5a4516318df58ba46614a5b14f2indexed: launchId, token, hook

ProgrammableLaunchRouteStampedV1

ProgrammableLaunchRouteStampedV1(bytes32,uint8,bytes32,bytes32,bytes32)topic0 0x45e7cc355b63ca67d6278a0d8d23470ce2a0741a9c60283d7dee712df7a877a5indexed: launchId, kind, routePayloadHash

ProgrammableComponentStampedV1

ProgrammableComponentStampedV1(bytes32,address,uint8,bytes32)topic0 0x8147265e7396d6400cee8d049456a1f7438fdfbe2a7c81c976d51ba67e52ff4bindexed: launchId, component, kind

{
  "address": "0x8622DD5bAb44185f2A458ac90384Ac99248f8d56",
  "fromBlock": "0x1886b6c",
  "toBlock": "finalized",
  "topics": [
    [
      "0x6cf479a102f1eebc9244f48f8d68f6aa52b4c5a4516318df58ba46614a5b14f2",
      "0x45e7cc355b63ca67d6278a0d8d23470ce2a0741a9c60283d7dee712df7a877a5",
      "0x8147265e7396d6400cee8d049456a1f7438fdfbe2a7c81c976d51ba67e52ff4b"
    ]
  ]
}

Require eth_chainId == 0x1 and the exact Router emitter. Backfill bounded ranges from 25717612 to a finalized boundary and respect endBlock when present. Explicit block-number reads require at least 64 confirmations.

Decode each log by its matched signature and correlate the three event types by launchId. Only ProgrammableLaunchStampedV1 supplies token and hook plus the non-indexed PoolManager, poolId, and stampHash. Classify only from record.kind after reading the record at the same canonical block.

Persist block number and hash, transaction hash and index, and log index as the idempotency key. Replay an overlap window and prefer EIP-1898 reads with requireCanonical: true. If a stored block hash changes, rewind to the last common finalized checkpoint.

A matching topic is only a discovery candidate. The full backfill, live-follow, and reorg procedure is in the terminal and scanner guide.

Result states

Keep failed reads separate from valid negative results. Every state is evaluated against one finalized canonical block and the published Router binding.

STAMPED

Every activation, canonical-block, runtime, ABI-descriptor, immutable-binding, lookup, record, identity, proof, route and any required closing-hash gate succeeds. Current component-runtime equality is reported separately.

NOT_STAMPED

After the preflight and any required closing block-hash check, a successful canonical lookup returns bytes32(0).

UNAVAILABLE

The Router is outside its published block range, the chain is inactive, or required activation data is incomplete.

INDETERMINATE

A call fails, the Router binding cannot be verified, or a nonzero lookup and record are inconsistent.

Indeterminate is not a provenance result and is not a claim that the token, pool, or project is unsafe.

What a stamp proves

A verified record establishes that the returned Classic or Custom launch followed the canonical Router route at the observed block.

Router provenance

The route and origin are bound to this Router at or after startBlock. A record does not claim that every component was newly created; shared Classic infrastructure can be recorded by reference.

Atomic v4 pool check

For the recorded pool, the Router requires slot0.sqrtPriceX96 == 0 immediately before its authorized launch call and slot0.sqrtPriceX96 != 0 immediately after it, then writes the stamp in the same transaction. This establishes initialization during that atomic launch, not current pool state or liquidity.

Not a safety result

Safety, tradability, current pool state, current liquidity, audit coverage, review status, approval, endorsement, and permission to launch are not established by a stamp.

Not terminal support

A stamp does not automatically list a token in GMGN, Axiom, FOMO, or any other terminal. Each consumer decides whether and how to implement the published verification procedure.

Not generic discovery

Generic pool or token discovery in a third-party API is not Router stamp integration and must not be presented as Programmable provenance. GMGN market numbers are not canonical onchain stamp evidence; read current pool state separately through PoolManager or StateView.

Not launch authorization

General public submissions and open wallet self-service are not available. Approved Hookbuilder Applicants can use the gated flow for a prepared release. This reference grants neither access nor launch authorization.