@ickb/sdk 9000.0.1 → 9001.0.0

package/src/utils/chain.ts

@@ -1,43 +1,2 @@
-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

@@ -29,6 +29,10 @@ export const CheckedInt32LE = ccc.Codec.from<ccc.NumLike, number>({
   },
 });
 
+// CCC's unsigned codecs throw on overflow but encode a negative as its two's complement
+// without a word, and `Ratio.toBytes()` is public and skips `validate`, so these checked
+// codecs keep "never encode a negative" in one place; CCC has no signed Int32 codec at all.
+
 /** Checked codec for 8-bit unsigned integers. */
 export const CheckedUint8 = checkedUintLE(1);
 

package/src/utils/utils.ts

@@ -1,4 +1,5 @@
 import { ccc } from "@ckb-ccc/core";
+import { cccA } from "@ckb-ccc/core/advanced";
 
 /**
  * The default page size used when querying cells from the chain.
@@ -9,52 +10,91 @@ import { ccc } from "@ckb-ccc/core";
 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.
+ * A CCC client cache sized for a whole pool: 4096 headers and 4096 transaction bodies,
+ * where CCC's defaults keep 128 and 256 (SDK README, Account state). An LRU fills only as
+ * far as the book and pool need.
+ */
+export function clientCache(): ccc.ClientCacheMemory {
+  return new ccc.ClientCacheMemory(512, 4096, 4096);
+}
+
+/** A committed cell and the block the node names for its creating transaction. */
+export interface ScannedCell {
+  cell: ccc.Cell;
+  blockNumber: ccc.Num;
+}
+
+/**
+ * Reads every committed cell matching the key with the block the node names for it, page
+ * by page through the raw requestor (CCC's typed scan drops the block), bypassing CCC's
+ * cell cache. A full page whose cursor does not advance throws. Why: SDK README, Account
+ * state.
  */
 export async function findCells(
   client: ccc.Client,
   keyLike: ccc.ClientIndexerSearchKeyLike,
-): Promise<ccc.Cell[]> {
-  const key = ccc.ClientIndexerSearchKey.from(keyLike);
-  const cells: ccc.Cell[] = [];
+): Promise<ScannedCell[]> {
+  const requestor = jsonRpcRequestor(client);
+  const key = cccA.JsonRpcTransformers.indexerSearchKeyFrom(keyLike);
+  const cells: ScannedCell[] = [];
   let after: string | undefined;
   for (;;) {
-    const page = await client.findCellsPagedNoCache(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, no-restricted-syntax -- the node's indexer answer, parsed field by field below as CCC's own transformer does.
+    const page = (await requestor.request("get_cells", [
       key,
       "asc",
-      defaultCellPageSize,
+      ccc.numToHex(defaultCellPageSize),
       after,
-    );
-    cells.push(...page.cells);
-    if (page.cells.length < defaultCellPageSize) {
+    ])) as RawCellsPage;
+    for (const object of page.objects) {
+      cells.push({
+        cell: ccc.Cell.from({
+          outPoint: cccA.JsonRpcTransformers.outPointTo(object.out_point),
+          cellOutput: cccA.JsonRpcTransformers.cellOutputTo(object.output),
+          outputData: object.output_data ?? "0x",
+        }),
+        blockNumber: ccc.numFrom(object.block_number),
+      });
+    }
+    if (page.objects.length < defaultCellPageSize) {
       return cells;
     }
-    if (page.lastCursor === after) {
+    if (page.last_cursor === after) {
       throw new Error("Cell scan cursor did not advance");
     }
-    after = page.lastCursor;
+    after = page.last_cursor;
   }
 }
 
-/**
- * Local transaction inclusion metadata.
- */
-export interface TransactionHeader {
-  /**
-   * The block header used for inclusion-dependent calculations.
-   */
-  header: ccc.ClientBlockHeader;
+/** 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];
+    }),
+  );
+}
 
-  /**
-   * The transaction hash when the caller has resolved it for the header.
-   */
-  txHash?: ccc.Hex;
+/** The fields of the indexer's `get_cells` answer the scan reads. */
+interface RawCellsPage {
+  last_cursor: string;
+  objects: Array<{
+    out_point: cccA.JsonRpcOutPoint;
+    output: cccA.JsonRpcCellOutput;
+    output_data?: ccc.Hex;
+    block_number: ccc.Hex;
+  }>;
 }
 
 /**
@@ -110,86 +150,17 @@ export function isPlainCapacityCell(cell: ccc.Cell): boolean {
 }
 
 /**
- * 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
+ * The client's JSON-RPC requestor, which the SDK's raw reads need: scans with block
+ * numbers, status polls and transaction proofs. 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;
+export function jsonRpcRequestor(client: ccc.Client): ccc.RequestorJsonRpc {
+  const requestor = "requestor" in client ? client.requestor : undefined;
+  if (!(requestor instanceof ccc.RequestorJsonRpc)) {
+    throw new TypeError("The SDK needs a JSON-RPC client");
   }
-  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;
+  return requestor;
 }
 
 /** `numerator / denominator` rounded up; the denominator is positive. */

package/src/utils/verified_client.ts

@@ -0,0 +1,136 @@
+import { ccc } from "@ckb-ccc/core";
+
+/**
+ * Wraps `inner` into a client that checks the reads the SDK makes: every header it hands
+ * out against the header's own hash, a header read by number against the number asked
+ * for, a transaction read by hash against the hash of its body, and a cell against the
+ * body of its creating transaction. Other reads pass through unchecked; the cell
+ * beside `getCellWithHeader`'s header is one, since the SDK reads only its header.
+ *
+ * @remarks It wraps the client, not the SDK's readers, because CCC's own DAO valuation
+ * (`Cell.getNervosDaoInfo`, in the send) reads headers through the client it is given.
+ * Why each check exists: SDK README, Account state.
+ */
+export function verifiedClient(inner: ccc.Client): ccc.Client {
+  return new VerifiedClient(inner);
+}
+
+// @ts-expect-error TS2655: the abstract members are forwarded by the proxy at runtime, as in CCC's own connector.
+class VerifiedClient extends ccc.Proxy.Base(ccc.Client) {
+  public static readonly [ccc.Proxy.localKeys] = ["bodies"];
+
+  /** Creating transactions `getCell` read, so concurrent reads of one share a request. */
+  private readonly bodies = new Map<
+    ccc.Hex,
+    Promise<ccc.ClientTransactionResponse | undefined>
+  >();
+
+  public override async getTipHeader(): Promise<ccc.ClientBlockHeader> {
+    return verified(await this[ccc.Proxy.inner].getTipHeader());
+  }
+
+  public override async getHeaderByNumber(
+    ...args: Parameters<ccc.Client["getHeaderByNumber"]>
+  ): Promise<ccc.ClientBlockHeader | undefined> {
+    const header = ccc.apply(
+      verified,
+      await this[ccc.Proxy.inner].getHeaderByNumber(...args),
+    );
+    const number = ccc.numFrom(args[0]);
+    if (header !== undefined && header.number !== number) {
+      throw new Error(`Header ${header.hash} answers for block ${number.toString()}`);
+    }
+    return header;
+  }
+
+  public override async getTransaction(
+    ...args: Parameters<ccc.Client["getTransaction"]>
+  ): ReturnType<ccc.Client["getTransaction"]> {
+    return verifiedBody(await this[ccc.Proxy.inner].getTransaction(...args), args[0]);
+  }
+
+  /**
+   * The output of the verified creating transaction, cache first: CCC keys cached
+   * transactions by their body's hash, and its own `getCell` would build the cell from a
+   * read this wrapper never sees, then cache it.
+   */
+  public override async getCell(
+    ...args: Parameters<ccc.Client["getCell"]>
+  ): ReturnType<ccc.Client["getCell"]> {
+    const outPoint = ccc.OutPoint.from(args[0]);
+    const { txHash } = outPoint;
+    let body = this.bodies.get(txHash);
+    if (body === undefined) {
+      body = this.readBody(txHash);
+      this.bodies.set(txHash, body);
+    }
+    const output = (await body)?.transaction.getOutput(outPoint.index);
+    return output === undefined
+      ? undefined
+      : ccc.Cell.from({
+          outPoint,
+          cellOutput: output.cellOutput,
+          outputData: output.outputData,
+        });
+  }
+
+  private async readBody(
+    txHash: ccc.Hex,
+  ): Promise<ccc.ClientTransactionResponse | undefined> {
+    // CCC's own cache keys bodies by their hash, but a consumer's cache need not.
+    return (
+      verifiedBody(await this.cache.getTransactionResponse(txHash), txHash) ??
+      (await this.getTransaction(txHash))
+    );
+  }
+
+  public override async getCellWithHeader(
+    ...args: Parameters<ccc.Client["getCellWithHeader"]>
+  ): ReturnType<ccc.Client["getCellWithHeader"]> {
+    const result = await this[ccc.Proxy.inner].getCellWithHeader(...args);
+    ccc.apply(verified, result?.header);
+    return result;
+  }
+}
+
+/** The response when its body hashes to the hash asked for, else throws. */
+function verifiedBody(
+  response: ccc.ClientTransactionResponse | undefined,
+  txHash: ccc.HexLike,
+): ccc.ClientTransactionResponse | undefined {
+  const asked = ccc.hexFrom(txHash);
+  if (response !== undefined && response.transaction.hash() !== asked) {
+    throw new Error(`Transaction ${asked} was answered with a body of another hash`);
+  }
+  return response;
+}
+
+/** The header when its fields hash to the hash it carries, else throws. */
+function verified(header: ccc.ClientBlockHeader): ccc.ClientBlockHeader {
+  const computed = headerHash(header);
+  if (computed !== header.hash) {
+    throw new Error(`Header ${header.hash} carries the fields of ${computed}`);
+  }
+  return header;
+}
+
+/**
+ * The hash of a header as the chain computes it: blake2b over the header struct, each
+ * number little-endian, in declaration order, the nonce last.
+ */
+export function headerHash(header: ccc.ClientBlockHeader): ccc.Hex {
+  const { dao } = header;
+  return ccc.hashCkb(
+    ccc.numLeToBytes(header.version, 4),
+    ccc.numLeToBytes(header.compactTarget, 4),
+    ccc.numLeToBytes(header.timestamp, 8),
+    ccc.numLeToBytes(header.number, 8),
+    ccc.numLeToBytes(header.epoch.toNum(), 8),
+    header.parentHash,
+    header.transactionsRoot,
+    header.proposalsHash,
+    header.extraHash,
+    ...[dao.c, dao.ar, dao.s, dao.u].map((field) => ccc.numLeToBytes(field, 8)),
+    ccc.numLeToBytes(header.nonce, 16),
+  );
+}

package/dist/utils/transaction_header.d.ts

@@ -1,17 +0,0 @@
-import type { ccc } from "@ckb-ccc/core";
-/**
- * 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 declare function getTransactionHeader(client: ccc.Client, txHash: ccc.Hex): Promise<ccc.ClientBlockHeader | undefined>;
-/**
- * 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 declare function transactionHeaders(client: ccc.Client, txHashes: Iterable<ccc.Hex>): Promise<Map<ccc.Hex, ccc.ClientBlockHeader>>;
-/** The headers of a batch of block numbers, each read once; every block must exist. */
-export declare function headersByNumber(client: ccc.Client, blockNumbers: Iterable<ccc.Num>): Promise<Map<ccc.Num, ccc.ClientBlockHeader>>;
-//# sourceMappingURL=transaction_header.d.ts.map

package/dist/utils/transaction_header.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transaction_header.d.ts","sourceRoot":"","sources":["../../src/utils/transaction_header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,GAAG,CAAC,MAAM,EAClB,MAAM,EAAE,GAAG,CAAC,GAAG,GACd,OAAO,CAAC,GAAG,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAS5C;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,GAAG,CAAC,MAAM,EAClB,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,GAC1B,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAc9C;AAED,uFAAuF;AACvF,wBAAsB,eAAe,CACnC,MAAM,EAAE,GAAG,CAAC,MAAM,EAClB,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,GAC9B,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAc9C"}

package/dist/utils/transaction_header.js

@@ -1,44 +0,0 @@
-import { jsonRpcRequestor, rawTransactionStatus } from "./utils.js";
-/**
- * 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, txHash) {
-    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, txHashes) {
-    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, blockNumbers) {
-    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];
-    }));
-}
-//# sourceMappingURL=transaction_header.js.map

package/dist/utils/transaction_header.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transaction_header.js","sourceRoot":"","sources":["../../src/utils/transaction_header.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAAkB,EAClB,MAAe;IAEf,MAAM,SAAS,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC3C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,CAAC,MAAM,MAAM,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC;IACjE,CAAC;IACD,MAAM,EAAE,WAAW,EAAE,GAAG,oBAAoB,CAC1C,MAAM,SAAS,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAC5D,CAAC;IACF,OAAO,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACvF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,MAAkB,EAClB,QAA2B;IAE3B,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CACrE,CAAC;IACF,OAAO,IAAI,GAAG,CACZ,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QAC7B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,+BAA+B,MAAM,EAAE,CAAC,CAAC;QAC3D,CAAC;QACD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AAED,uFAAuF;AACvF,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAAkB,EAClB,YAA+B;IAE/B,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;IAC5C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC,CAC3E,CAAC;IACF,OAAO,IAAI,GAAG,CACZ,QAAQ,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE;QAClC,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/src/utils/transaction_header.ts

@@ -1,66 +0,0 @@
-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];
-    }),
-  );
-}