@ickb/sdk 1000.0.82 → 9001.0.0

package/src/udt.ts

@@ -0,0 +1,249 @@
+import { ccc, mol } from "@ckb-ccc/core";
+import { isDaoDeposit } from "./dao.ts";
+import { CheckedUint128LE, CheckedUint32LE, CheckedUint64LE } from "./utils/codec.ts";
+import type { ExchangeRatio } from "./utils/utils.ts";
+
+const ickbXudtTypeOccupiedSize = 69;
+const udtDataSize = 16;
+const AR_0: ccc.Num = 10000000000000000n; // Base scale for CKB
+const depositUsedCapacity = ccc.fixedPointFrom(82); // 82n CKB
+const depositCapacityDelta = (depositUsedCapacity * AR_0) / ccc.fixedPointFrom(100000);
+const xudtOwnerMode = 0x80000000n;
+
+// A receipt's fixed prefix: 4 bytes of deposit quantity and 8 of deposit amount.
+export const receiptDataBytes = 12;
+
+/** The receipt payload for one or more identical iCKB deposits. */
+export interface ReceiptData {
+  /** Number of identical deposits represented by this receipt. */
+  depositQuantity: ccc.Num;
+  /** Free CKB capacity of each represented deposit before iCKB conversion. */
+  depositAmount: ccc.FixedPoint;
+}
+
+const ReceiptDataCodec = mol.struct({
+  depositQuantity: CheckedUint32LE,
+  depositAmount: CheckedUint64LE,
+});
+
+/** Encodes a receipt payload. */
+export function encodeReceiptData(data: ReceiptData): ccc.Bytes {
+  return ReceiptDataCodec.encode(data);
+}
+
+/**
+ * Decodes the fixed receipt-data prefix and ignores trailing cell payload bytes.
+ *
+ * @remarks The receipt data prefix is 12 bytes after the `0x` marker: 4 bytes for deposit
+ * quantity and 8 bytes for deposit amount. Later payload bytes belong to other protocol
+ * data and are intentionally tolerated here.
+ */
+export function decodeReceiptData(outputData: ccc.Hex): ReceiptData {
+  return ReceiptDataCodec.decode(outputData.slice(0, 2 + 2 * receiptDataBytes));
+}
+
+/**
+ * Soft per-deposit iCKB value cap used before applying the excess discount.
+ */
+export const ICKB_DEPOSIT_CAP = ccc.fixedPointFrom(100000); // 100,000 iCKB
+
+/**
+ * The iCKB xUDT token: its scripts, code cells, and the iCKB accounting of a
+ * transaction's inputs. Inputs carry iCKB as xUDT balances, as receipt value,
+ * and negatively as the first-phase deposits a transaction re-mints.
+ */
+export class IckbUdt {
+  /** The iCKB xUDT type script. */
+  public readonly script: ccc.Script;
+
+  /** The iCKB dep group, which also carries the xUDT and iCKB Logic code cells. */
+  public readonly cellDeps: ccc.CellDep[];
+
+  /** Logic script whose hash is embedded in this iCKB xUDT type script. */
+  public readonly logicScript: ccc.Script;
+
+  /** The Nervos DAO script, to recognize the first-phase deposits a transaction re-mints. */
+  public readonly daoScript: ccc.Script;
+
+  /** Creates an instance of IckbUdt from its code and script references. */
+  constructor({
+    script,
+    cellDeps,
+    logicScript,
+    daoScript,
+  }: {
+    script: ccc.ScriptLike;
+    cellDeps: ccc.CellDepLike[];
+    logicScript: ccc.ScriptLike;
+    daoScript: ccc.ScriptLike;
+  }) {
+    this.script = ccc.Script.from(script);
+    this.cellDeps = cellDeps.map((cellDep) => ccc.CellDep.from(cellDep));
+    this.logicScript = ccc.Script.from(logicScript);
+    this.daoScript = ccc.Script.from(daoScript);
+  }
+
+  /**
+   * Computes the iCKB UDT type script from raw UDT and Logic scripts.
+   *
+   * Concatenates the iCKB logic script hash with the fixed 4-byte little-endian
+   * xUDT owner-mode flags postfix ("00000080") to form the UDT type script args.
+   *
+   * @param udtScript - The raw xUDT script (codeHash and hashType reused).
+   * @param ickbLogic - The iCKB logic script (hash used for args).
+   * @returns A new Script with the computed args.
+   */
+  public static typeScriptFrom(udtScript: ccc.Script, ickbLogic: ccc.Script): ccc.Script {
+    const { codeHash, hashType } = udtScript;
+    return new ccc.Script(
+      codeHash,
+      hashType,
+      ccc.hexFrom(
+        ccc.bytesConcat(ickbLogic.hash(), CheckedUint32LE.encode(xudtOwnerMode)),
+      ),
+    );
+  }
+
+  /**
+   * Minimum capacity for an iCKB xUDT cell locked by the supplied lock script.
+   */
+  public static minimumXudtCellCapacity(lock: ccc.Script): ccc.FixedPoint {
+    return (
+      BigInt(8 + lock.occupiedSize + ickbXudtTypeOccupiedSize + udtDataSize) * ccc.One
+    );
+  }
+
+  /**
+   * Returns true when a cell carries this iCKB xUDT type and enough UDT data.
+   */
+  public isUdt(cellLike: ccc.CellAnyLike): boolean {
+    const cell = ccc.CellAny.from(cellLike);
+    return (
+      cell.cellOutput.type?.eq(this.script) === true &&
+      ccc.bytesFrom(cell.outputData).length >= udtDataSize
+    );
+  }
+
+  /**
+   * iCKB carried by the transaction's inputs: xUDT balances plus receipt value, minus the
+   * first-phase deposits it re-mints. Receipts and deposits take the value the state read
+   * gave them at their deposit headers; a protocol input missing from `protocolCells` is
+   * a builder bug and throws, since iCKB Logic would refuse whatever it was valued at.
+   */
+  public async inputBalance(
+    tx: ccc.Transaction,
+    client: ccc.Client,
+    protocolCells: readonly ProtocolCell[],
+  ): Promise<ccc.Num> {
+    const values = new Map(
+      protocolCells.map(({ cell, udtValue }) => [cell.outPoint.toHex(), udtValue]),
+    );
+    let balance = ccc.Zero;
+    for (const input of tx.inputs) {
+      const cell = await input.getCell(client);
+      if (this.isUdt(cell)) {
+        balance += ccc.udtBalanceFrom(cell.outputData);
+        continue;
+      }
+      const sign = this.protocolSign(cell);
+      if (sign === 0n) {
+        continue;
+      }
+      const value = values.get(cell.outPoint.toHex());
+      if (value === undefined) {
+        throw new Error(
+          `iCKB input ${cell.outPoint.toHex()} has no value from the state read`,
+        );
+      }
+      balance += sign * value;
+    }
+    return balance;
+  }
+
+  /** 1 for a receipt, -1 for a first-phase iCKB deposit, 0 for any other cell. */
+  private protocolSign(cell: ccc.Cell): bigint {
+    const { type, lock } = cell.cellOutput;
+    if (type !== undefined && this.logicScript.eq(type)) {
+      return 1n;
+    }
+    return this.logicScript.eq(lock) && isDaoDeposit(cell, this.daoScript) ? -1n : 0n;
+  }
+
+  /** Adds the iCKB change output when the surplus is positive; zero needs no output. */
+  public addChange(tx: ccc.Transaction, lock: ccc.ScriptLike, balance: ccc.Num): void {
+    if (balance <= ccc.Zero) {
+      return;
+    }
+    tx.addOutput({ lock, type: this.script }, CheckedUint128LE.encode(balance));
+  }
+}
+
+/**
+ * Calculates iCKB value for unoccupied CKB capacity at a deposit header.
+ *
+ * @remarks
+ * Values above {@link ICKB_DEPOSIT_CAP} receive a 10% discount only on the
+ * excess amount.
+ */
+export function ickbValue(
+  ckbUnoccupiedCapacity: ccc.FixedPoint,
+  header: ccc.ClientBlockHeader,
+): ccc.FixedPoint {
+  let ickbAmount = udtFromCkb(ckbUnoccupiedCapacity, ickbAccountingRatio(header));
+  if (ICKB_DEPOSIT_CAP < ickbAmount) {
+    // Apply a 10% discount for the amount exceeding the soft iCKB cap per deposit.
+    ickbAmount -= (ickbAmount - ICKB_DEPOSIT_CAP) / 10n;
+  }
+
+  return ickbAmount;
+}
+
+/** The iCKB worth `amount` CKB at `ratio`, rounded down. */
+export function udtFromCkb(amount: ccc.FixedPoint, ratio: ExchangeRatio): ccc.FixedPoint {
+  assertPositive(ratio);
+  return (amount * ratio.ckbScale) / ratio.udtScale;
+}
+
+/** The CKB worth `amount` iCKB at `ratio`, rounded down. */
+export function ckbFromUdt(amount: ccc.FixedPoint, ratio: ExchangeRatio): ccc.FixedPoint {
+  assertPositive(ratio);
+  return (amount * ratio.udtScale) / ratio.ckbScale;
+}
+
+function assertPositive({ ckbScale, udtScale }: ExchangeRatio): void {
+  if (ckbScale <= 0n || udtScale <= 0n) {
+    throw new Error("Exchange ratio scales must be positive");
+  }
+}
+
+/**
+ * Calculates the free-capacity accounting ratio at a block header.
+ *
+ * @param header - The block header whose DAO accumulated rate is used.
+ * @returns An object containing the CKB and UDT scales.
+ */
+export function ickbAccountingRatio(header: ccc.ClientBlockHeader): ExchangeRatio {
+  return {
+    ckbScale: AR_0,
+    udtScale: header.dao.ar,
+  };
+}
+
+/**
+ * Calculates the gross iCKB exchange ratio for a recoverable standard deposit.
+ *
+ * @remarks Includes the standard deposit's 82 CKB occupied capacity spread
+ * over the 100,000 iCKB reference amount.
+ */
+export function ickbExchangeRatio(header: ccc.ClientBlockHeader): ExchangeRatio {
+  return {
+    ckbScale: AR_0,
+    udtScale: header.dao.ar + depositCapacityDelta,
+  };
+}
+
+/** A receipt or iCKB deposit with the iCKB value the state read gave it. */
+export interface ProtocolCell {
+  cell: ccc.Cell;
+  udtValue: ccc.Num;
+}

