@rhinestone/shared-configs 1.9.0 → 1.10.1

package/dist/scripts/validation.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyChainNetworks = classifyChainNetworks;
+exports.classifyChainCaip2 = classifyChainCaip2;
+exports.classifyChainExplorers = classifyChainExplorers;
 exports.classifyChainStacks = classifyChainStacks;
 exports.validateChainConfig = validateChainConfig;
 exports.formatValidationIssues = formatValidationIssues;
@@ -72,6 +74,18 @@ const STACKS = new Set(['op-stack', 'zksync', 'celo', 'vanilla']);
 // canonical positive integers — no leading zeros, which would let "01" and "1"
 // both address chain 1.
 const CHAIN_ID_KEY = /^[1-9][0-9]*$/;
+// CAIP-2 (https://chainagnostic.org/CAIPs/caip-2): `<namespace>:<reference>`.
+//
+// Deliberately shape-only — the namespace set is not ours to close, and a chain
+// arriving under a namespace this build has never heard of is a new chain, not
+// a malformed one.
+//
+// Deliberately looser than the spec on namespace length too. CAIP-2 caps it at
+// 8 characters; `hypercore` is 9, and that spelling is canonical for us across
+// the orchestrator, the SDK and deposit-service. Tightening this to the spec
+// would fail the build on our own established id, so the bound is the org's,
+// not the spec's.
+const CAIP2 = /^[-a-z0-9]{3,16}:[-_a-zA-Z0-9]{1,32}$/;
 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;
@@ -107,8 +121,26 @@ function structuralProblems(chain) {
     if (!STACKS.has(chain.stack)) {
         problems.push(`stack ${JSON.stringify(chain.stack)} is not one of ${[...STACKS].join(', ')}`);
     }
-    if (!isAbsentOr(chain.caip2, isNonEmptyString))
-        problems.push('caip2 is not a string');
+    // Same deal as `network` and `stack` for EVM chains, where it is derived
+    // rather than authored — but unlike those two it is authored in the jsonnet
+    // for every chain whose id is not an EIP-155 one. Required either way: it is
+    // the id consumers key a chain by on the wire, and until it was always
+    // present each of them re-derived `eip155:<id>` for itself.
+    if (!CAIP2.test(chain.caip2)) {
+        problems.push(`caip2 ${JSON.stringify(chain.caip2)} is not a "<namespace>:<reference>" identifier`);
+    }
+    // Nullable, but the key has to be present: `null` is the answer for a chain
+    // with no explorer, and absent is not an answer at all. Stamped by
+    // classifyChainExplorers rather than authored for most chains, and checked
+    // here for the same reason as `network` and `stack` — this is the gate the
+    // published artifact passes through, and `ChainEntry` types consumers as
+    // though the key is always there.
+    if (!('explorer' in chain)) {
+        problems.push('explorer is missing (use null for a chain with no explorer)');
+    }
+    else if (chain.explorer !== null && !isChainExplorer(chain.explorer)) {
+        problems.push(`explorer ${JSON.stringify(chain.explorer)} is not null or { url (no trailing slash), addressPath, txPath (both slash-wrapped) }`);
+    }
     if (!isAbsentOr(chain.virtual, (v) => typeof v === 'boolean')) {
         problems.push('virtual is not a boolean');
     }
@@ -288,6 +320,185 @@ function classifyChainNetworks(chains, mainnets, testnets) {
     }
     return { chains: classified, issues };
 }
