@ickb/sdk 1000.0.82 → 9000.0.1

package/src/utils/chain.ts

@@ -0,0 +1,43 @@
+import type { ccc } from "@ckb-ccc/core";
+
+/** Public CKB networks supported by Stack consumers. */
+export type SupportedChain = "mainnet" | "testnet";
+
+/** Canonical public identity of one supported CKB network. */
+export interface ChainIdentity {
+  /** Stack network selector represented by this identity. */
+  readonly chain: SupportedChain;
+  /** CKB specification network name. */
+  readonly networkName: string;
+  /** Canonical genesis block hash. */
+  readonly genesisHash: ccc.Hex;
+  /** Canonical genesis message used by the CKB specification. */
+  readonly genesisMessage: string;
+  /** Public specification location from which the genesis identity was derived. */
+  readonly genesisSource: string;
+  /** Canonical address prefix for this network. */
+  readonly addressPrefix: "ckb" | "ckt";
+}
+
+/** The immutable canonical identity of each supported chain. */
+export const chainIdentities = Object.freeze({
+  mainnet: Object.freeze({
+    chain: "mainnet",
+    networkName: "ckb",
+    genesisHash: "0x92b197aa1fba0f63633922c61c92375c9c074a93e85963554f5499fe1450d0e5",
+    genesisMessage:
+      "lina 0x18e020f6b1237a3d06b75121f25a7efa0550e4b3f44f974822f471902424c104",
+    genesisSource:
+      "https://raw.githubusercontent.com/nervosnetwork/ckb/develop/resource/specs/mainnet.toml",
+    addressPrefix: "ckb",
+  }),
+  testnet: Object.freeze({
+    chain: "testnet",
+    networkName: "ckb_testnet",
+    genesisHash: "0x10639e0895502b5688a6be8cf69460d76541bfa4821629d86d62ba0aae3f9606",
+    genesisMessage: "aggron-v4",
+    genesisSource:
+      "https://raw.githubusercontent.com/nervosnetwork/ckb/develop/resource/specs/testnet.toml",
+    addressPrefix: "ckt",
+  }),
+} as const satisfies Record<SupportedChain, ChainIdentity>);

package/src/utils/codec.ts

@@ -0,0 +1,74 @@
+import { ccc } from "@ckb-ccc/core";
+
+/**
+ * Codec for little-endian 32-bit signed integers.
+ *
+ * @remarks
+ * The encoder rejects numeric values outside the signed 32-bit range before
+ * writing bytes. Decoding reads a signed little-endian integer from the bytes
+ * after CCC byte normalization.
+ */
+export const CheckedInt32LE = ccc.Codec.from<ccc.NumLike, number>({
+  byteLength: 4,
+  encode: (numLike) => {
+    const normalized = normalizeInteger(numLike);
+    if (normalized < -2147483648n || normalized > 2147483647n) {
+      throw new Error("NumLike out of int32 bounds");
+    }
+    const num = Number(normalized);
+    const encoded = new Uint8Array(4);
+    new DataView(encoded.buffer).setInt32(0, num, true);
+    return encoded;
+  },
+  decode: (bytesLike) => {
+    const bytes = ccc.bytesFrom(bytesLike);
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getInt32(
+      0,
+      true,
+    );
+  },
+});
+
+/** Checked codec for 8-bit unsigned integers. */
+export const CheckedUint8 = checkedUintLE(1);
+
+/** Checked codec for little-endian 32-bit unsigned integers. */
+export const CheckedUint32LE = checkedUintLE(4);
+
+/** Checked codec for little-endian 64-bit unsigned integers. */
+export const CheckedUint64LE = checkedUintLE(8);
+
+/** Checked codec for little-endian 128-bit unsigned integers. */
+export const CheckedUint128LE = checkedUintLE(16);
+
+function checkedUintLE(byteLength: number): ccc.Codec<ccc.NumLike, ccc.Num> {
+  const bitLength = BigInt(byteLength * 8);
+  const max = (1n << bitLength) - 1n;
+  return ccc.Codec.from({
+    byteLength,
+    encode: (numLike: ccc.NumLike) => {
+      const num = normalizeInteger(numLike);
+      if (num < 0n || num > max) {
+        throw new Error(`NumLike out of uint${String(bitLength)} bounds`);
+      }
+      return ccc.numLeToBytes(num, byteLength);
+    },
+    decode: ccc.numFromBytes,
+  });
+}
+
+function normalizeInteger(numLike: ccc.NumLike): ccc.Num {
+  if (typeof numLike === "number") {
+    if (!Number.isFinite(numLike) || !Number.isInteger(numLike)) {
+      throw new TypeError("NumLike must be a finite integer");
+    }
+    if (!Number.isSafeInteger(numLike)) {
+      throw new TypeError("NumLike number must be a safe integer");
+    }
+  }
+  try {
+    return ccc.numFrom(numLike);
+  } catch {
+    throw new TypeError("NumLike must be a finite integer");
+  }
+}

