@ckb-ccc/core 1.10.0 → 1.11.0

package/src/hasher/hasherCkb.ts

@@ -1,8 +1,6 @@
 import { blake2b } from "@noble/hashes/blake2b";
 import { BytesLike, bytesFrom } from "../bytes/index.js";
-import { CellInput, CellInputLike } from "../ckb/index.js";
 import { Hex, hexFrom } from "../hex/index.js";
-import { NumLike, numLeToBytes } from "../num/index.js";
 import { CKB_BLAKE2B_PERSONAL } from "./advanced.js";
 import { Hasher } from "./hasher.js";
 
@@ -81,27 +79,3 @@ export function hashCkb(...data: BytesLike[]): Hex {
   data.forEach((d) => hasher.update(d));
   return hasher.digest();
 }
-
-/**
- * Computes the Type ID hash of the given data.
- * @public
- *
- * @param cellInputLike - The first cell input of the transaction.
- * @param outputIndex - The output index of the Type ID cell.
- * @returns The hexadecimal string representation of the hash.
- *
- * @example
- * ```typescript
- * const hash = hashTypeId(cellInput, outputIndex); // Outputs something like "0x..."
- * ```
- */
-
-export function hashTypeId(
-  cellInputLike: CellInputLike,
-  outputIndex: NumLike,
-): Hex {
-  return hashCkb(
-    CellInput.from(cellInputLike).toBytes(),
-    numLeToBytes(outputIndex, 8),
-  );
-}

package/src/molecule/codec.ts

@@ -459,34 +459,71 @@ type UnionDecoded<
   : never;
 
 /**
- * Union is a dynamic-size type.
- * Serializing a union has two steps:
- * - Serialize an item type id in bytes as a 32 bit unsigned integer in little-endian. The item type id is the index of the inner items, and it's starting at 0.
- * - Serialize the inner item.
- * @param codecLayout the union item record
- * @param fields the custom item type id record
+ * Constructs a union codec that can serialize and deserialize values tagged with a type identifier.
+ *
+ * If all variants have the same fixed size, the resulting union codec is fixed-size (header + payload).
+ * Otherwise, it falls back to a dynamic-size codec.
+ *
+ * Serialization format:
+ * 1. 4-byte little-endian unsigned integer for the variant index.
+ * 2. Encoded bytes of the selected variant.
+ *
+ * @typeParam T
+ *   A record mapping variant names to codecs.
+ * @param codecLayout
+ *   An object whose keys are variant names and values are codecs for each variant.
+ * @param fields
+ *   Optional mapping from variant names to custom numeric IDs. If omitted, the index
+ *   of each variant in `codecLayout` is used as its ID.
+ *
+ *
  * @example
- * // without custom id
- * union({ cafe: Uint8, bee: Uint8 })
- * // with custom id
- * union({ cafe: Uint8, bee: Uint8 }, { cafe: 0xcafe, bee: 0xbee })
+ * // Dynamic union without custom numeric IDs
+ * union({ cafe: Uint8, bee: Uint16 })
+ *
+ * // Dynamic union with custom numeric IDs
+ * union({ cafe: Uint8, bee: Uint16 }, { cafe: 0xcafe, bee: 0xbee })
+ *
+ * // Fixed-size union without custom numeric IDs
+ * const PaddedUint8 = struct({ data : u8, padding : u8 })
+ * union({ cafe: PaddedUint8, bee: Uint16 });
+ *
+ * // Fixed-size union with custom numeric IDs
+ * union({ cafe: PaddedUint8, bee: Uint16 }, { cafe: 0xcafe, bee: 0xbee })
  */
