@rhinestone/shared-configs 1.11.1 → 1.12.0

package/dist/configs/chains.json

@@ -6,6 +6,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "mainnet",
         "name": "Ethereum",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -13,6 +14,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://eth.merkle.io",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -96,6 +98,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "optimism",
         "name": "OP Mainnet",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -103,6 +106,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://mainnet.optimism.io",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -197,6 +201,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "bsc",
         "name": "BNB Smart Chain",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -204,6 +209,7 @@
             "symbol": "BNB"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://56.rpc.thirdweb.com",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -271,6 +277,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "gnosis",
         "name": "Gnosis",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -278,6 +285,7 @@
             "symbol": "XDAI"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.gnosischain.com",
         "settlementLayers": [
             "RELAY",
             "NEAR",
@@ -312,6 +320,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "unichain",
         "name": "Unichain",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -319,6 +328,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://mainnet.unichain.org",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -401,6 +411,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "polygon",
         "name": "Polygon",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -408,6 +419,7 @@
             "symbol": "POL"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://polygon.drpc.org",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -478,6 +490,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "monad",
         "name": "Monad",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -485,6 +498,7 @@
             "symbol": "MON"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.monad.xyz",
         "settlementLayers": [
             "ACROSS",
             "RELAY",
@@ -553,6 +567,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "sonic",
         "name": "Sonic",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -560,6 +575,7 @@
             "symbol": "S"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.soniclabs.com",
         "settlementLayers": [
             "ECO",
             "RELAY",
@@ -600,6 +616,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "hyperevm",
         "name": "HyperEVM",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -607,6 +624,7 @@
             "symbol": "HYPE"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.hyperliquid.xyz/evm",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -658,6 +676,7 @@
             "txPath": "/explorer/tx/",
             "url": "https://app.hyperliquid.xyz"
         },
+        "iconSlug": "hyperevm",
         "name": "HyperCore",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -697,6 +716,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "soneium",
         "name": "Soneium Mainnet",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -704,6 +724,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.soneium.org",
         "settlementLayers": [
             "ACROSS",
             "RELAY"
@@ -771,6 +792,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "robinhood",
         "name": "Robinhood Chain",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -778,6 +800,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.mainnet.chain.robinhood.com",
         "settlementLayers": [
             "ACROSS",
             "RELAY"
@@ -834,6 +857,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "base",
         "name": "Base",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -841,6 +865,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://mainnet.base.org",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -909,6 +934,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "plasma",
         "name": "Plasma",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -916,6 +942,7 @@
             "symbol": "XPL"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.plasma.to",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -958,6 +985,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "plasma",
         "name": "Plasma Testnet",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -965,6 +993,7 @@
             "symbol": "XPL"
         },
         "network": "testnet",
+        "publicRpcUrl": "https://testnet-rpc.plasma.to",
         "settlementLayers": [
             "ECO"
         ],
@@ -1009,6 +1038,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "arbitrum",
         "name": "Arbitrum One",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1016,6 +1046,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://arb1.arbitrum.io/rpc",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -1099,6 +1130,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "avalanche",
         "name": "Avalanche",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1106,6 +1138,7 @@
             "symbol": "AVAX"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://api.avax.network/ext/bc/C/rpc",
         "settlementLayers": [
             "ACROSS",
             "RELAY",
@@ -1182,6 +1215,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "base",
         "name": "Base Sepolia",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1189,6 +1223,7 @@
             "symbol": "ETH"
         },
         "network": "testnet",
+        "publicRpcUrl": "https://sepolia.base.org",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -1263,6 +1298,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "arbitrum",
         "name": "Arbitrum Sepolia",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1270,6 +1306,7 @@
             "symbol": "ETH"
         },
         "network": "testnet",
+        "publicRpcUrl": "https://sepolia-rollup.arbitrum.io/rpc",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -1330,6 +1367,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "katana",
         "name": "Katana",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1337,6 +1375,7 @@
             "symbol": "ETH"
         },
         "network": "mainnet",
+        "publicRpcUrl": "https://rpc.katana.network",
         "settlementLayers": [
             "RELAY",
             "RHINO"
@@ -1394,6 +1433,7 @@
             "txPath": "/explorer/tx/",
             "url": "https://app.hyperliquid.xyz"
         },
+        "iconSlug": "hyperevm",
         "name": "HyperCore Spot",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1433,6 +1473,7 @@
             "txPath": "/explorer/tx/",
             "url": "https://app.hyperliquid.xyz"
         },
