@gfxlabs/oku-chains 1.12.3 → 1.12.5

package/dist/index-mjs.js

@@ -6842,6 +6842,111 @@ const zkSync = makeConfig({
     },
 });
 
+/**
+ * Placeholder numeric `id` used by non-EVM chains.
+ *
+ * viem's `Chain` (which {@link IChainInfo} extends) requires a numeric `id`,
+ * but non-EVM chains (e.g. Bitcoin) have no EVM chain id. They use `0` as a
+ * sentinel and rely on `caip2Namespace` + `caip2Reference` for identity and
+ * resolution instead. `0` is never a valid EVM chain id, so it cannot collide.
+ */
+const NON_EVM_CHAIN_ID = 0;
+/**
+ * True if the chain is non-EVM (i.e. uses the {@link NON_EVM_CHAIN_ID}
+ * placeholder id and a non-`eip155` CAIP-2 namespace). Non-EVM chains live in
+ * the same {@link IChainInfo} shape as EVM chains, so EVM-only fields
+ * (contracts, uniswap metadata, etc.) will be present but empty.
+ */
+function isNonEvmChain(c) {
+    return c.id === NON_EVM_CHAIN_ID && c.caip2Namespace !== "eip155";
+}
+/** True if the chain is an EVM chain. Inverse of {@link isNonEvmChain}. */
+function isEvmChain(c) {
+    return !isNonEvmChain(c);
+}
+
+/**
+ * Bitcoin mainnet.
+ *
+ * A non-EVM chain expressed within the EVM-shaped {@link IChainInfo} so it
+ * flows through the existing resolvers and consumers unchanged. Because viem's
+ * `Chain` requires a numeric `id`, Bitcoin uses the {@link NON_EVM_CHAIN_ID}
+ * (`0`) placeholder and is identified/resolved via CAIP-2 instead:
+ * `bip122:000000000019d6689c085ae165831e93`, where the reference is the first
+ * 32 hex chars of the genesis block hash per the CAIP-2 `bip122` namespace.
+ *
+ * EVM-only fields (uniswap, morpho, contracts, etc.) are present but empty.
+ *
+ * Refs:
+ *   - https://github.com/ChainAgnostic/namespaces/blob/main/bip122/caip2.md
+ */
+const chain = defineChain({
+    id: NON_EVM_CHAIN_ID,
+    name: "Bitcoin",
+    nativeCurrency: {
+        name: "Bitcoin",
+        symbol: "BTC",
+        decimals: 8,
+    },
+    rpcUrls: {
+        default: {
+            http: ["https://bitcoin-rpc.publicnode.com"],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: "mempool.space",
+            url: "https://mempool.space",
+            apiUrl: "https://mempool.space/api",
+        },
+    },
+});
+const bitcoin = makeConfig({
+    ...chain,
+    caip2Namespace: "bip122",
+    caip2Reference: "000000000019d6689c085ae165831e93",
+    internalName: "bitcoin",
+    transactionType: "bitcoin",
+    sortIndex: 1000,
+    launchTime: 1231006505,
+    blockTimeSeconds: 600,
+    deprecated: false,
+    logoUrl: "https://cms.oku.trade/cdn/public/chains/bitcoin-logo.webp",
+    nativeLogoUrl: "https://cms.oku.trade/cdn/public/natives/btc.png",
+    blockAid: "bitcoin",
+    estimatedSwapGas: 0,
+    estimatedBridgeGas: 0,
+    estimatedWrapGas: 0,
+    initCodeHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    defaultPool: "0x0000000000000000000000000000000000000000",
+    defaultToken0: "0x0000000000000000000000000000000000000000",
+    defaultToken1: "0x0000000000000000000000000000000000000000",
+    tokenList: [],
+    stables: [],
+    watchlist: [],
+    v4Watchlist: [],
+    externalId: {
+        coingecko: "bitcoin",
+    },
+    markets: {},
+    bridges: {},
+    oracles: {
+        coingecko: {
+            slug: "bitcoin",
+            native: "bitcoin",
+        },
+    },
+    uniswap: {},
+    morpho: {},
+    token: {},
+    oku: {},
+    contracts: {
+        nftManager: {
+            address: "0x0000000000000000000000000000000000000000",
+        },
+    },
+});
+
 /**
  * Parse a CAIP-2 chain ID string into its namespace and reference components.
  *
@@ -6875,20 +6980,33 @@ function parseCAIP2(caip2) {
 function formatCAIP2(id) {
     return `${id.namespace}:${id.reference}`;
 }
+/**
+ * The CAIP-2 reference component for a chain.
+ *
+ * If the chain sets an explicit `caip2Reference` (e.g. a non-EVM chain like
+ * Bitcoin, whose reference is a genesis hash prefix), it is used verbatim.
+ * Otherwise the reference is derived from the numeric `id` (the historical
+ * behavior for EVM chains, e.g. "1" for Ethereum mainnet).
+ */
+function caip2Reference(chain) {
+    return chain.caip2Reference ?? String(chain.id);
+}
 /**
  * Convert a chain config to its CAIP-2 identifier string.
  *
  * @example
  * ```ts
- * import { mainnet } from "@gfxlabs/oku-chains";
+ * import { mainnet, bitcoin } from "@gfxlabs/oku-chains";
  * toCAIP2(mainnet)
  * // => "eip155:1"
+ * toCAIP2(bitcoin)
+ * // => "bip122:000000000019d6689c085ae165831e93"
  * ```
  */
 function toCAIP2(chain) {
     return formatCAIP2({
         namespace: chain.caip2Namespace,
-        reference: String(chain.id),
+        reference: caip2Reference(chain),
     });
 }
 /**
@@ -6905,13 +7023,147 @@ function toCAIP2(chain) {
  */
 function fromCAIP2(caip2, chains) {
     const { namespace, reference } = parseCAIP2(caip2);
-    const chain = chains.find((c) => c.caip2Namespace === namespace && String(c.id) === reference);
+    const chain = chains.find((c) => c.caip2Namespace === namespace && caip2Reference(c) === reference);
     if (!chain) {
         throw new Error(`No chain found for CAIP-2 identifier: "${caip2}"`);
     }
     return chain;
 }
 
