@rhinestone/shared-configs 1.16.0 → 1.18.0

package/dist/scripts/validation.js

@@ -40,6 +40,7 @@ exports.validateChainIconSlugs = validateChainIconSlugs;
 exports.classifyChainPublicRpcUrls = classifyChainPublicRpcUrls;
 exports.classifyChainStacks = classifyChainStacks;
 exports.validateChainConfig = validateChainConfig;
+exports.validateOftCoverage = validateOftCoverage;
 exports.formatValidationIssues = formatValidationIssues;
 const celo_1 = require("viem/celo");
 const viemChains = __importStar(require("viem/chains"));
@@ -93,6 +94,87 @@ const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
 const isNonEmptyString = (v) => typeof v === 'string' && v.length > 0;
 const isNonNegativeInt = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
 const isAbsentOr = (v, check) => v === undefined || check(v);
+// Every vendor layer's REQUIRED payload, keyed by the SettlementLayer value
+// that switches it on. This is what replaces the chain-id allowlists the
+// jsonnet used to carry with "must match <map> in the orchestrator" comments —
+// nothing enforced those, and they had drifted. A layer declared without the
+// identifiers needed to address it is a route we advertise and then cannot
+// take, so it fails the build rather than the fill.
+const SETTLEMENT_CONFIG_SCHEMA = {
+    RHINO: { key: 'rhino', required: { chainName: isNonEmptyString } },
+    CCTP: { key: 'cctp', required: { domain: isNonNegativeInt } },
+    NEAR: { key: 'near', required: { prefix: isNonEmptyString } },
+    OFT: {
+        key: 'oft',
+        required: { adapter: isNonEmptyString, layerZeroEid: isNonNegativeInt },
+    },
+};
+// Optional payload fields, shape-checked only when present. `bridgeContract` is
+// absent for a destination-only chain, which nothing originates from.
+const SETTLEMENT_CONFIG_OPTIONAL = {
+    rhino: { bridgeContract: isNonEmptyString },
+};
+const SETTLEMENT_CONFIG_KEYS = new Set(Object.values(SETTLEMENT_CONFIG_SCHEMA).map((entry) => entry.key));
+/**
+ * Cross-checks `settlementConfig` against `settlementLayers`.
+ *
+ * Both directions matter. A layer with no payload is unaddressable; a payload
+ * for a layer that is off is a route someone believes is live — the producer
+ * emits neither, so either means the derivation broke.
+ */
+function settlementConfigProblems(chain) {
+    const problems = [];
+    const config = chain.settlementConfig;
+    if (config !== undefined && !isObject(config)) {
+        return ['settlementConfig is not an object'];
+    }
+    const cfg = (config ?? {});
+    const layers = new Set(Array.isArray(chain.settlementLayers)
+        ? chain.settlementLayers.filter((l) => typeof l === 'string')
+        : []);
+    for (const key of Object.keys(cfg)) {
+        if (!SETTLEMENT_CONFIG_KEYS.has(key)) {
+            problems.push(`settlementConfig has unknown layer ${JSON.stringify(key)} — add it to SETTLEMENT_CONFIG_SCHEMA and to SettlementConfig in src/types.ts`);
+        }
+    }
+    for (const [layer, { key, required }] of Object.entries(SETTLEMENT_CONFIG_SCHEMA)) {
+        const payload = cfg[key];
+        if (!layers.has(layer)) {
+            if (payload !== undefined) {
+                problems.push(`settlementConfig.${key} is present but ${layer} is not in settlementLayers`);
+            }
+            continue;
+        }
+        if (!isObject(payload)) {
+            problems.push(`settlementLayers contains ${layer} but settlementConfig.${key} is missing`);
+            continue;
+        }
+        for (const [field, check] of Object.entries(required)) {
+            if (!check(payload[field])) {
+                problems.push(`settlementConfig.${key}.${field} ${JSON.stringify(payload[field])} is invalid — ${layer} cannot be addressed without it`);
+            }
+        }
+        for (const [field, check] of Object.entries(SETTLEMENT_CONFIG_OPTIONAL[key] ?? {})) {
+            if (!isAbsentOr(payload[field], check)) {
+                problems.push(`settlementConfig.${key}.${field} is invalid`);
+            }
+        }
+    }
+    // A non-EVM chain's 1Click asset ids are not derivable from the on-chain
+    // address, so every token on one has to carry its own. Missing it is not a
+    // degraded route: `toNearAssetId` throws mid-plan.
+    if (layers.has('NEAR') &&
+        typeof chain.vmType === 'string' &&
+        chain.vmType !== 'evm' &&
+        Array.isArray(chain.tokens)) {
+        for (const token of chain.tokens) {
+            if (isObject(token) && !isNonEmptyString(token.nearAssetId)) {
+                problems.push(`token ${JSON.stringify(token.symbol)} has no nearAssetId, which a non-EVM NEAR chain cannot derive`);
+            }
+        }
+    }
+    return problems;
+}
 /**
  * Structural checks on one chain entry, returning human-readable problems.
  *
@@ -196,6 +278,10 @@ function structuralProblems(chain) {
             }
             if (!isAbsentOr(token.priceSymbol, isNonEmptyString))
                 problems.push(`${at}.priceSymbol is not a string`);
+            if (!isAbsentOr(token.rhinoSymbol, isNonEmptyString))
+                problems.push(`${at}.rhinoSymbol is not a string`);
+            if (!isAbsentOr(token.nearAssetId, isNonEmptyString))
+                problems.push(`${at}.nearAssetId is not a string`);
             if (!isAbsentOr(token.unpriced, (v) => typeof v === 'boolean'))
                 problems.push(`${at}.unpriced is not a boolean`);
             if (!isAbsentOr(token.pegGroup, (v) => PEG_GROUPS.has(v))) {
@@ -218,6 +304,7 @@ function structuralProblems(chain) {
             }
         }
     }
+    problems.push(...settlementConfigProblems(chain));
     const quoterConfig = chain.swapQuoterConfig;
     if (quoterConfig !== undefined) {
         if (!isObject(quoterConfig)) {
@@ -885,6 +972,56 @@ function validateChainConfig(chains) {
         hasErrors: issues.some((issue) => issue.severity === 'error'),
     };
 }
+/**
+ * Insists that every chain the OFT registry deploys on declares OFT.
+ *
+ * The chain block states the membership and reads the adapter and endpoint id
+ * back out of config/oft.jsonnet, so the two can only disagree one way: a
+ * deployment added to the OFT registry whose chain block was never given an
+ * `oft` entry. That chain silently stops advertising OFT, which is invisible in
+ * a diff of either file on its own — this is the check that sees both.
+ */
+function validateOftCoverage(chains, oft) {
+    const issues = [];
+    const expected = new Map();
+    for (const registry of Object.values(oft)) {
+        if (!isObject(registry) || !isObject(registry.adapters))
+            continue;
+        for (const [chainId, adapter] of Object.entries(registry.adapters)) {
+            if (typeof adapter === 'string')
+                expected.set(chainId, adapter);
+        }
+    }
+    for (const [chainId, adapter] of expected) {
+        const chain = chains[chainId];
+        if (!chain)
+            continue;
+        const chainName = isNonEmptyString(chain.name) ? chain.name : '<unnamed>';
+        const config = isObject(chain.settlementConfig)
+            ? chain.settlementConfig.oft
+            : undefined;
+        if (!Array.isArray(chain.settlementLayers) || !chain.settlementLayers.includes('OFT')) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: 'config/oft.jsonnet deploys an OFT adapter here, but the chain declares no OFT layer — add `oft: oftLayer.forChain(<chain_id>)` to its supported_settlement_layers',
+            });
+            continue;
+        }
+        if (!isObject(config) ||
+            typeof config.adapter !== 'string' ||
+            config.adapter.toLowerCase() !== adapter.toLowerCase()) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: `settlementConfig.oft.adapter ${JSON.stringify(config?.adapter)} does not match config/oft.jsonnet's ${JSON.stringify(adapter)}`,
+            });
+        }
+    }
+    return issues;
+}
 /**
  * Formats validation issues for console output.
  *

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[];