+        "iconSlug": "hyperevm",
         "name": "HyperCore Perp",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1472,6 +1513,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "mainnet",
         "name": "Sepolia",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1479,6 +1521,7 @@
             "symbol": "ETH"
         },
         "network": "testnet",
+        "publicRpcUrl": "https://11155111.rpc.thirdweb.com",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -1549,6 +1592,7 @@
             "addressPath": "/address/",
             "txPath": "/tx/"
         },
+        "iconSlug": "optimism",
         "name": "OP Sepolia",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1556,6 +1600,7 @@
             "symbol": "ETH"
         },
         "network": "testnet",
+        "publicRpcUrl": "https://sepolia.optimism.io",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -1616,6 +1661,7 @@
             "txPath": "/#/transaction/",
             "url": "https://tronscan.org"
         },
+        "iconSlug": "tron",
         "name": "Tron",
         "nativeToken": {
             "address": "0x0000000000000000000000000000000000000000",
@@ -1662,6 +1708,7 @@
             "txPath": "/tx/",
             "url": "https://solscan.io"
         },
+        "iconSlug": "solana",
         "name": "Solana",
         "nativeToken": {
             "address": "11111111111111111111111111111111",

package/dist/scripts/__tests__/validation.test.js

@@ -73,6 +73,12 @@ function errorsFor(chain) {
         ["an explorer url with a trailing slash", {
                 explorer: { url: "https://etherscan.io/", addressPath: "/address/", txPath: "/tx/" },
             }],
+        // A stem, not a path or a URL — the whole point of publishing a slug is that
+        // the artifact says nothing about where the file is served from.
+        ["an iconSlug that is a full URL", { iconSlug: "https://s3.rhinestone.dev/chains/base.svg" }],
+        ["an iconSlug carrying its extension", { iconSlug: "base.svg" }],
+        ["an iconSlug carrying a directory", { iconSlug: "chains/base" }],
+        ["an iconSlug that is not a string", { iconSlug: 42 }],
     ])("rejects %s", (_label, overrides) => {
         (0, bun_test_1.expect)(errorsFor(validChain(overrides)).length).toBeGreaterThan(0);
     });
@@ -387,6 +393,145 @@ function errorsFor(chain) {
         }
     });
 });
