@gibs/bridge-sdk 1.13.1 → 1.18.0

package/dist/cjs/quote-fees.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalQuoteCostUsd = exports.lifiQuoteFees = exports.relayQuoteFees = void 0;
+/**
+ * What a consolidated route actually charges, normalized across the aggregators.
+ *
+ * WHY THIS EXISTS. A quote used to carry `fromAmount` and nothing else about
+ * cost, so the interface could show the reader only the omnibridge crossing fee
+ * — a figure that is real, and on a twenty-five dollar transfer is a rounding
+ * error beside what the aggregator takes. Measured on one live route on
+ * 2026-09-01: Relay charged 1.466338 USD Coin, or 5.54%, and none of it
+ * appeared anywhere on screen.
+ *
+ * THE FLAG THAT MATTERS IS `includedInFromAmount`. The two providers express
+ * cost differently, and the difference is not cosmetic:
+ *
+ *   Relay folds everything into `fromAmount`. You send 26.466338 to receive
+ *   25.000000, and the 1.466338 difference IS the fee.
+ *
+ *   LI.FI does not. On the same route it quoted `fromAmount` 25.317074 and a
+ *   SEPARATE LayerZero fee of 0.000561734871157119 ether — about 1.37 dollars —
+ *   marked `included: false`, which the sender pays on top in native currency.
+ *
+ * So comparing the two on `fromAmount` alone reads LI.FI as more than a dollar
+ * cheaper when it is in fact slightly dearer. Anything that ranks or displays
+ * cost has to add the charges that sit outside `fromAmount`, and that is what
+ * this flag is for.
+ */
+const asRecord = (value) => typeof value === 'object' && value !== null ? value : null;
+const asNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : null;
+/**
+ * Reads a provider's currency block into a token descriptor.
+ *
+ * Returns null rather than filling in defaults: a charge whose token is unknown
+ * cannot be formatted, and inventing eighteen decimals for it would print a
+ * number wrong by many orders of magnitude.
+ */
+const feeToken = (value) => {
+    const currency = asRecord(value);
+    const decimals = asNumber(currency?.decimals);
+    const chainId = asNumber(currency?.chainId);
+    if (typeof currency?.symbol !== 'string' || decimals === null || chainId === null) {
+        return null;
+    }
+    return { symbol: currency.symbol, decimals, chainId };
+};
+/** Parses a provider's amount string, dropping a charge that is zero or unreadable. */
+const feeAmount = (value) => {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return null;
+    }
+    try {
+        // Relay reports "0.0" for an unused fee slot, which BigInt rejects; a
+        // fractional string here is always zero in practice, and a charge we cannot
+        // read exactly is one we must not display.
+        const amount = BigInt(String(value).split('.')[0] ?? '');
+        return amount > 0n ? amount : null;
+    }
+    catch {
+        return null;
+    }
+};
+const usdOf = (value) => typeof value === 'string' || typeof value === 'number' ? String(value) : null;
+/**
+ * The charges Relay reports, in the order a reader meets them.
+ *
+ * `fees.relayer` IS DELIBERATELY SKIPPED. It is the sum of `relayerGas` and
+ * `relayerService`, so listing it beside them would count the same money twice
+ * and make the breakdown disagree with the amount the sender pays.
+ *
+ * `fees.gas` is the sender's OWN origin-chain transaction cost. It sits outside
+ * `fromAmount` because the wallet pays it directly, which is exactly the case
+ * `includedInFromAmount` exists to mark.
+ * @param payload - the raw body from Relay's quote endpoint
+ * @returns the charges, in display order
+ */
+const relayQuoteFees = (payload) => {
+    const fees = asRecord(asRecord(payload)?.fees);
+    if (!fees) {
+        return [];
+    }
+    const rows = [
+        { key: 'relayerGas', label: 'Destination network cost', kind: 'gas', included: true },
+        { key: 'relayerService', label: 'Relay service fee', kind: 'service', included: true },
+        { key: 'app', label: 'Referral fee', kind: 'integrator', included: true },
+        { key: 'gas', label: 'Origin network cost', kind: 'gas', included: false },
+    ];
+    return rows.flatMap(({ key, label, kind, included }) => {
+        const node = asRecord(fees[key]);
+        const amount = feeAmount(node?.amount);
+        const token = feeToken(node?.currency);
+        if (amount === null || token === null) {
+            return [];
+        }
+        return [
+            {
+                kind,
+                label,
+                amount,
+                token,
+                amountUsd: usdOf(node?.amountUsd),
+                includedInFromAmount: included,
+            },
+        ];
+    });
+};
+exports.relayQuoteFees = relayQuoteFees;
+/**
+ * The charges LI.FI reports.
+ *
+ * `feeCosts` CARRIES ITS OWN `included` FLAG and it is the whole point of
+ * reading this: a fee marked `included: false` is paid on top of `fromAmount`,
+ * in that fee's own token, and on a live route it was worth more than a dollar.
+ * `gasCosts` is the sender's own origin transaction and is never included.
+ * @param payload - the raw body from LI.FI's quote endpoint
+ * @returns the charges, in display order
+ */
+const lifiQuoteFees = (payload) => {
+    const estimate = asRecord(asRecord(payload)?.estimate);
+    if (!estimate) {
+        return [];
+    }
+    const feeCosts = Array.isArray(estimate.feeCosts) ? estimate.feeCosts : [];
+    const gasCosts = Array.isArray(estimate.gasCosts) ? estimate.gasCosts : [];
+    const fromFeeCosts = feeCosts.flatMap((entry) => {
+        const fee = asRecord(entry);
+        const amount = feeAmount(fee?.amount);
+        const token = feeToken(fee?.token);
+        if (amount === null || token === null) {
+            return [];
+        }
+        return [
+            {
+                kind: 'service',
+                label: typeof fee?.name === 'string' ? fee.name : 'Provider fee',
+                amount,
+                token,
+                amountUsd: usdOf(fee?.amountUSD),
+                // Absent is treated as NOT included. A fee we wrongly call included
+                // disappears from the total and understates the route; one we wrongly
+                // call excluded overstates it. Overstating is the safe direction.
+                includedInFromAmount: fee?.included === true,
+            },
+        ];
+    });
+    const fromGasCosts = gasCosts.flatMap((entry) => {
+        const gas = asRecord(entry);
+        const amount = feeAmount(gas?.amount);
+        const token = feeToken(gas?.token);
+        if (amount === null || token === null) {
+            return [];
+        }
+        return [
+            {
+                kind: 'gas',
+                label: 'Origin network cost',
+                amount,
+                token,
+                amountUsd: usdOf(gas?.amountUSD),
+                includedInFromAmount: false,
+            },
+        ];
+    });
+    return [...fromFeeCosts, ...fromGasCosts];
+};
+exports.lifiQuoteFees = lifiQuoteFees;
+/**
+ * What the route costs the sender all in, in United States dollars.
+ *
+ * `fromAmount` already contains every charge marked included, so only the ones
+ * marked otherwise are added. This is the figure two providers must be compared
+ * on: ranking them on `fromAmount` alone picked LI.FI over Relay by more than a
+ * dollar on a route where LI.FI was in fact the dearer of the two, because its
+ * LayerZero fee is charged outside the amount.
+ *
+ * Returns null when the input's own dollar value is unknown — a partial total
+ * would rank routes against each other on different bases.
+ * @param quote.fromAmountUsd - the provider's dollar value for the input amount
+ * @param quote.fees - the route's charges
+ * @returns the all-in dollar cost, or null when it cannot be totalled
+ */
+const totalQuoteCostUsd = ({ fromAmountUsd, fees, }) => {
+    if (fromAmountUsd === null) {
+        return null;
+    }
+    const base = Number(fromAmountUsd);
+    if (!Number.isFinite(base)) {
+        return null;
+    }
+    return fees.reduce((total, fee) => {
+        if (fee.includedInFromAmount) {
+            return total;
+        }
+        const value = Number(fee.amountUsd);
+        // A charge outside the amount whose dollar value we cannot read is left out
+        // rather than guessed. It is named in the breakdown either way, so the
+        // reader still sees it even when the total cannot count it.
+        return Number.isFinite(value) ? total + value : total;
+    }, base);
+};
+exports.totalQuoteCostUsd = totalQuoteCostUsd;

