@rhinestone/shared-configs 1.17.0 → 1.19.0

package/dist/scripts/vendor-drift/identity.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Chain identity across three settlement-layer vendors, plus the pre-migration
+ * fallback for vendor detail `configs/chains.json` does not carry yet.
+ *
+ * Identity is not derivable and not published by the vendor: Rhino names chains
+ * (`MATIC_POS`) and its `networkId` is not a chain id off the EVM set (SOLANA is
+ * `900`, and `BITCOIN`/`SN_MAIN`/`TON` are strings); 1Click uses its own slug
+ * (`pol`, `avax`). Both tables are deliberately wider than what we claim — a
+ * vendor chain with no entry here can only be reported as unmapped, never as a
+ * chain we could newly serve.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONECLICK_TOKENS_URL = exports.RHINO_CONFIGS_URL = exports.CCTP_CONTRACTS = exports.BASELINE_CCTP_DOMAINS = exports.BASELINE_NEAR_CHAIN_IDS = exports.BASELINE_RHINO_CHAIN_IDS = exports.BASELINE_RHINO_BRIDGE_CONTRACTS = exports.NEAR_NON_EVM_ASSET_IDS = exports.NEAR_CHAIN_SLUGS = exports.RHINO_CHAIN_NAMES = void 0;
+exports.RHINO_CHAIN_NAMES = {
+    1: "ETHEREUM",
+    10: "OPTIMISM",
+    56: "BINANCE",
+    100: "GNOSIS",
+    130: "UNICHAIN",
+    137: "MATIC_POS",
+    146: "SONIC",
+    999: "HYPEREVM",
+    8453: "BASE",
+    9745: "PLASMA",
+    42161: "ARBITRUM",
+    43114: "AVALANCHE",
+    57073: "INK",
+    747474: "KATANA",
+    728126428: "TRON",
+    792703809: "SOLANA",
+};
+exports.NEAR_CHAIN_SLUGS = {
+    1: "eth",
+    10: "op",
+    56: "bsc",
+    100: "gnosis",
+    137: "pol",
+    143: "monad",
+    8453: "base",
+    9745: "plasma",
+    42161: "arb",
+    43114: "avax",
+    728126428: "tron",
+    792703809: "sol",
+};
+/**
+ * Per-token 1Click asset ids for non-EVM chains. 1Click wraps each non-EVM
+ * token under a NEAR-internal hex id that the EVM
+ * `nep141:{slug}-{address}.omft.near` derivation cannot produce, so these
+ * cannot be computed from the registry address.
+ *
+ * Keyed by the chain-native address as `chains.json` stores it — base58 is
+ * case-sensitive, so these keys are not lowercased.
+ */
+exports.NEAR_NON_EVM_ASSET_IDS = {
+    792703809: {
+        "11111111111111111111111111111111": "nep141:sol.omft.near",
+        So11111111111111111111111111111111111111112: "nep141:sol.omft.near",
+        EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: "nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near",
+        Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB: "nep141:sol-c800a4bd850783ccb82c2b2c7e84175443606352.omft.near",
+    },
+    728126428: {
+        "0x0000000000000000000000000000000000000000": "nep141:tron.omft.near",
+        TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t: "nep141:tron-d28a265909efecdcee7c5028585214ea0b96f015.omft.near",
+    },
+};
+/**
+ * Vendor detail that `configs/chains.json` does not carry yet — the per-layer
+ * maps the orchestrator holds in `src/settlement/layer/{rhino,cctp}/config.ts`
+ * and `near/httpClient.ts`.
+ *
+ * Read only where the registry entry has no `settlementLayerConfig` for the
+ * layer, so it becomes dead the moment that config lands in the registry.
+ * Deleting an entry here silently narrows what the check compares — do not
+ * prune it to "fix" a finding.
+ */
+exports.BASELINE_RHINO_BRIDGE_CONTRACTS = {
+    1: "0xbca3039a18c0d2f2f84ba8a028c67290bc045afa",
+    10: "0x0bca65bf4b4c8803d2f0b49353ed57caaf3d66dc",
+    56: "0xb80a582fa430645a043bb4f6135321ee01005fef",
+    100: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+    130: "0xb0d7040b93fe5b099d3ce02ea86c4a1b695732d0",
+    137: "0xBA4EEE20F434bC3908A0B18DA496348657133A7E",
+    146: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+    999: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+    8453: "0x2f59e9086ec8130e21bd052065a9e6b2497bb102",
+    9745: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+    42161: "0x10417734001162Ea139e8b044DFe28DbB8B28ad0",
+    43114: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+    747474: "0x04317f0e4795b1e1bab333234153fa10aaac79e9",
+    4217: "0x5e023c31e1d3dcd08a1b3e8c96f6ef8aa8fcacd1",
+};
+/** Chains the orchestrator's own Rhino map covers, contract or not. */
+exports.BASELINE_RHINO_CHAIN_IDS = [
+    1, 10, 56, 100, 130, 137, 146, 999, 4217, 8453, 9745, 42161, 43114, 747474,
+    728126428, 792703809,
+];
+/** Chains the orchestrator's own NEAR prefix map covers. */
+exports.BASELINE_NEAR_CHAIN_IDS = [
+    1, 10, 56, 100, 137, 196, 8453, 42161, 43114, 80094, 534352, 728126428,
+    792703809,
+];
+exports.BASELINE_CCTP_DOMAINS = {
+    1: 0,
+    10: 2,
+    56: 17,
+    130: 10,
+    137: 7,
+    143: 15,
+    146: 13,
+    999: 19,
+    8453: 6,
+    42161: 3,
+    43114: 1,
+    792703809: 5,
+    11155111: 0,
+    11155420: 2,
+    84532: 6,
+    421614: 3,
+};
+/**
+ * TokenMessengerV2 and MessageTransmitterV2 are each deployed at one address
+ * across every EVM chain, but mainnet and testnet use different ones —
+ * probing a testnet with the mainnet address reads "not deployed" on four
+ * chains that are fine.
+ */
+exports.CCTP_CONTRACTS = {
+    mainnet: {
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    },
+    testnet: {
+        tokenMessenger: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+        messageTransmitter: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    },
+};
+exports.RHINO_CONFIGS_URL = "https://api.rhino.fi/bridge/configs";
+exports.ONECLICK_TOKENS_URL = "https://1click.chaindefuser.com/v0/tokens";

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

