@gfxlabs/oku-chains 1.12.5 → 1.12.6

package/dist/browser.js

@@ -6855,17 +6855,102 @@
      */
     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.
+     * 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
      */
-    function isNonEvmChain(c) {
-        return c.id === NON_EVM_CHAIN_ID && c.caip2Namespace !== "eip155";
+    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;
     }
-    /** True if the chain is an EVM chain. Inverse of {@link isNonEvmChain}. */
-    function isEvmChain(c) {
-        return !isNonEvmChain(c);
+    /**
+     * 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);
     }
 
     /**
@@ -7309,6 +7394,93 @@
     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;
@@ -7326,6 +7498,7 @@
     exports.buildNetworkIndex = buildNetworkIndex;
     exports.caip2Reference = caip2Reference;
     exports.celo = celo;
+    exports.chainType = chainType;
     exports.corn = corn;
     exports.etherlink = etherlink;
     exports.filecoin = filecoin;
@@ -7337,6 +7510,7 @@
     exports.hemi = hemi;
     exports.hyperevm = hyperevm;
     exports.isEvmChain = isEvmChain;
+    exports.isNetworkType = isNetworkType;
     exports.isNonEvmChain = isNonEvmChain;
     exports.lens = lens;
     exports.lightlink = lightlink;

package/dist/index-mjs.js

@@ -6852,17 +6852,102 @@ const zkSync = makeConfig({
  */
 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.
+ * 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
  */
-function isNonEvmChain(c) {
-    return c.id === NON_EVM_CHAIN_ID && c.caip2Namespace !== "eip155";
+var ChainType;
+(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"] = "";
+})(ChainType || (ChainType = {}));
+/** All recognized CAIP-2 namespaces, keyed by {@link ChainType}. */
+const CHAIN_TYPE_BY_NAMESPACE = {
+    [ChainType.EVM]: ChainType.EVM,
+    [ChainType.Bitcoin]: ChainType.Bitcoin,
+    [ChainType.Solana]: 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;
 }
-/** True if the chain is an EVM chain. Inverse of {@link isNonEvmChain}. */
-function isEvmChain(c) {
-    return !isNonEvmChain(c);
+/**
+ * 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)] ?? 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(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);
 }
 
 /**
@@ -7306,5 +7391,92 @@ function networkByString(s) {
 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(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));
+}
 
-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 };
+export { ALL_NETWORKS, ChainType, MAINNET_CHAINS, NON_EVM_CHAINS, NON_EVM_CHAIN_ID, NetworkNotFoundError, arbitrum, avalanche, base, bitcoin, blast, bob, boba, bsc, buildNetworkIndex, caip2Reference, celo, chainType, corn, etherlink, filecoin, formatCAIP2, fromCAIP2, gensyn, gnosis, goat, hemi, hyperevm, isEvmChain, isNetworkType, 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

@@ -6854,17 +6854,102 @@ const zkSync = makeConfig({
  */
 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.
+ * 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
  */
-function isNonEvmChain(c) {
-    return c.id === NON_EVM_CHAIN_ID && c.caip2Namespace !== "eip155";
+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;
 }
-/** True if the chain is an EVM chain. Inverse of {@link isNonEvmChain}. */
-function isEvmChain(c) {
-    return !isNonEvmChain(c);
+/**
+ * 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);
 }
 
 /**
@@ -7308,6 +7393,93 @@ function networkByString(s) {
 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;
@@ -7325,6 +7497,7 @@ exports.bsc = bsc;
 exports.buildNetworkIndex = buildNetworkIndex;
 exports.caip2Reference = caip2Reference;
 exports.celo = celo;
+exports.chainType = chainType;
 exports.corn = corn;
 exports.etherlink = etherlink;
 exports.filecoin = filecoin;
@@ -7336,6 +7509,7 @@ exports.goat = goat;
 exports.hemi = hemi;
 exports.hyperevm = hyperevm;
 exports.isEvmChain = isEvmChain;
+exports.isNetworkType = isNetworkType;
 exports.isNonEvmChain = isNonEvmChain;
 exports.lens = lens;
 exports.lightlink = lightlink;

package/dist/types/index.d.ts

@@ -5,6 +5,7 @@ export * from "./util/caip2";
 export { makeConfig } from "./util/index";
 export { buildNetworkIndex, type NetworkIndex, NetworkNotFoundError, } from "./util/lookup";
 import type { IChainInfo } from "./spec";
+import { ChainType } from "./spec";
 export declare const MAINNET_CHAINS: readonly [Readonly<{
     name: "Arbitrum";
     launchTime: 1688997600;
@@ -10836,3 +10837,59 @@ export declare function networkByString(s: string): IChainInfo;
  * @throws {NetworkNotFoundError} if no matching chain is found
  */
 export declare function networkByCAIP2(caip2: string): IChainInfo;
+/**
+ * Accepted input for the chain-family helpers ({@link chainType},
+ * {@link isNetworkType}, etc.).
+ *
+ * - `IChainInfo`: classified by its `caip2Namespace`.
+ * - CAIP-2 string (contains `:`, e.g. `"eip155:1"`) or bare namespace
+ *   (e.g. `"bip122"`): classified directly by the namespace, no lookup needed.
+ * - internal name (e.g. `"bitcoin"`) or numeric id / id string: resolved to a
+ *   chain via the network index first, then classified.
+ */
+export type ChainLike = IChainInfo | string | number;
+/**
+ * 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
+ * ```
+ */
+export declare function chainType(c: ChainLike): ChainType;
+/**
+ * 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
+ * ```
+ */
+export declare function isNetworkType(type: ChainType, c: ChainLike): boolean;
+/**
+ * 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.
+ */
+export declare function isEvmChain(c: ChainLike): boolean;
+/**
+ * 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.
+ */
+export declare function isNonEvmChain(c: ChainLike): boolean;

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

@@ -242,11 +242,67 @@ export interface IChainInfo<formatters extends ChainFormatters | undefined = Cha
  */
 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.
+ * 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
+ */
+export declare enum ChainType {
+    /** EVM chains (CAIP-2 namespace `eip155`). */
+    EVM = "eip155",
+    /** Bitcoin (CAIP-2 namespace `bip122`). */
+    Bitcoin = "bip122",
+    /** Solana (CAIP-2 namespace `solana`). */
+    Solana = "solana",
+    /** Unknown / unrecognized CAIP-2 namespace. */
+    Unknown = ""
+}
+/**
+ * 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
+ * ```
+ */
+export declare function chainType(c: IChainInfo | string): ChainType;
+/**
+ * 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
+ * ```
+ */
+export declare function isNetworkType(type: ChainType, c: IChainInfo | string): boolean;
+/**
+ * True if the chain is an EVM chain (CAIP-2 namespace `eip155`). Accepts an
+ * {@link IChainInfo} object or a CAIP-2 string.
+ */
+export declare function isEvmChain(c: IChainInfo | string): boolean;
+/**
+ * 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.
  */
-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;
+export declare function isNonEvmChain(c: IChainInfo | string): boolean;

package/package.json

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