@rhinestone/shared-configs 2.0.0 → 2.1.0

package/dist/scripts/validation.js

@@ -42,6 +42,7 @@ exports.classifyChainStacks = classifyChainStacks;
 exports.validateChainConfig = validateChainConfig;
 exports.validateOftCoverage = validateOftCoverage;
 exports.formatValidationIssues = formatValidationIssues;
+const viem_1 = require("viem");
 const celo_1 = require("viem/celo");
 const viemChains = __importStar(require("viem/chains"));
 const op_stack_1 = require("viem/op-stack");
@@ -72,12 +73,17 @@ const SWAP_QUOTERS = new Set([
 ]);
 const VM_TYPES = new Set(['evm', 'svm', 'tvm']);
 const PEG_GROUPS = new Set(['USD', 'ETH']);
+const TOKEN_AUTHORIZATION_STANDARDS = new Set([
+    'erc3009',
+    'erc2612',
+]);
 const NETWORKS = new Set(['mainnet', 'testnet']);
 const STACKS = new Set(['op-stack', 'zksync', 'celo', 'vanilla']);
 // Registry keys are chain ids consumers index by directly, so they must be
 // canonical positive integers — no leading zeros, which would let "01" and "1"
 // both address chain 1.
 const CHAIN_ID_KEY = /^[1-9][0-9]*$/;
+const BYTES32 = /^0x[0-9a-fA-F]{64}$/;
 // CAIP-2 (https://chainagnostic.org/CAIPs/caip-2): `<namespace>:<reference>`.
 //
 // Deliberately shape-only — the namespace set is not ours to close, and a chain