+/**
+ * Stamps every chain with its canonical CAIP-2 id, deriving `eip155:<chainId>`
+ * for the chains that do not declare one.
+ *
+ * Why this exists: `caip2` was authored only for the chains whose id is not an
+ * EIP-155 one (Solana, Tron, HyperCore), so every consumer that wanted a CAIP-2
+ * id had to carry the same `entry.caip2 ?? \`eip155:${id}\`` fallback — the
+ * orchestrator, deposit-service, the SDK and the indexers each had their own.
+ * A fallback repeated in five places is a rule with five chances to drift, and
+ * the one place it is genuinely load-bearing (HyperCore, whose `eip155:1337`
+ * spelling is wrong) is exactly where getting it wrong is silent.
+ *
+ * Derived rather than authored per chain for the same reason `network` is: an
+ * EVM chain's CAIP-2 id is a restatement of its chain id, so authoring it would
+ * only create a second copy that could disagree with the first.
+ *
+ * Uniqueness is checked because `chainIdFromCaip2` is a reverse lookup over this
+ * field — two chains sharing an id makes that lookup silently return whichever
+ * came first.
+ */
+function classifyChainCaip2(chains) {
+    const issues = [];
+    const classified = {};
+    const seen = new Map();
+    for (const [chainId, chain] of Object.entries(chains)) {
+        const chainName = isNonEmptyString(chain?.name)
+            ? chain.name
+            : '<unnamed>';
+        const declared = chain?.caip2;
+        // A malformed declaration is left exactly as authored rather than replaced
+        // with the derived form: quietly publishing `eip155:1337` for HyperCore is
+        // the precise mistake this field exists to prevent, so the structural check
+        // reports the real value instead.
+        if (declared !== undefined && !(typeof declared === 'string' && CAIP2.test(declared))) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: `declares a malformed caip2 ${JSON.stringify(declared)} — expected "<namespace>:<reference>"`,
+            });
+            classified[chainId] = withSortedKeys({ ...chain });
+            continue;
+        }
+        // A real EVM chain — and only a real EVM chain — has an id that is
+        // definitionally `eip155:<chainId>`. Everything else is addressed by an id
+        // the registry key cannot express, so its caip2 has to be authored.
+        const derivable = chain.vmType === 'evm' && chain.virtual !== true;
+        const derived = `eip155:${chainId}`;
+        // Deriving for a non-EVM or virtual entry would hand it an `eip155:` id that
+        // is confidently wrong — the same failure as HyperCore's `eip155:1337`,
+        // reintroduced by the very thing meant to prevent it. So the next svm/tvm or
+        // virtual chain added without an authored caip2 fails the build here rather
+        // than reaching the artifact under a wire id nothing uses.
+        if (declared === undefined && !derivable) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: `is ${chain.virtual === true ? 'a virtual chain' : `vmType ${JSON.stringify(chain.vmType)}`} and must author its caip2 — only a non-virtual EVM chain can derive ${JSON.stringify(derived)} from its registry key`,
+            });
+            classified[chainId] = withSortedKeys({ ...chain });
+            continue;
+        }
+        const caip2 = declared === undefined ? derived : declared;
+        // Conversely, a declaration that disagrees with the derivable form is a typo
+        // rather than an override.
+        if (declared !== undefined && derivable && declared !== derived) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: `declares caip2 ${JSON.stringify(declared)} but is a non-virtual EVM chain, whose canonical id is ${JSON.stringify(derived)}`,
+            });
+        }
+        const collision = seen.get(caip2);
+        if (collision !== undefined) {
+            issues.push({
+                severity: 'error',
+                chainId,
+                chainName,
+                message: `resolves to caip2 ${JSON.stringify(caip2)}, which chain ${collision} already uses — a reverse lookup cannot tell them apart`,
+            });
+        }
+        else {
+            seen.set(caip2, chainId);
+        }
+        classified[chainId] = withSortedKeys({ ...chain, caip2 });
+    }
+    return { chains: classified, issues };
+}
+// Near-universal across EVM explorers (Etherscan, Blockscout and the -scan
+// forks all use these). Tronscan is the exception, and authors its own.
+const DEFAULT_ADDRESS_PATH = '/address/';
+const DEFAULT_TX_PATH = '/tx/';
+// The slash convention is enforced, not assumed: a link is built by plain
+// concatenation, so a path missing its leading slash or a url carrying a
+// trailing one produces a subtly wrong URL rather than an obviously broken one.
+function isChainExplorer(value) {
+    const hasSlashes = (v) => typeof v === 'string' && /^\/.*\/$/.test(v);
+    return (isObject(value) &&
+        typeof value.url === 'string' &&
+        value.url.length > 0 &&
+        !value.url.endsWith('/') &&
+        hasSlashes(value.addressPath) &&
+        hasSlashes(value.txPath));
+}
+/**
+ * Stamps every chain with its block explorer, derived from the chain's viem
+ * definition where it has one and authored in the jsonnet where it does not.
+ *
+ * Resolved by the entry's declared `viemChain` **name**, never by chain id. A
+ * lookup by id is actively wrong here: viem's chain 1337 is `localhost`, so
+ * HyperCore — whose registry key is 1337 — would silently inherit Localhost's
+ * metadata. That is the same mistake as addressing HyperCore by `eip155:1337`,
+ * arrived at from the other direction.
+ *
+ * A missing explorer is not an error. It resolves to `null`, which consumers
+ * render as plain text instead of a link; the cost of not knowing one is a
+ * missing hyperlink, not a wrong answer. It is still worth a warning, because
+ * the usual cause is a chain added without one rather than a chain that
+ * genuinely has none.
+ */
+function classifyChainExplorers(chains, networks) {
+    const issues = [];
+    const stamped = {};
+    const entriesById = new Map();
+    for (const entry of [...networks.mainnets, ...networks.testnets]) {
+        entriesById.set(String(entry.id), entry);
+    }
+    for (const [chainId, chain] of Object.entries(chains)) {
+        const chainName = isNonEmptyString(chain?.name)
+            ? chain.name
+            : '<unnamed>';
+        const authored = chain?.explorer;
+        // Authoring wins outright, unlike `stack` where viem's definition is what
+        // the consumer actually uses. An explorer is presentation: the jsonnet is
+        // the only place a non-default path (Tronscan's `/#/address/`) or a
+        // preferred explorer among several can be expressed.
+        if (authored !== undefined) {
+            if (!isChainExplorer(authored)) {
+                issues.push({
+                    severity: 'error',
+                    chainId,
+                    chainName,
+                    message: `declares a malformed explorer ${JSON.stringify(authored)} — expected { url, addressPath, txPath }`,
+                });
+                stamped[chainId] = withSortedKeys({ ...chain });
+                continue;
+            }
+            stamped[chainId] = withSortedKeys({ ...chain, explorer: authored });
+            continue;
+        }
+        const viemChainName = entriesById.get(chainId)?.viemChain;
+        const url = viemChainName
+            ? viemChains[viemChainName]?.blockExplorers?.default?.url
+            : undefined;
+        if (typeof url !== 'string' || url.length === 0) {
+            issues.push({
+                severity: 'warning',
+                chainId,
+                chainName,
+                message: viemChainName
+                    ? `viem chain "${viemChainName}" ships no block explorer — links will render as plain text until one is authored`
+                    : 'has no viemChain to derive a block explorer from and authors none — links will render as plain text',
+            });
+            stamped[chainId] = withSortedKeys({ ...chain, explorer: null });
+            continue;
+        }
+        stamped[chainId] = withSortedKeys({
+            ...chain,
+            explorer: {
+                url: url.replace(/\/+$/, ''),
+                addressPath: DEFAULT_ADDRESS_PATH,
+                txPath: DEFAULT_TX_PATH,
+            },
+        });
+    }
+    return { chains: stamped, issues };
+}
 const isChainStack = (v) => typeof v === 'string' && STACKS.has(v);
 const STACK_FORMATTERS = [
     ['op-stack', op_stack_1.chainConfig.formatters],

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

@@ -49,9 +49,19 @@ function bumpedVersion() {
     const [major, minor, patch] = packageVersion_1.PACKAGE_VERSION.split("-")[0].split(".");
     return `${major}.${minor}.${Number(patch) + 1}`;
 }
+// Must produce a genuinely older version for every PACKAGE_VERSION, including
+// the `x.y.0` releases where decrementing the patch has nowhere to go — clamping
+// to 0 there returned PACKAGE_VERSION itself, which the client accepts as the
+// steady state, so the staleness tests asserted the opposite of what they read.
 function olderVersion() {
-    const [major, minor, patch] = packageVersion_1.PACKAGE_VERSION.split("-")[0].split(".");
-    return `${major}.${minor}.${Math.max(0, Number(patch) - 1)}`;
+    const [major, minor, patch] = packageVersion_1.PACKAGE_VERSION.split("-")[0]
+        .split(".")
+        .map(Number);
+    if (patch > 0)
+        return `${major}.${minor}.${patch - 1}`;
+    if (minor > 0)
+        return `${major}.${minor - 1}.0`;
+    return `${major - 1}.0.0`;
 }
 function withEthereum(overrides) {
     return {

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

@@ -30,10 +30,16 @@ const TRON_CAIP2 = "tron:mainnet";
             (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)(SOLANA_CAIP2)).toBe(index_1.MainnetNetwork.SOLANA);
             (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)(TRON_CAIP2)).toBe(index_1.MainnetNetwork.TRON);
         });