package/dist/cjs/referral.d.ts

@@ -0,0 +1,85 @@
+import type { Hex } from 'viem';
+/**
+ * Referral configuration — the one place to set who gets paid.
+ *
+ * This module exists so the payout address is a single named edit rather than a
+ * constant buried among API urls. It deliberately imports nothing but a type, so
+ * the interface can read the address without pulling in a quote builder.
+ */
+/**
+ * Gibs Finance's own integrator identifier with LI.FI and Relay. LI.FI pays its
+ * integrator share against this string — the payout account is configured on
+ * LI.FI's side, which is why LI.FI needs no address here and Relay does.
+ *
+ * This is Gibs Finance's identity, not a setting for other consumers. The
+ * Relay API key that used to live beside it moved into the Gibs interface's
+ * own configuration (`packages/ui/src/lib/config.ts`): this package ships no
+ * key. Pass your own identifiers on each request — see the README.
+ */
+export declare const referralIntegrator = "gibs.finance";
+/**
+ * Resolves one attribution field (a LI.FI `integrator`, a Relay `referrer`)
+ * from a caller's override and this package's default for it.
+ *
+ * Three states, not two:
+ * - `undefined` (left out): the package default — which may itself be
+ *   `undefined`, meaning the field is not sent.
+ * - `null`: the field is OMITTED from the request. Never sent as `''`: Relay
+ *   reads any `referrer`, an empty one included, as "a referrer was supplied".
+ * - a string: sent as-is.
+ *
+ * @param override - the caller's value for the field
+ * @param packageDefault - the value used when the caller leaves the field out
+ * @returns the value to send, or undefined to omit the field
+ */
+export declare const resolveAttribution: (override: string | null | undefined, packageDefault: string | undefined) => string | undefined;
+/**
+ * Gibs Finance's payout address for Relay application fees.
+ *
+ * NO BUILDER APPLIES IT. A Relay request carries an `appFees` entry only when
+ * the caller passes `relayAppFee`. The Gibs interface passes this address
+ * explicitly; any other caller passes its own, or nothing.
+ *
+ * Set to the owner's receiving wallet. Setting it back to `null` is a working
+ * state rather than a broken one, and is the way to stop collecting: Relay
+ * rejects a fee entry that names no recipient, so the fee is omitted from the
+ * request entirely and nothing is charged. Every consumer already reads it this
+ * way — see {@link referralIsCollectable}.
+ *
+ * The literal is stored CHECKSUMMED (mixed case). That is not decoration: the
+ * mixed case IS the checksum, so a typo in the address fails `getAddress`
+ * instead of silently paying a wrong-but-valid account. Verified against viem's
+ * `getAddress` before being written here.
+ *
+ * One address serves every chain: Relay pays application fees on the DESTINATION
+ * chain, and every destination this app bridges to is Ethereum-style, so an
+ * ordinary Ethereum address receives from all of them.
+ */
+export declare const relayReferralRecipient: Hex | null;
+/**
+ * The application fee the Gibs interface charges, in basis points. Ten basis
+ * points is one tenth of one percent. The interface can override it per
+ * provider in stored settings; this is the value a reader who has never touched
+ * the setting gets.
+ *
+ * NO BUILDER APPLIES IT. It reaches a request only when a caller passes it as
+ * `relayAppFee.basisPoints` (Relay) or converts it to `lifiFee` (LI.FI).
+ */
+export declare const defaultReferralFeeBasisPoints = 10n;
+/**
+ * Whether a referral fee will ACTUALLY be collected, as opposed to merely being
+ * switched on.
+ *
+ * The distinction is the point of this helper. Relay's fee needs three things to
+ * be true at once, and the interface used to show a percentage whenever the
+ * first was true — so the fee row read "0.10%" while the missing recipient meant
+ * nothing was charged at all. Ask this rather than reading `enabled` alone.
+ *
+ * @param options - the switch state, the fee size, and the payout address
+ * @returns true only when a fee will reach a recipient
+ */
+export declare const referralIsCollectable: ({ enabled, basisPoints, recipient, }: {
+    enabled: boolean;
+    basisPoints: bigint;
+    recipient: Hex | null;
+}) => boolean;

