@gfxlabs/oku-chains 1.12.4 → 1.12.6

package/dist/browser.js

@@ -6845,6 +6845,196 @@
         },
     });
 
+    /**
+     * 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;
+    /**
+     * High-level chain family, derived from the chain's CAIP-2 namespace.
+     *
+     * The underlying string value of each member is the CAIP-2 namespace it maps
+     * to (e.g. `eip155` for EVM, `bip122` for Bitcoin), so {@link chainType} can
+     * resolve a chain's type directly from its `caip2Namespace` without relying on
+     * sentinel values like {@link NON_EVM_CHAIN_ID}.
+     *
+     * @see https://chainagnostic.org/CAIPs/caip-2
+     */
+    exports.ChainType = void 0;
+    (function (ChainType) {
+        /** EVM chains (CAIP-2 namespace `eip155`). */
+        ChainType["EVM"] = "eip155";
+        /** Bitcoin (CAIP-2 namespace `bip122`). */
+        ChainType["Bitcoin"] = "bip122";
+        /** Solana (CAIP-2 namespace `solana`). */
+        ChainType["Solana"] = "solana";
+        /** Unknown / unrecognized CAIP-2 namespace. */
+        ChainType["Unknown"] = "";
+    })(exports.ChainType || (exports.ChainType = {}));
+    /** All recognized CAIP-2 namespaces, keyed by {@link ChainType}. */
+    const CHAIN_TYPE_BY_NAMESPACE = {
+        [exports.ChainType.EVM]: exports.ChainType.EVM,
+        [exports.ChainType.Bitcoin]: exports.ChainType.Bitcoin,
+        [exports.ChainType.Solana]: exports.ChainType.Solana,
+    };
+    /**
+     * Resolve a CAIP-2 namespace from a chain-like value:
+     * - an {@link IChainInfo} object: its `caip2Namespace`
+     * - a CAIP-2 identifier string (e.g. `"eip155:1"`): the part before the `:`
+     * - a bare namespace string (e.g. `"eip155"`): used verbatim
+     *
+     * Note: a bare internal name (e.g. `"bitcoin"`) or numeric id is NOT a CAIP-2
+     * namespace and resolves to {@link ChainType.Unknown} here. Use the
+     * index-bound `chainType`/`isNetworkType` in the package entrypoint to resolve
+     * those (they look the chain up first).
+     */
+    function namespaceOf(c) {
+        if (typeof c === "string") {
+            const sep = c.indexOf(":");
+            return sep === -1 ? c : c.slice(0, sep);
+        }
+        return c.caip2Namespace;
+    }
+    /**
+     * The {@link ChainType} of a chain, derived from its CAIP-2 namespace.
+     *
+     * Accepts an {@link IChainInfo} object or a CAIP-2 string (a full identifier
+     * like `"eip155:1"` or a bare namespace like `"bip122"`). This is the
+     * canonical way to determine a chain's family. Prefer it over inspecting the
+     * numeric `id` (which is a placeholder for non-EVM chains).
+     *
+     * @example
+     * ```ts
+     * import { mainnet, bitcoin } from "@gfxlabs/oku-chains";
+     * chainType(mainnet)        // => ChainType.EVM
+     * chainType(bitcoin)        // => ChainType.Bitcoin
+     * chainType("eip155:1")     // => ChainType.EVM
+     * chainType("bip122")       // => ChainType.Bitcoin
+     * ```
+     */
+    function chainType$1(c) {
+        return CHAIN_TYPE_BY_NAMESPACE[namespaceOf(c)] ?? exports.ChainType.Unknown;
+    }
+    /**
+     * True if the chain belongs to the given {@link ChainType} family.
+     *
+     * Reusable, namespace-driven replacement for one-off `isBitcoinChain` style
+     * checks. The chain may be an {@link IChainInfo} object or a CAIP-2 string.
+     *
+     * @example
+     * ```ts
+     * import { ChainType, isNetworkType, bitcoin } from "@gfxlabs/oku-chains";
+     * isNetworkType(ChainType.Bitcoin, bitcoin)        // => true
+     * isNetworkType(ChainType.EVM, bitcoin)            // => false
+     * isNetworkType(ChainType.EVM, "eip155:1")         // => true
+     * ```
+     */
+    function isNetworkType$1(type, c) {
+        return chainType$1(c) === type;
+    }
+    /**
+     * True if the chain is an EVM chain (CAIP-2 namespace `eip155`). Accepts an
+     * {@link IChainInfo} object or a CAIP-2 string.
+     */
+    function isEvmChain$1(c) {
+        return isNetworkType$1(exports.ChainType.EVM, c);
+    }
+    /**
+     * True if the chain is non-EVM (i.e. its CAIP-2 namespace is not `eip155`).
+     * 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. Accepts an {@link IChainInfo} object or a CAIP-2 string.
+     */
+    function isNonEvmChain$1(c) {
+        return !isEvmChain$1(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 +7068,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 +7111,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 +7130,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 +7161,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 +7172,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 +7191,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 +7221,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 +7302,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 +7334,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 +7356,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 +7365,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,25 +7385,120 @@
         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
      */
     function networkByCAIP2(caip2) {
         return networkByCAIP2$1(caip2, _idx);
     }
+    /**
+     * Resolve a {@link ChainLike} input to the chain's `caip2Namespace`. Returns
+     * `""` (→ {@link ChainType.Unknown}) when the input cannot be classified.
+     */
+    function namespaceOfChainLike(c) {
+        if (typeof c === "object") {
+            return c.caip2Namespace;
+        }
+        if (typeof c === "string") {
+            // Full CAIP-2 identifier (namespace:reference) — classify by namespace.
+            const sep = c.indexOf(":");
+            if (sep !== -1) {
+                return c.slice(0, sep);
+            }
+            // Bare CAIP-2 namespace (e.g. "eip155", "bip122").
+            if (Object.values(exports.ChainType).includes(c) && c !== "") {
+                return c;
+            }
+            // Otherwise treat as an internal name or numeric id string: resolve it.
+            try {
+                return networkByString$1(c, _idx).caip2Namespace;
+            }
+            catch {
+                return "";
+            }
+        }
+        // Numeric chain id.
+        try {
+            return networkById$1(Math.trunc(c), _idx).caip2Namespace;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * The {@link ChainType} of a chain. Accepts an {@link IChainInfo} object, a
+     * CAIP-2 identifier or namespace string, an internal name, or a numeric chain
+     * id. Internal names and numeric ids are resolved via the network index.
+     *
+     * @example
+     * ```ts
+     * import { chainType, ChainType } from "@gfxlabs/oku-chains";
+     * chainType(1)            // => ChainType.EVM
+     * chainType("mainnet")    // => ChainType.EVM
+     * chainType("eip155:1")   // => ChainType.EVM
+     * chainType("bitcoin")    // => ChainType.Bitcoin
+     * chainType("bip122")     // => ChainType.Bitcoin
+     * ```
+     */
+    function chainType(c) {
+        return chainType$1(namespaceOfChainLike(c));
+    }
+    /**
+     * True if the chain belongs to the given {@link ChainType} family. Accepts an
+     * {@link IChainInfo} object, a CAIP-2 identifier or namespace string, an
+     * internal name, or a numeric chain id.
+     *
+     * Reusable, namespace-driven replacement for one-off `isBitcoinChain` style
+     * checks, e.g. `isNetworkType(ChainType.Bitcoin, "bitcoin")`.
+     *
+     * @example
+     * ```ts
+     * import { isNetworkType, ChainType } from "@gfxlabs/oku-chains";
+     * isNetworkType(ChainType.Bitcoin, "bitcoin")   // => true
+     * isNetworkType(ChainType.EVM, 1)               // => true
+     * isNetworkType(ChainType.EVM, "eip155:1")      // => true
+     * ```
+     */
+    function isNetworkType(type, c) {
+        return isNetworkType$1(type, namespaceOfChainLike(c));
+    }
+    /**
+     * True if the chain is an EVM chain (CAIP-2 namespace `eip155`). Accepts an
+     * {@link IChainInfo} object, a CAIP-2 string, an internal name, or a numeric
+     * chain id.
+     */
+    function isEvmChain(c) {
+        return isEvmChain$1(namespaceOfChainLike(c));
+    }
+    /**
+     * True if the chain is non-EVM (its CAIP-2 namespace is not `eip155`). Accepts
+     * an {@link IChainInfo} object, a CAIP-2 string, an internal name, or a
+     * numeric chain id.
+     */
+    function isNonEvmChain(c) {
+        return isNonEvmChain$1(namespaceOfChainLike(c));
+    }
 
+    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.chainType = chainType;
     exports.corn = corn;
     exports.etherlink = etherlink;
     exports.filecoin = filecoin;
@@ -7165,11 +7509,15 @@
     exports.goat = goat;
     exports.hemi = hemi;
     exports.hyperevm = hyperevm;
+    exports.isEvmChain = isEvmChain;
+    exports.isNetworkType = isNetworkType;
+    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;