@rhinestone/shared-configs 1.17.0 → 1.19.0

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

@@ -0,0 +1,569 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffRhino = diffRhino;
+exports.nearAssetId = nearAssetId;
+exports.diffNear = diffNear;
+exports.diffCctp = diffCctp;
+exports.diffRegistryConsistency = diffRegistryConsistency;
+const identity_1 = require("./identity");
+const NATIVE_ADDRESSES = new Set([
+    "0x0000000000000000000000000000000000000000",
+    "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+]);
+/**
+ * Every placeholder this registry uses for a chain's gas token. The EVM/Tron
+ * zero address plus Solana's System Program id, which `NATIVE_ADDRESSES` must
+ * not carry — that set drives the EVM asset-id derivation, where an SVM address
+ * has no meaning.
+ */
+const NATIVE_PLACEHOLDERS = new Set([
+    ...NATIVE_ADDRESSES,
+    "11111111111111111111111111111111",
+]);
+function chainIds(registry) {
+    return Object.keys(registry)
+        .map(Number)
+        .filter((id) => Number.isFinite(id))
+        .sort((a, b) => a - b);
+}
+function claims(registry, layer) {
+    return chainIds(registry).filter((id) => (registry[String(id)]?.settlementLayers ?? []).includes(layer));
+}
+function label(registry, chainId) {
+    const name = registry[String(chainId)]?.name;
+    return name ? `${name} (${chainId})` : String(chainId);
+}
+/**
+ * Per-layer vendor config for one chain, read from the registry's
+ * `settlementConfig` — which keys layers lowercase, unlike the uppercase
+ * `settlementLayers` list these call sites use.
+ *
+ * The aliases and the case-insensitive lookup are what stop this check from
+ * silently falling back to the baseline tables if the emitted shape is ever
+ * renamed: a fallback that cannot be distinguished from a real read would make
+ * the whole check report on hardcoded values instead of the registry.
+ */
+function readLayerConfig(entry, layer) {
+    const blocks = entry?.settlementConfig ??
+        entry?.settlementLayerConfig ??
+        entry?.vendorConfig;
+    if (!blocks)
+        return undefined;
+    return blocks[layer] ?? blocks[layer.toLowerCase()];
+}
+function pickString(config, ...keys) {
+    for (const key of keys) {
+        const value = config?.[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+function pickNumber(config, ...keys) {
+    for (const key of keys) {
+        const value = config?.[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Rhino — GET https://api.rhino.fi/bridge/configs
+// ---------------------------------------------------------------------------
+function diffRhino(registry, vendor) {
+    const findings = [];
+    const byName = new Map(vendor.map((entry) => [entry.name, entry]));
+    const nameToChainId = new Map(Object.entries(identity_1.RHINO_CHAIN_NAMES).map(([id, name]) => [name, Number(id)]));
+    const claimed = new Set(claims(registry, "RHINO"));
+    for (const chainId of claimed) {
+        const entry = registry[String(chainId)];
+        const config = readLayerConfig(entry, "RHINO");
+        const vendorName = pickString(config, "chainName", "vendorChainName", "name") ??
+            identity_1.RHINO_CHAIN_NAMES[chainId];
+        if (!vendorName) {
+            findings.push({
+                layer: "RHINO",
+                severity: "drift",
+                kind: "mismatch",
+                code: "rhino_no_chain_name",
+                chainId,
+                message: `${label(registry, chainId)} claims RHINO but no Rhino chain name is known for it — the quote API cannot be called.`,
+            });
+            continue;
+        }
+        const served = byName.get(vendorName);
+        if (!served) {
+            findings.push({
+                layer: "RHINO",
+                severity: "drift",
+                kind: "overclaim",
+                code: "rhino_chain_dropped",
+                chainId,
+                message: `${label(registry, chainId)} claims RHINO but ${vendorName} is not in /bridge/configs at all.`,
+            });
+            continue;
+        }
+        if (served.status !== "enabled") {
+            findings.push({
+                layer: "RHINO",
+                severity: "drift",
+                kind: "overclaim",
+                code: "rhino_chain_disabled",
+                chainId,
+                message: `${label(registry, chainId)} claims RHINO but ${vendorName} is status="${served.status}".`,
+            });
+        }
+        // Rhino returns every networkId as a string, EVM chains included, so a
+        // typeof check compares nothing on the real payload. Non-numeric ids are
+        // the non-EVM chains (BITCOIN, SN_MAIN, TON) and have no chain id to
+        // disagree with.
+        const servedChainId = typeof served.networkId === "number"
+            ? served.networkId
+            : /^\d+$/.test(String(served.networkId))
+                ? Number(served.networkId)
+                : undefined;
+        if (entry?.vmType === "evm" &&
+            servedChainId !== undefined &&
+            servedChainId !== chainId) {
+            findings.push({
+                layer: "RHINO",
+                severity: "drift",
+                kind: "mismatch",
+                code: "rhino_network_id_mismatch",
+                chainId,
+                message: `${vendorName} maps to chain ${chainId} here but Rhino reports networkId=${served.networkId}.`,
+            });
+        }
+        const expected = pickString(config, "bridgeContract", "contractAddress", "depositContract") ?? identity_1.BASELINE_RHINO_BRIDGE_CONTRACTS[chainId];
+        const actual = served.contractAddress;
+        if (!expected) {
+            if (entry?.vmType === "evm") {
+                findings.push({
+                    layer: "RHINO",
+                    severity: "warning",
+                    kind: "note",
+                    code: "rhino_bridge_contract_unknown",
+                    chainId,
+                    message: `${label(registry, chainId)} claims RHINO but no bridge contract is recorded — Rhino serves ${actual ?? "none"}, unchecked.`,
+                });
+            }
+        }
+        else if (!actual) {
+            // The bridge contract is the fund-routing address this checker exists to
+            // verify, so Rhino omitting or renaming the field must surface as an
+            // unchecked address rather than pass as agreement.
+            findings.push({
+                layer: "RHINO",
+                severity: "warning",
+                kind: "note",
+                code: "rhino_bridge_contract_unserved",
+                chainId,
+                message: `${label(registry, chainId)} holds bridge contract ${expected} but Rhino's entry carries no contract address — left unverified.`,
+            });
+        }
+        else if (actual.toLowerCase() !== expected.toLowerCase()) {
+            findings.push({
+                layer: "RHINO",
+                severity: "drift",
+                kind: "mismatch",
+                code: "rhino_bridge_contract_changed",
+                chainId,
+                message: `${label(registry, chainId)} bridge contract disagrees — we hold ${expected}, Rhino serves ${actual}.`,
+            });
+        }
+    }
+    for (const served of vendor) {
+        const chainId = nameToChainId.get(served.name);
+        if (chainId === undefined) {
+            findings.push({
+                layer: "RHINO",
+                severity: "info",
+                kind: "note",
+                code: "rhino_chain_unmapped",
+                message: `Rhino serves ${served.name} (networkId=${String(served.networkId)}, ${served.status}) — no chain of ours maps to it.`,
+            });
+            continue;
+        }
+        if (claimed.has(chainId))
+            continue;
+        if (served.status !== "enabled")
+            continue;
+        if (!registry[String(chainId)]) {
+            findings.push({
+                layer: "RHINO",
+                severity: "info",
+                kind: "note",
+                code: "rhino_chain_unregistered",
+                chainId,
+                message: `Rhino serves ${served.name} which maps to chain ${chainId} — not in the registry.`,
+            });
+            continue;
+        }
+        findings.push({
+            layer: "RHINO",
+            severity: "drift",
+            kind: "underclaim",
+            code: "rhino_chain_available",
+            chainId,
+            message: `Rhino serves ${served.name} on ${label(registry, chainId)} but the registry does not claim RHINO there.`,
+        });
+    }
+    return findings;
+}
+// ---------------------------------------------------------------------------
+// NEAR / 1Click — GET https://1click.chaindefuser.com/v0/tokens
+// ---------------------------------------------------------------------------
+function nearAssetId(slug, chainId, address, registryConfig) {
+    const overrides = registryConfig?.["assetIds"];
+    if (overrides && typeof overrides === "object") {
+        const hit = overrides[address];
+        if (typeof hit === "string")
+            return hit;
+    }
+    const nonEvm = identity_1.NEAR_NON_EVM_ASSET_IDS[chainId];
+    if (nonEvm)
+        return nonEvm[address];
+    const lower = address.toLowerCase();
+    if (NATIVE_ADDRESSES.has(lower))
+        return `nep141:${slug}.omft.near`;
+    return `nep141:${slug}-${lower}.omft.near`;
+}
+function declaresNear(token) {
+    return (Array.isArray(token.settlementLayers) &&
+        token.settlementLayers.includes("NEAR"));
+}
+/**
+ * Whether the registry expresses NEAR coverage per token at all.
+ *
+ * Mirrors what the consumer does, which is what makes the two branches below
+ * mean anything: a registry declaring NEAR on no token predates the field, and
+ * the orchestrator then advertises every token on a NEAR-enabled chain — so
+ * every token is a claim and has to be checked as one. Once ANY token declares
+ * NEAR the field is being authored, and a token without it is a decision not to
+ * route, not an absence.
+ */
+function registryDeclaresNearCoverage(registry) {
+    for (const entry of Object.values(registry)) {
+        for (const token of entry.tokens ?? []) {
+            if (declaresNear(token))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * 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.
+ */
+function diffNear(registry, vendor) {
+    const findings = [];
+    const perTokenCoverage = registryDeclaresNearCoverage(registry);
+    const servedSlugs = new Set(vendor.map((token) => token.blockchain));
+    const servedAssetIds = new Set(vendor.map((token) => token.assetId));
+    // 1Click returns NO `contractAddress` for a chain's gas token, while this
+    // registry stores one as a placeholder — so keying both sides on the raw
+    // address never matches a native, and `actual` reads as undefined for every
+    // one of them. That is invisible while the asset id resolves (the id check
+    // short-circuits first) and wrong the moment it stops: a native whose id has
+    // gone stale reports `near_token_dropped` — "1Click does not list it" — when
+    // 1Click does list it under a new id, and the message omits the very id
+    // needed to fix it. Both sides normalise to the same empty-address key.
+    const addressKey = (slug, address) => NATIVE_PLACEHOLDERS.has(address.toLowerCase())
+        ? `${slug}:`
+        : `${slug}:${address.toLowerCase()}`;
+    const bySlugAndAddress = new Map();
+    for (const token of vendor) {
+        const key = `${token.blockchain}:${(token.contractAddress ?? "").toLowerCase()}`;
+        if (!bySlugAndAddress.has(key))
+            bySlugAndAddress.set(key, token);
+    }
+    const slugToChainId = new Map(Object.entries(identity_1.NEAR_CHAIN_SLUGS).map(([id, slug]) => [slug, Number(id)]));
+    const claimed = new Set(claims(registry, "NEAR"));
+    for (const chainId of claimed) {
+        const entry = registry[String(chainId)];
+        const config = readLayerConfig(entry, "NEAR");
+        const slug = pickString(config, "prefix", "slug", "blockchain") ??
+            identity_1.NEAR_CHAIN_SLUGS[chainId];
+        if (!slug) {
+            findings.push({
+                layer: "NEAR",
+                severity: "drift",
+                kind: "mismatch",
+                code: "near_no_slug",
+                chainId,
+                message: `${label(registry, chainId)} claims NEAR but no 1Click blockchain slug is known for it — asset ids cannot be derived.`,
+            });
+            continue;
+        }
+        if (!servedSlugs.has(slug)) {
+            findings.push({
+                layer: "NEAR",
+                severity: "drift",
+                kind: "overclaim",
+                code: "near_blockchain_dropped",
+                chainId,
+                message: `${label(registry, chainId)} claims NEAR but 1Click lists no tokens for blockchain "${slug}".`,
+            });
+            continue;
+        }
+        for (const token of entry?.tokens ?? []) {
+            // The authored id is what the consumer sends, so it is what must be
+            // checked. Deriving here regardless would report drift on a token we
+            // have already corrected, and — worse — would never notice an authored
+            // id going stale, which is the case this check exists for.
+            const expected = token.nearAssetId ?? nearAssetId(slug, chainId, token.address, config);
+            const actual = bySlugAndAddress.get(addressKey(slug, token.address));
+            if (perTokenCoverage && !declaresNear(token)) {
+                // Scoped to tokens the registry already lists: a 1Click asset we carry
+                // no entry for at all is a token-registry question, not NEAR coverage.
+                if (actual === undefined && !(expected && servedAssetIds.has(expected)))
+                    continue;
+                findings.push({
+                    layer: "NEAR",
+                    severity: "info",
+                    kind: "underclaim",
+                    code: "near_token_available",
+                    chainId,
+                    message: `1Click serves ${label(registry, chainId)} ${token.symbol} as ${actual?.assetId ?? expected}, but the registry does not declare NEAR for it.`,
+                });
+                continue;
+            }
+            if (!expected) {
+                findings.push({
+                    layer: "NEAR",
+                    severity: "drift",
+                    kind: "mismatch",
+                    code: "near_asset_id_unmapped",
+                    chainId,
+                    message: `${label(registry, chainId)} ${token.symbol} has no 1Click asset id mapping — a NEAR quote for it throws.`,
+                });
+                continue;
+            }
+            if (servedAssetIds.has(expected))
+                continue;
+            findings.push({
+                layer: "NEAR",
+                severity: "drift",
+                kind: actual ? "mismatch" : "overclaim",
+                code: actual ? "near_asset_id_changed" : "near_token_dropped",
+                chainId,
+                message: actual
+                    ? `${label(registry, chainId)} ${token.symbol} resolves to ${expected} but 1Click serves it as ${actual.assetId}.`
+                    : `${label(registry, chainId)} ${token.symbol} resolves to ${expected}, which 1Click does not list.`,
+            });
+        }
+    }
+    const unmappedSlugs = new Set();
+    for (const slug of servedSlugs) {
+        const chainId = slugToChainId.get(slug);
+        if (chainId === undefined) {
+            unmappedSlugs.add(slug);
+            continue;
+        }
+        if (claimed.has(chainId))
+            continue;
+        if (!registry[String(chainId)])
+            continue;
+        findings.push({
+            layer: "NEAR",
+            severity: "drift",
+            kind: "underclaim",
+            code: "near_chain_available",
+            chainId,
+            message: `1Click serves blockchain "${slug}" on ${label(registry, chainId)} but the registry does not claim NEAR there.`,
+        });
+    }
+    if (unmappedSlugs.size > 0) {
+        findings.push({
+            layer: "NEAR",
+            severity: "info",
+            kind: "note",
+            code: "near_slugs_unmapped",
+            message: `1Click serves ${unmappedSlugs.size} blockchains no chain of ours maps to: ${[...unmappedSlugs].sort().join(", ")}.`,
+        });
+    }
+    return findings;
+}
+// ---------------------------------------------------------------------------
+// CCTP — on-chain, Circle publishes no enumeration endpoint
+// ---------------------------------------------------------------------------
+function diffCctp(registry, probes) {
+    const findings = [];
+    const claimed = new Set(claims(registry, "CCTP"));
+    for (const probe of probes) {
+        const { chainId } = probe;
+        const entry = registry[String(chainId)];
+        const config = readLayerConfig(entry, "CCTP");
+        const expectedDomain = pickNumber(config, "domainId", "domain") ?? identity_1.BASELINE_CCTP_DOMAINS[chainId];
+        if (!probe.reachable) {
+            findings.push({
+                layer: "CCTP",
+                severity: "warning",
+                kind: "note",
+                code: "cctp_rpc_unreachable",
+                chainId,
+                message: `${label(registry, chainId)} not probed — ${probe.error}.`,
+            });
+            continue;
+        }
+        if (!probe.deployed) {
+            if (claimed.has(chainId)) {
+                findings.push({
+                    layer: "CCTP",
+                    severity: "drift",
+                    kind: "overclaim",
+                    code: "cctp_not_deployed",
+                    chainId,
+                    message: `${label(registry, chainId)} claims CCTP but TokenMessengerV2 ${probe.messenger} has no code there.`,
+                });
+            }
+            continue;
+        }
+        // Checked before the claim branch: code at the TokenMessenger address is
+        // only evidence of a Circle deployment if the contract points at the
+        // MessageTransmitter every other chain reports. Without this an unrelated
+        // contract that happens to sit at that address reads as a new CCTP chain.
+        const expectedTransmitter = entry?.network === "testnet"
+            ? identity_1.CCTP_CONTRACTS.testnet.messageTransmitter
+            : identity_1.CCTP_CONTRACTS.mainnet.messageTransmitter;
+        if (!probe.transmitter) {
+            // An unread transmitter is not a confirmed deployment. Falling through
+            // would let an RPC or ABI failure report `cctp_chain_available` on the
+            // strength of code existing at the address, which is exactly what this
+            // check refuses to accept on its own.
+            findings.push({
+                layer: "CCTP",
+                severity: "warning",
+                kind: "note",
+                code: "cctp_transmitter_unreadable",
+                chainId,
+                message: `${label(registry, chainId)} has code at TokenMessengerV2 ${probe.messenger} but localMessageTransmitter() could not be read — deployment unconfirmed, neither claimed nor unclaimed reported.`,
+            });
+            continue;
+        }
+        if (probe.transmitter.toLowerCase() !== expectedTransmitter.toLowerCase()) {
+            findings.push({
+                layer: "CCTP",
+                severity: "drift",
+                kind: "mismatch",
+                code: "cctp_transmitter_changed",
+                chainId,
+                message: `${label(registry, chainId)} localMessageTransmitter() is ${probe.transmitter}, not the ${expectedTransmitter} every other chain reports.`,
+            });
+            continue;
+        }
+        if (!claimed.has(chainId)) {
+            findings.push({
+                layer: "CCTP",
+                severity: "drift",
+                kind: "underclaim",
+                code: "cctp_chain_available",
+                chainId,
+                message: `${label(registry, chainId)} runs TokenMessengerV2 ${probe.messenger} pointing at the canonical transmitter, domain ${probe.domain ?? "?"} — the registry does not claim CCTP there.`,
+            });
+            continue;
+        }
+        if (probe.domain === undefined) {
+            findings.push({
+                layer: "CCTP",
+                severity: "warning",
+                kind: "note",
+                code: "cctp_domain_unreadable",
+                chainId,
+                message: `${label(registry, chainId)} has TokenMessengerV2 but localDomain() could not be read.`,
+            });
+        }
+        else if (expectedDomain === undefined) {
+            findings.push({
+                layer: "CCTP",
+                severity: "drift",
+                kind: "mismatch",
+                code: "cctp_domain_missing",
+                chainId,
+                message: `${label(registry, chainId)} claims CCTP but no domain id is recorded — on-chain says ${probe.domain}.`,
+            });
+        }
+        else if (expectedDomain !== probe.domain) {
+            findings.push({
+                layer: "CCTP",
+                severity: "drift",
+                kind: "mismatch",
+                code: "cctp_domain_mismatch",
+                chainId,
+                message: `${label(registry, chainId)} domain disagrees — we hold ${expectedDomain}, on-chain says ${probe.domain}.`,
+            });
+        }
+    }
+    const probed = new Set(probes.map((probe) => probe.chainId));
+    for (const chainId of claimed) {
+        if (probed.has(chainId))
+            continue;
+        findings.push({
+            layer: "CCTP",
+            severity: "warning",
+            kind: "note",
+            code: "cctp_not_probed",
+            chainId,
+            message: `${label(registry, chainId)} claims CCTP but was not probed (non-EVM chains are out of scope for the on-chain sweep).`,
+        });
+    }
+    return findings;
+}
+// ---------------------------------------------------------------------------
+// Registry self-consistency — chain-level settlementLayers vs per-layer config
+// ---------------------------------------------------------------------------
+const BASELINE_LAYER_CHAINS = {
+    RHINO: identity_1.BASELINE_RHINO_CHAIN_IDS,
+    NEAR: identity_1.BASELINE_NEAR_CHAIN_IDS,
+    CCTP: Object.keys(identity_1.BASELINE_CCTP_DOMAINS).map(Number),
+};
+function diffRegistryConsistency(registry) {
+    const findings = [];
+    for (const layer of ["RHINO", "NEAR", "CCTP"]) {
+        const claimed = new Set(claims(registry, layer));
+        const registryConfigured = chainIds(registry).filter((id) => readLayerConfig(registry[String(id)], layer) !== undefined);
+        const configured = new Set(registryConfigured.length > 0
+            ? registryConfigured
+            : BASELINE_LAYER_CHAINS[layer]);
+        for (const chainId of claimed) {
+            if (configured.has(chainId))
+                continue;
+            findings.push({
+                layer: "REGISTRY",
+                severity: "drift",
+                kind: "mismatch",
+                code: "layer_claimed_without_config",
+                chainId,
+                message: `${label(registry, chainId)} lists ${layer} in settlementLayers but the ${layer} config has no entry for it.`,
+            });
+        }
+        for (const chainId of configured) {
+            if (claimed.has(chainId))
+                continue;
+            findings.push({
+                layer: "REGISTRY",
+                severity: "drift",
+                kind: "mismatch",
+                code: registry[String(chainId)]
+                    ? "layer_config_without_claim"
+                    : "layer_config_for_unknown_chain",
+                chainId,
+                message: registry[String(chainId)]
+                    ? `${label(registry, chainId)} has ${layer} config but does not list ${layer} in settlementLayers.`
+                    : `${layer} config carries chain ${chainId}, which is not in the registry at all.`,
+            });
+        }
+    }
+    return findings;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+export type SettlementLayerName = "RHINO" | "NEAR" | "CCTP";
+export declare const RHINO_CHAIN_NAMES: Record<number, string>;
+export declare const NEAR_CHAIN_SLUGS: Record<number, string>;
+/**
+ * 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.
+ */
+export declare const NEAR_NON_EVM_ASSET_IDS: Record<number, Record<string, string>>;
+/**
+ * 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.
+ */
+export declare const BASELINE_RHINO_BRIDGE_CONTRACTS: Record<number, string>;
+/** Chains the orchestrator's own Rhino map covers, contract or not. */
+export declare const BASELINE_RHINO_CHAIN_IDS: number[];
+/** Chains the orchestrator's own NEAR prefix map covers. */
+export declare const BASELINE_NEAR_CHAIN_IDS: number[];
+export declare const BASELINE_CCTP_DOMAINS: Record<number, number>;
+/**
+ * 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.
+ */
+export declare const CCTP_CONTRACTS: {
+    readonly mainnet: {
+        readonly tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d";
+        readonly messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+    };
+    readonly testnet: {
+        readonly tokenMessenger: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA";
+        readonly messageTransmitter: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275";
+    };
+};
+export declare const RHINO_CONFIGS_URL = "https://api.rhino.fi/bridge/configs";
+export declare const ONECLICK_TOKENS_URL = "https://1click.chaindefuser.com/v0/tokens";