package/dist/cjs/referral.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referralIsCollectable = exports.defaultReferralFeeBasisPoints = exports.relayReferralRecipient = exports.resolveAttribution = exports.referralIntegrator = void 0;
+/**
+ * Referral configuration — the one place to set who gets paid.
+ *
+ * This module exists so the payout address is a single named edit rather than a
+ * constant buried among API urls. It deliberately imports nothing but a type, so
+ * the interface can read the address without pulling in a quote builder.
+ */
+/**
+ * Gibs Finance's own integrator identifier with LI.FI and Relay. LI.FI pays its
+ * integrator share against this string — the payout account is configured on
+ * LI.FI's side, which is why LI.FI needs no address here and Relay does.
+ *
+ * This is Gibs Finance's identity, not a setting for other consumers. The
+ * Relay API key that used to live beside it moved into the Gibs interface's
+ * own configuration (`packages/ui/src/lib/config.ts`): this package ships no
+ * key. Pass your own identifiers on each request — see the README.
+ */
+exports.referralIntegrator = 'gibs.finance';
+/**
+ * Resolves one attribution field (a LI.FI `integrator`, a Relay `referrer`)
+ * from a caller's override and this package's default for it.
+ *
+ * Three states, not two:
+ * - `undefined` (left out): the package default — which may itself be
+ *   `undefined`, meaning the field is not sent.
+ * - `null`: the field is OMITTED from the request. Never sent as `''`: Relay
+ *   reads any `referrer`, an empty one included, as "a referrer was supplied".
+ * - a string: sent as-is.
+ *
+ * @param override - the caller's value for the field
+ * @param packageDefault - the value used when the caller leaves the field out
+ * @returns the value to send, or undefined to omit the field
+ */
+const resolveAttribution = (override, packageDefault) => (override === null ? undefined : (override ?? packageDefault));
+exports.resolveAttribution = resolveAttribution;
+/**
+ * Gibs Finance's payout address for Relay application fees.
+ *
+ * NO BUILDER APPLIES IT. A Relay request carries an `appFees` entry only when
+ * the caller passes `relayAppFee`. The Gibs interface passes this address
+ * explicitly; any other caller passes its own, or nothing.
+ *
+ * Set to the owner's receiving wallet. Setting it back to `null` is a working
+ * state rather than a broken one, and is the way to stop collecting: Relay
+ * rejects a fee entry that names no recipient, so the fee is omitted from the
+ * request entirely and nothing is charged. Every consumer already reads it this
+ * way — see {@link referralIsCollectable}.
+ *
+ * The literal is stored CHECKSUMMED (mixed case). That is not decoration: the
+ * mixed case IS the checksum, so a typo in the address fails `getAddress`
+ * instead of silently paying a wrong-but-valid account. Verified against viem's
+ * `getAddress` before being written here.
+ *
+ * One address serves every chain: Relay pays application fees on the DESTINATION
+ * chain, and every destination this app bridges to is Ethereum-style, so an
+ * ordinary Ethereum address receives from all of them.
+ */
+exports.relayReferralRecipient = '0xAF2ce0189f46f5663715b0b9ED2a10eA924AB9B0';
+/**
+ * The application fee the Gibs interface charges, in basis points. Ten basis
+ * points is one tenth of one percent. The interface can override it per
+ * provider in stored settings; this is the value a reader who has never touched
+ * the setting gets.
+ *
+ * NO BUILDER APPLIES IT. It reaches a request only when a caller passes it as
+ * `relayAppFee.basisPoints` (Relay) or converts it to `lifiFee` (LI.FI).
+ */
+exports.defaultReferralFeeBasisPoints = 10n;
+/**
+ * Whether a referral fee will ACTUALLY be collected, as opposed to merely being
+ * switched on.
+ *
+ * The distinction is the point of this helper. Relay's fee needs three things to
+ * be true at once, and the interface used to show a percentage whenever the
+ * first was true — so the fee row read "0.10%" while the missing recipient meant
+ * nothing was charged at all. Ask this rather than reading `enabled` alone.
+ *
+ * @param options - the switch state, the fee size, and the payout address
+ * @returns true only when a fee will reach a recipient
+ */
+const referralIsCollectable = ({ enabled, basisPoints, recipient, }) => enabled && basisPoints > 0n && recipient !== null;
+exports.referralIsCollectable = referralIsCollectable;

