@rhinestone/shared-configs 2.20.1 → 2.21.1

package/dist/configs/chain-indexer.json

@@ -10,7 +10,8 @@
         "reorg_window_k": 32,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 36000
+        "streaming_poll_interval_ms": 36000,
+        "vm": "evm"
     },
     "10": {
         "finality": "sequencer",
@@ -23,7 +24,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 6000
+        "streaming_poll_interval_ms": 6000,
+        "vm": "evm"
     },
     "56": {
         "finality": "probabilistic",
@@ -36,7 +38,8 @@
         "reorg_window_k": 32,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "100": {
         "finality": "probabilistic",
@@ -49,7 +52,8 @@
         "reorg_window_k": 32,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 15000
+        "streaming_poll_interval_ms": 15000,
+        "vm": "evm"
     },
     "130": {
         "finality": "sequencer",
@@ -62,7 +66,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "137": {
         "finality": "probabilistic",
@@ -75,7 +80,8 @@
         "reorg_window_k": 64,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 4500
+        "streaming_poll_interval_ms": 4500,
+        "vm": "evm"
     },
     "143": {
         "finality": "instant",
@@ -88,7 +94,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "146": {
         "finality": "instant",
@@ -101,7 +108,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 4500
+        "streaming_poll_interval_ms": 4500,
+        "vm": "evm"
     },
     "196": {
         "finality": "sequencer",
@@ -114,7 +122,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "999": {
         "finality": "instant",
@@ -127,7 +136,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "1868": {
         "finality": "sequencer",
@@ -140,7 +150,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 6000
+        "streaming_poll_interval_ms": 6000,
+        "vm": "evm"
     },
     "4663": {
         "finality": "sequencer",
@@ -153,7 +164,22 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
+    },
+    "5042": {
+        "finality": "instant",
+        "finality_poll_interval_ms": 0,
+        "finality_source": "instant",
+        "grace_ms": 0,
+        "max_catchup_blocks": 5000,
+        "parse_concurrency": 8,
+        "poll_interval_ms": 1000,
+        "reorg_window_k": 4,
+        "reverify_delay_ms": 0,
+        "scan_batch_max_blocks": 200,
+        "streaming_poll_interval_ms": 15000,
+        "vm": "evm"
     },
     "8453": {
         "finality": "sequencer",
@@ -166,7 +192,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 6000
+        "streaming_poll_interval_ms": 6000,
+        "vm": "evm"
     },
     "9745": {
         "finality": "instant",
@@ -179,7 +206,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "9746": {
         "finality": "instant",
@@ -192,7 +220,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "42161": {
         "finality": "sequencer",
@@ -205,7 +234,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "43114": {
         "finality": "instant",
@@ -218,7 +248,8 @@
         "reorg_window_k": 4,
         "reverify_delay_ms": 0,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "57073": {
         "finality": "sequencer",
@@ -231,7 +262,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "84532": {
         "finality": "sequencer",
@@ -244,7 +276,8 @@
         "reorg_window_k": 8,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 6000
+        "streaming_poll_interval_ms": 6000,
+        "vm": "evm"
     },
     "421614": {
         "finality": "sequencer",
@@ -257,7 +290,8 @@
         "reorg_window_k": 8,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "747474": {
         "finality": "sequencer",
@@ -270,7 +304,8 @@
         "reorg_window_k": 16,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 3000
+        "streaming_poll_interval_ms": 3000,
+        "vm": "evm"
     },
     "11155111": {
         "finality": "probabilistic",
@@ -283,7 +318,8 @@
         "reorg_window_k": 32,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 36000
+        "streaming_poll_interval_ms": 36000,
+        "vm": "evm"
     },
     "11155420": {
         "finality": "sequencer",
@@ -296,6 +332,29 @@
         "reorg_window_k": 8,
         "reverify_delay_ms": 500,
         "scan_batch_max_blocks": 200,
-        "streaming_poll_interval_ms": 6000
+        "streaming_poll_interval_ms": 6000,
+        "vm": "evm"
+    },
+    "792703809": {
+        "commitment": "finalized",
+        "max_catchup_signatures": 5000,
+        "overlap_slots": 300,
+        "page_limit": 1000,
+        "poll_interval_ms": 2000,
+        "topics": [
+            "5q44zFF8gziimbCipqNQ7GYed8pkTRDmUKFUFTwd4DjB"
+        ],
+        "vm": "svm"
+    },
+    "792703810": {
+        "commitment": "finalized",
+        "max_catchup_signatures": 5000,
+        "overlap_slots": 300,
+        "page_limit": 1000,
+        "poll_interval_ms": 2000,
+        "topics": [
+            "5q44zFF8gziimbCipqNQ7GYed8pkTRDmUKFUFTwd4DjB"
+        ],
+        "vm": "svm"
     }
 }

package/dist/configs/chains.json

@@ -1519,6 +1519,66 @@
             "symbol": "WETH"
         }
     },
+    "5042": {
+        "caip2": "eip155:5042",
+        "explorer": {
+            "addressPath": "/address/",
+            "txPath": "/tx/",
+            "url": "https://explorer.arc.io"
+        },
+        "iconSlug": "arc",
+        "name": "Arc",
+        "nativeToken": {
+            "address": "0x0000000000000000000000000000000000000000",
+            "decimals": 18,
+            "symbol": "USDC"
+        },
+        "network": "mainnet",
+        "providerIds": {
+            "alchemy": null,
+            "zerion": null
+        },
+        "publicRpcUrl": "https://rpc.mainnet.arc.io",
+        "sessionCapable": false,
+        "settlementConfig": {
+            "cctp": {
+                "domain": 26
+            },
+            "rhino": {
+                "bridgeContract": "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+                "chainName": "ARC"
+            }
+        },
+        "settlementLayers": [
+            "ACROSS",
+            "RELAY",
+            "RHINO",
+            "CCTP"
+        ],
+        "stack": "vanilla",
+        "swapQuoters": [],
+        "tokens": [
+            {
+                "address": "0x3600000000000000000000000000000000000000",
+                "appFee": true,
+                "approvalSlot": null,
+                "balanceSlot": null,
+                "decimals": 6,
+                "gasRefund": true,
+                "pegGroup": "USD",
+                "settlementLayers": [
+                    "ACROSS"
+                ],
+                "symbol": "USDC"
+            }
+        ],
+        "vmType": "evm",
+        "wrappedNativeToken": {
+            "address": "0x3600000000000000000000000000000000000000",
+            "decimals": 6,
+            "symbol": "USDC"
+        }
+    },
     "8453": {
         "caip2": "eip155:8453",
         "explorer": {
@@ -3142,6 +3202,7 @@
             "alchemy": null,
             "zerion": null
         },
+        "rpcId": "mainnet-beta",
         "sessionCapable": false,
         "settlementConfig": {
             "cctp": {
@@ -3246,6 +3307,7 @@
             "alchemy": null,
             "zerion": null
         },
+        "rpcId": "devnet",
         "sessionCapable": false,
         "settlementConfig": {
             "cctp": {

package/dist/configs/contracts.dev.json

@@ -96,6 +96,10 @@
         "swapAdapter": "0x58BC7d9279A38a1537c2f74426dBDbD804AD3A18",
         "swapAdapterTokenSpender": "0xc5f6641b3ade357c5df77a1859d16528fe8b3e93"
     },
+    "5042": {
+        "acrossBridge": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84",
+        "spokepool": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84"
+    },
     "8453": {
         "ecoArbiter": "0x1BeBAfb3D05d84A5Bfd94800c88d1342f755d8AB",
         "acrossBridge": "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",

package/dist/configs/contracts.json

@@ -96,6 +96,10 @@
         "swapAdapter": "0xaE448E141F230AC3c6F6dA981C0882356c9B91a6",
         "swapAdapterTokenSpender": "0x3115c923734471b9da1d5bfef161d9c9e9963859"
     },
+    "5042": {
+        "acrossBridge": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84",
+        "spokepool": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84"
+    },
     "8453": {
         "ecoArbiter": "0x2e7627CCfAe4eDb336eEb5a70f08415B0F1a2b8C",
         "acrossBridge": "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",

package/dist/configs/mainnets.json

@@ -73,6 +73,13 @@
             "Alchemy"
         ]
     },
+    "5042": {
+        "providers": [
+            "Alchemy",
+            "arc-public-rpc",
+            "DRPC"
+        ]
+    },
     "8453": {
         "providers": [
             "DRPC",

package/dist/configs/providers.json

@@ -13,6 +13,7 @@
             "999": "hyperliquid-mainnet",
             "1868": "soneium-mainnet",
             "4663": "robinhood-mainnet",
+            "5042": "arc-mainnet",
             "8453": "base-mainnet",
             "9745": "plasma-mainnet",
             "9746": "plasma-testnet",
@@ -41,6 +42,7 @@
             "999": "hyperliquid",
             "1868": "soneium",
             "4663": "robinhood",
+            "5042": "arc",
             "8453": "base",
             "9745": "plasma",
             "9746": "plasma-testnet",
@@ -55,6 +57,12 @@
         },
         "url_template": "https://lb.drpc.org/ogrpc?network={{chain_param}}&dkey=${DRPC_API_KEY}"
     },
+    "arc-public-rpc": {
+        "chain_mapping": {
+            "5042": "5042"
+        },
+        "url_template": "https://rpc.mainnet.arc.io"
+    },
     "eRPC": {
         "chain_mapping": {
             "1": "1",
@@ -69,6 +77,7 @@
             "999": "999",
             "1868": "1868",
             "4663": "4663",
+            "5042": "5042",
             "8453": "8453",
             "9745": "9745",
             "9746": "9746",

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

@@ -327,6 +327,56 @@ function errorsFor(chain) {
         (0, bun_test_1.expect)(error.message).toContain("TELEPORT");
         (0, bun_test_1.expect)(error.message).toContain("src/types.ts");
     });
+    // Absent is fine: chainRegistry() defaults it to the chain id, and a
+    // consumer reading a document written before the field existed does the
+    // same. Only the two ways AUTHORING can get it wrong are checked.
+    (0, bun_test_1.it)("accepts a chain with no rpcId", () => {
+        (0, bun_test_1.expect)(errorsFor(validChain())).toEqual([]);
+    });
+    (0, bun_test_1.it)("accepts an rpcId that matches the chain id", () => {
+        (0, bun_test_1.expect)(errorsFor(validChain({ rpcId: "1" }))).toEqual([]);
+    });
+    (0, bun_test_1.it)("rejects an rpcId override on an EVM chain", () => {
+        const [error] = errorsFor(validChain({ rpcId: "mainnet" }));
+        (0, bun_test_1.expect)(error.message).toContain("does not match the chain id");
+    });
+    // The failure this prevents is an empty feed, which reads exactly like a
+    // chain with no traffic — so it has to fail the build, not runtime.
+    (0, bun_test_1.it)("rejects a Solana chain whose rpcId is still the numeric default", () => {
+        const errors = (0, validation_1.validateChainConfig)({
+            "792703810": validChain({
+                name: "Solana Devnet",
+                vmType: "svm",
+                network: "testnet",
+                caip2: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+                rpcId: "792703810",
+            }),
+        }).issues.filter((i) => i.severity === "error");
+        (0, bun_test_1.expect)(errors.map((e) => e.message).join("\n")).toContain("addressed by its cluster name");
+    });
+    (0, bun_test_1.it)("rejects a Solana chain with no rpcId at all", () => {
+        const errors = (0, validation_1.validateChainConfig)({
+            "792703810": validChain({
+                name: "Solana Devnet",
+                vmType: "svm",
+                network: "testnet",
+                caip2: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+            }),
+        }).issues.filter((i) => i.severity === "error");
+        (0, bun_test_1.expect)(errors.map((e) => e.message).join("\n")).toContain("addressed by its cluster name");
+    });
+    (0, bun_test_1.it)("accepts a Solana chain addressed by its cluster", () => {
+        const errors = (0, validation_1.validateChainConfig)({
+            "792703810": validChain({
+                name: "Solana Devnet",
+                vmType: "svm",
+                network: "testnet",
+                caip2: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+                rpcId: "devnet",
+            }),
+        }).issues.filter((i) => i.severity === "error");
+        (0, bun_test_1.expect)(errors).toEqual([]);
+    });
 });
 (0, bun_test_1.describe)("validateChainConfig — reachability", () => {
     (0, bun_test_1.it)("returns no issues for chains with multiple settlement layers", () => {
@@ -516,6 +566,7 @@ function errorsFor(chain) {
 /** A complete class-B entry, so semantic tests don't trip the shape checks. */
 function validIndexerEntry(overrides = {}) {
     return {
+        vm: "evm",
         poll_interval_ms: 1000,
         streaming_poll_interval_ms: 15000,
         reorg_window_k: 16,
@@ -541,12 +592,12 @@ function validIndexerEntry(overrides = {}) {
         (0, bun_test_1.expect)(issues).toHaveLength(1);
         (0, bun_test_1.expect)(issues[0].message).toContain("no chain-indexer entry");
     });
-    (0, bun_test_1.it)("reports an entry addressing no real EVM chain", () => {
+    (0, bun_test_1.it)("reports an entry addressing a chain the indexer does not dial", () => {
         const issues = (0, validation_1.validateChainIndexerCoverage)({}, {
             "1": validIndexerEntry(),
         });
         (0, bun_test_1.expect)(issues).toHaveLength(1);
-        (0, bun_test_1.expect)(issues[0].message).toContain("no real EVM chain");
+        (0, bun_test_1.expect)(issues[0].message).toContain("no chain the indexer dials");
     });
     // HyperCore is vmType "evm" with a hypercore: caip2 — the eip155 namespace,
     // not vmType, decides whether the indexer dials a chain.
@@ -627,6 +678,105 @@ function validIndexerEntry(overrides = {}) {
         });
         (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain("the only legal value is false");
     });
+    /** The Solana entry as the artifact publishes it. */
+    function validSvmEntry(overrides = {}) {
+        return {
+            vm: "svm",
+            poll_interval_ms: 2000,
+            commitment: "finalized",
+            topics: ["5q44zFF8gziimbCipqNQ7GYed8pkTRDmUKFUFTwd4DjB"],
+            page_limit: 1000,
+            overlap_slots: 300,
+            max_catchup_signatures: 5000,
+            ...overrides,
+        };
+    }
+    function solanaChain(overrides = {}) {
+        return validChain({
+            name: "Solana Devnet",
+            vmType: "svm",
+            network: "testnet",
+            caip2: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+            rpcId: "devnet",
+            ...overrides,
+        });
+    }
+    (0, bun_test_1.it)("accepts a complete SVM entry", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateChainIndexerCoverage)({ "792703810": solanaChain() }, {
+            "792703810": validSvmEntry(),
+        })).toEqual([]);
+    });
+    (0, bun_test_1.it)("requires an entry for a Solana chain, like any other dialable chain", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "792703810": solanaChain() }, {});
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("SVM chain has no chain-indexer entry");
+    });
+    // The knob sets are disjoint, so judging an entry against the wrong one
+    // reports every field of both as wrong — which is the point: an SVM entry is
+    // not an EVM entry missing eleven fields.
+    (0, bun_test_1.it)("rejects EVM knobs on a Solana chain", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "792703810": solanaChain() }, { "792703810": validIndexerEntry() });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain('`vm` = "evm" but solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1 is a svm chain');
+    });
+    // The dangerous direction: the indexer reads `vm` first and passes over
+    // families it does not index, so an svm tag on an EVM chain would validate
+    // as a coherent SVM entry here and then leave that chain silently unscanned.
+    (0, bun_test_1.it)("rejects an svm tag on an EVM chain", () => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "1": validChain() }, {
+            "1": validSvmEntry(),
+        });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain("would never be scanned");
+    });
+    bun_test_1.it.each([
+        ["a missing SVM field", { topics: undefined }, "missing `topics`"],
+        ["an empty topic list", { topics: [] }, "`topics` = [] is not a legal value"],
+        [
+            "a malformed topic",
+            { topics: ["not-base58-и"] },
+            "is not a legal value",
+        ],
+        // A character-count regex accepts both of these — they are legal base58
+        // characters at a legal length — but neither decodes to a 32-byte account.
+        // A marker like this would pass the build and then name a feed no
+        // transaction can appear in, which reads as a chain with no traffic.
+        [
+            "a topic that decodes to 33 bytes",
+            { topics: ["z".repeat(44)] },
+            "is not a legal value",
+        ],
+        [
+            "a topic that decodes to 43 zero bytes",
+            { topics: ["1".repeat(43)] },
+            "is not a legal value",
+        ],
+        [
+            "a commitment nothing settles at",
+            { commitment: "processed" },
+            '`commitment` = "processed" is not a legal value',
+        ],
+        // Not a narrow allowlist: the SVM entry omits every reorg and retraction
+        // knob BECAUSE a finalized signature is settled. Reading at `confirmed`
+        // has to arrive with the retraction kind, not as a value a facts release
+        // can set on its own.
+        [
+            "a reversible commitment the schema cannot retract",
+            { commitment: "confirmed" },
+            '`commitment` = "confirmed" is not a legal value',
+        ],
+        [
+            "a page limit above the RPC ceiling",
+            { page_limit: 1001 },
+            "`page_limit` = 1001 is not a legal value",
+        ],
+        [
+            "an EVM knob smuggled in",
+            { reorg_window_k: 16 },
+            "unrecognized field `reorg_window_k`",
+        ],
+    ])("rejects %s on an SVM entry", (_label, overrides, expected) => {
+        const issues = (0, validation_1.validateChainIndexerCoverage)({ "792703810": solanaChain() }, { "792703810": validSvmEntry(overrides) });
+        (0, bun_test_1.expect)(issues.map((i) => i.message).join("\n")).toContain(expected);
+    });
     (0, bun_test_1.it)("accepts a coherent instant-class entry", () => {
         const entry = validIndexerEntry({
             finality: "instant",

package/dist/scripts/generate.js

@@ -162,6 +162,12 @@ function renderChains(chainRegistry, mainnets, testnets) {
         "  /** Public, unauthenticated https JSON-RPC endpoint — what a browser needs to",
         "   *  build this chain with `defineChain`. Absent means display-only. */",
         "  publicRpcUrl?: string;",
+        "  /** How this chain is addressed when dialling it, within its architecture:",
+        "   *  the last segment of `{proxy}/{architecture}/{rpcId}`. Present only where",
+        "   *  the chain id is NOT what you dial — the cluster name (`mainnet-beta`,",
+        "   *  `devnet`) on Solana. Absent means the chain id is the id, so read it as",
+        "   *  `chain.rpcId ?? String(chainId)` rather than branching on vmType. */",
+        "  rpcId?: 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.",

package/dist/scripts/validation.d.ts

@@ -226,19 +226,24 @@ export declare function validateChainConfig(chains: ChainRegistry): ValidationRe
  */
 export declare function validateOftCoverage(chains: ChainRegistry, oft: Record<string, unknown>): ValidationIssue[];
 /**
- * Insists that every real EVM chain carries a complete, coherent chain-indexer
- * entry, and that no entry addresses a chain that does not exist.
+ * Insists that every chain the indexer dials carries a complete, coherent
+ * chain-indexer entry, and that no entry addresses a chain that does not exist.
  *
- * The indexer scans every dialable EVM chain, and its contract is that an
- * unclassified chain is a hard failure — this check moves that failure from
- * the indexer's boot to this build, where the person adding the chain sees it
- * (RHI-6107). Selected by the `eip155:` caip2 namespace, NOT by vmType:
+ * The indexer scans every dialable chain it has a machine for, and its contract
+ * is that an unclassified chain is a hard failure — this check moves that
+ * failure from the indexer's boot to this build, where the person adding the
+ * chain sees it (RHI-6107). Selected by the caip2 NAMESPACE, NOT by vmType:
  * HyperCore is vmType "evm" with a `hypercore:` caip2 and must not require an
  * entry — the same discriminator the publish workflow's contracts guard uses,
  * for the same reason. Runs after `classifyChainCaip2`, which stamps the field.
  *
- * The cross-field rules mirror chain-indexer's `ChainScanSettings::validate`,
- * so a value set this check accepts is one the indexer will accept.
+ * Two families today (`eip155:` → evm, `solana:` → svm), with disjoint knob
+ * sets — an entry is judged against the one its chain implies, and its own `vm`
+ * is cross-checked against that rather than trusted (RHI-7338).
+ *
+ * The EVM cross-field rules mirror chain-indexer's
+ * `ChainScanSettings::validate`, so a value set this check accepts is one the
+ * indexer will accept.
  *
  * A chain deliberately not indexed carries `{ indexed: false }` as its whole
  * entry — a decision the check accepts, unlike a missing entry.

package/dist/scripts/validation.js

@@ -104,6 +104,47 @@ const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
 const isNonEmptyString = (v) => typeof v === 'string' && v.length > 0;
 const isNonNegativeInt = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
 const isAbsentOr = (v, check) => v === undefined || check(v);
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+/**
+ * Decode base58 (Bitcoin/Solana alphabet), or null if the string is not
+ * base58. Each leading `1` stands for one leading zero byte.
+ *
+ * Decoded rather than pattern-matched because the length is what actually
+ * matters and a character-count regex does not imply it: 44 `z`s are all legal
+ * base58 characters and decode to THIRTY-THREE bytes, while 43 `1`s decode to
+ * 43 zero bytes. Both would pass a `{43,44}` regex and neither is an account.
+ * The failure that buys is a marker that validates here and then names a feed
+ * no transaction can ever appear in — silence indistinguishable from a chain
+ * with no traffic.
+ */
+function decodeBase58(value) {
+    if (value.length === 0)
+        return null;
+    const bytes = [];
+    for (const char of value) {
+        let carry = BASE58_ALPHABET.indexOf(char);
+        if (carry < 0)
+            return null;
+        for (let i = 0; i < bytes.length; i++) {
+            carry += bytes[i] * 58;
+            bytes[i] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    let zeros = 0;
+    while (zeros < value.length && value[zeros] === '1')
+        zeros += 1;
+    return Uint8Array.from([
+        ...new Array(zeros).fill(0),
+        ...bytes.reverse(),
+    ]);
+}
+/** A base58 Solana account address: exactly 32 bytes once decoded. */
+const isBase58Account = (v) => typeof v === 'string' && decodeBase58(v)?.length === 32;
 // Every vendor layer's REQUIRED payload, keyed by the SettlementLayer value
 // that switches it on. This is what replaces the chain-id allowlists the
 // jsonnet used to carry with "must match <map> in the orchestrator" comments —
@@ -282,6 +323,30 @@ function structuralProblems(registryChainId, chain) {
     if (!isAbsentOr(chain.publicRpcUrl, isPublicRpcUrl)) {
         problems.push(`publicRpcUrl ${JSON.stringify(chain.publicRpcUrl)} is not an https:// URL`);
     }
+    // `rpcId` is authored, and only where the chain id is not what you dial — so
+    // absence is the normal answer and carries meaning ("the chain id is the
+    // id"). There is deliberately no blanket presence check; what is checked is
+    // the two ways authoring it can go wrong.
+    //
+    // An `rpcId` on an EVM chain that is not its own id routes every call for
+    // that chain to the wrong network. A Solana chain with none leaves a consumer
+    // falling back to `{proxy}/svm/792703810`, which reaches nothing — and the
+    // symptom is an empty feed, indistinguishable from a chain with no traffic,
+    // which is why it has to fail here rather than at runtime.
+    if (!isAbsentOr(chain.rpcId, isNonEmptyString)) {
+        problems.push(`rpcId ${JSON.stringify(chain.rpcId)} is not a non-empty string`);
+    }
+    else if (typeof chain.caip2 === 'string' &&
+        chain.caip2.startsWith('eip155:') &&
+        chain.rpcId !== undefined &&
+        chain.rpcId !== registryChainId) {
+        problems.push(`rpcId ${JSON.stringify(chain.rpcId)} does not match the chain id for an eip155 chain — EVM chains are addressed by their id, so drop the override`);
+    }
+    else if (typeof chain.caip2 === 'string' &&
+        chain.caip2.startsWith('solana:') &&
+        (chain.rpcId === undefined || chain.rpcId === registryChainId)) {
+        problems.push('rpcId is missing or is the chain id, but a Solana chain is addressed by its cluster name (e.g. "devnet") — author it in config/non_evm_chains.jsonnet');
+    }
     if (!isAbsentOr(chain.virtual, (v) => typeof v === 'boolean')) {
         problems.push('virtual is not a boolean');
     }
@@ -1236,12 +1301,15 @@ const CHAIN_INDEXER_FINALITY_SOURCE = new Set([
     'safe',
     'instant',
 ]);
-// Every field of one chain-indexer entry, all required. The wire is exact on
-// purpose: the indexer's own contract is "every field mandatory — a knob nobody
-// set is a decision nobody made", so a missing field here is the same authoring
-// mistake as a missing entry, and an unrecognized field is a typo that would
-// otherwise ship silently.
+// Every field of one EVM chain-indexer entry, all required. The wire is exact
+// on purpose: the indexer's own contract is "every field mandatory — a knob
+// nobody set is a decision nobody made", so a missing field here is the same
+// authoring mistake as a missing entry, and an unrecognized field is a typo
+// that would otherwise ship silently.
+//
+// The SVM set below is disjoint from this one — see CHAIN_INDEXER_FIELDS_BY_VM.
 const CHAIN_INDEXER_FIELDS = {
+    vm: (v) => v === 'evm',
     poll_interval_ms: isNonNegativeInt,
     streaming_poll_interval_ms: isNonNegativeInt,
     reorg_window_k: isNonNegativeInt,
@@ -1254,38 +1322,104 @@ const CHAIN_INDEXER_FIELDS = {
     finality_poll_interval_ms: isNonNegativeInt,
     grace_ms: isNonNegativeInt,
 };
+// `finalized` is the ONLY legal commitment, and that is a coherence rule, not
+// a narrow allowlist waiting to be widened.
+//
+// The SVM entry carries no reorg window, no grace period and no retraction
+// vocabulary — the family has one message kind where EVM has four — and it can
+// omit all of that precisely BECAUSE a finalized signature is settled. Admit
+// `confirmed` here and that stops being true: the indexer would publish
+// reversible signatures as settled with nothing in the schema able to take
+// them back, and the build would pass.
+//
+// So the two travel together. Reading at `confirmed` is a real thing we may
+// want one day; it arrives with the retraction kind, as one change, not as a
+// value someone can set in a facts release. Same shape as the EVM rule that
+// `finality: instant` and `finality_source: instant` imply each other.
+//
+// `processed` is absent for a further reason: eRPC refuses it outright for
+// getSignaturesForAddress and getTransaction.
+const CHAIN_INDEXER_COMMITMENT = new Set(['finalized']);
+// The SVM knob set — a different machine, so none of the EVM fields above
+// apply. There is no block scan, no parent-hash chain and no log filter: the
+// unit is a transaction signature reached through the address → signature
+// index. And no reorg or finality knobs, because ingest is at `finalized`
+// commitment where a signature is settled (RHI-7338).
+//
+// `commitment` is its own field rather than an assumed constant because
+// omitting it on the wire silently yields eRPC's `confirmed` network default —
+// unrooted reads that look exactly like correct operation.
+const CHAIN_INDEXER_SVM_FIELDS = {
+    vm: (v) => v === 'svm',
+    poll_interval_ms: isNonNegativeInt,
+    commitment: (v) => typeof v === 'string' && CHAIN_INDEXER_COMMITMENT.has(v),
+    // A list, not a scalar: rotating the marker or adding our own no-op program
+    // id as a second topic must be a facts release, not an indexer deploy. Each
+    // entry is a base58 account address.
+    topics: (v) => Array.isArray(v) && v.length > 0 && v.every((t) => isBase58Account(t)),
+    page_limit: (v) => isNonNegativeInt(v) && v > 0 && v <= 1000,
+    overlap_slots: isNonNegativeInt,
+    max_catchup_signatures: isNonNegativeInt,
+};
+// Which machine an entry's knobs belong to. Mirrors the `vm` tag chain-indexer
+// reads before anything else in the entry: an unrecognised value there is
+// skipped rather than indexed, so a typo here would silently stop a chain
+// being scanned, which is why it fails the build instead.
+const CHAIN_INDEXER_FIELDS_BY_VM = {
+    evm: CHAIN_INDEXER_FIELDS,
+    svm: CHAIN_INDEXER_SVM_FIELDS,
+};
+// Which caip2 namespace implies which machine, for the cross-check that an
+// entry's `vm` matches the chain it addresses. Namespace rather than vmType,
+// for the same reason coverage is selected that way: HyperCore is vmType "evm"
+// under a `hypercore:` caip2 and is not a chain the indexer dials.
+const CHAIN_INDEXER_VM_BY_NAMESPACE = {
+    eip155: 'evm',
+    solana: 'svm',
+};
 /**
- * Insists that every real EVM chain carries a complete, coherent chain-indexer
- * entry, and that no entry addresses a chain that does not exist.
+ * Insists that every chain the indexer dials carries a complete, coherent
+ * chain-indexer entry, and that no entry addresses a chain that does not exist.
  *
- * The indexer scans every dialable EVM chain, and its contract is that an
- * unclassified chain is a hard failure — this check moves that failure from
- * the indexer's boot to this build, where the person adding the chain sees it
- * (RHI-6107). Selected by the `eip155:` caip2 namespace, NOT by vmType:
+ * The indexer scans every dialable chain it has a machine for, and its contract
+ * is that an unclassified chain is a hard failure — this check moves that
+ * failure from the indexer's boot to this build, where the person adding the
+ * chain sees it (RHI-6107). Selected by the caip2 NAMESPACE, NOT by vmType:
  * HyperCore is vmType "evm" with a `hypercore:` caip2 and must not require an
  * entry — the same discriminator the publish workflow's contracts guard uses,
  * for the same reason. Runs after `classifyChainCaip2`, which stamps the field.
  *
- * The cross-field rules mirror chain-indexer's `ChainScanSettings::validate`,
- * so a value set this check accepts is one the indexer will accept.
+ * Two families today (`eip155:` → evm, `solana:` → svm), with disjoint knob
+ * sets — an entry is judged against the one its chain implies, and its own `vm`
+ * is cross-checked against that rather than trusted (RHI-7338).
+ *
+ * The EVM cross-field rules mirror chain-indexer's
+ * `ChainScanSettings::validate`, so a value set this check accepts is one the
+ * indexer will accept.
  *
  * A chain deliberately not indexed carries `{ indexed: false }` as its whole
  * entry — a decision the check accepts, unlike a missing entry.
  */
 function validateChainIndexerCoverage(chains, chainIndexer) {
     const issues = [];
-    const requiresEntry = (chain) => typeof chain.caip2 === 'string' &&
-        chain.caip2.startsWith('eip155:') &&
-        chain.virtual !== true;
+    // Which machine's knobs a chain takes, or undefined for one the indexer does
+    // not dial at all. Keyed on the caip2 NAMESPACE for the reason in the doc
+    // comment: HyperCore is vmType "evm" under `hypercore:` and must stay
+    // exempt.
+    const machineOf = (chain) => typeof chain.caip2 === 'string'
+        ? CHAIN_INDEXER_VM_BY_NAMESPACE[chain.caip2.split(':')[0]]
+        : undefined;
+    const requiresEntry = (chain) => machineOf(chain) !== undefined && chain.virtual !== true;
     for (const [chainId, chain] of Object.entries(chains)) {
-        if (!requiresEntry(chain))
+        const machine = machineOf(chain);
+        if (machine === undefined || chain.virtual === true)
             continue;
         if (chainIndexer[chainId] === undefined) {
             issues.push({
                 severity: 'error',
                 chainId,
                 chainName: isNonEmptyString(chain.name) ? chain.name : '<unnamed>',
-                message: 'EVM chain has no chain-indexer entry — classify it in config/chain-indexer.jsonnet (see docs/add-chain.md, "Classify the chain for the indexer")',
+                message: `${machine.toUpperCase()} chain has no chain-indexer entry — classify it in config/chain-indexer.jsonnet (see docs/add-chain.md, "Classify the chain for the indexer")`,
             });
         }
     }
@@ -1294,7 +1428,7 @@ function validateChainIndexerCoverage(chains, chainIndexer) {
         const chainName = chain && isNonEmptyString(chain.name) ? chain.name : '<not in registry>';
         const issue = (message) => issues.push({ severity: 'error', chainId, chainName, message });
         if (!chain || !requiresEntry(chain)) {
-            issue('chain-indexer entry addresses no real EVM chain — remove it from config/chain-indexer.jsonnet, or add the chain first');
+            issue('chain-indexer entry addresses no chain the indexer dials — remove it from config/chain-indexer.jsonnet, or add the chain first');
             continue;
         }
         if (!isObject(entry)) {
@@ -1316,7 +1450,19 @@ function validateChainIndexerCoverage(chains, chainIndexer) {
             }
             continue;
         }
-        for (const [field, check] of Object.entries(CHAIN_INDEXER_FIELDS)) {
+        // Which machine's knobs this entry is judged against. Cross-checked
+        // against the chain rather than taken from the entry: an `svm` tag on an
+        // eip155 chain would otherwise be validated as a coherent SVM entry and
+        // then silently skipped by the indexer, which reads `vm` first and passes
+        // over families it does not index — a chain that stops being scanned with
+        // nothing failing anywhere (RHI-7338).
+        const machine = machineOf(chain);
+        if (entry.vm !== undefined && entry.vm !== machine) {
+            issue(`chain-indexer \`vm\` = ${JSON.stringify(entry.vm)} but ${chain.caip2} is a ${machine} chain — the indexer skips entries for machines it does not index, so this one would never be scanned`);
+            continue;
+        }
+        const fields = CHAIN_INDEXER_FIELDS_BY_VM[machine];
+        for (const [field, check] of Object.entries(fields)) {
             if (entry[field] === undefined) {
                 issue(`chain-indexer entry is missing \`${field}\` — every field is mandatory, a knob nobody set is a decision nobody made`);
             }
@@ -1325,10 +1471,17 @@ function validateChainIndexerCoverage(chains, chainIndexer) {
             }
         }
         for (const field of Object.keys(entry)) {
-            if (!(field in CHAIN_INDEXER_FIELDS)) {
+            if (!(field in fields)) {
                 issue(`chain-indexer entry carries unrecognized field \`${field}\` — the artifact's shape is exact, fix the name or drop it`);
             }
         }
+        // The cross-field rules below are EVM classification coherence — reorg
+        // window against finality source against watermark cadence. The SVM entry
+        // has no reorg or finality knobs to be incoherent about: at `finalized`
+        // commitment a signature is settled, so there is no second classification
+        // to agree with.
+        if (machine !== 'evm')
+            continue;
         const instantClass = entry.finality === 'instant';
         const instantSource = entry.finality_source === 'instant';
         if (instantClass !== instantSource) {

package/dist/src/chains.d.ts

@@ -66,6 +66,12 @@ interface Chain {
     /** Public, unauthenticated https JSON-RPC endpoint — what a browser needs to
      *  build this chain with `defineChain`. Absent means display-only. */
     publicRpcUrl?: string;
+    /** How this chain is addressed when dialling it, within its architecture:
+     *  the last segment of `{proxy}/{architecture}/{rpcId}`. Present only where
+     *  the chain id is NOT what you dial — the cluster name (`mainnet-beta`,
+     *  `devnet`) on Solana. Absent means the chain id is the id, so read it as
+     *  `chain.rpcId ?? String(chainId)` rather than branching on vmType. */
+    rpcId?: 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.

package/dist/src/chains.js

@@ -1572,6 +1572,71 @@ const chains = {
             "Alchemy"
         ]
     },
+    "5042": {
+        "caip2": "eip155:5042",
+        "explorer": {
+            "addressPath": "/address/",
+            "txPath": "/tx/",
+            "url": "https://explorer.arc.io"
+        },
+        "iconSlug": "arc",
+        "name": "Arc",
+        "nativeToken": {
+            "address": "0x0000000000000000000000000000000000000000",
+            "decimals": 18,
+            "symbol": "USDC"
+        },
+        "network": "mainnet",
+        "providerIds": {
+            "alchemy": null,
+            "zerion": null
+        },
+        "publicRpcUrl": "https://rpc.mainnet.arc.io",
+        "sessionCapable": false,
+        "settlementConfig": {
+            "cctp": {
+                "domain": 26
+            },
+            "rhino": {
+                "bridgeContract": "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+                "chainName": "ARC"
+            }
+        },
+        "settlementLayers": [
+            "ACROSS",
+            "RELAY",
+            "RHINO",
+            "CCTP"
+        ],
+        "stack": "vanilla",
+        "swapQuoters": [],
+        "tokens": [
+            {
+                "address": "0x3600000000000000000000000000000000000000",
+                "appFee": true,
+                "approvalSlot": null,
+                "balanceSlot": null,
+                "decimals": 6,
+                "gasRefund": true,
+                "pegGroup": "USD",
+                "settlementLayers": [
+                    "ACROSS"
+                ],
+                "symbol": "USDC"
+            }
+        ],
+        "vmType": "evm",
+        "wrappedNativeToken": {
+            "address": "0x3600000000000000000000000000000000000000",
+            "decimals": 6,
+            "symbol": "USDC"
+        },
+        "providers": [
+            "Alchemy",
+            "arc-public-rpc",
+            "DRPC"
+        ]
+    },
     "8453": {
         "caip2": "eip155:8453",
         "explorer": {
@@ -3245,6 +3310,7 @@ const chains = {
             "alchemy": null,
             "zerion": null
         },
+        "rpcId": "mainnet-beta",
         "sessionCapable": false,
         "settlementConfig": {
             "cctp": {
@@ -3350,6 +3416,7 @@ const chains = {
             "alchemy": null,
             "zerion": null
         },
+        "rpcId": "devnet",
         "sessionCapable": false,
         "settlementConfig": {
             "cctp": {

package/dist/src/generated/contracts.dev.js

@@ -99,6 +99,10 @@ const contractAddresses = {
         "swapAdapter": "0x58BC7d9279A38a1537c2f74426dBDbD804AD3A18",
         "swapAdapterTokenSpender": "0xc5f6641b3ade357c5df77a1859d16528fe8b3e93"
     },
+    "5042": {
+        "acrossBridge": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84",
+        "spokepool": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84"
+    },
     "8453": {
         "ecoArbiter": "0x1BeBAfb3D05d84A5Bfd94800c88d1342f755d8AB",
         "acrossBridge": "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",

package/dist/src/generated/contracts.js

@@ -99,6 +99,10 @@ const contractAddresses = {
         "swapAdapter": "0xaE448E141F230AC3c6F6dA981C0882356c9B91a6",
         "swapAdapterTokenSpender": "0x3115c923734471b9da1d5bfef161d9c9e9963859"
     },
+    "5042": {
+        "acrossBridge": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84",
+        "spokepool": "0x9b4A302A548c7e313c2b74C461db7b84d3074A84"
+    },
     "8453": {
         "ecoArbiter": "0x2e7627CCfAe4eDb336eEb5a70f08415B0F1a2b8C",
         "acrossBridge": "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",

package/dist/src/generated/networks.d.ts

@@ -2222,6 +2222,60 @@ declare const mainnetChains: ({
     }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042;
+    name: "Arc";
+    nativeCurrency: {
+        readonly name: "USDC";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly [];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
 })[];
 declare const testnetChains: ({
     blockExplorers: {
@@ -5242,6 +5296,60 @@ declare const chains: ({
     }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 5042;
+    name: "Arc";
+    nativeCurrency: {
+        readonly name: "USDC";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly [];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
 } | {
     blockExplorers: {
         readonly default: {
@@ -6060,7 +6168,8 @@ declare enum MainnetNetwork {
     ROBINHOOD,
     AVALANCHE,
     INK,
-    XLAYER
+    XLAYER,
+    ARC
 }
 declare enum TestnetNetwork {
     ETHEREUM_SEPOLIA,

package/dist/src/generated/networks.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPStackChains = exports.TestnetNetwork = exports.MainnetNetwork = exports.chains = exports.testnetChains = exports.mainnetChains = void 0;
 // Auto-generated by scripts/generate.ts. Do not edit manually.
 const chains_1 = require("viem/chains");
-const mainnetChains = [chains_1.mainnet, chains_1.optimism, chains_1.base, chains_1.arbitrum, chains_1.polygon, chains_1.soneium, chains_1.sonic, chains_1.plasma, chains_1.gnosis, chains_1.bsc, chains_1.hyperEvm, chains_1.monad, chains_1.unichain, chains_1.katana, chains_1.robinhood, chains_1.avalanche, chains_1.ink, chains_1.xLayer];
+const mainnetChains = [chains_1.mainnet, chains_1.optimism, chains_1.base, chains_1.arbitrum, chains_1.polygon, chains_1.soneium, chains_1.sonic, chains_1.plasma, chains_1.gnosis, chains_1.bsc, chains_1.hyperEvm, chains_1.monad, chains_1.unichain, chains_1.katana, chains_1.robinhood, chains_1.avalanche, chains_1.ink, chains_1.xLayer, chains_1.arc];
 exports.mainnetChains = mainnetChains;
 const testnetChains = [chains_1.sepolia, chains_1.optimismSepolia, chains_1.baseSepolia, chains_1.arbitrumSepolia, chains_1.plasmaTestnet];
 exports.testnetChains = testnetChains;
@@ -34,6 +34,7 @@ var MainnetNetwork;
     MainnetNetwork[MainnetNetwork["AVALANCHE"] = chains_1.avalanche.id] = "AVALANCHE";
     MainnetNetwork[MainnetNetwork["INK"] = chains_1.ink.id] = "INK";
     MainnetNetwork[MainnetNetwork["XLAYER"] = chains_1.xLayer.id] = "XLAYER";
+    MainnetNetwork[MainnetNetwork["ARC"] = chains_1.arc.id] = "ARC";
 })(MainnetNetwork || (exports.MainnetNetwork = MainnetNetwork = {}));
 var TestnetNetwork;
 (function (TestnetNetwork) {

package/dist/src/generated/packageVersion.d.ts

@@ -1,2 +1,2 @@
-declare const PACKAGE_VERSION = "2.20.1";
+declare const PACKAGE_VERSION = "2.21.1";
 export { PACKAGE_VERSION };

package/dist/src/generated/packageVersion.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_VERSION = void 0;
 // Auto-generated by scripts/generate.ts. Do not edit manually.
-const PACKAGE_VERSION = "2.20.1";
+const PACKAGE_VERSION = "2.21.1";
 exports.PACKAGE_VERSION = PACKAGE_VERSION;

package/dist/src/types.d.ts

@@ -349,6 +349,26 @@ interface ChainEntry {
      * `validateChainIconSlugs`.
      */
     iconSlug?: string;
+    /**
+     * The identifier this chain is addressed by when you dial it, within its
+     * architecture — the last path segment of `{proxy}/{architecture}/{rpcId}`.
+     *
+     * For an EVM chain it is the chain id as a string. For Solana it is the
+     * cluster name (`mainnet-beta`, `devnet`), which is what every Solana RPC
+     * endpoint and the CLI call it, and what eRPC keys its network by. Not a
+     * proxy-specific spelling: a vendor endpoint uses the same word.
+     *
+     * Read this instead of branching on `vmType` and rebuilding the segment per
+     * family: every consumer that reached Solana previously kept its own caip2 →
+     * cluster table, and those tables drifted from each other.
+     *
+     * Present only where the chain id is NOT what you dial — the two Solana
+     * entries today, and nowhere else. **Absent means the chain id is the id**,
+     * so a consumer reads `chain.rpcId ?? String(chainId)`. Storing the id again
+     * on every EVM entry would be a second copy of the key it sits under, which
+     * is the kind of copy that drifts.
+     */
+    rpcId?: string;
     /**
      * A public, unauthenticated JSON-RPC endpoint over HTTPS, when one is known.
      *
@@ -463,7 +483,7 @@ type ContractAddresses = Record<string, Record<string, Address>>;
 interface ChainRegistry {
     [chainId: string]: ChainEntry;
 }
-type ProviderName = 'DRPC' | 'Alchemy' | 'gnosis-tenderly' | 'plasma-tenderly' | 'local-rpc' | 'quicknode-hypervm' | 'soneium-public-rpc';
+type ProviderName = 'DRPC' | 'Alchemy' | 'gnosis-tenderly' | 'plasma-tenderly' | 'local-rpc' | 'quicknode-hypervm' | 'soneium-public-rpc' | 'arc-public-rpc';
 interface ChainItem {
     providers: ProviderName[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/shared-configs",
-  "version": "2.20.1",
+  "version": "2.21.1",
   "description": "Reusable configuration files for Rhinestone services",
   "author": {
     "name": "Rhinestone",