+(0, bun_test_1.describe)("classifyChainPublicRpcUrls", () => {
+    const nets = (mainnets, testnets = []) => ({ mainnets, testnets });
+    (0, bun_test_1.it)("derives the endpoint from viem's own chain definition", () => {
+        const { chains, issues } = (0, validation_1.classifyChainPublicRpcUrls)({ "8453": validChain({ name: "Base" }) }, nets([{ id: 8453, viemChain: "base" }]));
+        (0, bun_test_1.expect)(chains["8453"].publicRpcUrl).toBe("https://mainnet.base.org");
+        (0, bun_test_1.expect)(issues).toEqual([]);
+    });
+    // The regression this exists for, and the reason it is worse here than for
+    // explorers: viem's id 999 is claimed by hyperEvm, hyperliquid, wanchainTestnet
+    // and zoraTestnet. An id lookup would publish a live endpoint for the wrong
+    // chain, which fails at connect time rather than at render time.
+    (0, bun_test_1.it)("resolves by declared viemChain name, never by chain id", () => {
+        const { chains } = (0, validation_1.classifyChainPublicRpcUrls)({ "999": validChain({ name: "HyperEVM", caip2: "eip155:999" }) }, nets([{ id: 999, viemChain: "hyperEvm" }]));
+        (0, bun_test_1.expect)(chains["999"].publicRpcUrl).toBe("https://rpc.hyperliquid.xyz/evm");
+    });
+    (0, bun_test_1.it)("lets an authored endpoint win, for a chain viem does not ship", () => {
+        const { chains, issues } = (0, validation_1.classifyChainPublicRpcUrls)({
+            "424242": validChain({
+                name: "Newchain",
+                publicRpcUrl: "https://rpc.newchain.example",
+            }),
+        }, nets([{ id: 424242 }]));
+        (0, bun_test_1.expect)(chains["424242"].publicRpcUrl).toBe("https://rpc.newchain.example");
+        (0, bun_test_1.expect)(issues).toEqual([]);
+    });
+    // A browser on an https page cannot call an http endpoint at all, so an
+    // authored one is a URL that never connects rather than a working fallback.
+    (0, bun_test_1.it)("errors on an authored endpoint that is not https", () => {
+        const { issues } = (0, validation_1.classifyChainPublicRpcUrls)({ "1": validChain({ publicRpcUrl: "http://rpc.example" }) }, nets([{ id: 1, viemChain: "mainnet" }]));
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].severity).toBe("error");
+    });
+    // Absent is a real answer — the chain is display-only — so a real EVM chain
+    // with nothing to derive warns rather than failing the build.
+    (0, bun_test_1.it)("warns and leaves the field absent when nothing can supply one", () => {
+        const { chains, issues } = (0, validation_1.classifyChainPublicRpcUrls)({ "424242": validChain({ name: "Newchain" }) }, nets([{ id: 424242 }]));
+        (0, bun_test_1.expect)("publicRpcUrl" in chains["424242"]).toBe(false);
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].severity).toBe("warning");
+    });
+    // Non-EVM and virtual chains are never synthesised as viem chains, so there
+    // is nothing for them to be missing and nothing worth reporting.
+    (0, bun_test_1.it)("stays silent for chains that are never built as viem chains", () => {
+        const { issues } = (0, validation_1.classifyChainPublicRpcUrls)({
+            "792703809": validChain({ name: "Solana", vmType: "svm" }),
+            "1337": validChain({ name: "HyperCore", virtual: true }),
+        }, nets([{ id: 792703809 }, { id: 1337 }]));
+        (0, bun_test_1.expect)(issues).toEqual([]);
+    });
+    // Asserted against the shipped registry rather than by re-running the
+    // classifier, so this covers what actually reaches the artifact.
+    (0, bun_test_1.it)("gives every real EVM chain a well-formed https endpoint", () => {
+        for (const [id, entry] of Object.entries(index_1.chainRegistry)) {
+            const e = entry;
+            const isSynthesisable = e.vmType === "evm" && e.virtual !== true;
+            if (!isSynthesisable) {
+                (0, bun_test_1.expect)("publicRpcUrl" in e, id).toBe(false);
+                continue;
+            }
+            (0, bun_test_1.expect)(e.publicRpcUrl, id).toMatch(/^https:\/\/\S+$/);
+            (0, bun_test_1.expect)(e.publicRpcUrl.endsWith("/"), id).toBe(false);
+        }
+    });
+});
+(0, bun_test_1.describe)("validateChainIconSlugs", () => {
+    (0, bun_test_1.it)("passes a chain that carries a mark", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIconSlugs)({ "8453": validChain({ name: "Base", iconSlug: "base" }) })).toEqual([]);
+    });
+    // The whole point of the gate. `iconSlug` is authored by hand, so a chain
+    // added without one produces a blank tile in production and nothing anywhere
+    // reports it — no type, no test, no log. This turns that into a build failure
+    // while someone is already editing the registry.
+    (0, bun_test_1.it)("errors when a chain has neither a mark nor an exemption", () => {
+        const issues = (0, validation_1.validateChainIconSlugs)({
+            "424242": validChain({ name: "Newchain" }),
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].severity).toBe("error");
+        (0, bun_test_1.expect)(issues[0].chainId).toBe("424242");
+        // Both remedies are named, because which one is right is a product call.
+        (0, bun_test_1.expect)(issues[0].message).toContain("s3-public");
+        (0, bun_test_1.expect)(issues[0].message).toContain("CHAINS_WITHOUT_ICON");
+    });
+    // Absence is allowed, but only as a decision written down in code. The real
+    // exemption map is empty, so these two inject one rather than requiring some
+    // chain be left un-iconed purely to have something to assert against.
+    const exempt = new Map([["424242", "Newchain — no mark published"]]);
+    (0, bun_test_1.it)("accepts an absent mark for a chain listed in CHAINS_WITHOUT_ICON", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIconSlugs)({ "424242": validChain({ name: "Newchain" }) }, exempt)).toEqual([]);
+    });
+    // A stale exemption permanently excuses the chain it names, so the next person
+    // to drop that slug gets no warning at all.
+    (0, bun_test_1.it)("errors when an exempted chain gains a mark, so the exemption cannot rot", () => {
+        const issues = (0, validation_1.validateChainIconSlugs)({ "424242": validChain({ name: "Newchain", iconSlug: "newchain" }) }, exempt);
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].severity).toBe("error");
+        (0, bun_test_1.expect)(issues[0].message).toContain("remove the exemption");
+    });
+    bun_test_1.it.each([
+        ["a full URL", "https://s3.rhinestone.dev/chains/base.svg"],
+        ["an extension", "base.svg"],
+        ["a directory", "chains/base"],
+        ["uppercase", "Base"],
+    ])("errors on a slug carrying %s", (_label, iconSlug) => {
+        const issues = (0, validation_1.validateChainIconSlugs)({
+            "8453": validChain({ name: "Base", iconSlug }),
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("malformed");
+    });
+    (0, bun_test_1.it)("passes the real generated registry", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIconSlugs)(index_1.chainRegistry)).toEqual([]);
+    });
+    // Asserted against the shipped registry rather than by re-running the check,
+    // so this covers what actually reaches the artifact.
+    (0, bun_test_1.it)("gives every shipped chain a mark", () => {
+        const withoutIcon = Object.entries(index_1.chainRegistry)
+            .filter(([, e]) => e.iconSlug === undefined)
+            .map(([id]) => id);
+        (0, bun_test_1.expect)(withoutIcon).toEqual([]);
+    });
+    // Two reuse rules that would otherwise look like copy-paste errors in the
+    // jsonnet. A testnet is visually the same chain as its mainnet, and all three
+    // HyperCore ids are Hyperliquid — the same branding as HyperEVM.
+    bun_test_1.it.each([
+        ["11155111", "1"],
+        ["11155420", "10"],
+        ["84532", "8453"],
+        ["421614", "42161"],
+        ["9746", "9745"],
+        ["1337", "999"],
+        ["1337001", "999"],
+        ["1337002", "999"],
+    ])("reuses chain %s's glyph from chain %s", (child, parent) => {
+        const slug = index_1.chainRegistry[parent].iconSlug;
+        (0, bun_test_1.expect)(slug).toBeDefined();
+        (0, bun_test_1.expect)(index_1.chainRegistry[child].iconSlug).toBe(slug);
+    });
+});
 (0, bun_test_1.describe)("classifyChainStacks", () => {
     const nets = (mainnets, testnets = []) => ({ mainnets, testnets });
     // The common case: nothing is authored anywhere. viem already knows what Base

package/dist/scripts/generate.js

@@ -132,6 +132,14 @@ function renderChains(chainRegistry, mainnets, testnets) {
         "  caip2: string;",
         "  /** Block explorer, or null for a chain that has none (render plain text). */",
         "  explorer: Explorer | null;",
+        "  /** Filename stem of this chain's mark in s3-public's `chains/` directory,",
+        "   *  served today at `https://s3.rhinestone.dev/chains/<slug>.svg`. A slug and",
+        "   *  not a URL so the CDN stays a consumer's concern. Absent means no mark —",
+        "   *  render a coloured initial chip, never an error. */",
+        "  iconSlug?: string;",
+        "  /** Public, unauthenticated https JSON-RPC endpoint — what a browser needs to",
+        "   *  build this chain with `defineChain`. Absent means display-only. */",
+        "  publicRpcUrl?: string;",
         "  /** True for virtual chains (e.g. HyperCore) that settle on another chain. */",
         "  virtual?: boolean;",
         "  /** Which directions of transfer the chain supports; absent means both.",
@@ -394,12 +402,22 @@ async function generate() {
     const { chains: caip2Classified, issues: caip2Issues } = (0, validation_1.classifyChainCaip2)(stackClassified);
     // Then the block explorer, so a consumer rendering a link for a chain added
     // after its release does not need a hand-maintained table of its own.
-    const { chains: classifiedChains, issues: explorerIssues } = (0, validation_1.classifyChainExplorers)(caip2Classified, output.networks);
+    const { chains: explorerClassified, issues: explorerIssues } = (0, validation_1.classifyChainExplorers)(caip2Classified, output.networks);
+    // Then the public RPC endpoint, the last thing a browser consumer needs to
+    // build a viem `Chain` for a chain it was never compiled against — and the
+    // one that decides whether that chain is connectable or only displayable.
+    const { chains: classifiedChains, issues: publicRpcUrlIssues } = (0, validation_1.classifyChainPublicRpcUrls)(explorerClassified, output.networks);
+    // `iconSlug` is authored, not derived, so there is nothing to classify — only
+    // to insist on. A chain added without one would otherwise reach production as
+    // a blank tile, which nothing anywhere reports.
+    const iconSlugIssues = (0, validation_1.validateChainIconSlugs)(classifiedChains);
     const classificationIssues = [
         ...networkIssues,
         ...stackIssues,
         ...caip2Issues,
         ...explorerIssues,
+        ...publicRpcUrlIssues,
+        ...iconSlugIssues,
     ];
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "chains.json"), `${JSON.stringify(classifiedChains, null, 2)}\n`);
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "mainnets.json"), `${JSON.stringify(output.mainnets, null, 2)}\n`);