package/dist/cjs/relay-currencies.d.ts

@@ -0,0 +1,47 @@
+import type { Token } from './types.js';
+/**
+ * Relay currencies endpoint. Anonymous access works at the same 50-requests-per-
+ * minute tier as the quote endpoint; used to discover the source tokens a
+ * non-Ethereum origin chain (Solana, Bitcoin) can bridge from.
+ */
+export declare const relayCurrenciesUrl = "https://api.relay.link/currencies/v2";
+/** The JSON body for `POST /currencies/v2`. */
+export type RelayCurrenciesRequestBody = {
+    /** Relay chain identifiers to list currencies for. */
+    chainIds: number[];
+    /** Optional cap on how many currencies Relay returns per chain. */
+    limit?: number;
+};
+/**
+ * Builds the Relay currencies request body.
+ *
+ * @returns the request body, or null when no chain ids are supplied
+ */
+export declare const buildRelayCurrenciesRequest: ({ chainIds, limit, }: {
+    chainIds: number[];
+    limit?: number;
+}) => RelayCurrenciesRequestBody | null;
+/**
+ * Relay's own chain registry — the provider's word on which chains it
+ * supports AT ALL, distinct from `/currencies/v2` (which chains currently
+ * have priced currencies). A chain absent here can never be asked about, on
+ * `/currencies/v2` or `/quote` alike; see `parseRelayChains`.
+ */
+export declare const relayChainsUrl = "https://api.relay.link/chains";
+/**
+ * Normalizes a `GET /chains` response body to the chain ids Relay lists.
+ * Mirrors `parseLifiChains` (`consolidated-quote.ts`) for LI.FI's own chain
+ * list: read the provider's own registry, never a hand-written exclusion.
+ *
+ * @returns the chain ids Relay lists, or null when the payload shape is unexpected
+ */
+export declare const parseRelayChains: (payload: unknown) => number[] | null;
+/**
+ * Maps Relay's flat `/currencies/v2` array onto the shared `Token` shape. A
+ * Relay currency's `address` is already a string (a Solana mint or a Bitcoin
+ * native address), so no widening is needed. Malformed entries are skipped
+ * rather than failing the whole list.
+ *
+ * @returns the tokens, or an empty list when the payload is not an array
+ */
+export declare const parseRelayCurrencies: (payload: unknown) => Token[];