+/**
+ * Error thrown when a network cannot be found by any lookup method.
+ */
+class NetworkNotFoundError extends Error {
+    constructor(input) {
+        super(`chain not found: ${String(input)}`);
+        this.name = "NetworkNotFoundError";
+    }
+}
+/**
+ * Build a lookup index from a list of chains for fast repeated lookups.
+ * Pre-computes maps keyed by chain ID, internal name, and CAIP-2 identifier.
+ *
+ * Non-EVM chains use the {@link NON_EVM_CHAIN_ID} (`0`) placeholder id and are
+ * intentionally NOT registered in `byId` (they are not resolvable by numeric
+ * id, and would otherwise all collide on `0`). They remain resolvable by
+ * internal name and by their explicit CAIP-2 identifier.
+ */
+function buildNetworkIndex(chains) {
+    const byId = new Map();
+    const byName = new Map();
+    const byCAIP2 = new Map();
+    for (const chain of chains) {
+        if (chain.id !== NON_EVM_CHAIN_ID) {
+            byId.set(chain.id, chain);
+        }
+        byName.set(chain.internalName, chain);
+        byCAIP2.set(`${chain.caip2Namespace}:${caip2Reference(chain)}`, chain);
+    }
+    return { byId, byName, byCAIP2 };
+}
+/**
+ * Look up a chain by its numeric chain ID. Non-EVM chains use the
+ * {@link NON_EVM_CHAIN_ID} placeholder and are not resolvable here.
+ */
+function networkById$1(id, idx) {
+    const chain = idx.byId.get(id);
+    if (!chain) {
+        throw new NetworkNotFoundError(id);
+    }
+    return chain;
+}
+/**
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
+ */
+function networkByName$1(name, idx) {
+    const chain = idx.byName.get(name);
+    if (!chain) {
+        throw new NetworkNotFoundError(name);
+    }
+    return chain;
+}
+/**
+ * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1" or
+ * "bip122:000000000019d6689c085ae165831e93"). This is the way to resolve
+ * non-EVM chains.
+ */
+function networkByCAIP2$1(caip2, idx) {
+    // Validate the format
+    parseCAIP2(caip2);
+    const chain = idx.byCAIP2.get(caip2);
+    if (!chain) {
+        throw new NetworkNotFoundError(caip2);
+    }
+    return chain;
+}
+/**
+ * Look up a chain from a string. Tries, in order:
+ * 1. CAIP-2 identifier (if the string contains ":")
+ * 2. Internal name
+ * 3. Numeric chain ID (parsed from string)
+ *
+ * Non-EVM chains are only reachable via the CAIP-2 or internal-name paths,
+ * never via the numeric-id fallback.
+ *
+ * Mirrors the Go `NetworkByString` function.
+ */
+function networkByString$1(s, idx) {
+    if (s === "") {
+        throw new NetworkNotFoundError("empty string");
+    }
+    // Try CAIP-2
+    if (s.includes(":")) {
+        return networkByCAIP2$1(s, idx);
+    }
+    // Try internal name
+    const byName = idx.byName.get(s);
+    if (byName) {
+        return byName;
+    }
+    // Try numeric chain ID
+    const parsed = Number(s);
+    if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
+        const byId = idx.byId.get(Math.trunc(parsed));
+        if (byId) {
+            return byId;
+        }
+    }
+    throw new NetworkNotFoundError(s);
+}
+/**
+ * Resolve a chain from an arbitrary input. Accepts:
+ * - `number`: treated as a numeric chain ID (EVM-only)
+ * - `string`: tried as CAIP-2 identifier (if it contains ":"), then as
+ *   internal name, then as a numeric chain ID string
+ * - `IChainInfo`: returned directly (pass-through)
+ *
+ * Non-EVM chains have a placeholder numeric id, so they can only be resolved
+ * via their CAIP-2 identifier or internal name (or passed through directly).
+ *
+ * Mirrors the Go `NetworkByAny` function.
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkByAny$1(v, idx) {
+    if (v == null) {
+        throw new NetworkNotFoundError("null");
+    }
+    // Pass-through if already a chain config object
+    if (typeof v === "object" && "id" in v && "internalName" in v) {
+        return v;
+    }
+    // Numeric chain ID
+    if (typeof v === "number") {
+        return networkById$1(Math.trunc(v), idx);
+    }
+    // String: CAIP-2, name, or numeric string
+    if (typeof v === "string") {
+        return networkByString$1(v, idx);
+    }
+    throw new NetworkNotFoundError(v);
+}
+
 const MAINNET_CHAINS = [
     arbitrum,
     base,
@@ -6962,5 +7214,97 @@ const MAINNET_CHAINS = [
     gensyn,
     pharos,
 ];
+/**
+ * Non-EVM chains (e.g. Bitcoin). These share the {@link IChainInfo} shape as
+ * EVM chains but use the `NON_EVM_CHAIN_ID` (`0`) placeholder id and are
+ * resolvable only via CAIP-2 (or internal name). Kept as a separate array so
+ * the EVM-only surface (and the Go codegen, which reads `MAINNET_CHAINS`) is
+ * unaffected.
+ */
+const NON_EVM_CHAINS = [
+    bitcoin,
+];
+/**
+ * All networks, EVM and non-EVM. Use this when you need to enumerate every
+ * supported chain regardless of type.
+ */
+const ALL_NETWORKS = [
+    ...MAINNET_CHAINS,
+    ...NON_EVM_CHAINS,
+];
+/**
+ * Pre-built lookup index over all networks (EVM + non-EVM), like Go's
+ * module-level maps. Resolution functions below bind to this index.
+ */
+const _idx = buildNetworkIndex(ALL_NETWORKS);
+/**
+ * Resolve a chain from an arbitrary input. Accepts:
+ * - `number`: treated as chain ID
+ * - `string`: tried as CAIP-2 identifier (if it contains ":"), then as
+ *   internal name, then as a numeric chain ID string
+ * - `IChainInfo`: returned directly (pass-through)
+ *
+ * Mirrors the Go `NetworkByAny` function.
+ *
+ * Non-EVM chains (e.g. Bitcoin) use a placeholder numeric id and can only be
+ * resolved via their CAIP-2 identifier or internal name. Use `isNonEvmChain`
+ * if you need to distinguish them.
+ *
+ * @example
+ * ```ts
+ * import { networkByAny } from "@gfxlabs/oku-chains";
+ *
+ * networkByAny(1)           // by chain ID (EVM)
+ * networkByAny("mainnet")   // by internal name
+ * networkByAny("eip155:1")  // by CAIP-2 (EVM)
+ * networkByAny("42161")     // by chain ID string (EVM)
+ * networkByAny("bip122:000000000019d6689c085ae165831e93") // by CAIP-2 (non-EVM)
+ * networkByAny("bitcoin")   // by internal name (non-EVM)
+ * ```
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkByAny(v) {
+    return networkByAny$1(v, _idx);
+}
+/**
+ * Look up a chain by its numeric chain ID. Non-EVM chains use a placeholder id
+ * and are not resolvable here.
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkById(id) {
+    return networkById$1(id, _idx);
+}
+/**
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkByName(name) {
+    return networkByName$1(name, _idx);
+}
+/**
+ * Look up a chain from a string. Tries, in order:
+ * 1. CAIP-2 identifier (if the string contains ":")
+ * 2. Internal name
+ * 3. Numeric chain ID (parsed from string)
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkByString(s) {
+    return networkByString$1(s, _idx);
+}
+/**
+ * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1" or
+ * "bip122:000000000019d6689c085ae165831e93"). This is the way to resolve
+ * non-EVM chains.
+ *
+ * @throws {NetworkNotFoundError} if no matching chain is found
+ */
+function networkByCAIP2(caip2) {
+    return networkByCAIP2$1(caip2, _idx);
+}
 
