@rhinestone/shared-configs 1.14.0 → 1.16.0

package/dist/scripts/hoistUniform.d.ts

@@ -0,0 +1,30 @@
+export type RawContracts = Record<string, Record<string, string>>;
+/**
+ * Hoist every address that is identical on all chains carrying it into the `*`
+ * wildcard, leaving each chain with only what genuinely differs there.
+ *
+ * Consumers resolve a chain as `{ ...wildcard, ...chainSpecific }`, so this
+ * changes nothing for a chain that already had the key. What it changes is the
+ * chain the map has never heard of: chains now arrive at runtime in the facts
+ * artifact while this map is baked into the consumer's image, so a new chain
+ * falls back to the bare wildcard and every address missing from it resolves to
+ * `undefined`. That is not theoretical — it is why the first quote to Ink 500'd
+ * (RHI-5703): `permit2` was absent from the wildcard, so a `spender: undefined`
+ * reached viem, which threw inside a `catch` that then discarded the chain.
+ *
+ * Hoisted only with evidence: at least two chains carrying the key, and exactly
+ * one distinct address between them. One chain proves nothing about uniformity,
+ * and a key whose value varies is genuinely per-chain (`spokepool` has 16
+ * distinct addresses across 18 chains, `oftProxy` 7 across 7).
+ *
+ * Keys that split by *network* rather than by chain are deliberately left
+ * per-chain — the eco family is one mainnet address and one testnet address.
+ * A single wildcard value would hand a new testnet the mainnet portal, and a
+ * confidently wrong address is worse than a missing one.
+ *
+ * Note this widens resolution: a chain that never had `acrossHandler` now
+ * resolves one. Capability is gated by `settlementLayers` in the registry, not
+ * by the presence of a key here, so that is safe — but it does mean this file
+ * stops being a record of what is deployed where.
+ */
+export declare const hoistUniformAddresses: (contracts: RawContracts) => RawContracts;

package/dist/scripts/hoistUniform.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hoistUniformAddresses = void 0;
+/**
+ * Hoist every address that is identical on all chains carrying it into the `*`
+ * wildcard, leaving each chain with only what genuinely differs there.
+ *
+ * Consumers resolve a chain as `{ ...wildcard, ...chainSpecific }`, so this
+ * changes nothing for a chain that already had the key. What it changes is the
+ * chain the map has never heard of: chains now arrive at runtime in the facts
+ * artifact while this map is baked into the consumer's image, so a new chain
+ * falls back to the bare wildcard and every address missing from it resolves to
+ * `undefined`. That is not theoretical — it is why the first quote to Ink 500'd
+ * (RHI-5703): `permit2` was absent from the wildcard, so a `spender: undefined`
+ * reached viem, which threw inside a `catch` that then discarded the chain.
+ *
+ * Hoisted only with evidence: at least two chains carrying the key, and exactly
+ * one distinct address between them. One chain proves nothing about uniformity,
+ * and a key whose value varies is genuinely per-chain (`spokepool` has 16
+ * distinct addresses across 18 chains, `oftProxy` 7 across 7).
+ *
+ * Keys that split by *network* rather than by chain are deliberately left
+ * per-chain — the eco family is one mainnet address and one testnet address.
+ * A single wildcard value would hand a new testnet the mainnet portal, and a
+ * confidently wrong address is worse than a missing one.
+ *
+ * Note this widens resolution: a chain that never had `acrossHandler` now
+ * resolves one. Capability is gated by `settlementLayers` in the registry, not
+ * by the presence of a key here, so that is safe — but it does mean this file
+ * stops being a record of what is deployed where.
+ */
+const hoistUniformAddresses = (contracts) => {
+    const perChain = Object.entries(contracts).filter(([id]) => id !== "*");
+    const addressesByKey = new Map();
+    for (const [, entries] of perChain) {
+        for (const [key, address] of Object.entries(entries)) {
+            const seen = addressesByKey.get(key) ?? new Set();
+            seen.add(address.toLowerCase());
+            addressesByKey.set(key, seen);
+        }
+    }
+    const chainsCarrying = (key) => perChain.filter(([, entries]) => key in entries).length;
+    const uniform = [...addressesByKey.entries()]
+        .filter(([key, addresses]) => addresses.size === 1 && chainsCarrying(key) > 1)
+        .map(([key]) => key);
+    if (uniform.length === 0) {
+        return contracts;
+    }
+    const wildcard = { ...(contracts["*"] ?? {}) };
+    for (const key of uniform) {
+        const source = perChain.find(([, entries]) => key in entries);
+        if (source) {
+            wildcard[key] = source[1][key];
+        }
+    }
+    const hoisted = { "*": wildcard };
+    for (const [chainId, entries] of perChain) {
+        hoisted[chainId] = Object.fromEntries(Object.entries(entries).filter(([key, address]) => !(key in wildcard) || wildcard[key] !== address));
+    }
+    return hoisted;
+};
+exports.hoistUniformAddresses = hoistUniformAddresses;

