@rhinestone/shared-configs 1.15.0 → 1.17.0

package/dist/scripts/__tests__/validation.test.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const bun_test_1 = require("bun:test");
 const validation_1 = require("../validation");
 const index_1 = require("../../src/index");
+const oft_json_1 = __importDefault(require("../../configs/oft.json"));
 const nativeToken = { address: "0x0", symbol: "ETH", decimals: 18 };
 /** A structurally complete entry, so semantic tests don't trip structural checks. */
 function validChain(overrides = {}) {
@@ -147,6 +151,119 @@ function errorsFor(chain) {
         (0, bun_test_1.expect)(result.hasErrors).toBe(false);
     });
 });
+// These replace the "must match <map> in the orchestrator" comments the jsonnet
+// used to carry over four flat chain-id allowlists. A layer advertised without
+// the identifiers that address it is a route offered and then not taken, so the
+// build is the only place left to catch it.
+(0, bun_test_1.describe)("validateChainConfig — settlementConfig", () => {
+    const withLayer = (layer, config) => validChain({
+        settlementLayers: ["RELAY", layer],
+        settlementConfig: config,
+    });
+    bun_test_1.it.each([
+        ["RHINO", "rhino", { chainName: "ETHEREUM" }],
+        ["CCTP", "cctp", { domain: 0 }],
+        ["NEAR", "near", { prefix: "eth" }],
+        ["OFT", "oft", { adapter: "0xadapter", layerZeroEid: 30101 }],
+    ])("accepts %s with its payload", (layer, key, payload) => {
+        (0, bun_test_1.expect)(errorsFor(withLayer(layer, { [key]: payload }))).toEqual([]);
+    });
+    bun_test_1.it.each([
+        ["RHINO", "rhino"],
+        ["CCTP", "cctp"],
+        ["NEAR", "near"],
+        ["OFT", "oft"],
+    ])("rejects %s declared with no payload", (layer, key) => {
+        const errors = errorsFor(withLayer(layer, {}));
+        (0, bun_test_1.expect)(errors).toHaveLength(1);
+        (0, bun_test_1.expect)(errors[0].message).toContain(`settlementConfig.${key} is missing`);
+    });
+    bun_test_1.it.each([
+        ["RHINO", { rhino: {} }, "rhino.chainName"],
+        ["CCTP", { cctp: { domain: "0" } }, "cctp.domain"],
+        ["NEAR", { near: { prefix: "" } }, "near.prefix"],
+        ["OFT", { oft: { adapter: "0xa" } }, "oft.layerZeroEid"],
+    ])("rejects %s whose payload is incomplete", (layer, config, field) => {
+        const errors = errorsFor(withLayer(layer, config));
+        (0, bun_test_1.expect)(errors.some((e) => e.message.includes(field))).toBe(true);
+    });
+    // Domain 0 is Ethereum, so a truthiness check would drop a real route.
+    (0, bun_test_1.it)("accepts CCTP domain 0", () => {
+        (0, bun_test_1.expect)(errorsFor(withLayer("CCTP", { cctp: { domain: 0 } }))).toEqual([]);
+    });
+    // Absent for a destination-only chain, which nothing originates from.
+    (0, bun_test_1.it)("accepts a rhino entry with no bridgeContract", () => {
+        (0, bun_test_1.expect)(errorsFor(withLayer("RHINO", { rhino: { chainName: "SOLANA" } }))).toEqual([]);
+    });
+    (0, bun_test_1.it)("rejects a payload for a layer that is not enabled", () => {
+        const errors = errorsFor(validChain({ settlementConfig: { cctp: { domain: 6 } } }));
+        (0, bun_test_1.expect)(errors).toHaveLength(1);
+        (0, bun_test_1.expect)(errors[0].message).toContain("CCTP is not in settlementLayers");
+    });
+    (0, bun_test_1.it)("rejects an unknown layer key", () => {
+        const errors = errorsFor(validChain({ settlementConfig: { hop: {} } }));
+        (0, bun_test_1.expect)(errors).toHaveLength(1);
+        (0, bun_test_1.expect)(errors[0].message).toContain("unknown layer");
+    });
+    // 1Click's non-EVM ids are NEAR-internal; deriving one produces a string it
+    // rejects, so a missing id throws mid-plan rather than degrading.
+    (0, bun_test_1.it)("rejects a non-EVM NEAR chain whose token has no nearAssetId", () => {
+        const errors = errorsFor(validChain({
+            vmType: "svm",
+            settlementLayers: ["RELAY", "NEAR"],
+            settlementConfig: { near: { prefix: "sol" } },
+            tokens: [{ ...nativeToken, balanceSlot: null, approvalSlot: null }],
+        }));
+        (0, bun_test_1.expect)(errors).toHaveLength(1);
+        (0, bun_test_1.expect)(errors[0].message).toContain("nearAssetId");
+    });
+    (0, bun_test_1.it)("does not require nearAssetId on an EVM NEAR chain", () => {
+        (0, bun_test_1.expect)(errorsFor(validChain({
+            settlementLayers: ["RELAY", "NEAR"],
+            settlementConfig: { near: { prefix: "eth" } },
+        }))).toEqual([]);
+    });
+});
+// The chain block states OFT membership and reads its addresses back out of
+// config/oft.jsonnet, so the one way the two can disagree is an adapter added
+// there whose chain block was never given an `oft` entry — invisible in a diff
+// of either file alone.
+(0, bun_test_1.describe)("validateOftCoverage", () => {
+    (0, bun_test_1.it)("accepts the real generated registry", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateOftCoverage)(index_1.chainRegistry, oft_json_1.default)).toEqual([]);
+    });
+    (0, bun_test_1.it)("reports a chain with an adapter but no OFT layer", () => {
+        const issues = (0, validation_1.validateOftCoverage)({ "1": validChain() }, {
+            USDT0: { adapters: { "1": "0xadapter" } },
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("declares no OFT layer");
+    });
+    (0, bun_test_1.it)("reports an adapter the chain entry disagrees with", () => {
+        const chain = validChain({
+            settlementLayers: ["RELAY", "OFT"],
+            settlementConfig: { oft: { adapter: "0xstale", layerZeroEid: 30101 } },
+        });
+        const issues = (0, validation_1.validateOftCoverage)({ "1": chain }, {
+            USDT0: { adapters: { "1": "0xadapter" } },
+        });
+        (0, bun_test_1.expect)(issues).toHaveLength(1);
+        (0, bun_test_1.expect)(issues[0].message).toContain("does not match");
+    });
+    // The registry is authored in checksummed hex; the chain block is not.
+    (0, bun_test_1.it)("compares adapters case-insensitively", () => {
+        const chain = validChain({
+            settlementLayers: ["RELAY", "OFT"],
+            settlementConfig: { oft: { adapter: "0xABC", layerZeroEid: 30101 } },
+        });
+        (0, bun_test_1.expect)((0, validation_1.validateOftCoverage)({ "1": chain }, {
+            USDT0: { adapters: { "1": "0xabc" } },
+        })).toEqual([]);
+    });
+    (0, bun_test_1.it)("ignores an OFT chain that is not in the registry", () => {
+        (0, bun_test_1.expect)((0, validation_1.validateOftCoverage)({}, { USDT0: { adapters: { "1": "0xa" } } })).toEqual([]);
+    });
+});
 (0, bun_test_1.describe)("formatValidationIssues", () => {
     (0, bun_test_1.it)("returns empty string for no issues", () => {
         (0, bun_test_1.expect)((0, validation_1.formatValidationIssues)({ issues: [], hasErrors: false })).toBe("");

package/dist/scripts/generate.js

@@ -89,7 +89,7 @@ function renderChains(chainRegistry, mainnets, testnets) {
     }
     return [
         "// Auto-generated by scripts/generate.ts. Do not edit manually.",
-        'import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";',
+        'import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementConfig, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";',
         "",
         "interface Token {",
         "  /** EVM: 0x-prefixed hex. SVM: base58 SPL mint. TVM: base58 (T-prefixed). */",
@@ -102,6 +102,11 @@ function renderChains(chainRegistry, mainnets, testnets) {
         "  approvalSlot: number | null;",
         "  /** Bridge layers that can carry this token on this chain, when known. */",
         "  settlementLayers?: SettlementLayer[];",
+        "  /** Rhino's own symbol for this token, where it differs from ours. */",
+        "  rhinoSymbol?: string;",
+        "  /** NEAR 1Click asset id, for tokens whose id 1Click does not derive from",
+        "   *  the on-chain address (non-EVM chains). */",
+        "  nearAssetId?: string;",
         "  unpriced?: boolean;",
         "}",
         "",
@@ -150,6 +155,10 @@ function renderChains(chainRegistry, mainnets, testnets) {
         "  wrappedNativeToken: NativeToken;",
         "  tokens: Token[];",
         "  settlementLayers: SettlementLayer[];",
+        "  /** Per-vendor addressing for the enabled layers that need it (Rhino chain",
+        "   *  name, CCTP domain, NEAR prefix, OFT adapter). Third-party addresses —",
+        "   *  never the contracts block, which is read as Rhinestone-deployed. */",
+        "  settlementConfig?: SettlementConfig;",
         "  providers: ProviderName[];",
         "  swapQuoters: SwapQuoter[];",
         "  swapQuoterConfig?: Partial<Record<SwapQuoter, SwapQuoterConfig>>;",
@@ -412,6 +421,10 @@ async function generate() {
     // to insist on. A chain added without one would otherwise reach production as
     // a blank tile, which nothing anywhere reports.
     const iconSlugIssues = (0, validation_1.validateChainIconSlugs)(classifiedChains);
+    // The one check that needs both files: a chain block declares OFT membership
+    // and reads its addresses back out of the OFT registry, so only an adapter
+    // added there without the matching chain entry can drift.
+    const oftCoverageIssues = (0, validation_1.validateOftCoverage)(classifiedChains, output.oft);
     const classificationIssues = [
         ...networkIssues,
         ...stackIssues,
@@ -419,6 +432,7 @@ async function generate() {
         ...explorerIssues,
         ...publicRpcUrlIssues,
         ...iconSlugIssues,
+        ...oftCoverageIssues,
     ];
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "chains.json"), `${JSON.stringify(classifiedChains, null, 2)}\n`);
     await (0, promises_1.writeFile)(node_path_1.default.join(configsDir, "mainnets.json"), `${JSON.stringify(output.mainnets, null, 2)}\n`);

package/dist/scripts/validation.d.ts

@@ -215,6 +215,16 @@ export declare function classifyChainStacks(chains: ChainRegistry, networks: {
  * - Single-layer fragility: chains with exactly one settlement layer (warning)
  */
 export declare function validateChainConfig(chains: ChainRegistry): ValidationResult;
+/**
+ * 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.
+ */
+export declare function validateOftCoverage(chains: ChainRegistry, oft: Record<string, unknown>): ValidationIssue[];
 /**
  * Formats validation issues for console output.
  *

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/src/chains.d.ts

@@ -1,4 +1,4 @@
-import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";
+import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementConfig, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";
 interface Token {
     /** EVM: 0x-prefixed hex. SVM: base58 SPL mint. TVM: base58 (T-prefixed). */
     address: string;
@@ -10,6 +10,11 @@ interface Token {
     approvalSlot: number | null;
     /** Bridge layers that can carry this token on this chain, when known. */
     settlementLayers?: SettlementLayer[];
+    /** Rhino's own symbol for this token, where it differs from ours. */
+    rhinoSymbol?: string;
+    /** NEAR 1Click asset id, for tokens whose id 1Click does not derive from
+     *  the on-chain address (non-EVM chains). */
+    nearAssetId?: string;
     unpriced?: boolean;
 }
 interface NativeToken {
@@ -58,6 +63,10 @@ interface Chain {
     wrappedNativeToken: NativeToken;
     tokens: Token[];
     settlementLayers: SettlementLayer[];
+    /** Per-vendor addressing for the enabled layers that need it (Rhino chain
+     *  name, CCTP domain, NEAR prefix, OFT adapter). Third-party addresses —
+     *  never the contracts block, which is read as Rhinestone-deployed. */
+    settlementConfig?: SettlementConfig;
     providers: ProviderName[];
     swapQuoters: SwapQuoter[];
     swapQuoterConfig?: Partial<Record<SwapQuoter, SwapQuoterConfig>>;