+
 export function union<T extends Record<string, CodecLike<any, any>>>(
   codecLayout: T,
   fields?: Record<keyof T, number | undefined | null>,
 ): Codec<UnionEncodable<T>, UnionDecoded<T>> {
-  const keys = Object.keys(codecLayout);
+  const entries = Object.entries(codecLayout);
+
+  // Determine if all variants have a fixed and equal byteLength.
+  let byteLength: number | undefined;
+  if (entries.length > 0) {
+    const firstLen = entries[0][1].byteLength;
+    if (
+      firstLen !== undefined &&
+      entries.every(([, { byteLength: len }]) => len === firstLen)
+    ) {
+      // Add 4 bytes for the type header
+      byteLength = firstLen + 4;
+    }
+  }
 
   return Codec.from({
+    byteLength,
     encode({ type, value }) {
       const typeStr = type.toString();
       const codec = codecLayout[typeStr];
       if (!codec) {
         throw new Error(
-          `union: invalid type, expected ${keys.toString()}, but got ${typeStr}`,
+          `union: invalid type, expected ${entries.map((e) => e[0]).toString()}, but got ${typeStr}`,
         );
       }
-      const fieldId = fields ? (fields[typeStr] ?? -1) : keys.indexOf(typeStr);
+      const fieldId = fields
+        ? (fields[typeStr] ?? -1)
+        : entries.findIndex((e) => e[0] === typeStr);
       if (fieldId < 0) {
         throw new Error(`union: invalid field id ${fieldId} of ${typeStr}`);
       }

package/src/signer/ckb/signerCkbScriptReadonly.ts

@@ -4,31 +4,46 @@ import { Client } from "../../client/index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
 
 /**
- * A class extending Signer that provides read-only access to a CKB script.
- * This class does not support signing operations.
+ * A read-only signer for a CKB script. It can be used to get addresses,
+ * but not to sign transactions. This is useful when you want to watch an address
+ * without having the private key.
+ *
  * @public
  */
 export class SignerCkbScriptReadonly extends Signer {
+  /**
+   * The type of the signer.
+   */
   get type(): SignerType {
     return SignerType.CKB;
   }
 
+  /**
+   * The sign type of the signer.
+   * As this is a read-only signer, the sign type is {@link SignerSignType.Unknown}.
+   */
   get signType(): SignerSignType {
     return SignerSignType.Unknown;
   }
 
-  private readonly script: Script;
+  /**
+   * The scripts associated with the signer.
+   */
+  public readonly scripts: Script[];
 
   /**
    * Creates an instance of SignerCkbScriptReadonly.
    *
    * @param client - The client instance used for communication.
-   * @param script - The script associated with the signer.
+   * @param scripts - The scripts associated with the signer. Can be a single script, an array of scripts, or multiple script arguments.
    */
-  constructor(client: Client, script: ScriptLike) {
+  constructor(client: Client, ...scripts: (ScriptLike | ScriptLike[])[]) {
     super(client);
 
-    this.script = Script.from(script);
+    this.scripts = scripts.flat().map(Script.from);
+    if (this.scripts.length === 0) {
+      throw new Error("SignerCkbScriptReadonly requires at least one script.");
+    }
   }
 
   /**
@@ -71,8 +86,9 @@ export class SignerCkbScriptReadonly extends Signer {
    * const addressObjs = await signer.getAddressObjs(); // Outputs the array of Address objects
    * ```
    */
-
   async getAddressObjs(): Promise<Address[]> {
-    return [Address.fromScript(this.script, this.client)];
+    return this.scripts.map((script) =>
+      Address.fromScript(script, this.client),
+    );
   }
 }

package/src/signer/signer/index.ts

@@ -6,6 +6,7 @@ import {
   Client,
   ClientFindTransactionsGroupedResponse,
   ClientFindTransactionsResponse,
+  ClientIndexerSearchKeyFilterLike,
 } from "../../client/index.js";
 import { Hex } from "../../hex/index.js";
 import { Num } from "../../num/index.js";
@@ -239,6 +240,39 @@ export abstract class Signer {
     );
   }
 
+  /**
+   * Find cells of this signer
+   *
+   * @param filter - The filter for the search key.
+   * @param withData - Whether to include cell data in the response.
+   * @param order - The order of the returned cells, can be "asc" or "desc".
+   * @param limit - The maximum number of cells for every querying chunk.
+   * @returns A async generator that yields all matching cells
+   */
+  async *findCellsOnChain(
+    filter: ClientIndexerSearchKeyFilterLike,
+    withData?: boolean | null,
+    order?: "asc" | "desc",
+    limit?: number,
+  ): AsyncGenerator<Cell> {
+    const scripts = await this.getAddressObjs();
+    for (const { script } of scripts) {
+      for await (const cell of this.client.findCellsOnChain(
+        {
+          script,
+          scriptType: "lock",
+          filter,
+          scriptSearchMode: "exact",
+          withData,
+        },
+        order,
+        limit,
+      )) {
+        yield cell;
+      }
+    }
+  }
+
   /**
    * Find cells of this signer
    *