@gfxlabs/oku-chains 1.12.4 → 1.12.6

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,77 @@ 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;
+/**
+ * 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 | string): 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.6",
   "license": "MIT",
   "main": "./dist/index.js",
   "module": "./dist/index-mjs.js",