@@ -0,0 +1,10 @@
+/**
+ * Compares `configs/chains.json` against what the Rhino, NEAR/1Click and CCTP
+ * vendors serve right now, in both directions.
+ *
+ * Reports, never gates. It exits 0 even with drift so it can never sit between
+ * us and a release; `--strict` is for a human running it locally.
+ *
+ *   bun run scripts/vendor-drift/main.ts [--json] [--strict]
+ */
+export {};

package/dist/scripts/vendor-drift/main.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Compares `configs/chains.json` against what the Rhino, NEAR/1Click and CCTP
+ * vendors serve right now, in both directions.
+ *
+ * Reports, never gates. It exits 0 even with drift so it can never sit between
+ * us and a release; `--strict` is for a human running it locally.
+ *
+ *   bun run scripts/vendor-drift/main.ts [--json] [--strict]
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const diff_1 = require("./diff");
+const report_1 = require("./report");
+const vendors_1 = require("./vendors");
+function loadJson(relative) {
+    const file = node_path_1.default.join(__dirname, "..", "..", relative);
+    return JSON.parse((0, node_fs_1.readFileSync)(file, "utf8"));
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const asJson = argv.includes("--json");
+    const strict = argv.includes("--strict");
+    const registry = loadJson("configs/chains.json");
+    const providers = loadJson("configs/providers.json");
+    const findings = (0, diff_1.diffRegistryConsistency)(registry);
+    const skipped = [];
+    const [rhino, oneClick] = await Promise.all([
+        (0, vendors_1.collectRhino)(),
+        (0, vendors_1.collectOneClick)(),
+    ]);
+    if (rhino.ok) {
+        findings.push(...(0, diff_1.diffRhino)(registry, rhino.value));
+    }
+    else {
+        skipped.push(`RHINO — ${rhino.error}`);
+    }
+    if (oneClick.ok) {
+        findings.push(...(0, diff_1.diffNear)(registry, oneClick.value));
+    }
+    else {
+        skipped.push(`NEAR — ${oneClick.error}`);
+    }
+    const probes = await (0, vendors_1.collectCctp)(registry, providers, process.env);
+    const reachable = probes.filter((probe) => probe.reachable).length;
+    if (reachable === 0) {
+        skipped.push("CCTP — no EVM chain was reachable; set ALCHEMY_API_KEY or DRPC_API_KEY, or a VENDOR_DRIFT_RPC_<chainId> override.");
+    }
+    else {
+        findings.push(...(0, diff_1.diffCctp)(registry, probes));
+        const unreachable = probes.length - reachable;
+        if (unreachable > 0) {
+            skipped.push(`CCTP — ${unreachable} of ${probes.length} EVM chains were unreachable; a chain Circle added there would not be seen.`);
+        }
+    }
+    if (asJson) {
+        console.log(JSON.stringify({ findings, skipped }, null, 2));
+    }
+    else {
+        console.log((0, report_1.formatText)(findings, skipped));
+    }
+    const summaryFile = process.env.GITHUB_STEP_SUMMARY;
+    if (summaryFile) {
+        (0, node_fs_1.appendFileSync)(summaryFile, `${(0, report_1.formatMarkdown)(findings, skipped)}\n`);
+    }
+    const drift = (0, report_1.countBy)(findings, "drift");
+    if (strict && drift > 0)
+        process.exitCode = 1;
+}
+main().catch((error) => {
+    console.error(`vendor-drift failed: ${error.stack ?? error}`);
+    process.exitCode = 1;
+});

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