package/dist/scripts/validation.d.ts

@@ -122,6 +122,57 @@ export declare function classifyChainExplorers(chains: ChainRegistry, networks:
     chains: ChainRegistry;
     issues: ValidationIssue[];
 };
+/**
+ * Fails the build for a chain that has neither a mark nor an explicit exemption.
+ *
+ * Why an error and not a warning: `iconSlug` is authored by hand, so the failure
+ * mode of a new chain is silence — nobody forgets a field they were never
+ * prompted for, and the result is a blank tile in production that no test, type
+ * or log names. The gate turns that into a build failure at the moment someone
+ * is already editing the registry, which is the only point where the decision is
+ * cheap. CHAINS_WITHOUT_ICON is how "this chain genuinely has no mark" is said
+ * out loud, in code review, rather than being indistinguishable from an oversight.
+ *
+ * Deliberately offline. Whether `chains/<slug>.svg` actually exists on the CDN is
+ * not checked and must not be: the build would then fail on a CDN blip or in a
+ * sandboxed CI runner, which is a far more frequent failure than a typo'd slug
+ * and produces a red build with nothing wrong in the diff. The cost of a bad slug
+ * is one missing image; the cost of a network-dependent build gate is every build.
+ */
+export declare function validateChainIconSlugs(chains: ChainRegistry, exemptions?: ReadonlyMap<string, string>): ValidationIssue[];
+/**
+ * Stamps every chain with a public JSON-RPC endpoint, derived from the chain's
+ * viem definition where it has one and authored in the jsonnet where it does
+ * not.
+ *
+ * Why this exists: a browser consumer building a viem `Chain` with
+ * `defineChain` — for a chain newer than its pinned viem — already gets id,
+ * name, native currency, `explorer` and `stack` from this registry. The RPC
+ * endpoint was the only missing piece, and it is the piece that decides whether
+ * a newly added chain is a first-class wallet-connect target or display-only.
+ * It is the PUBLIC endpoint on purpose: the rpc-proxy path needs an API key,
+ * which is the one thing a browser cannot have.
+ *
+ * Resolved by the entry's declared `viemChain` **name**, never by chain id, for
+ * the same reason as `classifyChainExplorers` — only worse here, because the
+ * consequence is a live endpoint for the wrong chain rather than a dead link.
+ * viem 2.55 has 23 chain ids claimed by more than one export: id 999 is
+ * `hyperEvm`, `hyperliquid`, `wanchainTestnet` and `zoraTestnet`, so an id
+ * lookup for HyperEVM can hand out a Zora testnet RPC.
+ *
+ * A missing endpoint is not an error — it resolves to the field being absent,
+ * and a consumer treats that chain as display-only. It is worth a warning for a
+ * real EVM chain, where the usual cause is a chain viem does not ship yet; for
+ * a non-EVM or virtual chain there is nothing to warn about, since none of them
+ * is ever built as a viem chain.
+ */
+export declare function classifyChainPublicRpcUrls(chains: ChainRegistry, networks: {
+    mainnets: StackNetworkEntry[];
+    testnets: StackNetworkEntry[];
+}): {
+    chains: ChainRegistry;
+    issues: ValidationIssue[];
+};
 /** The subset of a generated network entry that stack classification needs. */
 export interface StackNetworkEntry {
     id: number;