package/dist/cjs/relay-currencies.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRelayCurrencies = exports.parseRelayChains = exports.relayChainsUrl = exports.buildRelayCurrenciesRequest = exports.relayCurrenciesUrl = void 0;
+/**
+ * Relay currencies endpoint. Anonymous access works at the same 50-requests-per-
+ * minute tier as the quote endpoint; used to discover the source tokens a
+ * non-Ethereum origin chain (Solana, Bitcoin) can bridge from.
+ */
+exports.relayCurrenciesUrl = 'https://api.relay.link/currencies/v2';
+/**
+ * Builds the Relay currencies request body.
+ *
+ * @returns the request body, or null when no chain ids are supplied
+ */
+const buildRelayCurrenciesRequest = ({ chainIds, limit, }) => {
+    if (chainIds.length === 0) {
+        return null;
+    }
+    return { chainIds, ...(limit === undefined ? {} : { limit }) };
+};
+exports.buildRelayCurrenciesRequest = buildRelayCurrenciesRequest;
+const asRecord = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return null;
+    }
+    return value;
+};
+/**
+ * Relay's own chain registry — the provider's word on which chains it
+ * supports AT ALL, distinct from `/currencies/v2` (which chains currently
+ * have priced currencies). A chain absent here can never be asked about, on
+ * `/currencies/v2` or `/quote` alike; see `parseRelayChains`.
+ */
+exports.relayChainsUrl = 'https://api.relay.link/chains';
+/**
+ * Normalizes a `GET /chains` response body to the chain ids Relay lists.
+ * Mirrors `parseLifiChains` (`consolidated-quote.ts`) for LI.FI's own chain
+ * list: read the provider's own registry, never a hand-written exclusion.
+ *
+ * @returns the chain ids Relay lists, or null when the payload shape is unexpected
+ */
+const parseRelayChains = (payload) => {
+    const body = asRecord(payload);
+    if (body === null || !Array.isArray(body.chains)) {
+        return null;
+    }
+    const ids = [];
+    for (const chain of body.chains) {
+        const record = asRecord(chain);
+        if (record !== null && typeof record.id === 'number') {
+            ids.push(record.id);
+        }
+    }
+    return ids;
+};
+exports.parseRelayChains = parseRelayChains;
+/**
+ * Maps Relay's flat `/currencies/v2` array onto the shared `Token` shape. A
+ * Relay currency's `address` is already a string (a Solana mint or a Bitcoin
+ * native address), so no widening is needed. Malformed entries are skipped
+ * rather than failing the whole list.
+ *
+ * @returns the tokens, or an empty list when the payload is not an array
+ */
+const parseRelayCurrencies = (payload) => {
+    if (!Array.isArray(payload)) {
+        return [];
+    }
+    const tokens = [];
+    for (const entry of payload) {
+        const record = asRecord(entry);
+        if (!record) {
+            continue;
+        }
+        const { chainId, address, symbol, name, decimals } = record;
+        if (typeof chainId !== 'number' ||
+            typeof address !== 'string' ||
+            typeof symbol !== 'string' ||
+            typeof name !== 'string' ||
+            typeof decimals !== 'number') {
+            continue;
+        }
+        const metadata = asRecord(record.metadata);
+        tokens.push({
+            chainId,
+            address,
+            symbol,
+            name,
+            decimals,
+            logoURI: typeof metadata?.logoURI === 'string' ? metadata.logoURI : null,
+        });
+    }
+    return tokens;
+};
+exports.parseRelayCurrencies = parseRelayCurrencies;