package/src/utils/chain.ts

@@ -0,0 +1,2 @@
+/** Public CKB networks supported by Stack consumers. */
+export type SupportedChain = "mainnet" | "testnet";

package/src/utils/codec.ts

@@ -0,0 +1,78 @@
+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,
+    );
+  },
+});
+
+// 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);
+
+/** 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/utils.ts

@@ -0,0 +1,208 @@
+import { ccc } from "@ckb-ccc/core";
+import { cccA } from "@ckb-ccc/core/advanced";
+
+/**
+ * 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;
+
+/**
+ * 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<ScannedCell[]> {
+  const requestor = jsonRpcRequestor(client);
+  const key = cccA.JsonRpcTransformers.indexerSearchKeyFrom(keyLike);
+  const cells: ScannedCell[] = [];
+  let after: string | undefined;
+  for (;;) {
+    // 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",
+      ccc.numToHex(defaultCellPageSize),
+      after,
+    ])) 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.last_cursor === after) {
+      throw new Error("Cell scan cursor did not advance");
+    }
+    after = page.last_cursor;
+  }
+}
+
+/** 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 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;
+  }>;
+}
+
+/**
+ * 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";
+}
+
+/**
+ * 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 {
+  const requestor = "requestor" in client ? client.requestor : undefined;
+  if (!(requestor instanceof ccc.RequestorJsonRpc)) {
+    throw new TypeError("The SDK needs a JSON-RPC client");
+  }
+  return requestor;
+}
+
+/** `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/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/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"}