package/dist/src/__tests__/chainFactsClient.test.js

@@ -467,4 +467,50 @@ function clientWith(extra = {}) {
             (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
         });
     });
+    (0, bun_test_1.describe)("contracts", () => {
+        const CONTRACTS = {
+            prod: { "*": { permit2: "0xPP" }, "1": { spokepool: "0x11" } },
+            dev: { "*": { permit2: "0xPP" }, "1": { spokepool: "0xDD" } },
+        };
+        (0, bun_test_1.it)("installs contracts carried by the artifact", async () => {
+            serveSigned({ ...payload(), contracts: CONTRACTS });
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getContracts("prod")["1"].spokepool).toBe("0x11");
+            (0, bun_test_1.expect)(client.getContracts("dev")["1"].spokepool).toBe("0xDD");
+        });
+        // Every artifact published before contracts existed is this shape, and the
+        // consumer has to stay exactly where it was rather than lose its addresses.
+        (0, bun_test_1.it)("keeps the bundled contracts when the artifact omits them", async () => {
+            serveSigned(payload());
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("remote");
+            (0, bun_test_1.expect)(client.getContracts("prod")).toEqual(clientWith().getSnapshot().contracts.prod);
+        });
+        // A bad contracts block must not cost the consumer a chain update it would
+        // otherwise have taken — chains install, contracts fall back, error reported.
+        bun_test_1.it.each([
+            ["a missing half", { prod: CONTRACTS.prod }],
+            ["a non-object entry", { prod: { "1": "nope" }, dev: CONTRACTS.dev }],
+            ["a non-string address", { prod: { "1": { permit2: 5 } }, dev: CONTRACTS.dev }],
+            ["an unusable chain key", { prod: { "01": { permit2: "0xPP" } }, dev: CONTRACTS.dev }],
+        ])("rejects %s without failing the read", async (_label, contracts) => {
+            const phases = [];
+            serveSigned({ ...payload(), contracts });
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("remote");
+            (0, bun_test_1.expect)(phases).toContain("parse");
+            (0, bun_test_1.expect)(client.getContracts("prod")).toEqual(clientWith().getSnapshot().contracts.prod);
+        });
+        (0, bun_test_1.it)("accepts the wildcard key alongside chain ids", async () => {
+            serveSigned({ ...payload(), contracts: CONTRACTS });
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getContracts("prod")["*"].permit2).toBe("0xPP");
+        });
+    });
 });

package/dist/src/chainFactsClient.d.ts