package/dist/cjs/relay-depository.d.ts

@@ -0,0 +1,2 @@
+import { type Hex } from 'viem';
+export declare const relayDepositoryByChainId: ReadonlyMap<number, Hex>;

package/dist/cjs/relay-depository.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayDepositoryByChainId = void 0;
+const viem_1 = require("viem");
+/**
+ * Relay's deposit contract (its "depository") on each Ethereum-style chain:
+ * the ONLY address a Relay origin deposit may be sent to, and the only
+ * address it may ask the reader to approve.
+ *
+ * WHY A FIXED TABLE. A quote that names its own spender cannot be trusted to
+ * name an honest one: a compromised quote host could name any contract. This
+ * table ships with the code and changes only through a release.
+ *
+ * SOURCE. Relay's Chains API, `GET https://api.relay.link/chains`, field
+ * `chains[].protocol.v2.depository`, read 2026-10-07 for every chain whose
+ * `vmType` is `evm`. Relay's documentation says its depository addresses are
+ * published only through that API
+ * (https://docs.relay.link/references/protocol/addresses). A live quote the
+ * same day (Ethereum USDC to Base, `POST /quote/v2`) approved and deposited to
+ * exactly the Ethereum entry below.
+ *
+ * NOT THE `contracts` BLOCK. The same API also lists `relayReceiver`,
+ * `approvalProxy` and `erc20Router` under `chains[].contracts`. The live
+ * quote used none of them, so they are left out: an address the quote does
+ * not use is not one this table should accept.
+ *
+ * A CHAIN NOT LISTED IS REFUSED. If Relay adds a chain or moves a depository,
+ * deposits there are refused until this table is updated.
+ */
+const common = (0, viem_1.getAddress)('0x4cd00e387622c35bddb9b4c962c136462338bc31');
+const alternate = (0, viem_1.getAddress)('0x59916da825d2d2ec1bf878d71c88826f6633ecca');
+exports.relayDepositoryByChainId = new Map([
+    [1, common], // ethereum
+    [10, common], // optimism
+    [25, alternate], // cronos
+    [56, common], // bsc
+    [100, common], // gnosis
+    [130, common], // unichain
+    [137, common], // polygon
+    [143, common], // monad
+    [146, common], // sonic
+    [169, common], // manta-pacific
+    [196, common], // xlayer
+    [288, common], // boba
+    [324, common], // zksync
+    [360, common], // shape
+    [480, common], // world-chain
+    [747, common], // flow-evm
+    [988, common], // stable
+    [999, common], // hyperevm
+    [1088, alternate], // metis
+    [1135, common], // lisk
+    [1868, common], // soneium
+    [2020, common], // ronin
+    [2741, common], // abstract
+    [2818, common], // morph
+    [4217, common], // tempo
+    [4326, common], // megaeth
+    [4663, common], // robinhood
+    [5000, alternate], // mantle
+    [5031, common], // somnia
+    [5042, common], // arc
+    [5330, common], // superseed
+    [8453, common], // base
+    [9745, common], // plasma
+    [33139, common], // apechain
+    [34443, common], // mode
+    [42018, common], // mythos
+    [42161, common], // arbitrum
+    [42220, common], // celo
+    [43114, common], // avalanche
+    [48900, common], // zircuit
+    [57073, common], // ink
+    [59144, alternate], // linea
+    [60808, common], // bob
+    [80094, common], // berachain
+    [81457, common], // blast
+    [97477, common], // doma
+    [98866, common], // plume
+    [534352, common], // scroll
+    [685689, common], // gensyn
+    [747474, common], // katana
+    [5064014, common], // ethereal
+    [7777777, common], // zora
+]);