Deployed Contracts

ChainRender is live on three testnets — the Ethereum Sepolia, Robinhood Chain, and Circle Arc testnets. This page lists the core deployed contracts you integrate against. The canonical, complete, always-current address list is deployment/additive/addresses.json (Sepolia) plus the per-chain chains.json manifest in the repository — this page surfaces the key entries for convenience.

Always verify against the canonical file. Deployments evolve (new versions are added alongside old ones — nothing is ever removed). The repository's addresses.json / chains.json are the source of truth; the addresses below are the current core set at the time of writing. Verify any address on a block explorer before integrating.

Networks

ChainRender is deployed on three testnets. App identity is the content hash, so the same app has the same hash on every chain — nothing bridges; only the infrastructure contract addresses differ per chain.

• Canonical Sepolia addresses: deployment/additive/addresses.json.
• Canonical per-chain manifest (all chains): chains.json, generated by scripts/build-chains-manifest.mjs from each chain's deployment/genesis-addresses.<chainId>.json. The builder reads it to populate the chain selector, so it can never drift from what was actually deployed.

Core render path (Sepolia)

Additive history (all stay live): earlier router/interpreter versions remain callable — RenderRouter_v106 0x3bb7613e… (+ interpreter 0x58122fe6…) and the superseded base 0x0322b911…. The addresses above are the current "ctxfix" stack the live viewer renders through; pin to whichever version your app was built against.

Now on all three chains: ComponentRegistryFast is the canonical component store on every chain — a gas-optimized (MCOPY) twin of ComponentRegistry that reads back byte-identically; Sepolia keeps the legacy ComponentRegistry above for already-seeded apps. OpcodeInterpreterV3 (a second render target that emits a self-contained SVG document from the same component bytes, alongside the HTML V3Html/V4Html) is also live on all three chains.

Flagship app + theming (Sepolia, current)

Proven balances — Milestone 1 (Sepolia)

The proof stack behind Proven Balances: it proves token balances against Sepolia's own state root and renders them with block, age and grade. All six are source-verified on Etherscan. Deployment record: deployments/xchain-m1-11155111.json.

Testnet-disposable. These contracts may be redeployed in a later milestone (for example a CreateX redeploy of the factory, once tokens need the same address on several chains). Milestone 2 reuses them unchanged. Always take addresses from the deployment record.

Proven balances — Milestone 2 (Sepolia → Robinhood Chain Testnet)

Sepolia balances proven on Robinhood (Proven Balances, On another chain). Deployed and accepted end to end on 2026-10-06; all five are source-verified (Etherscan for the sender, Robinhood's Blockscout explorer for the rest). Deployment record: deployments/xchain-m2-46630.json.

The sender and receiver were deployed through CreateX (CREATE3) so each could name the other in its constructor. Proven token on Robinhood: the Sepolia CRPD (0xf69528c0…5504), registered in the Robinhood cache.

Proven balances — Milestone 3, snapshot mode (existing tokens, Sepolia → Robinhood)

Balances of tokens ChainRender did not create, from the token's own balanceOf run on Sepolia (Proven Balances, Tokens ChainRender didn't create). Deployed, accepted and source-verified on 2026-10-06. The Robinhood cache reuses the Milestone 2 ArbParentRootSource as its only root source. Deployment record: deployments/xchain-m3-46630.json.

Tokens proven on Robinhood: Sepolia WETH9 (0xfff99767…6b14) and USDC (0x1c7d4b19…7238).

Proven balances — Milestone 3, storage-layout mode (existing tokens, Sepolia → Robinhood)