@@ -1,13 +1,35 @@
-import type { ChainRegistry } from "./types";
+import type { ChainRegistry, ContractAddresses } from "./types";
+/**
+ * Both contract maps, because the artifact is one global object while consumers
+ * pick by their own environment — the orchestrator reads the dev map on dev and
+ * the prod map everywhere else. Publishing only one would make the artifact
+ * environment-specific, which the single-URL design rules out.
+ */
+interface ContractsByEnv {
+    prod: ContractAddresses;
+    dev: ContractAddresses;
+}
 /** Wire format of the published facts artifact. */
 interface ChainFactsPayload {
     version: string;
     chains: ChainRegistry;
+    /**
+     * Optional: artifacts published before contracts were carried do not have it,
+     * and those stay valid. A payload without contracts keeps the bundled maps,
+     * which is the same position a consumer was in before this field existed.
+     */
+    contracts?: ContractsByEnv;
 }
 type ChainFactsSource = "remote" | "bundled";
 type ChainFactsErrorPhase = "config" | "fetch" | "verify" | "parse" | "stale";
 interface ChainFactsSnapshot {
     chains: ChainRegistry;
+    /**
+     * Per-chain contract addresses, keyed by environment. Falls back to the
+     * bundled maps when a remote artifact omits them, so this is always populated
+     * and a consumer never has to decide what to do about a missing half.
+     */
+    contracts: ContractsByEnv;
     source: ChainFactsSource;
     /** null for "bundled", which ships with the package and has no version stamp of its own. */
     version: string | null;
@@ -43,6 +65,8 @@ interface ChainFactsClient {
     /** The active facts: remote once a refresh has succeeded, otherwise bundled. */
     getSnapshot(): ChainFactsSnapshot;
     getChainRegistry(): ChainRegistry;
+    /** Contract addresses for one environment, from the active snapshot. */
+    getContracts(env: keyof ContractsByEnv): ContractAddresses;
 }
 /**
  * Reads chain facts remote-first, falling back to the registry bundled with
@@ -53,4 +77,4 @@ interface ChainFactsClient {
  */
 declare function createChainFactsClient(options?: ChainFactsClientOptions): ChainFactsClient;
 export { createChainFactsClient };
-export type { ChainFactsClient, ChainFactsClientOptions, ChainFactsErrorPhase, ChainFactsPayload, ChainFactsSnapshot, ChainFactsSource, };
+export type { ChainFactsClient, ChainFactsClientOptions, ChainFactsErrorPhase, ChainFactsPayload, ChainFactsSnapshot, ChainFactsSource, ContractsByEnv, };

package/dist/src/chainFactsClient.js

@@ -5,12 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createChainFactsClient = createChainFactsClient;
 const chains_json_1 = __importDefault(require("../configs/chains.json"));
+const contracts_json_1 = __importDefault(require("../configs/contracts.json"));
+const contracts_dev_json_1 = __importDefault(require("../configs/contracts.dev.json"));
 const chainFactsKey_1 = require("./generated/chainFactsKey");
 const packageVersion_1 = require("./generated/packageVersion");
 const bundledChainRegistry = chains_json_1.default;
+const bundledContracts = {
+    prod: contracts_json_1.default,
+    dev: contracts_dev_json_1.default,
+};
 const DEFAULT_FETCH_TIMEOUT_MS = 5_000;
 const BUNDLED_SNAPSHOT = {
     chains: bundledChainRegistry,
+    contracts: bundledContracts,
     source: "bundled",
     version: null,
 };
@@ -44,6 +51,25 @@ function isChainRegistry(value) {
     return (entries.length > 0 &&
         entries.every(([id, entry]) => CHAIN_ID_KEY.test(id) && looksLikeChainEntry(entry)));
 }
+// Structural only, matching isChainRegistry's reasoning: an unknown contract
+// key at read time just means an older consumer is reading a newer artifact.
+// Keys are chain ids or the "*" wildcard consumers merge underneath a chain.
+function isContractAddresses(value) {
+    if (!isObject(value))
+        return false;
+    return Object.entries(value).every(([id, entry]) => (id === "*" || CHAIN_ID_KEY.test(id)) &&
+        isObject(entry) &&
+        Object.values(entry).every((address) => typeof address === "string"));
+}
+// Both halves must be present and usable, or the field is rejected whole. A
+// half-valid contracts block would silently leave one environment on bundled
+// data while the other moved forward, which is the kind of split nobody would
+// think to look for.
+function isContractsByEnv(value) {
+    return (isObject(value) &&
+        isContractAddresses(value.prod) &&
+        isContractAddresses(value.dev));
+}
 // Both sides are release versions produced by the same pipeline, so a numeric
 // x.y.z comparison is enough; a pre-release suffix (-alpha.N) is ignored, since
 // pre-release tags never publish to the facts CDN.
@@ -254,7 +280,19 @@ function createChainFactsClient(options = {}) {
             report(new Error(`chain facts ${body.version} is older than this package's bundled registry (${packageVersion_1.PACKAGE_VERSION}) — treating as stale and keeping bundled data`), "stale");
             return null;
         }
-        return { version: body.version, chains };
+        // Contracts are rejected on their own rather than failing the whole read:
+        // a malformed contracts block should not cost the consumer a chain update
+        // it would otherwise have taken. The absence is reported so it is visible.
+        let contracts;
+        if (body.contracts !== undefined) {
+            if (isContractsByEnv(body.contracts)) {
+                contracts = body.contracts;
+            }
+            else {
+                report(new Error("chain facts payload has an unusable contracts block — keeping bundled contracts"), "parse");
+            }
+        }
+        return { version: body.version, chains, contracts };
     }
     async function fetchAndInstall() {
         const payload = await fetchRemote();
@@ -262,6 +300,9 @@ function createChainFactsClient(options = {}) {
             return false;
         snapshot = {
             chains: payload.chains,
+            // An artifact that carries no contracts leaves the bundled maps in place,
+            // which is where every consumer was before the field existed.
+            contracts: payload.contracts ?? bundledContracts,
             source: "remote",
             version: payload.version,
         };
@@ -291,5 +332,6 @@ function createChainFactsClient(options = {}) {
         },
         getSnapshot: () => snapshot,
         getChainRegistry: () => snapshot.chains,
+        getContracts: (env) => snapshot.contracts[env],
     };
 }

