@gfxlabs/oku-chains 1.12.4 → 1.12.5

package/dist/browser.js

@@ -6845,6 +6845,111 @@
         },
     });
 
+    /**
+     * 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 = viem.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.
      *
@@ -6878,20 +6983,33 @@
     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),
         });
     }
     /**
@@ -6908,7 +7026,7 @@
      */
     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}"`);
         }
@@ -6927,20 +7045,28 @@
     /**
      * 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) {
-            byId.set(chain.id, chain);
+            if (chain.id !== NON_EVM_CHAIN_ID) {
+                byId.set(chain.id, chain);
+            }
             byName.set(chain.internalName, chain);
-            byCAIP2.set(`${chain.caip2Namespace}:${chain.id}`, chain);
+            byCAIP2.set(`${chain.caip2Namespace}:${caip2Reference(chain)}`, chain);
         }
         return { byId, byName, byCAIP2 };
     }
     /**
-     * Look up a chain by its numeric chain ID.
+     * 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);
@@ -6950,7 +7076,8 @@
         return chain;
     }
     /**
-     * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+     * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+     * "bitcoin").
      */
     function networkByName$1(name, idx) {
         const chain = idx.byName.get(name);
@@ -6960,7 +7087,9 @@
         return chain;
     }
     /**
-     * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+     * 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
@@ -6977,6 +7106,9 @@
      * 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) {
@@ -7004,11 +7136,14 @@
     }
     /**
      * Resolve a chain from an arbitrary input. Accepts:
-     * - `number`: treated as chain ID
+     * - `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
@@ -7082,8 +7217,29 @@
         gensyn,
         pharos,
     ];
-    /** Pre-built lookup index over MAINNET_CHAINS (like Go's module-level maps). */
-    const _idx = buildNetworkIndex(MAINNET_CHAINS);
+    /**
+     * 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
@@ -7093,14 +7249,20 @@
      *
      * 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
+     * networkByAny(1)           // by chain ID (EVM)
      * networkByAny("mainnet")   // by internal name
-     * networkByAny("eip155:1")  // by CAIP-2
-     * networkByAny("42161")     // by chain ID string
+     * 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
@@ -7109,7 +7271,8 @@
         return networkByAny$1(v, _idx);
     }
     /**
-     * Look up a chain by its numeric chain ID.
+     * 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
      */
@@ -7117,7 +7280,8 @@
         return networkById$1(id, _idx);
     }
     /**
-     * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+     * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+     * "bitcoin").
      *
      * @throws {NetworkNotFoundError} if no matching chain is found
      */
@@ -7136,7 +7300,9 @@
         return networkByString$1(s, _idx);
     }
     /**
-     * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+     * 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
      */
@@ -7144,16 +7310,21 @@
         return networkByCAIP2$1(caip2, _idx);
     }
 
+    exports.ALL_NETWORKS = ALL_NETWORKS;
     exports.MAINNET_CHAINS = MAINNET_CHAINS;
+    exports.NON_EVM_CHAINS = NON_EVM_CHAINS;
+    exports.NON_EVM_CHAIN_ID = NON_EVM_CHAIN_ID;
     exports.NetworkNotFoundError = NetworkNotFoundError;
     exports.arbitrum = arbitrum;
     exports.avalanche = avalanche;
     exports.base = base;
+    exports.bitcoin = bitcoin;
     exports.blast = blast;
     exports.bob = bob;
     exports.boba = boba;
     exports.bsc = bsc;
     exports.buildNetworkIndex = buildNetworkIndex;
+    exports.caip2Reference = caip2Reference;
     exports.celo = celo;
     exports.corn = corn;
     exports.etherlink = etherlink;
@@ -7165,11 +7336,14 @@
     exports.goat = goat;
     exports.hemi = hemi;
     exports.hyperevm = hyperevm;
+    exports.isEvmChain = isEvmChain;
+    exports.isNonEvmChain = isNonEvmChain;
     exports.lens = lens;
     exports.lightlink = lightlink;
     exports.linea = linea;
     exports.lisk = lisk;
     exports.mainnet = mainnet;
+    exports.makeConfig = makeConfig;
     exports.manta = manta;
     exports.mantle = mantle;
     exports.matchain = matchain;

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,7 +7023,7 @@ 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}"`);
     }