-        (0, bun_test_1.it)("returns undefined for unknown / eip155 caip2 strings", () => {
-            // eip155 references are not registry-backed; callers parse them numerically.
-            (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("eip155:1")).toBeUndefined();
+        (0, bun_test_1.it)("resolves eip155 caip2 strings, now that every entry carries one", () => {
+            (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("eip155:1")).toBe(index_1.MainnetNetwork.ETHEREUM);
+            (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("eip155:999")).toBe(index_1.MainnetNetwork.HYPEREVM);
+        });
+        (0, bun_test_1.it)("returns undefined for ids no chain uses", () => {
+            // 1337 is HyperCore's *registry key*, but its caip2 is `hypercore:mainnet`
+            // — so the eip155 spelling resolves to nothing, which is the point of
+            // reading the field instead of deriving it.
             (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("eip155:1337")).toBeUndefined();
+            (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("eip155:999999999")).toBeUndefined();
             (0, bun_test_1.expect)((0, index_1.chainIdFromCaip2)("hypercore:testnet")).toBeUndefined();
         });
     });

package/dist/src/chainVirtualization.d.ts

@@ -9,17 +9,19 @@ export declare function isNonEvmChainId(chainId: number): boolean;
  */
 export declare function getNonEvmChainIds(): number[];
 /**
- * Canonical CAIP-2 string for a chain id. Returns the registry-declared
- * `caip2` when present (non-EVM entries today), otherwise falls back to the
- * `eip155:<chainId>` form. Throws nothing — returns the fallback for any
- * unknown id so callers don't need to special-case absent entries.
+ * Canonical CAIP-2 string for a chain id, read straight off the registry —
+ * every entry carries one (see `classifyChainCaip2`). Falls back to the
+ * `eip155:<chainId>` form for an id the registry does not know, so callers
+ * don't need to special-case an absent entry.
  */
 export declare function getCaip2(chainId: number): string;
 /**
- * Reverse lookup — find the numeric chain id whose registry-declared
- * `caip2` matches the input, or `undefined` if no entry has it. EVM chains
- * (which omit `caip2` in the registry) are NOT covered by this lookup;
- * callers parse `eip155:N` references on their own.
+ * Reverse lookup — the numeric chain id addressed by a CAIP-2 string, or
+ * `undefined` if no registry entry uses it.
+ *
+ * Covers every chain, EVM included: `caip2` is present on all entries, and the
+ * generator rejects two chains resolving to the same one, so this is
+ * unambiguous.
  */
 export declare function chainIdFromCaip2(caip2: string): number | undefined;
 //# sourceMappingURL=chainVirtualization.d.ts.map