package/dist/src/chains.js

@@ -1281,91 +1281,6 @@ const chains = {
             "Alchemy"
         ]
     },
-    "57073": {
-        "caip2": "eip155:57073",
-        "explorer": {
-            "url": "https://explorer.inkonchain.com",
-            "addressPath": "/address/",
-            "txPath": "/tx/"
-        },
-        "iconSlug": "ink",
-        "name": "Ink",
-        "nativeToken": {
-            "address": "0x0000000000000000000000000000000000000000",
-            "decimals": 18,
-            "symbol": "ETH"
-        },
-        "network": "mainnet",
-        "publicRpcUrl": "https://rpc-gel.inkonchain.com",
-        "settlementLayers": [
-            "ACROSS",
-            "ECO",
-            "RELAY",
-            "OFT"
-        ],
-        "stack": "op-stack",
-        "swapQuoters": [
-            "0x"
-        ],
-        "tokens": [
-            {
-                "address": "0x0000000000000000000000000000000000000000",
-                "approvalSlot": null,
-                "balanceSlot": null,
-                "decimals": 18,
-                "pegGroup": "ETH",
-                "settlementLayers": [
-                    "ACROSS"
-                ],
-                "symbol": "ETH"
-            },
-            {
-                "address": "0x4200000000000000000000000000000000000006",
-                "approvalSlot": 1,
-                "balanceSlot": 0,
-                "decimals": 18,
-                "pegGroup": "ETH",
-                "priceSymbol": "ETH",
-                "settlementLayers": [
-                    "ACROSS"
-                ],
-                "symbol": "WETH"
-            },
-            {
-                "address": "0x2d270e6886d130d724215a266106e6832161eaed",
-                "approvalSlot": 10,
-                "balanceSlot": 9,
-                "decimals": 6,
-                "pegGroup": "USD",
-                "settlementLayers": [
-                    "ACROSS"
-                ],
-                "symbol": "USDC"
-            },
-            {
-                "address": "0x0200c29006150606b650577bbe7b6248f58470c1",
-                "approvalSlot": 52,
-                "balanceSlot": 51,
-                "decimals": 6,
-                "pegGroup": "USD",
-                "priceSymbol": "USDT",
-                "settlementLayers": [
-                    "ACROSS"
-                ],
-                "symbol": "USDT0"
-            }
-        ],
-        "vmType": "evm",
-        "wrappedNativeToken": {
-            "address": "0x4200000000000000000000000000000000000006",
-            "decimals": 18,
-            "symbol": "WETH"
-        },
-        "providers": [
-            "DRPC",
-            "Alchemy"
-        ]
-    },
     "84532": {
         "caip2": "eip155:84532",
         "explorer": {