@@ -0,0 +1,5 @@
+import type { Finding, Kind, Severity } from "./diff";
+export declare function countBy(findings: Finding[], severity: Severity): number;
+export declare function countKind(findings: Finding[], kind: Kind): number;
+export declare function formatText(findings: Finding[], skipped: string[]): string;
+export declare function formatMarkdown(findings: Finding[], skipped: string[]): string;

package/dist/scripts/vendor-drift/report.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countBy = countBy;
+exports.countKind = countKind;
+exports.formatText = formatText;
+exports.formatMarkdown = formatMarkdown;
+const SEVERITY_ORDER = ["drift", "warning", "info"];
+const KIND_ORDER = ["overclaim", "underclaim", "mismatch", "note"];
+const KIND_HEADING = {
+    overclaim: "We claim it, the vendor does not serve it",
+    underclaim: "The vendor serves it, we do not claim it",
+    mismatch: "Both sides claim it and disagree on the detail",
+    note: "Notes",
+};
+function countBy(findings, severity) {
+    return findings.filter((finding) => finding.severity === severity).length;
+}
+function countKind(findings, kind) {
+    return findings.filter((finding) => finding.kind === kind && finding.severity !== "info").length;
+}
+function group(findings, kind) {
+    return findings
+        .filter((finding) => finding.kind === kind)
+        .sort((a, b) => SEVERITY_ORDER.indexOf(a.severity) -
+        SEVERITY_ORDER.indexOf(b.severity) ||
+        a.layer.localeCompare(b.layer) ||
+        (a.chainId ?? 0) - (b.chainId ?? 0));
+}
+function headline(findings) {
+    return `${countKind(findings, "overclaim")} overclaimed, ${countKind(findings, "underclaim")} unclaimed but available, ${countKind(findings, "mismatch")} detail mismatches (${countBy(findings, "drift")} drift, ${countBy(findings, "warning")} warnings, ${countBy(findings, "info")} informational)`;
+}
+function formatText(findings, skipped) {
+    const lines = [];
+    lines.push("Settlement-layer vendor drift");
+    lines.push(headline(findings));
+    for (const kind of KIND_ORDER) {
+        const rows = group(findings, kind);
+        if (rows.length === 0)
+            continue;
+        lines.push("");
+        lines.push(`${KIND_HEADING[kind]} (${rows.length})`);
+        for (const finding of rows) {
+            lines.push(`  [${finding.layer}/${finding.code}] ${finding.message}`);
+        }
+    }
+    if (skipped.length > 0) {
+        lines.push("");
+        lines.push("NOT CHECKED");
+        for (const reason of skipped)
+            lines.push(`  ${reason}`);
+    }
+    if (findings.length === 0 && skipped.length === 0) {
+        lines.push("");
+        lines.push("No disagreement with any vendor.");
+    }
+    return lines.join("\n");
+}
+function formatMarkdown(findings, skipped) {
+    const drift = countBy(findings, "drift");
+    const lines = [];
+    lines.push("## Settlement-layer vendor drift");
+    lines.push("");
+    // The workflow always exits green, so this line is the only signal anyone
+    // reads. Claiming agreement after a run that could not reach a vendor would
+    // report a clean check we did not perform.
+    lines.push(drift > 0
+        ? `:warning: **${drift} disagreement${drift === 1 ? "" : "s"}** between \`configs/chains.json\` and what the vendors serve today.`
+        : skipped.length > 0
+            ? `:grey_question: No disagreement found, but ${skipped.length} check${skipped.length === 1 ? " was" : "s were"} not run — coverage below is incomplete.`
+            : ":white_check_mark: `configs/chains.json` agrees with Rhino, 1Click and CCTP on-chain.");
+    lines.push("");
+    lines.push(headline(findings));
+    if (skipped.length > 0) {
+        lines.push("");
+        lines.push("> [!IMPORTANT]");
+        lines.push("> **Not checked this run:**");
+        for (const reason of skipped)
+            lines.push(`> - ${reason}`);
+    }
+    for (const kind of KIND_ORDER) {
+        const rows = group(findings, kind);
+        if (rows.length === 0)
+            continue;
+        lines.push("");
+        lines.push(`### ${KIND_HEADING[kind]} (${rows.length})`);
+        lines.push("");
+        lines.push("| Layer | Chain | Finding |");
+        lines.push("| --- | --- | --- |");
+        for (const finding of rows) {
+            lines.push(`| ${finding.layer} | ${finding.chainId ?? "—"} | ${finding.message.replace(/\|/g, "\\|")} |`);
+        }
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Vendor-side collection. Every fetch resolves to a result, never throws — a
+ * vendor being down degrades that layer to a warning and leaves the rest of the
+ * report intact.
+ */
+import type { CctpProbe, OneClickToken, Registry, RhinoVendorEntry } from "./diff";
+export type Collected<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function collectRhino(): Promise<Collected<RhinoVendorEntry[]>>;
+export declare function collectOneClick(): Promise<Collected<OneClickToken[]>>;
+type ProviderRegistry = Record<string, {
+    chain_mapping?: Record<string, string>;
+    url_template?: string;
+}>;
+/**
+ * RPC candidates for one chain, most reliable first. Mirrors how the rest of
+ * the repo resolves RPCs: `configs/providers.json` templates expanded from the
+ * same `ALCHEMY_API_KEY` / `DRPC_API_KEY` the health and balance workflows
+ * already carry, then the registry's own public RPC as a keyless fallback so
+ * the sweep still runs for a contributor with no keys.
+ */
+export declare function rpcCandidates(chainId: number, registry: Registry, providers: ProviderRegistry, env: Record<string, string | undefined>): string[];
+/**
+ * Sweeps every real EVM chain in the registry, not just the ones claiming
+ * CCTP — a chain Circle newly supports is invisible otherwise. `virtual`
+ * chains (the HyperCore venue ids) have no RPC of their own and are skipped.
+ */
+export declare function collectCctp(registry: Registry, providers: ProviderRegistry, env: Record<string, string | undefined>): Promise<CctpProbe[]>;
+export {};

package/dist/scripts/vendor-drift/vendors.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Vendor-side collection. Every fetch resolves to a result, never throws — a
+ * vendor being down degrades that layer to a warning and leaves the rest of the
+ * report intact.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRhino = collectRhino;
+exports.collectOneClick = collectOneClick;
+exports.rpcCandidates = rpcCandidates;
+exports.collectCctp = collectCctp;
+const identity_1 = require("./identity");
+const HTTP_TIMEOUT_MS = 30_000;
+const RPC_TIMEOUT_MS = 15_000;
+const RPC_CONCURRENCY = 6;
+// keccak256("localMessageTransmitter()") and keccak256("localDomain()").
+const SELECTOR_LOCAL_MESSAGE_TRANSMITTER = "0x2c121921";
+const SELECTOR_LOCAL_DOMAIN = "0x8d3638f4";
+async function getJson(url) {
+    try {
+        const response = await fetch(url, {
+            headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            return { ok: false, error: `HTTP ${response.status} from ${url}` };
+        }
+        return { ok: true, value: await response.json() };
+    }
+    catch (error) {
+        return { ok: false, error: `${url}: ${error.message}` };
+    }
+}
+async function collectRhino() {
+    const result = await getJson(identity_1.RHINO_CONFIGS_URL);
+    if (!result.ok)
+        return result;
+    const payload = result.value;
+    if (typeof payload !== "object" || payload === null) {
+        return { ok: false, error: `${identity_1.RHINO_CONFIGS_URL} returned a non-object` };
+    }
+    const entries = Object.entries(payload).map(([name, entry]) => ({
+        name,
+        networkId: entry?.networkId,
+        status: typeof entry?.status === "string" ? entry.status : undefined,
+        contractAddress: typeof entry?.contractAddress === "string" && entry.contractAddress
+            ? entry.contractAddress
+            : undefined,
+    }));
+    if (entries.length === 0) {
+        return { ok: false, error: `${identity_1.RHINO_CONFIGS_URL} returned no chains` };
+    }
+    return { ok: true, value: entries };
+}
+async function collectOneClick() {
+    const result = await getJson(identity_1.ONECLICK_TOKENS_URL);
+    if (!result.ok)
+        return result;
+    const payload = result.value;
+    if (!Array.isArray(payload)) {
+        return { ok: false, error: `${identity_1.ONECLICK_TOKENS_URL} returned a non-array` };
+    }
+    const tokens = payload
+        .filter((token) => typeof token?.assetId === "string" &&
+        typeof token?.blockchain === "string")
+        .map((token) => ({
+        assetId: token.assetId,
+        blockchain: token.blockchain,
+        symbol: typeof token.symbol === "string" ? token.symbol : undefined,
+        contractAddress: typeof token.contractAddress === "string"
+            ? token.contractAddress
+            : undefined,
+    }));
+    if (tokens.length === 0) {
+        return { ok: false, error: `${identity_1.ONECLICK_TOKENS_URL} returned no tokens` };
+    }
+    return { ok: true, value: tokens };
+}
+/**
+ * RPC candidates for one chain, most reliable first. Mirrors how the rest of
+ * the repo resolves RPCs: `configs/providers.json` templates expanded from the
+ * same `ALCHEMY_API_KEY` / `DRPC_API_KEY` the health and balance workflows
+ * already carry, then the registry's own public RPC as a keyless fallback so
+ * the sweep still runs for a contributor with no keys.
+ */
+function rpcCandidates(chainId, registry, providers, env) {
+    const override = env[`VENDOR_DRIFT_RPC_${chainId}`];
+    if (override)
+        return [override];
+    const urls = [];
+    for (const providerName of ["Alchemy", "DRPC"]) {
+        const provider = providers[providerName];
+        const param = provider?.chain_mapping?.[String(chainId)];
+        const template = provider?.url_template;
+        if (!param || !template)
+            continue;
+        const expanded = template.replace(/\$\{([A-Z0-9_]+)\}/g, (_match, key) => env[key] ?? "");
+        if (/\$\{|\/v2\/$|dkey=$/.test(expanded))
+            continue;
+        urls.push(expanded.replace("{{chain_param}}", param));
+    }
+    const publicRpc = registry[String(chainId)]?.publicRpcUrl;
+    if (publicRpc)
+        urls.push(publicRpc);
+    return urls;
+}
+async function rpcCall(url, method, params) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+        signal: AbortSignal.timeout(RPC_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    const body = (await response.json());
+    if (body.error)
+        throw new Error(body.error.message ?? "rpc error");
+    if (typeof body.result !== "string")
+        throw new Error("no result");
+    return body.result;
+}
+async function probeChain(chainId, messenger, urls) {
+    if (urls.length === 0) {
+        return { chainId, reachable: false, error: "no RPC URL available" };
+    }
+    let lastError = "unknown";
+    for (const url of urls) {
+        try {
+            const code = await rpcCall(url, "eth_getCode", [messenger, "latest"]);
+            if (code === "0x" || code === "0x0") {
+                return { chainId, reachable: true, messenger, deployed: false };
+            }
+            let transmitter;
+            let domain;
+            try {
+                const raw = await rpcCall(url, "eth_call", [
+                    { to: messenger, data: SELECTOR_LOCAL_MESSAGE_TRANSMITTER },
+                    "latest",
+                ]);
+                transmitter = `0x${raw.slice(-40)}`;
+                const rawDomain = await rpcCall(url, "eth_call", [
+                    { to: transmitter, data: SELECTOR_LOCAL_DOMAIN },
+                    "latest",
+                ]);
+                domain = Number.parseInt(rawDomain, 16);
+                if (!Number.isFinite(domain))
+                    domain = undefined;
+            }
+            catch {
+                // Deployment is established by the code check; a failed follow-up read
+                // is reported as an unreadable domain rather than a missing chain.
+            }
+            return {
+                chainId,
+                reachable: true,
+                messenger,
+                deployed: true,
+                transmitter,
+                domain,
+            };
+        }
+        catch (error) {
+            lastError = error.message;
+        }
+    }
+    return { chainId, reachable: false, error: lastError };
+}
+/**
+ * Sweeps every real EVM chain in the registry, not just the ones claiming
+ * CCTP — a chain Circle newly supports is invisible otherwise. `virtual`
+ * chains (the HyperCore venue ids) have no RPC of their own and are skipped.
+ */
+async function collectCctp(registry, providers, env) {
+    const targets = Object.keys(registry)
+        .map(Number)
+        .filter((id) => {
+        const entry = registry[String(id)];
+        return Number.isFinite(id) && entry?.vmType === "evm" && !entry.virtual;
+    })
+        .sort((a, b) => a - b);
+    const probes = [];
+    for (let i = 0; i < targets.length; i += RPC_CONCURRENCY) {
+        const batch = targets.slice(i, i + RPC_CONCURRENCY);
+        probes.push(...(await Promise.all(batch.map((chainId) => {
+            const contracts = registry[String(chainId)]?.network === "testnet"
+                ? identity_1.CCTP_CONTRACTS.testnet
+                : identity_1.CCTP_CONTRACTS.mainnet;
+            return probeChain(chainId, contracts.tokenMessenger, rpcCandidates(chainId, registry, providers, env));
+        }))));
+    }
+    return probes;
+}

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

@@ -65,18 +65,28 @@ const TRON_CAIP2 = "tron:mainnet";
         }
     });
     (0, bun_test_1.describe)("chain roles", () => {
-        (0, bun_test_1.it)("splits HyperCore by direction: Core L1 originates, venues receive", () => {
-            // Deposits arrive from the Core L1 without naming a venue; a delivery
-            // must name the account it credits. Declaring it here is what makes a
-            // perp *deposit source* unrepresentable rather than merely unimplemented,
-            // and all three ids share the `hypercore:` namespace — so a namespace
-            // switch could not draw this line at any level of effort.
+        (0, bun_test_1.it)("splits HyperCore by direction: spot both ways, perp delivery-only", () => {
+            // Declaring it here is what makes a perp *deposit source* unrepresentable
+            // rather than merely unimplemented, and all three ids share the
+            // `hypercore:` namespace — so a namespace switch could not draw this line
+            // at any level of effort.
+            //
+            // Spot originates because a HyperCore deposit already IS a spot credit:
+            // ingestion admits only an absent `destinationDex` or an explicit
+            // `"spot"`. Perp stays delivery-only — a managed account cannot sign
+            // perp→spot, so a perp deposit would strand.
+            (0, bun_test_1.expect)((0, index_1.canBeOrigin)(index_1.HYPERCORE_SPOT_CHAIN_ID)).toBe(true);
+            (0, bun_test_1.expect)((0, index_1.canBeDestination)(index_1.HYPERCORE_SPOT_CHAIN_ID)).toBe(true);
+            (0, bun_test_1.expect)((0, index_1.canBeOrigin)(index_1.HYPERCORE_PERP_CHAIN_ID)).toBe(false);
+            (0, bun_test_1.expect)((0, index_1.canBeDestination)(index_1.HYPERCORE_PERP_CHAIN_ID)).toBe(true);
+        });
+        (0, bun_test_1.it)("keeps the retiring hypercore:mainnet readable as an origin", () => {
+            // Stored `deposits.chain` rows and account rules still carry the spelling
+            // (RHI-5606). Until they are all migrated and the entry dropped, a
+            // consumer resolving one must still get an origin, or those deposits are
+            // rejected as unmapped rather than degrading quietly.
             (0, bun_test_1.expect)((0, index_1.canBeOrigin)(1337)).toBe(true);
             (0, bun_test_1.expect)((0, index_1.canBeDestination)(1337)).toBe(false);
-            for (const venue of [index_1.HYPERCORE_SPOT_CHAIN_ID, index_1.HYPERCORE_PERP_CHAIN_ID]) {
-                (0, bun_test_1.expect)((0, index_1.canBeOrigin)(venue)).toBe(false);
-                (0, bun_test_1.expect)((0, index_1.canBeDestination)(venue)).toBe(true);
-            }
         });
         (0, bun_test_1.it)("defaults both directions for chains that declare no roles", () => {
             // Absent `roles` must mean both, so adding the field is a no-op for every

package/dist/src/chainVirtualization.d.ts

@@ -13,8 +13,8 @@ export declare function canBeOrigin(chainId: number): boolean;
  * Whether funds can be DELIVERED to this chain — i.e. it is a valid intent
  * destination.
  *
- * False for `hypercore:mainnet`: deposits arrive from the Core L1 venue-agnostically,
- * but a delivery must name the account it credits, so `hypercore:spot` /
+ * False for the retiring `hypercore:mainnet`, which names the Core L1 without
+ * naming the account a delivery would credit, so `hypercore:spot` /
  * `hypercore:perp` are the only HyperCore destinations. Answering that from data
  * is what lets a consumer refuse the ambiguous id without knowing its number.
  */

package/dist/src/chainVirtualization.js

@@ -46,8 +46,8 @@ function canBeOrigin(chainId) {
  * Whether funds can be DELIVERED to this chain — i.e. it is a valid intent
  * destination.
  *
- * False for `hypercore:mainnet`: deposits arrive from the Core L1 venue-agnostically,
- * but a delivery must name the account it credits, so `hypercore:spot` /
+ * False for the retiring `hypercore:mainnet`, which names the Core L1 without
+ * naming the account a delivery would credit, so `hypercore:spot` /
  * `hypercore:perp` are the only HyperCore destinations. Answering that from data
  * is what lets a consumer refuse the ambiguous id without knowing its number.
  */