package/dist/src/chainVirtualization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainVirtualization.d.ts","sourceRoot":"","sources":["../../src/chainVirtualization.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAiB,MAAM,EAAE,MAAM,SAAS,CAAC;AAIrD,mEAAmE;AACnE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAI5C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKlE"}
+{"version":3,"file":"chainVirtualization.d.ts","sourceRoot":"","sources":["../../src/chainVirtualization.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAiB,MAAM,EAAE,MAAM,SAAS,CAAC;AAIrD,mEAAmE;AACnE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAI5C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKlE"}

package/dist/src/chainVirtualization.js

@@ -44,22 +44,21 @@ function getNonEvmChainIds() {
         .map(([id]) => Number(id));
 }
 /**
- * Canonical CAIP-2 string for a chain id. Returns the registry-declared
- * `caip2` when present (non-EVM entries today), otherwise falls back to the
- * `eip155:<chainId>` form. Throws nothing — returns the fallback for any
- * unknown id so callers don't need to special-case absent entries.
+ * Canonical CAIP-2 string for a chain id, read straight off the registry —
+ * every entry carries one (see `classifyChainCaip2`). Falls back to the
+ * `eip155:<chainId>` form for an id the registry does not know, so callers
+ * don't need to special-case an absent entry.
  */
 function getCaip2(chainId) {
-    const entry = chainRegistry[String(chainId)];
-    if (entry?.caip2)
-        return entry.caip2;
-    return `eip155:${chainId}`;
+    return chainRegistry[String(chainId)]?.caip2 ?? `eip155:${chainId}`;
 }
 /**
- * Reverse lookup — find the numeric chain id whose registry-declared
- * `caip2` matches the input, or `undefined` if no entry has it. EVM chains
- * (which omit `caip2` in the registry) are NOT covered by this lookup;
- * callers parse `eip155:N` references on their own.
+ * Reverse lookup — the numeric chain id addressed by a CAIP-2 string, or
+ * `undefined` if no registry entry uses it.
+ *
+ * Covers every chain, EVM included: `caip2` is present on all entries, and the
+ * generator rejects two chains resolving to the same one, so this is
+ * unambiguous.
  */
 function chainIdFromCaip2(caip2) {
     for (const [id, entry] of Object.entries(chainRegistry)) {

package/dist/src/chains.d.ts

@@ -18,6 +18,14 @@ interface NativeToken {
     symbol: string;
     decimals: number;
 }
+interface Explorer {
+    /** Origin, no trailing slash. */
+    url: string;
+    /** Path to an address page, with both slashes (`/address/`). */
+    addressPath: string;
+    /** Path to a transaction page, with both slashes (`/tx/`). */
+    txPath: string;
+}
 interface Chain {
     name: string;
     vmType: VmType;
@@ -25,8 +33,11 @@ interface Chain {
     network: ChainNetwork;
     /** Execution stack, for consumers that must synthesise a viem `Chain`. */
     stack: ChainStack;
-    /** CAIP-2 chain identifier; populated for non-eip155 chains only. */
-    caip2?: string;
+    /** CAIP-2 chain identifier. Present on every chain: authored for the
+     *  non-eip155 ones, derived as `eip155:<chainId>` for the rest. */
+    caip2: string;
+    /** Block explorer, or null for a chain that has none (render plain text). */
+    explorer: Explorer | null;
     /** True for virtual chains (e.g. HyperCore) that settle on another chain. */
     virtual?: boolean;
     nativeToken: NativeToken;
@@ -39,5 +50,5 @@ interface Chain {
 }
 declare const chains: Record<SupportedChain, Chain>;
 export { chains };
-export type { Chain, Token, NativeToken };
+export type { Chain, Token, NativeToken, Explorer };
 //# sourceMappingURL=chains.d.ts.map

package/dist/src/chains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../src/chains.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEvJ,UAAU,KAAK;IACb,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,WAAW;IACnB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,OAAO,EAAE,YAAY,CAAC;IACtB,0EAA0E;IAC1E,KAAK,EAAE,UAAU,CAAC;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,kBAAkB,EAAE,WAAW,CAAC;IAChC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC;CAClE;AAED,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CA2iDzC,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../src/chains.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEvJ,UAAU,KAAK;IACb,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,WAAW;IACnB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,QAAQ;IAChB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,OAAO,EAAE,YAAY,CAAC;IACtB,0EAA0E;IAC1E,KAAK,EAAE,UAAU,CAAC;IAClB;uEACmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,kBAAkB,EAAE,WAAW,CAAC;IAChC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC;CAClE;AAED,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CAwrDzC,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC"}