@rhinestone/shared-configs 1.7.16 → 1.8.0

package/dist/src/chainFactsClient.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChainFactsClient = createChainFactsClient;
+const chains_json_1 = __importDefault(require("../configs/chains.json"));
+const chainFactsKey_1 = require("./generated/chainFactsKey");
+const packageVersion_1 = require("./generated/packageVersion");
+const bundledChainRegistry = chains_json_1.default;
+const DEFAULT_FETCH_TIMEOUT_MS = 5_000;
+const BUNDLED_SNAPSHOT = {
+    chains: bundledChainRegistry,
+    source: "bundled",
+    version: null,
+};
+// 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]*$/;
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Enough to tell chain facts from some other JSON that happens to be keyed by
+// chain id (the mainnets/providers blobs are, so a misconfigured URL would
+// otherwise be accepted), and no more.
+//
+// Exhaustive field and enum validation runs once at build time, in yeet's
+// generator (scripts/validation.ts), where the data and the type unions ship in
+// the same version. Repeating it here would be both redundant and wrong: an
+// unknown settlement layer at build time means the unions need updating, but at
+// read time it just means an older consumer is reading a newer artifact, which
+// has to keep working — that's the whole point of the project. Integrity and
+// provenance are the artifact signature's job.
+function looksLikeChainEntry(value) {
+    return (isObject(value) &&
+        typeof value.name === "string" &&
+        Array.isArray(value.tokens));
+}
+function isChainRegistry(value) {
+    if (!isObject(value))
+        return false;
+    const entries = Object.entries(value);
+    return (entries.length > 0 &&
+        entries.every(([id, entry]) => CHAIN_ID_KEY.test(id) && looksLikeChainEntry(entry)));
+}
+// Both sides are release versions produced by the same pipeline, so a numeric
+// x.y.z comparison is enough; a pre-release suffix (-alpha.N) is ignored, since
+// pre-release tags never publish to the facts CDN.
+//
+// Returns false when either version is unparseable rather than treating it as
+// stale: an odd version string is a pipeline bug to observe, not a reason to
+// stop taking chain updates, and the signature already establishes provenance.
+function isOlderRelease(candidate, baseline) {
+    const parse = (v) => {
+        const parts = v.split("-")[0].split(".");
+        if (parts.length !== 3)
+            return null;
+        const nums = parts.map((p) => Number(p));
+        return nums.every((n) => Number.isInteger(n) && n >= 0) ? nums : null;
+    };
+    const a = parse(candidate);
+    const b = parse(baseline);
+    if (!a || !b)
+        return false;
+    for (let i = 0; i < 3; i += 1) {
+        if (a[i] !== b[i])
+            return a[i] < b[i];
+    }
+    return false;
+}
+// ── Signature verification ───────────────────────────────────────────────────
+const P256_COORDINATE_BYTES = 32;
+function base64ToBytes(base64) {
+    // atob, not Buffer: available in browsers, Node >= 16, Bun and Deno alike.
+    const binary = atob(base64.replace(/\s+/g, ""));
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes;
+}
+/**
+ * Converts a DER/ASN.1 ECDSA signature to the fixed-width r‖s form WebCrypto
+ * requires.
+ *
+ * KMS `Sign` with ECDSA_SHA_256 returns DER — `30 <len> 02 <rlen> r 02 <slen> s`,
+ * ~70-72 bytes and variable — while `crypto.subtle.verify` expects exactly 64
+ * bytes of raw r‖s for P-256. Passing DER through does NOT throw; it just
+ * returns false for every signature. So this conversion is the difference
+ * between a working verifier and one that silently rejects every legitimate
+ * artifact (confirmed empirically before writing it).
+ *
+ * Each INTEGER is minimally encoded and signed, so r/s may carry a leading 0x00
+ * when the high bit is set, or be shorter than 32 bytes when leading zeroes were
+ * dropped. Both normalise to a left-padded 32 bytes.
+ */
+function derToRawEcdsaSignature(der) {
+    let offset = 0;
+    const nextByte = () => {
+        if (offset >= der.length)
+            throw new Error("signature truncated");
+        return der[offset++];
+    };
+    if (nextByte() !== 0x30)
+        throw new Error("signature is not a DER SEQUENCE");
+    // Sequence length: short form, or long form (0x80 | number-of-length-bytes).
+    let sequenceLength = nextByte();
+    if (sequenceLength & 0x80) {
+        const lengthBytes = sequenceLength & 0x7f;
+        sequenceLength = 0;
+        for (let i = 0; i < lengthBytes; i += 1) {
+            sequenceLength = (sequenceLength << 8) | nextByte();
+        }
+    }
+    if (offset + sequenceLength !== der.length) {
+        throw new Error("DER sequence length does not match signature length");
+    }
+    const readCoordinate = () => {
+        if (nextByte() !== 0x02)
+            throw new Error("expected a DER INTEGER");
+        const length = nextByte();
+        if (offset + length > der.length) {
+            throw new Error("DER INTEGER overruns the signature");
+        }
+        let bytes = der.subarray(offset, offset + length);
+        offset += length;
+        while (bytes.length > 0 && bytes[0] === 0x00)
+            bytes = bytes.subarray(1);
+        if (bytes.length > P256_COORDINATE_BYTES) {
+            throw new Error("DER INTEGER wider than the P-256 coordinate size");
+        }
+        const padded = new Uint8Array(P256_COORDINATE_BYTES);
+        padded.set(bytes, P256_COORDINATE_BYTES - bytes.length);
+        return padded;
+    };
+    const r = readCoordinate();
+    const s = readCoordinate();
+    const raw = new Uint8Array(P256_COORDINATE_BYTES * 2);
+    raw.set(r, 0);
+    raw.set(s, P256_COORDINATE_BYTES);
+    return raw;
+}
+async function verifyArtifactSignature(publicKeyBase64, signatureBase64, payloadBytes) {
+    const key = await crypto.subtle.importKey("spki", base64ToBytes(publicKeyBase64), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    return crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, derToRawEcdsaSignature(base64ToBytes(signatureBase64)), payloadBytes);
+}
+/**
+ * Reads chain facts remote-first, falling back to the registry bundled with
+ * this package at publish time. Reads never throw — a failed or malformed
+ * fetch leaves the previous tier in place, so callers always get a usable
+ * registry. `getSnapshot().source` reports which tier served it, so consumers
+ * can alert on having run bundled for longer than expected.
+ */
+function createChainFactsClient(options = {}) {
+    const { onError } = options;
+    // Explicit null means "disable"; omitted (or undefined) means "take the
+    // published default". `??` alone cannot express that — it treats null and
+    // undefined alike — so null is checked first.
+    const remoteUrl = options.remoteUrl === null
+        ? null
+        : (options.remoteUrl ?? chainFactsKey_1.CHAIN_FACTS_LATEST_URL);
+    const publicKey = options.publicKey === null
+        ? null
+        : (options.publicKey ?? chainFactsKey_1.CHAIN_FACTS_PUBLIC_KEY);
+    const fetchTimeoutMs = options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    let snapshot = BUNDLED_SNAPSHOT;
+    // A caller's logging hook must never break the never-throws contract.
+    function report(error, phase) {
+        try {
+            onError?.(error, phase);
+        }
+        catch (hookError) {
+            console.error("[chainFactsClient] onError callback threw", hookError);
+        }
+    }
+    async function fetchRemote() {
+        if (!remoteUrl)
+            return null;
+        if (!publicKey) {
+            // Fail closed rather than reading unverified: the payload checks are only
+            // structural, so without a key there is nothing establishing that these
+            // facts came from the release pipeline.
+            report(new Error("remoteUrl is set but publicKey is not — refusing to read chain facts unverified; serving bundled"), "config");
+            return null;
+        }
+        // The timeout must cover the body reads as well as the headers — otherwise a
+        // remote that stalls mid-body is unbounded.
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+        let payloadBytes;
+        let signatureBase64;
+        try {
+            const get = async (url) => {
+                const response = await fetch(url, { signal: controller.signal });
+                if (!response.ok) {
+                    throw new Error(`chain facts fetch failed for ${url}: ${response.status} ${response.statusText}`);
+                }
+                return response;
+            };
+            // Detached signature, fetched in parallel with the artifact it covers.
+            const [payloadResponse, signatureResponse] = await Promise.all([
+                get(remoteUrl),
+                get(`${remoteUrl}.sig`),
+            ]);
+            payloadBytes = new Uint8Array(await payloadResponse.arrayBuffer());
+            signatureBase64 = await signatureResponse.text();
+        }
+        catch (error) {
+            report(error, "fetch");
+            return null;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        // Verify before parsing, over the exact bytes served. Nothing downstream
+        // touches the payload until the signature checks out.
+        try {
+            const verified = await verifyArtifactSignature(publicKey, signatureBase64, payloadBytes);
+            if (!verified)
+                throw new Error("signature did not verify");
+        }
+        catch (error) {
+            report(error, "verify");
+            return null;
+        }
+        let body;
+        try {
+            body = JSON.parse(new TextDecoder().decode(payloadBytes));
+        }
+        catch (error) {
+            report(error, "parse");
+            return null;
+        }
+        if (!isObject(body) ||
+            typeof body.version !== "string" ||
+            !isChainRegistry(body.chains)) {
+            report(new Error("chain facts payload has no version or an unusable chains registry"), "parse");
+            return null;
+        }
+        // A signature proves provenance, not freshness: a previous release's
+        // artifact stays validly signed forever. So if the CDN publish fails while
+        // the npm publish succeeds, a consumer that bumps gets a bundled registry
+        // newer than `latest.json` — and a valid remote snapshot would otherwise
+        // override it, hiding the change behind a *successful* read.
+        //
+        // Compared by VERSION, not by chain-id set: an artifact can carry every
+        // chain id and still be older, because a facts change is often a new token,
+        // quoter, or native-token detail on an EXISTING chain. Both versions come
+        // from the same release pipeline — the artifact version IS the package
+        // version — so comparing them is meaningful rather than an assumption about
+        // arbitrary strings. Equal is accepted: that is the steady state.
+        const chains = body.chains;
+        if (isOlderRelease(body.version, packageVersion_1.PACKAGE_VERSION)) {
+            report(new Error(`chain facts ${body.version} is older than this package's bundled registry (${packageVersion_1.PACKAGE_VERSION}) — treating as stale and keeping bundled data`), "stale");
+            return null;
+        }
+        return { version: body.version, chains };
+    }
+    async function fetchAndInstall() {
+        const payload = await fetchRemote();
+        if (!payload)
+            return false;
+        snapshot = {
+            chains: payload.chains,
+            source: "remote",
+            version: payload.version,
+        };
+        return true;
+    }
+    // Concurrent refreshes share one fetch. Without this, overlapping calls can
+    // install out of order — A reads v1, B reads v2 and installs it, then A
+    // resolves and puts v1 back — which would hide a newly added chain from a
+    // running service until some later refresh happened to win. A periodic timer
+    // plus an on-demand refresh is enough to hit that, so it is not theoretical.
+    // Serialising also avoids fetching the same artifact twice.
+    //
+    // This orders installs within a process; it does not make the artifact
+    // monotonic across CloudFront edges, where a later read can legitimately
+    // return an older `latest.json`. That is inherent to a CDN and self-corrects
+    // on the next refresh; ruling it out would need an ordering assumption about
+    // version strings that the format does not currently guarantee.
+    let inFlight = null;
+    return {
+        refresh() {
+            if (!inFlight) {
+                inFlight = fetchAndInstall().finally(() => {
+                    inFlight = null;
+                });
+            }
+            return inFlight;
+        },
+        getSnapshot: () => snapshot,
+        getChainRegistry: () => snapshot.chains,
+    };
+}

package/dist/src/chains.d.ts

@@ -1,4 +1,4 @@
-import type { PegGroup, ProviderName, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";
+import type { ChainNetwork, ChainStack, PegGroup, ProviderName, SettlementLayer, SupportedChain, SwapQuoter, SwapQuoterConfig, VmType } from "./types";
 interface Token {
     /** EVM: 0x-prefixed hex. SVM: base58 SPL mint. TVM: base58 (T-prefixed). */
     address: string;
@@ -19,6 +19,10 @@ interface NativeToken {
 interface Chain {
     name: string;
     vmType: VmType;
+    /** Whether this chain is a mainnet or a testnet. */
+    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;
     /** True for virtual chains (e.g. HyperCore) that settle on another chain. */

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,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE7H,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,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,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,CAuyCzC,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,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,CAw1CzC,CAAC;AAEF,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC"}

package/dist/src/chains.js

@@ -9,6 +9,7 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -18,6 +19,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -79,6 +81,7 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -88,6 +91,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "op-stack",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -157,6 +161,7 @@ const chains = {
             "decimals": 18,
             "symbol": "BNB"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -164,6 +169,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "1inch",
             "0x",
@@ -215,11 +221,13 @@ const chains = {
             "decimals": 18,
             "symbol": "XDAI"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "RELAY",
             "NEAR",
             "RHINO"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "1inch",
             "velora"
@@ -253,6 +261,7 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -261,6 +270,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "op-stack",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -322,6 +332,7 @@ const chains = {
             "decimals": 18,
             "symbol": "POL"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -331,6 +342,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -384,11 +396,13 @@ const chains = {
             "decimals": 18,
             "symbol": "MON"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "RELAY",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "0x"
         ],
@@ -443,12 +457,14 @@ const chains = {
             "decimals": 18,
             "symbol": "S"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ECO",
             "RELAY",
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -483,12 +499,14 @@ const chains = {
             "decimals": 18,
             "symbol": "HYPE"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
             "RELAY",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "0x"
         ],
@@ -531,7 +549,9 @@ const chains = {
             "decimals": 18,
             "symbol": "HYPE"
         },
+        "network": "mainnet",
         "settlementLayers": [],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -559,10 +579,12 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "RELAY"
         ],
+        "stack": "op-stack",
         "swapQuoters": [],
         "tokens": [
             {
@@ -617,10 +639,12 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "RELAY"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "1inch",
             "0x"
@@ -670,6 +694,7 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -678,6 +703,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "op-stack",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -729,6 +755,7 @@ const chains = {
             "decimals": 18,
             "symbol": "XPL"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -736,9 +763,11 @@ const chains = {
             "OFT",
             "RHINO"
         ],
+        "stack": "vanilla",
         "swapQuoterConfig": {},
         "swapQuoters": [
-            "0x"
+            "0x",
+            "fynd"
         ],
         "tokens": [
             {
@@ -770,9 +799,11 @@ const chains = {
             "decimals": 18,
             "symbol": "XPL"
         },
+        "network": "testnet",
         "settlementLayers": [
             "ECO"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -812,6 +843,7 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
@@ -821,6 +853,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoterConfig": {},
         "swapQuoters": [
             "1inch",
@@ -882,6 +915,7 @@ const chains = {
             "decimals": 18,
             "symbol": "AVAX"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "ACROSS",
             "RELAY",
@@ -889,6 +923,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [
             "1inch",
             "0x",
@@ -955,11 +990,13 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "testnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
             "CCTP"
         ],
+        "stack": "op-stack",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1016,11 +1053,13 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "testnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1067,10 +1106,12 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "RELAY",
             "RHINO"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1127,11 +1168,13 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "testnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1178,11 +1221,13 @@ const chains = {
             "decimals": 18,
             "symbol": "ETH"
         },
+        "network": "testnet",
         "settlementLayers": [
             "ACROSS",
             "ECO",
             "CCTP"
         ],
+        "stack": "op-stack",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1230,12 +1275,14 @@ const chains = {
             "decimals": 6,
             "symbol": "TRX"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "RELAY",
             "OFT",
             "NEAR",
             "RHINO"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {
@@ -1270,6 +1317,7 @@ const chains = {
             "decimals": 9,
             "symbol": "SOL"
         },
+        "network": "mainnet",
         "settlementLayers": [
             "RELAY",
             "OFT",
@@ -1277,6 +1325,7 @@ const chains = {
             "RHINO",
             "CCTP"
         ],
+        "stack": "vanilla",
         "swapQuoters": [],
         "tokens": [
             {