@@ -6924,20 +7042,28 @@ class NetworkNotFoundError extends Error {
 /**
  * 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) {
-        byId.set(chain.id, chain);
+        if (chain.id !== NON_EVM_CHAIN_ID) {
+            byId.set(chain.id, chain);
+        }
         byName.set(chain.internalName, chain);
-        byCAIP2.set(`${chain.caip2Namespace}:${chain.id}`, chain);
+        byCAIP2.set(`${chain.caip2Namespace}:${caip2Reference(chain)}`, chain);
     }
     return { byId, byName, byCAIP2 };
 }
 /**
- * Look up a chain by its numeric chain ID.
+ * 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);
@@ -6947,7 +7073,8 @@ function networkById$1(id, idx) {
     return chain;
 }
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  */
 function networkByName$1(name, idx) {
     const chain = idx.byName.get(name);
@@ -6957,7 +7084,9 @@ function networkByName$1(name, idx) {
     return chain;
 }
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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
@@ -6974,6 +7103,9 @@ function networkByCAIP2$1(caip2, idx) {
  * 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) {
@@ -7001,11 +7133,14 @@ function networkByString$1(s, idx) {
 }
 /**
  * Resolve a chain from an arbitrary input. Accepts:
- * - `number`: treated as chain ID
+ * - `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
@@ -7079,8 +7214,29 @@ const MAINNET_CHAINS = [
     gensyn,
     pharos,
 ];
-/** Pre-built lookup index over MAINNET_CHAINS (like Go's module-level maps). */
-const _idx = buildNetworkIndex(MAINNET_CHAINS);
+/**
+ * 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
@@ -7090,14 +7246,20 @@ const _idx = buildNetworkIndex(MAINNET_CHAINS);
  *
  * 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
+ * networkByAny(1)           // by chain ID (EVM)
  * networkByAny("mainnet")   // by internal name
- * networkByAny("eip155:1")  // by CAIP-2
- * networkByAny("42161")     // by chain ID string
+ * 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
@@ -7106,7 +7268,8 @@ function networkByAny(v) {
     return networkByAny$1(v, _idx);
 }
 /**
- * Look up a chain by its numeric chain ID.
+ * 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
  */
@@ -7114,7 +7277,8 @@ function networkById(id) {
     return networkById$1(id, _idx);
 }
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  *
  * @throws {NetworkNotFoundError} if no matching chain is found
  */
@@ -7133,7 +7297,9 @@ function networkByString(s) {
     return networkByString$1(s, _idx);
 }
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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
  */
@@ -7141,4 +7307,4 @@ function networkByCAIP2(caip2) {
     return networkByCAIP2$1(caip2, _idx);
 }
 
-export { MAINNET_CHAINS, NetworkNotFoundError, arbitrum, avalanche, base, blast, bob, boba, bsc, buildNetworkIndex, celo, corn, etherlink, filecoin, formatCAIP2, fromCAIP2, gensyn, gnosis, goat, hemi, hyperevm, lens, lightlink, linea, lisk, mainnet, 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 };
+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 };

package/dist/index.js

@@ -6844,6 +6844,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 = viem.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.
  *
@@ -6877,20 +6982,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),
     });
 }
 /**
@@ -6907,7 +7025,7 @@ 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}"`);
     }
@@ -6926,20 +7044,28 @@ class NetworkNotFoundError extends Error {
 /**
  * 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) {
-        byId.set(chain.id, chain);
+        if (chain.id !== NON_EVM_CHAIN_ID) {
+            byId.set(chain.id, chain);
+        }
         byName.set(chain.internalName, chain);
-        byCAIP2.set(`${chain.caip2Namespace}:${chain.id}`, chain);
+        byCAIP2.set(`${chain.caip2Namespace}:${caip2Reference(chain)}`, chain);
     }
     return { byId, byName, byCAIP2 };
 }
 /**
- * Look up a chain by its numeric chain ID.
+ * 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);
@@ -6949,7 +7075,8 @@ function networkById$1(id, idx) {
     return chain;
 }
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  */
 function networkByName$1(name, idx) {
     const chain = idx.byName.get(name);
@@ -6959,7 +7086,9 @@ function networkByName$1(name, idx) {
     return chain;
 }
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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
@@ -6976,6 +7105,9 @@ function networkByCAIP2$1(caip2, idx) {
  * 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) {
@@ -7003,11 +7135,14 @@ function networkByString$1(s, idx) {
 }
 /**
  * Resolve a chain from an arbitrary input. Accepts:
- * - `number`: treated as chain ID
+ * - `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
@@ -7081,8 +7216,29 @@ const MAINNET_CHAINS = [
     gensyn,
     pharos,
 ];
-/** Pre-built lookup index over MAINNET_CHAINS (like Go's module-level maps). */
-const _idx = buildNetworkIndex(MAINNET_CHAINS);
+/**
+ * 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
@@ -7092,14 +7248,20 @@ const _idx = buildNetworkIndex(MAINNET_CHAINS);
  *
  * 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
+ * networkByAny(1)           // by chain ID (EVM)
  * networkByAny("mainnet")   // by internal name
- * networkByAny("eip155:1")  // by CAIP-2
- * networkByAny("42161")     // by chain ID string
+ * 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
@@ -7108,7 +7270,8 @@ function networkByAny(v) {
     return networkByAny$1(v, _idx);
 }
 /**
- * Look up a chain by its numeric chain ID.
+ * 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
  */
@@ -7116,7 +7279,8 @@ function networkById(id) {
     return networkById$1(id, _idx);
 }
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  *
  * @throws {NetworkNotFoundError} if no matching chain is found
  */
@@ -7135,7 +7299,9 @@ function networkByString(s) {
     return networkByString$1(s, _idx);
 }
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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
  */
@@ -7143,16 +7309,21 @@ function networkByCAIP2(caip2) {
     return networkByCAIP2$1(caip2, _idx);
 }
 
+exports.ALL_NETWORKS = ALL_NETWORKS;
 exports.MAINNET_CHAINS = MAINNET_CHAINS;
+exports.NON_EVM_CHAINS = NON_EVM_CHAINS;
+exports.NON_EVM_CHAIN_ID = NON_EVM_CHAIN_ID;
 exports.NetworkNotFoundError = NetworkNotFoundError;
 exports.arbitrum = arbitrum;
 exports.avalanche = avalanche;
 exports.base = base;
+exports.bitcoin = bitcoin;
 exports.blast = blast;
 exports.bob = bob;
 exports.boba = boba;
 exports.bsc = bsc;
 exports.buildNetworkIndex = buildNetworkIndex;
+exports.caip2Reference = caip2Reference;
 exports.celo = celo;
 exports.corn = corn;
 exports.etherlink = etherlink;
@@ -7164,11 +7335,14 @@ exports.gnosis = gnosis;
 exports.goat = goat;
 exports.hemi = hemi;
 exports.hyperevm = hyperevm;
+exports.isEvmChain = isEvmChain;
+exports.isNonEvmChain = isNonEvmChain;
 exports.lens = lens;
 exports.lightlink = lightlink;
 exports.linea = linea;
 exports.lisk = lisk;
 exports.mainnet = mainnet;
+exports.makeConfig = makeConfig;
 exports.manta = manta;
 exports.mantle = mantle;
 exports.matchain = matchain;

package/dist/types/index.d.ts

@@ -1,7 +1,9 @@
 export * from "./definitions/index";
+export * from "./non-evm/index";
 export * from "./spec/index";
 export * from "./util/caip2";
-export { NetworkNotFoundError, type NetworkIndex, buildNetworkIndex, } from "./util/lookup";
+export { makeConfig } from "./util/index";
+export { buildNetworkIndex, type NetworkIndex, NetworkNotFoundError, } from "./util/lookup";
 import type { IChainInfo } from "./spec";
 export declare const MAINNET_CHAINS: readonly [Readonly<{
     name: "Arbitrum";
@@ -10762,6 +10764,19 @@ export declare const MAINNET_CHAINS: readonly [Readonly<{
 } & {
     caip2Namespace: string;
 }>];
+/**
+ * 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.
+ */
+export declare const NON_EVM_CHAINS: readonly IChainInfo[];
+/**
+ * All networks, EVM and non-EVM. Use this when you need to enumerate every
+ * supported chain regardless of type.
+ */
+export declare const ALL_NETWORKS: readonly IChainInfo[];
 /**
  * Resolve a chain from an arbitrary input. Accepts:
  * - `number`: treated as chain ID
@@ -10771,27 +10786,35 @@ export declare const MAINNET_CHAINS: readonly [Readonly<{
  *
  * 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
+ * networkByAny(1)           // by chain ID (EVM)
  * networkByAny("mainnet")   // by internal name
- * networkByAny("eip155:1")  // by CAIP-2
- * networkByAny("42161")     // by chain ID string
+ * 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
  */
 export declare function networkByAny(v: string | number | IChainInfo): IChainInfo;
 /**
- * Look up a chain by its numeric chain ID.
+ * 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
  */
 export declare function networkById(id: number): IChainInfo;
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  *
  * @throws {NetworkNotFoundError} if no matching chain is found
  */
@@ -10806,7 +10829,9 @@ export declare function networkByName(name: string): IChainInfo;
  */
 export declare function networkByString(s: string): IChainInfo;
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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
  */

package/dist/types/non-evm/bitcoin.d.ts

@@ -0,0 +1,83 @@
+export declare const bitcoin: Readonly<{
+    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: never[];
+    stables: never[];
+    watchlist: never[];
+    v4Watchlist: never[];
+    externalId: {
+        coingecko: string;
+    };
+    markets: {};
+    bridges: {};
+    oracles: {
+        coingecko: {
+            slug: string;
+            native: string;
+        };
+    };
+    uniswap: {};
+    morpho: {};
+    token: {};
+    oku: {};
+    contracts: {
+        nftManager: {
+            address: "0x0000000000000000000000000000000000000000";
+        };
+    };
+    blockExplorers: {
+        readonly default: {
+            readonly name: "mempool.space";
+            readonly url: "https://mempool.space";
+            readonly apiUrl: "https://mempool.space/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 0;
+    name: "Bitcoin";
+    nativeCurrency: {
+        readonly name: "Bitcoin";
+        readonly symbol: "BTC";
+        readonly decimals: 8;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://bitcoin-rpc.publicnode.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+} & {
+    caip2Namespace: string;
+}>;

package/dist/types/non-evm/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Non-EVM chain definitions.
+ *
+ * This folder holds chains that are not EVM-based and therefore do not extend
+ * viem's `Chain` (they have no numeric chain id). Each file exports an
+ * {@link INonEvmChainInfo} built via {@link makeNonEvmConfig}. These chains are
+ * resolvable only via CAIP-2 (and internal name), never via a numeric id.
+ *
+ * This barrel is maintained by hand (barrelsby only regenerates
+ * `src/definitions/`). Re-export new chains here when you add them.
+ */
+export * from "./bitcoin";

package/dist/types/spec/index.d.ts

@@ -164,6 +164,19 @@ export interface Oracles {
 }
 export interface IChainInfo<formatters extends ChainFormatters | undefined = ChainFormatters | undefined> extends Chain<formatters> {
     caip2Namespace: string;
+    /**
+     * Explicit CAIP-2 reference component.
+     *
+     * When set, it is used verbatim as the reference half of the chain's CAIP-2
+     * identifier (e.g. Bitcoin's genesis hash prefix
+     * "000000000019d6689c085ae165831e93"). When omitted, the reference is
+     * derived from the numeric `id` (the historical behavior, e.g. "1" for
+     * Ethereum mainnet).
+     *
+     * Non-EVM chains (which use `id: 0` as a placeholder since viem requires a
+     * numeric id) MUST set this so their CAIP-2 identifier resolves correctly.
+     */
+    caip2Reference?: string;
     logoUrl: string;
     launchTime: number;
     nativeLogoUrl: string;
@@ -219,3 +232,21 @@ export interface IChainInfo<formatters extends ChainFormatters | undefined = Cha
         metrom?: ChainContract;
     };
 }
+/**
+ * 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.
+ */
+export declare 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.
+ */
+export declare function isNonEvmChain(c: IChainInfo): boolean;
+/** True if the chain is an EVM chain. Inverse of {@link isNonEvmChain}. */
+export declare function isEvmChain(c: IChainInfo): boolean;

package/dist/types/util/caip2.d.ts

@@ -26,14 +26,25 @@ export declare function parseCAIP2(caip2: string): CAIP2Identifier;
  * ```
  */
 export declare function formatCAIP2(id: CAIP2Identifier): string;
+/**
+ * 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).
+ */
+export declare function caip2Reference(chain: IChainInfo): string;
 /**
  * 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"
  * ```
  */
 export declare function toCAIP2(chain: IChainInfo): string;

package/dist/types/util/lookup.d.ts

@@ -16,18 +16,27 @@ export interface NetworkIndex {
 /**
  * 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.
  */
 export declare function buildNetworkIndex(chains: readonly IChainInfo[]): NetworkIndex;
 /**
- * Look up a chain by its numeric chain ID.
+ * 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.
  */
 export declare function networkById(id: number, idx: NetworkIndex): IChainInfo;
 /**
- * Look up a chain by its internal name (e.g. "arbitrum", "mainnet").
+ * Look up a chain by its internal name (e.g. "arbitrum", "mainnet",
+ * "bitcoin").
  */
 export declare function networkByName(name: string, idx: NetworkIndex): IChainInfo;
 /**
- * Look up a chain by its CAIP-2 identifier string (e.g. "eip155:1").
+ * 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.
  */
 export declare function networkByCAIP2(caip2: string, idx: NetworkIndex): IChainInfo;
 /**
@@ -36,16 +45,22 @@ export declare function networkByCAIP2(caip2: string, idx: NetworkIndex): IChain
  * 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.
  */
 export declare function networkByString(s: string, idx: NetworkIndex): IChainInfo;
 /**
  * Resolve a chain from an arbitrary input. Accepts:
- * - `number`: treated as chain ID
+ * - `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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gfxlabs/oku-chains",
-  "version": "1.12.4",
+  "version": "1.12.5",
   "license": "MIT",
   "main": "./dist/index.js",
   "module": "./dist/index-mjs.js",