@rhinestone/shared-configs 1.17.0 → 1.19.0

package/dist/scripts/__tests__/vendor-drift.test.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const diff_1 = require("../vendor-drift/diff");
+const identity_1 = require("../vendor-drift/identity");
+const vendors_1 = require("../vendor-drift/vendors");
+const report_1 = require("../vendor-drift/report");
+const codes = (findings) => findings.map((f) => f.code);
+const chain = (over = {}) => ({
+    name: "Test",
+    vmType: "evm",
+    settlementLayers: [],
+    tokens: [],
+    ...over,
+});
+(0, bun_test_1.describe)("diffRhino", () => {
+    const vendor = (over = {}) => ({
+        name: "BASE",
+        networkId: 8453,
+        status: "enabled",
+        contractAddress: "0x2f59e9086ec8130e21bd052065a9e6b2497bb102",
+        ...over,
+    });
+    (0, bun_test_1.test)("flags a chain we claim that the vendor no longer lists", () => {
+        const registry = {
+            "130": chain({ name: "Unichain", settlementLayers: ["RHINO"] }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffRhino)(registry, [vendor()]))).toContain("rhino_chain_dropped");
+    });
+    (0, bun_test_1.test)("a disabled vendor chain does not count as supported", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffRhino)(registry, [vendor({ status: "disabled" })]))).toContain("rhino_chain_disabled");
+    });
+    (0, bun_test_1.test)("a vendor entry with no contract address leaves ours unverified", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ contractAddress: undefined }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("rhino_bridge_contract_unserved");
+    });
+    (0, bun_test_1.test)("flags a silently changed bridge contract", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ contractAddress: "0xdeadbeef00000000000000000000000000000000" }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("rhino_bridge_contract_changed");
+    });
+    (0, bun_test_1.test)("case alone is not a bridge contract change", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ contractAddress: "0x2F59E9086EC8130E21BD052065A9E6B2497BB102" }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("rhino_bridge_contract_changed");
+    });
+    (0, bun_test_1.test)("flags a chain the vendor serves that we do not claim", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: [] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [vendor()]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("rhino_chain_available");
+        (0, bun_test_1.expect)(findings.find((f) => f.code === "rhino_chain_available")?.kind).toBe("underclaim");
+    });
+    // Rhino serves every networkId as a string, EVM included, so this is the
+    // shape the scheduled run actually sees.
+    (0, bun_test_1.test)("a string networkId is still compared against the chain id", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ networkId: "999" }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("rhino_network_id_mismatch");
+    });
+    (0, bun_test_1.test)("a matching string networkId is not a mismatch", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["RHINO"] }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ networkId: "8453" }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("rhino_network_id_mismatch");
+    });
+    (0, bun_test_1.test)("a non-numeric networkId is never compared against a chain id", () => {
+        const registry = {
+            "792703809": chain({
+                name: "Solana",
+                vmType: "svm",
+                settlementLayers: ["RHINO"],
+            }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [
+            vendor({ name: "SOLANA", networkId: 900, contractAddress: undefined }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("rhino_network_id_mismatch");
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("rhino_bridge_contract_unknown");
+    });
+    (0, bun_test_1.test)("registry config overrides the baseline bridge contract", () => {
+        const registry = {
+            "8453": chain({
+                name: "Base",
+                settlementLayers: ["RHINO"],
+                settlementLayerConfig: {
+                    RHINO: { chainName: "BASE", bridgeContract: "0xabc" },
+                },
+            }),
+        };
+        const findings = (0, diff_1.diffRhino)(registry, [vendor()]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("rhino_bridge_contract_changed");
+    });
+});
+(0, bun_test_1.describe)("nearAssetId", () => {
+    (0, bun_test_1.test)("derives the omft id from a lowercased EVM address", () => {
+        (0, bun_test_1.expect)((0, diff_1.nearAssetId)("base", 8453, "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")).toBe("nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near");
+    });
+    (0, bun_test_1.test)("native sentinels resolve to the bare chain asset", () => {
+        (0, bun_test_1.expect)((0, diff_1.nearAssetId)("base", 8453, "0x0000000000000000000000000000000000000000")).toBe("nep141:base.omft.near");
+    });
+    (0, bun_test_1.test)("non-EVM tokens never fall through to the EVM derivation", () => {
+        (0, bun_test_1.expect)((0, diff_1.nearAssetId)("sol", 792703809, "SomeUnknownMint")).toBeUndefined();
+    });
+});
+(0, bun_test_1.describe)("diffNear", () => {
+    const token = (over = {}) => ({
+        assetId: "nep141:base-0xaaa.omft.near",
+        blockchain: "base",
+        contractAddress: "0xaaa",
+        ...over,
+    });
+    (0, bun_test_1.test)("flags a blockchain slug the vendor dropped", () => {
+        const registry = {
+            "8453": chain({ name: "Base", settlementLayers: ["NEAR"] }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffNear)(registry, [token({ blockchain: "eth" })]))).toContain("near_blockchain_dropped");
+    });
+    (0, bun_test_1.test)("flags a token whose asset id the vendor re-issued", () => {
+        const registry = {
+            "8453": chain({
+                name: "Base",
+                settlementLayers: ["NEAR"],
+                tokens: [{ address: "0xAAA", symbol: "AAA" }],
+            }),
+        };
+        const findings = (0, diff_1.diffNear)(registry, [
+            token({ assetId: "nep245:v2_1.omni.hot.tg:8453_zzz" }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("near_asset_id_changed");
+    });
+    // The authored id is what the consumer sends, so deriving instead would both
+    // report drift on a token already corrected and miss an authored id going
+    // stale — the case this check exists for.
+    (0, bun_test_1.test)("an authored nearAssetId is checked, not the derivation", () => {
+        const registry = {
+            "8453": chain({
+                name: "Base",
+                settlementLayers: ["NEAR"],
+                tokens: [
+                    {
+                        address: "0xAAA",
+                        symbol: "AAA",
+                        nearAssetId: "nep245:v2_1.omni.hot.tg:8453_zzz",
+                    },
+                ],
+            }),
+        };
+        const served = [
+            token({ assetId: "nep245:v2_1.omni.hot.tg:8453_zzz" }),
+        ];
+        (0, bun_test_1.expect)(codes((0, diff_1.diffNear)(registry, served))).not.toContain("near_asset_id_changed");
+        // ...and a stale authored id is still caught.
+        const stale = {
+            "8453": chain({
+                name: "Base",
+                settlementLayers: ["NEAR"],
+                tokens: [
+                    { address: "0xAAA", symbol: "AAA", nearAssetId: "nep141:base-old" },
+                ],
+            }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffNear)(stale, served))).toContain("near_asset_id_changed");
+    });
+    (0, bun_test_1.test)("a matching asset id produces nothing", () => {
+        const registry = {
+            "8453": chain({
+                name: "Base",
+                settlementLayers: ["NEAR"],
+                tokens: [{ address: "0xAAA", symbol: "AAA" }],
+            }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffNear)(registry, [token()]))).not.toContain("near_asset_id_changed");
+    });
+    (0, bun_test_1.describe)("per-token coverage", () => {
+        const registryWith = (tokens) => ({
+            "8453": chain({ name: "Base", settlementLayers: ["NEAR"], tokens }),
+        });
+        (0, bun_test_1.test)("a declared token the vendor does not serve is an overclaim", () => {
+            const findings = (0, diff_1.diffNear)(registryWith([
+                { address: "0xAAA", symbol: "AAA", settlementLayers: ["NEAR"] },
+                { address: "0xBBB", symbol: "BBB", settlementLayers: ["NEAR"] },
+            ]), [token()]);
+            const dropped = findings.filter((f) => f.code === "near_token_dropped");
+            (0, bun_test_1.expect)(dropped).toHaveLength(1);
+            (0, bun_test_1.expect)(dropped[0]?.kind).toBe("overclaim");
+            (0, bun_test_1.expect)(dropped[0]?.message).toContain("BBB");
+        });
+        (0, bun_test_1.test)("an undeclared token the vendor does not serve is not reported", () => {
+            // The four this coverage change excludes. Reporting them as overclaims
+            // was the false positive.
+            const findings = (0, diff_1.diffNear)(registryWith([
+                { address: "0xAAA", symbol: "AAA", settlementLayers: ["NEAR"] },
+                { address: "0xBBB", symbol: "BBB", settlementLayers: ["ACROSS"] },
+            ]), [token()]);
+            (0, bun_test_1.expect)(codes(findings)).not.toContain("near_token_dropped");
+            (0, bun_test_1.expect)(codes(findings)).not.toContain("near_token_available");
+        });
+        (0, bun_test_1.test)("an undeclared token the vendor DOES serve is an underclaim", () => {
+            const findings = (0, diff_1.diffNear)(registryWith([
+                { address: "0xAAA", symbol: "AAA", settlementLayers: ["NEAR"] },
+                { address: "0xBBB", symbol: "BBB", settlementLayers: [] },
+            ]), [
+                token(),
+                token({
+                    assetId: "nep141:base-0xbbb.omft.near",
+                    contractAddress: "0xbbb",
+                    symbol: "BBB",
+                }),
+            ]);
+            const available = findings.filter((f) => f.code === "near_token_available");
+            (0, bun_test_1.expect)(available).toHaveLength(1);
+            (0, bun_test_1.expect)(available[0]?.kind).toBe("underclaim");
+            (0, bun_test_1.expect)(available[0]?.severity).toBe("info");
+            (0, bun_test_1.expect)(available[0]?.message).toContain("BBB");
+        });
+        (0, bun_test_1.test)("a native whose asset id went stale is a mismatch, not a drop", () => {
+            // 1Click returns no contractAddress for a gas token, so matching on the
+            // registry's zero-address placeholder has to normalise or every native
+            // reports as unlisted.
+            const findings = (0, diff_1.diffNear)({
+                "8453": chain({
+                    name: "Base",
+                    settlementLayers: ["NEAR"],
+                    tokens: [
+                        {
+                            address: "0x0000000000000000000000000000000000000000",
+                            symbol: "ETH",
+                            settlementLayers: ["NEAR"],
+                            nearAssetId: "nep141:base.omft.near",
+                        },
+                    ],
+                }),
+            }, [
+                token({
+                    assetId: "nep245:v2_1.omni.hot.tg:8453_native",
+                    contractAddress: undefined,
+                    symbol: "ETH",
+                }),
+            ]);
+            (0, bun_test_1.expect)(codes(findings)).toContain("near_asset_id_changed");
+            (0, bun_test_1.expect)(codes(findings)).not.toContain("near_token_dropped");
+            (0, bun_test_1.expect)(findings[0]?.message).toContain("nep245:v2_1.omni.hot.tg:8453_native");
+        });
+        (0, bun_test_1.test)("an undeclared native the vendor serves is still an underclaim", () => {
+            const findings = (0, diff_1.diffNear)({
+                "8453": chain({
+                    name: "Base",
+                    settlementLayers: ["NEAR"],
+                    tokens: [
+                        { address: "0xAAA", symbol: "AAA", settlementLayers: ["NEAR"] },
+                        {
+                            address: "0x0000000000000000000000000000000000000000",
+                            symbol: "ETH",
+                            settlementLayers: [],
+                        },
+                    ],
+                }),
+            }, [
+                token(),
+                token({
+                    assetId: "nep141:base.omft.near",
+                    contractAddress: undefined,
+                    symbol: "ETH",
+                }),
+            ]);
+            (0, bun_test_1.expect)(codes(findings)).toContain("near_token_available");
+        });
+        (0, bun_test_1.test)("a registry declaring NEAR on no token checks every token", () => {
+            // Pre-field artifact: the consumer advertises the whole chain, so every
+            // token is still a claim.
+            const findings = (0, diff_1.diffNear)(registryWith([
+                { address: "0xAAA", symbol: "AAA" },
+                { address: "0xBBB", symbol: "BBB" },
+            ]), [token()]);
+            (0, bun_test_1.expect)(codes(findings)).toContain("near_token_dropped");
+            (0, bun_test_1.expect)(codes(findings)).not.toContain("near_token_available");
+        });
+    });
+});
+(0, bun_test_1.describe)("diffCctp", () => {
+    const registry = {
+        "8453": chain({
+            name: "Base",
+            network: "mainnet",
+            settlementLayers: ["CCTP"],
+        }),
+        "57073": chain({ name: "Ink", network: "mainnet", settlementLayers: [] }),
+    };
+    const probe = (over) => ({
+        chainId: 8453,
+        reachable: true,
+        messenger: identity_1.CCTP_CONTRACTS.mainnet.tokenMessenger,
+        deployed: true,
+        transmitter: identity_1.CCTP_CONTRACTS.mainnet.messageTransmitter,
+        domain: 6,
+        ...over,
+    });
+    (0, bun_test_1.test)("a deployment on a chain we do not claim is an addition", () => {
+        const findings = (0, diff_1.diffCctp)(registry, [probe({ chainId: 57073, domain: 21 })]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("cctp_chain_available");
+    });
+    (0, bun_test_1.test)("a domain that disagrees with ours is drift", () => {
+        const findings = (0, diff_1.diffCctp)(registry, [probe({ domain: 99 })]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("cctp_domain_mismatch");
+    });
+    (0, bun_test_1.test)("an unrelated contract at the messenger address is not a new chain", () => {
+        const findings = (0, diff_1.diffCctp)(registry, [
+            probe({
+                chainId: 57073,
+                transmitter: "0x1111111111111111111111111111111111111111",
+            }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("cctp_transmitter_changed");
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("cctp_chain_available");
+    });
+    (0, bun_test_1.test)("an unreadable transmitter is unconfirmed, not a new chain", () => {
+        const findings = (0, diff_1.diffCctp)(registry, [
+            probe({ chainId: 57073, transmitter: undefined }),
+        ]);
+        (0, bun_test_1.expect)(codes(findings)).toContain("cctp_transmitter_unreadable");
+        (0, bun_test_1.expect)(codes(findings)).not.toContain("cctp_chain_available");
+        (0, bun_test_1.expect)(findings.every((f) => f.severity !== "drift")).toBe(true);
+    });
+    (0, bun_test_1.test)("an unreachable chain is a warning, never drift", () => {
+        const findings = (0, diff_1.diffCctp)(registry, [
+            { chainId: 8453, reachable: false, error: "timeout" },
+        ]);
+        (0, bun_test_1.expect)(findings.every((f) => f.severity !== "drift")).toBe(true);
+    });
+    (0, bun_test_1.test)("a claimed chain that was never probed is reported, not assumed fine", () => {
+        (0, bun_test_1.expect)(codes((0, diff_1.diffCctp)(registry, []))).toContain("cctp_not_probed");
+    });
+});
+(0, bun_test_1.describe)("diffRegistryConsistency", () => {
+    (0, bun_test_1.test)("flags a chain claiming a layer with no per-layer config", () => {
+        const registry = {
+            "1868": chain({ name: "Soneium", settlementLayers: ["CCTP"] }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffRegistryConsistency)(registry))).toContain("layer_claimed_without_config");
+    });
+    (0, bun_test_1.test)("flags per-layer config on a chain that does not claim the layer", () => {
+        const registry = {
+            "999": chain({ name: "HyperEVM", settlementLayers: [] }),
+        };
+        (0, bun_test_1.expect)(codes((0, diff_1.diffRegistryConsistency)(registry))).toContain("layer_config_without_claim");
+    });
+});
+(0, bun_test_1.describe)("rpcCandidates", () => {
+    const providers = {
+        Alchemy: {
+            chain_mapping: { "8453": "base-mainnet" },
+            url_template: "https://{{chain_param}}.g.alchemy.com/v2/${ALCHEMY_API_KEY}",
+        },
+    };
+    const registry = {
+        "8453": chain({ name: "Base", publicRpcUrl: "https://mainnet.base.org" }),
+    };
+    (0, bun_test_1.test)("expands a provider template from the environment", () => {
+        (0, bun_test_1.expect)((0, vendors_1.rpcCandidates)(8453, registry, providers, { ALCHEMY_API_KEY: "k" })[0]).toBe("https://base-mainnet.g.alchemy.com/v2/k");
+    });
+    (0, bun_test_1.test)("drops a template whose key is unset rather than calling it keyless", () => {
+        (0, bun_test_1.expect)((0, vendors_1.rpcCandidates)(8453, registry, providers, {})).toEqual([
+            "https://mainnet.base.org",
+        ]);
+    });
+    (0, bun_test_1.test)("an explicit override wins outright", () => {
+        (0, bun_test_1.expect)((0, vendors_1.rpcCandidates)(8453, registry, providers, {
+            ALCHEMY_API_KEY: "k",
+            VENDOR_DRIFT_RPC_8453: "http://localhost:8545",
+        })).toEqual(["http://localhost:8545"]);
+    });
+});
+(0, bun_test_1.describe)("formatMarkdown", () => {
+    // The workflow always exits green, so the summary headline is the only
+    // signal. A clean tick after an unreachable vendor reports a check we did
+    // not perform.
+    (0, bun_test_1.test)("a run with skipped checks never claims agreement", () => {
+        const md = (0, report_1.formatMarkdown)([], ["Rhino /bridge/configs unreachable"]);
+        (0, bun_test_1.expect)(md).not.toContain(":white_check_mark:");
+        (0, bun_test_1.expect)(md).toContain("not run");
+        (0, bun_test_1.expect)(md).toContain("Rhino /bridge/configs unreachable");
+    });
+    (0, bun_test_1.test)("a fully covered clean run still reports agreement", () => {
+        (0, bun_test_1.expect)((0, report_1.formatMarkdown)([], [])).toContain(":white_check_mark:");
+    });
+});

package/dist/scripts/vendor-drift/diff.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Pure diff between what `configs/chains.json` claims and what each vendor
+ * serves. No I/O — `vendors.ts` collects the vendor side, `main.ts` wires them.
+ */
+import { type SettlementLayerName } from "./identity";
+export type Severity = "drift" | "warning" | "info";
+/**
+ * Which direction the disagreement runs. `overclaim` is the dangerous one — we
+ * advertise a route the vendor will refuse, and an offered-but-unserved route
+ * fails at fill, not at quote.
+ */
+export type Kind = "overclaim" | "underclaim" | "mismatch" | "note";
+export type Finding = {
+    layer: SettlementLayerName | "REGISTRY";
+    severity: Severity;
+    kind: Kind;
+    code: string;
+    chainId?: number;
+    message: string;
+};
+export type RegistryToken = {
+    address: string;
+    symbol: string;
+    /** Authored override; when present it is what the consumer actually sends. */
+    nearAssetId?: string;
+    settlementLayers?: string[];
+};
+export type RegistryEntry = {
+    name?: string;
+    vmType?: string;
+    network?: string;
+    publicRpcUrl?: string;
+    virtual?: boolean;
+    settlementLayers?: string[];
+    tokens?: RegistryToken[];
+    settlementConfig?: Record<string, Record<string, unknown>>;
+    settlementLayerConfig?: Record<string, Record<string, unknown>>;
+    vendorConfig?: Record<string, Record<string, unknown>>;
+};
+export type Registry = Record<string, RegistryEntry>;
+export type RhinoVendorEntry = {
+    name: string;
+    networkId: unknown;
+    status?: string;
+    contractAddress?: string;
+};
+export type OneClickToken = {
+    assetId: string;
+    blockchain: string;
+    symbol?: string;
+    contractAddress?: string;
+};
+export type CctpProbe = {
+    chainId: number;
+    reachable: true;
+    messenger: string;
+    deployed: boolean;
+    transmitter?: string;
+    domain?: number;
+} | {
+    chainId: number;
+    reachable: false;
+    error: string;
+};
+export declare function diffRhino(registry: Registry, vendor: RhinoVendorEntry[]): Finding[];
+export declare function nearAssetId(slug: string, chainId: number, address: string, registryConfig?: Record<string, unknown>): string | undefined;
+/**
+ * Both directions, because a token is either claimed or not and each side has
+ * its own failure. A token we claim that 1Click will not serve is an
+ * **overclaim** — the route is offered and the quote fails `tokenOut is not
+ * valid`. A token 1Click does serve that we do not claim is an
+ * **underclaim** — capability left on the table, informational rather than
+ * drift because nothing breaks. Checking only the first would let coverage
+ * silently ossify; checking every token as a claim, which is what this did
+ * before per-token coverage existed, reports a deliberate exclusion as an
+ * overclaim.
+ */
+export declare function diffNear(registry: Registry, vendor: OneClickToken[]): Finding[];
+export declare function diffCctp(registry: Registry, probes: CctpProbe[]): Finding[];
+export declare function diffRegistryConsistency(registry: Registry): Finding[];