package/src/utils/transaction_header.ts

@@ -0,0 +1,66 @@
+import type { ccc } from "@ckb-ccc/core";
+import { jsonRpcRequestor, rawTransactionStatus } from "./utils.ts";
+
+/**
+ * The header of the block that committed `txHash`, without the transaction body, which no
+ * caller reads. A client with a JSON-RPC requestor, the connector's composed client
+ * included, asks the node for the status only (verbosity 1) and then the header by number,
+ * which CCC caches once confirmed; a cold read of the pool then moves a few bytes per
+ * deposit instead of every deposit transaction. Any other client keeps the typed lookup.
+ */
+export async function getTransactionHeader(
+  client: ccc.Client,
+  txHash: ccc.Hex,
+): Promise<ccc.ClientBlockHeader | undefined> {
+  const requestor = jsonRpcRequestor(client);
+  if (requestor === undefined) {
+    return (await client.getTransactionWithHeader(txHash))?.header;
+  }
+  const { blockNumber } = rawTransactionStatus(
+    await requestor.request("get_transaction", [txHash, "0x1"]),
+  );
+  return blockNumber === undefined ? undefined : client.getHeaderByNumber(blockNumber);
+}
+
+/**
+ * The committing headers of a batch of transactions, each hash read once. A batch is one
+ * coherent read: the cells came from one scan, so every header must exist.
+ */
+export async function transactionHeaders(
+  client: ccc.Client,
+  txHashes: Iterable<ccc.Hex>,
+): Promise<Map<ccc.Hex, ccc.ClientBlockHeader>> {
+  const distinct = [...new Set(txHashes)];
+  const headers = await Promise.all(
+    distinct.map(async (txHash) => getTransactionHeader(client, txHash)),
+  );
+  return new Map(
+    distinct.map((txHash, index) => {
+      const header = headers[index];
+      if (header === undefined) {
+        throw new Error(`Header not found for txHash ${txHash}`);
+      }
+      return [txHash, header];
+    }),
+  );
+}
+
+/** The headers of a batch of block numbers, each read once; every block must exist. */
+export async function headersByNumber(
+  client: ccc.Client,
+  blockNumbers: Iterable<ccc.Num>,
+): Promise<Map<ccc.Num, ccc.ClientBlockHeader>> {
+  const distinct = [...new Set(blockNumbers)];
+  const headers = await Promise.all(
+    distinct.map(async (blockNumber) => client.getHeaderByNumber(blockNumber)),
+  );
+  return new Map(
+    distinct.map((blockNumber, index) => {
+      const header = headers[index];
+      if (header === undefined) {
+        throw new Error(`Header not found for block number ${String(blockNumber)}`);
+      }
+      return [blockNumber, header];
+    }),
+  );
+}

package/src/utils/utils.ts