@@ -183,7 +189,7 @@ function settlementConfigProblems(chain) {
  * only sanity-check the envelope, so this is the single place a malformed
  * registry gets caught before it reaches anyone.
  */
-function structuralProblems(chain) {
+function structuralProblems(registryChainId, chain) {
     const problems = [];
     if (!isNonEmptyString(chain.name))
         problems.push('name is not a non-empty string');
@@ -241,6 +247,28 @@ function structuralProblems(chain) {
     if (!isAbsentOr(chain.virtual, (v) => typeof v === 'boolean')) {
         problems.push('virtual is not a boolean');
     }
+    // Required, and each vendor's key required within it: `null` says the vendor
+    // was checked and does not serve this chain, which is the answer a consumer
+    // acts on when it decides the chain cannot take deposits. An absent key is a
+    // different claim — an artifact older than the field — and letting the two
+    // look alike is exactly the silent gap this field exists to close.
+    if (!isObject(chain.providerIds)) {
+        problems.push('providerIds is missing (use null per vendor for a chain it does not serve)');
+    }
+    else {
+        for (const vendor of ['alchemy', 'zerion']) {
+            const id = chain.providerIds[vendor];
+            if (!(vendor in chain.providerIds)) {
+                problems.push(`providerIds.${vendor} is missing (use null if the vendor does not serve this chain)`);
+            }
+            else if (id !== null && !isNonEmptyString(id)) {
+                problems.push(`providerIds.${vendor} ${JSON.stringify(id)} is not a non-empty string or null`);
+            }
+        }
+    }
+    if (typeof chain.sessionCapable !== 'boolean') {
+        problems.push('sessionCapable is not a boolean');
+    }
     for (const field of ['nativeToken', 'wrappedNativeToken']) {
         const token = chain[field];
         if (!isObject(token)) {
@@ -287,6 +315,95 @@ function structuralProblems(chain) {
             if (!isAbsentOr(token.pegGroup, (v) => PEG_GROUPS.has(v))) {
                 problems.push(`${at}.pegGroup ${JSON.stringify(token.pegGroup)} is not a known peg group`);
             }
+            const authorization = token.authorization;
+            if (authorization !== undefined) {
+                if (chain.vmType !== 'evm') {
+                    problems.push(`${at}.authorization is only valid for EVM tokens`);
+                }
+                if (chain.virtual === true) {
+                    problems.push(`${at}.authorization is not valid on a virtual chain; use the settlement chain's token`);
+                }
+                if (!isObject(authorization)) {
+                    problems.push(`${at}.authorization is not an object`);
+                }
+                else {
+                    const standards = authorization.standards;
+                    if (!Array.isArray(standards) || standards.length === 0) {
+                        problems.push(`${at}.authorization.standards is not a non-empty array`);
+                    }
+                    else {
+                        const seen = new Set();
+                        for (const standard of standards) {
+                            if (!TOKEN_AUTHORIZATION_STANDARDS.has(standard)) {
+                                problems.push(`${at}.authorization.standards contains unknown value ${JSON.stringify(standard)}`);
+                            }
+                            else if (seen.has(standard)) {
+                                problems.push(`${at}.authorization.standards contains duplicate value ${JSON.stringify(standard)}`);
+                            }
+                            if (typeof standard === 'string')
+                                seen.add(standard);
+                        }
+                    }
+                    const domain = authorization.domain;
+                    if (!isObject(domain)) {
+                        problems.push(`${at}.authorization.domain is not an object`);
+                    }
+                    else {
+                        const verifyingContract = domain.verifyingContract;
+                        if (!isNonEmptyString(domain.name)) {
+                            problems.push(`${at}.authorization.domain.name is not a non-empty string`);
+                        }
+                        if (!isNonEmptyString(domain.version)) {
+                            problems.push(`${at}.authorization.domain.version is not a non-empty string`);
+                        }
+                        if (typeof verifyingContract !== 'string' ||
+                            !(0, viem_1.isAddress)(verifyingContract)) {
+                            problems.push(`${at}.authorization.domain.verifyingContract is not an EVM address`);
+                        }
+                        else if (typeof token.address === 'string' &&
+                            verifyingContract.toLowerCase() !== token.address.toLowerCase()) {
+                            problems.push(`${at}.authorization.domain.verifyingContract does not match the token address`);
+                        }
+                        const hasChainId = domain.chainId !== undefined;
+                        const hasSalt = domain.salt !== undefined;
+                        if (hasChainId === hasSalt) {
+                            problems.push(`${at}.authorization.domain must contain exactly one of chainId or salt`);
+                        }
+                        if (hasChainId) {
+                            if (!isNonNegativeInt(domain.chainId)) {
+                                problems.push(`${at}.authorization.domain.chainId is not a non-negative integer`);
+                            }
+                            else if (domain.chainId !== Number(registryChainId)) {
+                                problems.push(`${at}.authorization.domain.chainId does not match registry chain ${registryChainId}`);
+                            }
+                        }
+                        if (hasSalt && !BYTES32.test(String(domain.salt))) {
+                            problems.push(`${at}.authorization.domain.salt is not a bytes32 hex value`);
+                        }
+                        const pinnedSeparator = String(authorization.domainSeparator);
+                        if (!BYTES32.test(pinnedSeparator)) {
+                            problems.push(`${at}.authorization.domainSeparator is not a bytes32 hex value`);
+                        }
+                        else if (isNonEmptyString(domain.name) &&
+                            isNonEmptyString(domain.version) &&
+                            typeof verifyingContract === 'string' &&
+                            (0, viem_1.isAddress)(verifyingContract) &&
+                            hasChainId !== hasSalt &&
+                            (!hasChainId || isNonNegativeInt(domain.chainId)) &&
+                            (!hasSalt || BYTES32.test(String(domain.salt)))) {
+                            const derived = (0, viem_1.domainSeparator)({
+                                domain: domain,
+                            });
+                            if (derived.toLowerCase() !== pinnedSeparator.toLowerCase()) {
+                                problems.push(`${at}.authorization.domainSeparator does not match the declared EIP-712 domain`);
+                            }
+                        }
+                    }
+                    if (typeof authorization.eoaOnly !== 'boolean') {
+                        problems.push(`${at}.authorization.eoaOnly is not a boolean`);
+                    }
+                }
+            }
         });
     }
     for (const [field, allowed] of [
@@ -936,7 +1053,7 @@ function validateChainConfig(chains) {
             });
             continue;
         }
-        for (const problem of structuralProblems(chain)) {
+        for (const problem of structuralProblems(chainId, chain)) {
             issues.push({ severity: 'error', chainId, chainName, message: problem });
         }
         // Virtual chains (HyperCore) are reachable via their settlement chain, not

package/dist/src/chains.d.ts

@@ -1,4 +1,4 @@
-import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementConfig, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";
+import type { ChainNetwork, ChainStack, PegGroup, ProviderIds, ProviderName, SettlementConfig, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, TokenAuthorization, VmType } from "./types";
 interface Token {
     /** EVM: 0x-prefixed hex. SVM: base58 SPL mint. TVM: base58 (T-prefixed). */
     address: string;
@@ -8,6 +8,8 @@ interface Token {
     pegGroup?: PegGroup;
     balanceSlot: number | null;
     approvalSlot: number | null;
+    /** Token-native EIP-712 authorization support, when verified. */
+    authorization?: TokenAuthorization;
     /** 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. */
@@ -67,6 +69,13 @@ interface Chain {
      *  name, CCTP domain, NEAR prefix, OFT adapter). Third-party addresses —
      *  never the contracts block, which is read as Rhinestone-deployed. */
     settlementConfig?: SettlementConfig;
+    /** What the deposit-ingestion vendors call this chain. `null` means the
+     *  vendor was checked and does not serve it; both null means the chain
+     *  cannot take deposits. */
+    providerIds: ProviderIds;
+    /** Whether we open smart sessions here — a declared policy, not a
+     *  statement about what is deployed. */
+    sessionCapable: boolean;
     providers: ProviderName[];
     swapQuoters: SwapQuoter[];
     swapQuoterConfig?: Partial<Record<SwapQuoter, SwapQuoterConfig>>;