-export { MAINNET_CHAINS, arbitrum, avalanche, base, blast, bob, boba, bsc, celo, corn, etherlink, filecoin, formatCAIP2, fromCAIP2, gensyn, gnosis, goat, hemi, hyperevm, lens, lightlink, linea, lisk, mainnet, manta, mantle, matchain, metal, monad, moonbeam, nibiru, optimism, parseCAIP2, pharos, plasma, polygon, polygonZkEvm, redbelly, ronin, rootstock, saga, scroll, sei, sonic, taiko, telos, toCAIP2, tronShasta, unichain, worldchain, xdc, zerog, zkSync };
+export { ALL_NETWORKS, MAINNET_CHAINS, NON_EVM_CHAINS, NON_EVM_CHAIN_ID, NetworkNotFoundError, arbitrum, avalanche, base, bitcoin, blast, bob, boba, bsc, buildNetworkIndex, caip2Reference, celo, corn, etherlink, filecoin, formatCAIP2, fromCAIP2, gensyn, gnosis, goat, hemi, hyperevm, isEvmChain, isNonEvmChain, lens, lightlink, linea, lisk, mainnet, makeConfig, manta, mantle, matchain, metal, monad, moonbeam, networkByAny, networkByCAIP2, networkById, networkByName, networkByString, nibiru, optimism, parseCAIP2, pharos, plasma, polygon, polygonZkEvm, redbelly, ronin, rootstock, saga, scroll, sei, sonic, taiko, telos, toCAIP2, tronShasta, unichain, worldchain, xdc, zerog, zkSync };