@@ -0,0 +1,237 @@
+import { ccc } from "@ckb-ccc/core";
+
+/**
+ * The default page size used when querying cells from the chain.
+ *
+ * This page size is aligned with Nervos CKB's pull request #4576
+ * (https://github.com/nervosnetwork/ckb/pull/4576) to avoid excessive paging.
+ */
+export const defaultCellPageSize = 400;
+
+/**
+ * Reads every committed cell matching the key, page by page, without touching
+ * CCC's cell cache. The scan ends on the first short page.
+ *
+ * @remarks A full page must advance the cursor; otherwise the read throws so a faulty
+ * endpoint in the app's public node pool cannot keep the scan looping forever.
+ * The cursor continues ordering, not a coherent snapshot. There is no aggregate budget:
+ * a large book costs a slower read rather than a partial result.
+ */
+export async function findCells(
+  client: ccc.Client,
+  keyLike: ccc.ClientIndexerSearchKeyLike,
+): Promise<ccc.Cell[]> {
+  const key = ccc.ClientIndexerSearchKey.from(keyLike);
+  const cells: ccc.Cell[] = [];
+  let after: string | undefined;
+  for (;;) {
+    const page = await client.findCellsPagedNoCache(
+      key,
+      "asc",
+      defaultCellPageSize,
+      after,
+    );
+    cells.push(...page.cells);
+    if (page.cells.length < defaultCellPageSize) {
+      return cells;
+    }
+    if (page.lastCursor === after) {
+      throw new Error("Cell scan cursor did not advance");
+    }
+    after = page.lastCursor;
+  }
+}
+
+/**
+ * Local transaction inclusion metadata.
+ */
+export interface TransactionHeader {
+  /**
+   * The block header used for inclusion-dependent calculations.
+   */
+  header: ccc.ClientBlockHeader;
+
+  /**
+   * The transaction hash when the caller has resolved it for the header.
+   */
+  txHash?: ccc.Hex;
+}
+
+/**
+ * CKB and UDT amounts carried by a cell, order, or planned value.
+ */
+export interface ValueComponents {
+  /** CKB-side amount as a `ccc.FixedPoint`. */
+  ckbValue: ccc.FixedPoint;
+
+  /** UDT-side amount as a `ccc.FixedPoint`. */
+  udtValue: ccc.FixedPoint;
+}
+
+/**
+ * Integer scale pair for comparing or converting CKB-side and UDT-side values.
+ *
+ * @remarks
+ * CKB-to-UDT conversions multiply by `ckbScale` and divide by `udtScale`.
+ * UDT-to-CKB conversions swap the scales. Callers choose the rounding policy.
+ */
+export interface ExchangeRatio {
+  /** Numerator scale for CKB-side values. */
+  ckbScale: ccc.Num;
+
+  /** Numerator scale for UDT-side values. */
+  udtScale: ccc.Num;
+}
+
+/**
+ * Script plus cell dependencies needed to build transactions that use it.
+ */
+export interface ScriptDeps {
+  /**
+   * The lock or type script.
+   */
+  script: ccc.Script;
+
+  /**
+   * Cell dependencies required to resolve the script code.
+   */
+  cellDeps: ccc.CellDep[];
+}
+
+/**
+ * True when a cell has no type script and no data payload.
+ *
+ * @remarks
+ * This is a structural filter for plain capacity cells. Spendability still
+ * depends on the lock script, live cell state, and transaction context.
+ */
+export function isPlainCapacityCell(cell: ccc.Cell): boolean {
+  return cell.cellOutput.type === undefined && cell.outputData === "0x";
+}
+
+/**
+ * Performs asynchronously a binary search to find the smallest index `i` in the range [0, n)
+ * such that the function `f(i)` returns true. It is assumed that for the range
+ * [0, n), if `f(i)` is true, then `f(i+1)` is also true. This means that there
+ * is a prefix of the input range where `f` is false, followed by a suffix where
+ * `f` is true. If no such index exists, the function returns `n`.
+ *
+ * The function `f` is only called for indices in the range [0, n).
+ *
+ * @param n - The non-negative integer upper bound of the search range (exclusive).
+ * @param f - An async function that takes an index `i` and returns a boolean value.
+ * @returns The smallest index `i` such that `f(i)` is true, or `n` if no such index exists.
+ *
+ * @remarks Adapted from Go's standard library search implementation:
+ * {@link https://go.dev/src/sort/search.go}
+ */
+export async function asyncBinarySearch(
+  n: number,
+  f: (i: number) => Promise<boolean>,
+): Promise<number> {
+  // Define f(-1) == false and f(n) == true.
+  // Invariant: f(i-1) == false, f(j) == true.
+  let [i, j] = [0, n];
+  while (i < j) {
+    const h = Math.trunc((i + j) / 2);
+    // i ≤ h < j
+    if (!(await f(h))) {
+      i = h + 1; // preserves f(i-1) == false
+    } else {
+      j = h; // preserves f(j) == true
+    }
+  }
+  // i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
+  return i;
+}
+
+/**
+ * The client's JSON-RPC requestor, when it has one. The connector hands the interface a
+ * composition proxy over the public client (`ClientWithFeeRate`, a `ccc.Client` but not a
+ * `ccc.ClientJsonRpc`), so `instanceof` misses it; the proxy forwards the property.
+ */
+export function jsonRpcRequestor(client: ccc.Client): ccc.RequestorJsonRpc | undefined {
+  if (!("requestor" in client)) {
+    return undefined;
+  }
+  const { requestor } = client;
+  return requestor instanceof ccc.RequestorJsonRpc ? requestor : undefined;
+}
+
+/** A node's raw `get_transaction` status record (verbosity 1), the fields the stack reads. */
+export function rawTransactionStatus(response: unknown): {
+  status: string | undefined;
+  reason: string | undefined;
+  blockNumber: ccc.Num | undefined;
+} {
+  const record =
+    typeof response === "object" &&
+    response !== null &&
+    "tx_status" in response &&
+    typeof response.tx_status === "object" &&
+    response.tx_status !== null
+      ? response.tx_status
+      : {};
+  return {
+    status:
+      "status" in record && typeof record.status === "string" ? record.status : undefined,
+    reason:
+      "reason" in record && typeof record.reason === "string" ? record.reason : undefined,
+    blockNumber:
+      "block_number" in record && typeof record.block_number === "string"
+        ? ccc.numFrom(record.block_number)
+        : undefined,
+  };
+}
+
+export function minBigInt(left: bigint, right: bigint): bigint {
+  return left < right ? left : right;
+}
+
+export function maxBigInt(left: bigint, right: bigint): bigint {
+  return left > right ? left : right;
+}
+
+/** `numerator / denominator` rounded up; the denominator is positive. */
+export function ceilDiv(numerator: bigint, denominator: bigint): bigint {
+  return (numerator + denominator - 1n) / denominator;
+}
+
+/**
+ * Compares two bigint values using sort-compatible ordering.
+ *
+ * @returns `-1` when `left` is smaller, `1` when `left` is larger, and `0` when equal.
+ */
+export function compareBigInt(left: bigint, right: bigint): number {
+  if (left < right) {
+    return -1;
+  }
+
+  if (left > right) {
+    return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Yields unique items from the given iterable based on their hex representation.
+ *
+ * The function uses a Set to track the hex-string keys of items that have already been yielded.
+ * Only the first occurrence of each unique key is yielded.
+ *
+ * @typeParam T - A type that extends ccc.Entity.
+ * @param items - An iterable collection of items of type T.
+ * @returns A generator that yields items from the iterable, ensuring that each item's
+ *          hex representation (via toHex()) is unique.
+ */
+export function* unique<T extends ccc.Entity>(items: Iterable<T>): Generator<T> {
+  const set = new Set<string>();
+  for (const i of items) {
+    const key = i.toHex();
+    if (!set.has(key)) {
+      set.add(key);
+      yield i;
+    }
+  }
+}

package/dist/codec.d.ts

@@ -1,3 +0,0 @@
-import { mol } from "@ckb-ccc/core";
-export declare const PoolSnapshot: mol.Codec<number[], number[]>;
-//# sourceMappingURL=codec.d.ts.map

package/dist/codec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"../src/","sources":["codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,GAAG,EAAE,MAAM,eAAe,CAAC;AAgBzC,eAAO,MAAM,YAAY,+BAkDvB,CAAC"}

package/dist/codec.js

@@ -1,58 +0,0 @@
-import { ccc, mol } from "@ckb-ccc/core";
-import { max } from "@ickb/utils";
-const N = 1024;
-export const PoolSnapshot = mol.Codec.from({
-    encode: (bins) => {
-        if (bins.length !== N) {
-            throw new Error("Expected 1024 bins");
-        }
-        const bitsPerBin = computeBits(bins);
-        const buffer = new Uint8Array((bitsPerBin * N) >> 3);
-        let bitOffset = 0;
-        for (const count of bins) {
-            packBits(buffer, bitOffset, bitsPerBin, count);
-            bitOffset += bitsPerBin;
-        }
-        return buffer;
-    },
-    decode: (bufferLike) => {
-        const buffer = ccc.bytesFrom(bufferLike);
-        const bitsPerBin = (buffer.byteLength * 8) / N;
-        if (!Number.isInteger(bitsPerBin)) {
-            throw new Error("Invalid buffer length for 1024 bins");
-        }
-        const bins = new Array(N);
-        let bitOffset = 0;
-        for (let i = 0; i < N; i++) {
-            bins[i] = unpackBits(buffer, bitOffset, bitsPerBin);
-            bitOffset += bitsPerBin;
-        }
-        return bins;
-    },
-});
-function computeBits(bins) {
-    return Math.ceil(Math.log2(1 + max(1, ...bins)));
-}
-function packBits(buffer, bitOffset, width, value) {
-    let offset = bitOffset;
-    for (let i = 0; i < width; i++) {
-        const byteIndex = offset >> 3;
-        const bitInByte = offset % 8;
-        const bit = (value >> i) & 1;
-        buffer[byteIndex] |= bit << bitInByte;
-        offset++;
-    }
-}
-function unpackBits(buffer, bitOffset, width) {
-    let value = 0;
-    let offset = bitOffset;
-    for (let i = 0; i < width; i++) {
-        const byteIndex = offset >> 3;
-        const bitInByte = offset % 8;
-        const bit = (buffer[byteIndex] >> bitInByte) & 1;
-        value |= bit << i;
-        offset++;
-    }
-    return value;
-}
-//# sourceMappingURL=codec.js.map

package/dist/codec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec.js","sourceRoot":"../src/","sources":["codec.ts"],"names":[],"mappings":"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"}

package/src/codec.ts

@@ -1,138 +0,0 @@
-import { ccc, mol } from "@ckb-ccc/core";
-import { max } from "@ickb/utils";
-
-const N = 1024;
-
-/**
- * Codec for encoding and decoding a pool snapshot.
- *
- * The PoolSnapshotCodec encodes an array of 1024 numbers representing event counts for bins,
- * where the number of bits used per bin is dynamically computed as the ceiling of log2(max + 1)
- * across all bins. The codec provides methods to encode the array into a Uint8Array and decode
- * a Uint8Array back to the original array of numbers.
- *
- * @remarks The total number of bits for encoding all the bins is computed as bitsPerBin * 1024. The codec
- * does not have a fixed byteLength since it depends on the data.
- */
-export const PoolSnapshot = mol.Codec.from<number[]>({
-  /**
-   * Encodes an array of 1024 bin counts into a Uint8Array.
-   *
-   * @param bins - An array of 1024 numbers. Each number represents the event count for a bin.
-   * @returns A Uint8Array containing the packed bit representation of the bin counts.
-   * @throws Error if the input array does not contain exactly 1024 elements.
-   */
-  encode: (bins) => {
-    if (bins.length !== N) {
-      throw new Error("Expected 1024 bins");
-    }
-
-    const bitsPerBin = computeBits(bins);
-    const buffer = new Uint8Array((bitsPerBin * N) >> 3);
-
-    let bitOffset = 0;
-    for (const count of bins) {
-      packBits(buffer, bitOffset, bitsPerBin, count);
-      bitOffset += bitsPerBin;
-    }
-    return buffer;
-  },
-
-  /**
-   * Decodes a buffer into an array of 1024 bin counts.
-   *
-   * The function automatically computes the number of bits per bin from the buffer length,
-   * expecting that the total number of bits in the buffer is a multiple of 1024.
-   *
-   * @param bufferLike - The input that can be converted into a Uint8Array.
-   * @returns An array of 1024 numbers representing the decoded bin counts.
-   * @throws Error if the buffer length is invalid (i.e., its total bit count is not divisible by 1024).
-   */
-  decode: (bufferLike) => {
-    const buffer = ccc.bytesFrom(bufferLike);
-    // Determine bitsPerBin from the fixed structure (totalBits divided by N).
-    const bitsPerBin = (buffer.byteLength * 8) / N;
-    if (!Number.isInteger(bitsPerBin)) {
-      throw new Error("Invalid buffer length for 1024 bins");
-    }
-    const bins = new Array<number>(N);
-    let bitOffset = 0;
-    for (let i = 0; i < N; i++) {
-      bins[i] = unpackBits(buffer, bitOffset, bitsPerBin);
-      bitOffset += bitsPerBin;
-    }
-    return bins;
-  },
-  // Note: The byteLength is not fixed as it depends on the data (i.e., the maximum bin count).
-});
-
-/**
- * Computes the minimal number of bits required to represent the maximum number in the bins.
- *
- * Given an array of numbers that represent counts for each bin, this function calculates
- * the number of bits required to represent the maximum bin count. A minimum of 1 bit is
- * always returned.
- *
- * @param bins - An array of numbers, each representing a bin's value.
- * @returns The minimal number of bits required to represent the highest value among the bins.
- */
-function computeBits(bins: number[]): number {
-  return Math.ceil(Math.log2(1 + max(1, ...bins)));
-}
-
-/**
- * Packs a given numeric value into a Uint8Array (bit array) at the specified bit offset and width.
- *
- * The function encodes the given number into the provided buffer, using the specified number of bits (width)
- * starting from the specified bit offset. Each bit of the value is written into the buffer.
- *
- * @param buffer - The Uint8Array into which the value will be packed.
- * @param bitOffset - The starting bit index in the array where the value should be packed.
- * @param width - The number of bits to use for packing the value.
- * @param value - The numeric value to pack.
- */
-function packBits(
-  buffer: Uint8Array,
-  bitOffset: number,
-  width: number,
-  value: number,
-): void {
-  let offset = bitOffset;
-  for (let i = 0; i < width; i++) {
-    const byteIndex = offset >> 3;
-    const bitInByte = offset % 8;
-    const bit = (value >> i) & 1;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    buffer[byteIndex]! |= bit << bitInByte;
-    offset++;
-  }
-}
-
-/**
- * Unpacks a numeric value from a Uint8Array (bit array) starting at a given bit offset with a specified width.
- *
- * The function reads bits from the buffer starting at the bit offset and reconstructs a numeric value
- * using the specified number of bits (width).
- *
- * @param buffer - The Uint8Array from which the value will be unpacked.
- * @param bitOffset - The starting bit index in the buffer.
- * @param width - The number of bits to read for unpacking the value.
- * @returns The numeric value resulting from decoding the specified bits.
- */
-function unpackBits(
-  buffer: Uint8Array,
-  bitOffset: number,
-  width: number,
-): number {
-  let value = 0;
-  let offset = bitOffset;
-  for (let i = 0; i < width; i++) {
-    const byteIndex = offset >> 3;
-    const bitInByte = offset % 8;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const bit = (buffer[byteIndex]! >> bitInByte) & 1;
-    value |= bit << i;
-    offset++;
-  }
-  return value;
-}