Storage proofs of tokens ChainRender did not create, under content-addressed adoption claims (Proven Balances, without a transaction per value). Grade C by construction. Deployed, accepted and source-verified on 2026-10-07 (Etherscan; Robinhood's Blockscout explorer). Deployment record: deployments/xchain-m3b-46630.json.

The three adapters are at the same address with the same code on both chains (CreateX CREATE3, a salt not bound to a chain): a claim names them by address + code hash, so one claim works everywhere.

Adapters on Robinhood: PlainPinning, SlotProxyPinning, MappingWordLayout.

Adopted on Sepolia and registered on both chains: WETH9 (0xfff99767…6b14) under claim 0xfae8aac6088f9c8b1b4a5d255388ffe92c0c1f2167da8c9fadb40f635d6cc4e5 (plain/v1 + mapping-word/v1, Solidity order, slot 3, 256 bits; evidence 0x319df1e6…2657, pinned on IPFS as bafkreidkcv46nvu7oayhvegbdiengoconle67ct6ovt7ecnxlnhl3bwkkm). Sepolia USDC is refused (Delegates), and is shown via snapshot mode.

Cross-chain swap — Milestone 4 (Sepolia ↔ Robinhood, no bridge)

A hash-timelock swap whose second lock checks the first by storage proof (Proven Balances, Swapping across chains without a bridge). Deployed, accepted and source-verified on 2026-10-07 (Etherscan; Robinhood's Blockscout explorer). Deployment record: deployments/xchain-m4-46630.json. The swap is Grade C at most; proven lock states are Grade A relative to Robinhood, always with its facet.

HashTimelockSwap on Robinhood: explorer. Acceptance tokens: CRSA on Sepolia (0xed28bd4c…8fa8) and CRSB on Robinhood (0x5ba180d3…d5a4).

How to use these

• Render the flagship: RenderRouter.renderHash(0x83f0c192…) — a free eth_call.
• Render with a theme/size: RenderRouter.renderHashWithContext(appHash, ctx).
• Check a component exists: ComponentRegistry.exists(hash).

For the full deployment — every resolver, registry, and renderer (Sepolia is ~130 contracts) — read deployment/additive/addresses.json. New capability is deployed additively (new contracts alongside the live base, never replacing it), so the file grows over time and old addresses keep working.

Robinhood Chain Testnet (46630)

ChainRender runs the same core render path on the Robinhood Chain Testnet (chain 46630), deployed at Robinhood-specific addresses. Because app identity is the content hash, an app deployed to both chains carries the same hash on each — only the infrastructure contract addresses differ. (The on-chain library hashes below are byte-identical to Sepolia: same bytes, same hash.)

Network: chain id 46630 · explorer https://explorer.testnet.chain.robinhood.com · gas token ETH · free testnet gas via the site's Robinhood faucet toggle (Official / QuickNode / Chainstack / Chainlink).

Core render path (Robinhood)

Key registries, renderers & theming (Robinhood)

The full set — 109 contracts (every resolver, registry, renderer, verifier) — is in deployment/genesis-addresses.46630.json, surfaced through the generated chains.json. Verify any address on the Robinhood explorer before integrating.

On-chain libraries (Robinhood, DependencyRegistry 0xae75db71…)

Content-addressed, so these libHash values are byte-identical to Sepolia:

Circle Arc Testnet (5042002)

ChainRender runs the same core render path on the Circle Arc Testnet (chain 5042002), deployed at Arc-specific addresses. As with Robinhood, app identity is the content hash — the same app carries the same hash on Arc as on Sepolia/Robinhood; only the infrastructure addresses differ. (Arc's core addresses in fact came out identical to Robinhood's: the same deployer deploying the same contracts in the same order yields the same CREATE addresses — the chains remain fully independent deployments.)

Network: chain id 5042002 · explorer https://testnet.arcscan.app · gas token USDC · testnet USDC via the site's Arc faucet toggle (Circle / Chainlink / thirdweb).

USDC gas — the one Arc quirk. Arc's native gas token is USDC, and Arc exposes USDC twice: as the native gas asset it uses 18 decimals (standard wei-style — gas math and native balances behave like any ETH-style chain), while the USDC ERC-20 token uses 6 decimals at the fixed address 0x3600000000000000000000000000000000000000. Don't conflate the two — read a USDC token amount at 6 decimals and the native balance at 18. Rendering itself is unaffected (view calls are chain-agnostic).

Core render path (Arc)

Key registries, renderers & theming (Arc)

The full set — 109 contracts — is in deployment/genesis-addresses.5042002.json, surfaced through the generated chains.json. The on-chain library hashes are byte-identical to Sepolia/Robinhood (content-addressed). Verify any address on the Arc explorer before integrating.

The additive deployment discipline

ChainRender never redeploys the world to add a feature. New contracts (a new resolver, a new registry, a new interpreter version) are deployed against the live base and their addresses merged into the address file, leaving everything existing untouched. This is why:

• Old apps never break — the contracts they reference are immutable and stay live.
• The address file is append-only — entries are added, never removed.
• You can pin to a specific version — an app references exactly the contract addresses it was built against.

Verifying a deployment

Every ChainRender contract is ownerless and immutable (no admin, no upgrade key). To verify:

1. Read the contract's bytecode on a block explorer — confirm it matches the compiled artifact.
2. Confirm there's no owner/admin function.
3. Render an app through it against multiple RPCs — byte-identical output confirms honest behavior.

See Contracts → Verifying an App.

Related

• Contracts → Architecture · Contracts → Reading On-Chain · Contracts → Registries

On-chain libraries (DependencyRegistry)

Fetched by name (newest-wins), gzip-compressed, decompressed natively in the browser -- no CDN.

DeFi resolvers

All caller-supplied-address, view-only, ownerless, fail-closed (a reverting/missing target renders "unavailable"), and now deployed on all three chains. See DeFi Capabilities for detail.

RWA resolvers

Real-world-asset display + verification resolvers — on-chain reads rendered honestly, never enforcement or custody. Deployed on all three chains. Full detail (kinds, trust grades, the honest boundary) in RWA Capabilities.

(Addresses are per-deployment and additive; deployment/additive/addresses.json (Sepolia) and each chain's genesis-addresses.<chainId>.json — surfaced through chains.json — are the authoritative live set.)

CoW / intent-DeFi resolvers (Sepolia)

Intent-based DeFi — CoW Protocol conditional/programmatic orders, rendered + verified trustlessly. These are deployed on Ethereum Sepolia (where CoW's ComposableCoW is deployed); they are portable to any chain where ComposableCoW exists, because its address is a caller argument, not a hardcoded constant. They are not part of the all-three-chains resolver set above. Full detail in Intent DeFi & CoW Protocol.

ENS multichain resolver (Sepolia)

Addresses above are the current Sepolia set at the time of writing and come from this deployment's additive run — verify against deployment/additive/addresses.json (the authoritative live set) before integrating. See ENS Names & Integration for the ENS reads and RWA Capabilities for the vault.