@ckb-ccc/core 0.0.4 → 0.0.5-alpha.1

package/src/ckb/transaction.ts

@@ -3,7 +3,14 @@ import { Bytes, BytesLike, bytesFrom } from "../bytes";
 import { Client } from "../client";
 import { Hasher, ckbHash } from "../hasher";
 import { Hex, HexLike, hexFrom } from "../hex";
-import { Num, NumLike, numFrom, numFromBytes, numToBytes } from "../num";
+import {
+  Num,
+  NumLike,
+  numFrom,
+  numFromBytes,
+  numToBytes,
+  numToHex,
+} from "../num";
 import { apply } from "../utils";
 import * as mol from "./molecule.advanced";
 import { Script, ScriptLike } from "./script";
@@ -272,20 +279,26 @@ export class CellOutput {
 }
 
 export type CellLike = {
+  outPoint: OutPointLike;
   cellOutput: CellOutputLike;
   outputData: HexLike;
+  blockNumber: NumLike;
 };
 export class Cell {
   /**
    * Creates an instance of Cell.
    *
+   * @param outPoint - The output point of the cell.
    * @param cellOutput - The cell output of the cell.
    * @param outputData - The output data of the cell.
+   * @param blockNumber - The block number of the cell.
    */
 
   constructor(
+    public outPoint: OutPoint,
     public cellOutput: CellOutput,
     public outputData: Hex,
+    public blockNumber: Num,
   ) {}
 
   /**
@@ -300,7 +313,12 @@ export class Cell {
       return cell;
     }
 
-    return new Cell(CellOutput.from(cell.cellOutput), hexFrom(cell.outputData));
+    return new Cell(
+      OutPoint.from(cell.outPoint),
+      CellOutput.from(cell.cellOutput),
+      hexFrom(cell.outputData),
+      numFrom(cell.blockNumber),
+    );
   }
 }
 
@@ -309,6 +327,7 @@ export type CellInputLike = {
   since: NumLike;
   cellOutput?: CellOutputLike;
   outputData?: HexLike;
+  blockNumber?: NumLike;
 };
 export class CellInput {
   /**
@@ -318,6 +337,7 @@ export class CellInput {
    * @param since - The since value of the cell input.
    * @param cellOutput - The optional cell output associated with the cell input.
    * @param outputData - The optional output data associated with the cell input.
+   * @param blockNumber - The optional block number associated with the cell input.
    */
 
   constructor(
@@ -325,6 +345,7 @@ export class CellInput {
     public since: Num,
     public cellOutput?: CellOutput,
     public outputData?: Hex,
+    public blockNumber?: Num,
   ) {}
 
   /**
@@ -352,6 +373,7 @@ export class CellInput {
       numFrom(cellInput.since),
       apply(CellOutput.from, cellInput.cellOutput),
       apply(hexFrom, cellInput.outputData),
+      apply(numFrom, cellInput.blockNumber),
     );
   }
 
@@ -369,7 +391,7 @@ export class CellInput {
    */
 
   async completeExtraInfos(client: Client): Promise<CellInput> {
-    if (this.cellOutput && this.outputData) {
+    if (this.cellOutput && this.outputData && this.blockNumber) {
       return this;
     }
 
@@ -377,6 +399,7 @@ export class CellInput {
     if (cell) {
       this.cellOutput = cell.cellOutput;
       this.outputData = cell.outputData;
+      this.blockNumber = cell.blockNumber;
     }
     return this;
   }
@@ -751,6 +774,15 @@ export class Transaction {
     });
   }
 
+  stringify(): string {
+    return JSON.stringify(this, (_, value) => {
+      if (typeof value === "bigint") {
+        return numToHex(value);
+      }
+      return value;
+    });
+  }
+
   /**
    * Converts the raw transaction data to bytes.
    *
@@ -807,4 +839,167 @@ export class Transaction {
     hasher.update(numToBytes(raw.length, 8));
     hasher.update(raw);
   }
+
+  /**
+   * Computes the signing hash information for a given script.
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to an object containing the signing message and the witness position,
+   *          or undefined if no matching input is found.
+   *
+   * @example
+   * ```typescript
+   * const signHashInfo = await tx.getSignHashInfo(scriptLike, client);
+   * if (signHashInfo) {
+   *   console.log(signHashInfo.message); // Outputs the signing message
+   *   console.log(signHashInfo.position); // Outputs the witness position
+   * }
+   * ```
+   */
+  async getSignHashInfo(
+    scriptLike: ScriptLike,
+    client: Client,
+  ): Promise<{ message: Hex; position: number } | undefined> {
+    const script = Script.from(scriptLike);
+    let position = -1;
+    const hasher = new Hasher();
+    hasher.update(this.hash());
+
+    for (let i = 0; i < this.witnesses.length; i += 1) {
+      if (this.inputs[i]) {
+        const input = await this.inputs[i].completeExtraInfos(client);
+
+        if (!input.cellOutput) {
+          throw Error("Unable to resolve inputs info");
+        }
+
+        if (!script.eq(input.cellOutput.lock)) {
+          continue;
+        }
+
+        if (position === -1) {
+          position = i;
+        }
+      }
+
+      if (position === -1) {
+        return undefined;
+      }
+
+      Transaction.hashWitnessToHasher(this.witnesses[i], hasher);
+    }
+
+    if (position === -1) {
+      return undefined;
+    }
+
+    return {
+      message: hasher.digest(),
+      position,
+    };
+  }
+
+  /**
+   * Find the first occurrence of a input with the specified lock
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the prepared transaction
+   *
+   * @example
+   * ```typescript
+   * const index = await tx.findInputIndexByLock(scriptLike, client);
+   * ```
+   */
+  async findInputIndexByLock(
+    scriptLike: ScriptLike,
+    client: Client,
+  ): Promise<number | undefined> {
+    const script = Script.from(scriptLike);
+
+    for (let i = 0; i < this.inputs.length; i += 1) {
+      const input = await this.inputs[i].completeExtraInfos(client);
+
+      if (!input.cellOutput) {
+        throw Error("Unable to resolve inputs info");
+      }
+
+      if (script.eq(input.cellOutput.lock)) {
+        return i;
+      }
+    }
+  }
+
+  /**
+   * Get witness at index as WitnessArgs
+   *
+   * @param index - The index of the witness.
+   * @returns The witness parsed as WitnessArgs.
+   *
+   * @example
+   * ```typescript
+   * const witnessArgs = await tx.getWitnessArgsAt(0);
+   * ```
+   */
+  getWitnessArgsAt(index: number): WitnessArgs | undefined {
+    const rawWitness = this.witnesses[index];
+    return (rawWitness ?? "0x") !== "0x"
+      ? WitnessArgs.fromBytes(rawWitness)
+      : undefined;
+  }
+
+  /**
+   * Set witness at index by WitnessArgs
+   *
+   * @param index - The index of the witness.
+   * @param witness - The WitnessArgs to set.
+   * @returns The transaction itself.
+   *
+   * @example
+   * ```typescript
+   * await tx.setWitnessArgsAt(0, witnessArgs);
+   * ```
+   */
+  setWitnessArgsAt(index: number, witness: WitnessArgs): Transaction {
+    if (this.witnesses.length < index) {
+      this.witnesses.push(
+        ...Array.from(
+          new Array(index - this.witnesses.length),
+          (): Hex => "0x",
+        ),
+      );
+    }
+
+    this.witnesses[index] = hexFrom(witness.toBytes());
+    return this;
+  }
+
+  /**
+   * Prepare dummy witness for sighash all method
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param lockLen - The length of dummy lock bytes.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the prepared transaction
+   *
+   * @example
+   * ```typescript
+   * await tx.prepareSighashAllWitness(scriptLike, 85, client);
+   * ```
+   */
+  async prepareSighashAllWitness(
+    scriptLike: ScriptLike,
+    lockLen: number,
+    client: Client,
+  ): Promise<Transaction> {
+    const position = await this.findInputIndexByLock(scriptLike, client);
+    if (position === undefined) {
+      return this;
+    }
+
+    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
+    witness.lock = hexFrom(Array.from(new Array(lockLen), () => 0));
+    return this.setWitnessArgsAt(position, witness);
+  }
 }

package/src/client/client.ts

@@ -1,13 +1,26 @@
-import { Cell, OutPointLike, Script, TransactionLike } from "../ckb";
+import {
+  Cell,
+  OutPointLike,
+  Script,
+  ScriptLike,
+  TransactionLike,
+} from "../ckb";
+import { Zero } from "../fixedPoint";
 import { Hex, HexLike } from "../hex";
-import { numFrom } from "../num";
-import { ClientTransactionResponse, OutputsValidator } from "./clientTypes";
+import { Num, NumLike, numFrom } from "../num";
+import {
+  ClientFindCellsResponse,
+  ClientIndexerSearchKeyLike,
+  ClientTransactionResponse,
+  OutputsValidator,
+} from "./clientTypes";
 
 export enum KnownScript {
   Secp256k1Blake160,
   Secp256k1Multisig,
   AnyoneCanPay,
   JoyId,
+  COTA,
   OmniLock,
 }
 
@@ -39,8 +52,79 @@ export abstract class Client {
     }
 
     return Cell.from({
+      outPoint,
       cellOutput: transaction.transaction.outputs[index],
       outputData: transaction.transaction.outputsData[index] ?? "0x",
+      blockNumber: transaction.blockNumber,
     });
   }
+
+  abstract findCellsPaged(
+    key: ClientIndexerSearchKeyLike,
+    order?: "asc" | "desc",
+    limit?: NumLike,
+    after?: string,
+  ): Promise<ClientFindCellsResponse>;
+
+  async *findCells(
+    key: ClientIndexerSearchKeyLike,
+    order?: "asc" | "desc",
+    limit = 10,
+  ): AsyncGenerator<Cell> {
+    let last: string | undefined = undefined;
+
+    while (true) {
+      const { cells, lastCursor } = await this.findCellsPaged(
+        key,
+        order,
+        limit,
+        last,
+      );
+      for (const cell of cells) {
+        yield cell;
+      }
+      if (cells.length === 0 || cells.length < limit) {
+        return;
+      }
+      last = lastCursor;
+    }
+  }
+
+  findCellsByLockAndType(
+    lock: ScriptLike,
+    type: ScriptLike,
+    withData = true,
+  ): AsyncGenerator<Cell> {
+    return this.findCells({
+      script: lock,
+      scriptType: "lock",
+      scriptSearchMode: "exact",
+      filter: {
+        script: type,
+      },
+      withData,
+    });
+  }
+
+  abstract getCellsCapacity(key: ClientIndexerSearchKeyLike): Promise<Num>;
+
+  async getBalanceSingle(lock: ScriptLike): Promise<Num> {
+    return this.getCellsCapacity({
+      script: lock,
+      scriptType: "lock",
+      scriptSearchMode: "exact",
+      filter: {
+        scriptLenRange: [0, 1],
+        outputDataLenRange: [0, 1],
+      },
+    });
+  }
+
+  async getBalance(locks: ScriptLike[]): Promise<Num> {
+    return locks.reduce(
+      (res: Promise<Num>, lock) =>
+        this.getBalanceSingle(lock).then((a) => res.then((b) => a + b)),
+      Promise.resolve(Zero),
+    );
+  }
 }

package/src/client/clientPublicMainnet.advanced.ts

@@ -25,6 +25,11 @@ export const MAINNET_SCRIPTS: Record<
       "0xd00c84f0ec8fd441c38bc3f87a371f547190f2fcff88e642bc5bf54b9e318323",
     hashType: "type",
   },
+  [KnownScript.COTA]: {
+    codeHash:
+      "0x1122a4fb54697cf2e6e3a96c9d80fd398a936559b90954c6e88eb7ba0cf652df",
+    hashType: "type",
+  },
   [KnownScript.OmniLock]: {
     codeHash:
       "0x9b819793a64463aed77c615d6cb226eea5487ccfc0783043a587254cda2b6f26",

package/src/client/clientPublicTestnet.advanced.ts

@@ -25,6 +25,11 @@ export const TESTNET_SCRIPTS: Record<
       "0xd23761b364210735c19c60561d213fb3beae2fd6172743719eff6920e020baac",
     hashType: "type",
   },
+  [KnownScript.COTA]: {
+    codeHash:
+      "0x89cd8003a0eaf8e65e0c31525b7d1d5c1becefd2ea75bb4cff87810ae37764d8",
+    hashType: "type",
+  },
   [KnownScript.OmniLock]: {
     codeHash:
       "0xf329effd1c475a2978453c8600e1eaf0bc2087ee093c3ee64cc96ec6847752cb",

package/src/client/clientTypes.ts

@@ -1,4 +1,7 @@
-import { Transaction } from "../ckb";
+import { Cell, Script, ScriptLike, Transaction } from "../ckb";
+import { Hex, HexLike, hexFrom } from "../hex";
+import { Num, NumLike, numFrom } from "../num";
+import { apply } from "../utils";
 
 export type OutputsValidator = "passthrough" | "well_known_scripts_only";
 
@@ -11,4 +14,70 @@ export type TransactionStatus =
 export type ClientTransactionResponse = {
   transaction: Transaction;
   status: TransactionStatus;
+  blockNumber: Num;
+};
+
+export type ClientIndexerSearchKeyLike = {
+  script: ScriptLike;
+  scriptType: "lock" | "type";
+  scriptSearchMode?: "prefix" | "exact" | "partial";
+  filter?: {
+    script?: ScriptLike;
+    scriptLenRange?: [NumLike, NumLike];
+    outputData?: HexLike;
+    outputDataSearchMode?: "prefix" | "exact" | "partial";
+    outputDataLenRange?: [NumLike, NumLike];
+    outputCapacityRange?: [NumLike, NumLike];
+    blockRange?: [NumLike, NumLike];
+  };
+  withData?: boolean;
+};
+
+function rangeFrom([a, b]: [NumLike, NumLike]): [Num, Num] {
+  return [numFrom(a), numFrom(b)];
+}
+export class ClientIndexerSearchKey {
+  constructor(
+    public script: Script,
+    public scriptType: "lock" | "type",
+    public scriptSearchMode: "prefix" | "exact" | "partial" | undefined,
+    public filter:
+      | {
+          script?: Script;
+          scriptLenRange?: [Num, Num];
+          outputData?: Hex;
+          outputDataSearchMode?: "prefix" | "exact" | "partial";
+          outputDataLenRange?: [Num, Num];
+          outputCapacityRange?: [Num, Num];
+          blockRange?: [Num, Num];
+        }
+      | undefined,
+    public withData: boolean | undefined,
+  ) {}
+
+  static from(keyLike: ClientIndexerSearchKeyLike): ClientIndexerSearchKey {
+    return new ClientIndexerSearchKey(
+      Script.from(keyLike.script),
+      keyLike.scriptType,
+      keyLike.scriptSearchMode,
+      apply(
+        (filter: NonNullable<ClientIndexerSearchKeyLike["filter"]>) => ({
+          script: apply(Script.from, filter.script),
+          scriptLenRange: apply(rangeFrom, filter.scriptLenRange),
+          outputData: apply(hexFrom, filter.outputData),
+          outputDataSearchMode: filter.outputDataSearchMode,
+          outputDataLenRange: apply(rangeFrom, filter.outputDataLenRange),
+          outputCapacityRange: apply(rangeFrom, filter.outputCapacityRange),
+          blockRange: apply(rangeFrom, filter.blockRange),
+        }),
+        keyLike.filter,
+      ),
+      keyLike.withData,
+    );
+  }
+}
+
+export type ClientFindCellsResponse = {
+  lastCursor: string;
+  cells: Cell[];
 };

package/src/client/jsonRpc/index.ts

@@ -1,8 +1,14 @@
 import fetch from "cross-fetch";
 import { TransactionLike } from "../../ckb";
 import { Hex, HexLike, hexFrom } from "../../hex";
+import { Num, NumLike, numFrom, numToHex } from "../../num";
 import { Client } from "../client";
-import { ClientTransactionResponse, OutputsValidator } from "../clientTypes";
+import {
+  ClientFindCellsResponse,
+  ClientIndexerSearchKeyLike,
+  ClientTransactionResponse,
+  OutputsValidator,
+} from "../clientTypes";
 import { JsonRpcPayload, JsonRpcTransformers } from "./advanced";
 
 /**
@@ -89,6 +95,44 @@ export abstract class ClientJsonRpc extends Client {
     JsonRpcTransformers.transactionResponseTo,
   ) as (txHash: HexLike) => Promise<ClientTransactionResponse>;
 
+  /**
+   * find cells from node.
+   *
+   * @param key - The search key of cells.
+   * @param order - The order of cells.
+   * @param limit - The max return size of cells.
+   * @param after - Pagination parameter.
+   * @returns The found cells.
+   */
+
+  findCellsPaged = this.buildSender(
+    "get_cells",
+    [
+      JsonRpcTransformers.indexerSearchKeyFrom,
+      (order) => order ?? "asc",
+      (limit) => numToHex(limit ?? 10),
+    ],
+    JsonRpcTransformers.findCellsResponseTo,
+  ) as (
+    key: ClientIndexerSearchKeyLike,
+    order?: "asc" | "desc",
+    limit?: NumLike,
+    after?: string,
+  ) => Promise<ClientFindCellsResponse>;
+
+  /**
+   * get cells capacity from node.
+   *
+   * @param key - The search key of cells.
+   * @returns The sum of cells capacity.
+   */
+
+  getCellsCapacity = this.buildSender(
+    "get_cells_capacity",
+    [JsonRpcTransformers.indexerSearchKeyFrom],
+    ({ capacity }) => numFrom(capacity),
+  ) as (key: ClientIndexerSearchKeyLike) => Promise<Num>;
+
   /**
    * Builds a sender function for a JSON-RPC method.
    *
@@ -106,7 +150,15 @@ export abstract class ClientJsonRpc extends Client {
     return async (...req: unknown[]) => {
       const payload = ClientJsonRpc.buildPayload(
         rpcMethod,
-        await Promise.all(req.map((v, i) => transform(v, inTransformers[i]))),
+        await Promise.all(
+          req
+            .concat(
+              Array.from(
+                new Array(Math.max(inTransformers.length - req.length, 0)),
+              ),
+            )
+            .map((v, i) => transform(v, inTransformers[i])),
+        ),
       );
 
       return transform(await this.send(payload), outTransformer);

package/src/client/jsonRpc/transformers.ts

@@ -1,4 +1,5 @@
 import {
+  Cell,
   CellDep,
   CellDepLike,
   CellInput,
@@ -18,15 +19,23 @@ import {
   depTypeFrom,
   hashTypeFrom,
 } from "../../ckb";
-import { numToHex } from "../../num";
+import { Hex } from "../../hex";
+import { NumLike, numFrom, numToHex } from "../../num";
 import { apply } from "../../utils";
-import { ClientTransactionResponse, TransactionStatus } from "../clientTypes";
+import {
+  ClientFindCellsResponse,
+  ClientIndexerSearchKey,
+  ClientIndexerSearchKeyLike,
+  ClientTransactionResponse,
+  TransactionStatus,
+} from "../clientTypes";
 import {
   JsonRpcCellDep,
   JsonRpcCellInput,
   JsonRpcCellOutput,
   JsonRpcDepType,
   JsonRpcHashType,
+  JsonRpcIndexerSearchKey,
   JsonRpcOutPoint,
   JsonRpcScript,
   JsonRpcTransaction,
@@ -147,15 +156,75 @@ export class JsonRpcTransformers {
     });
   }
   static transactionResponseTo({
-    tx_status: { status },
+    tx_status: { status, block_number },
     transaction,
   }: {
-    tx_status: { status: TransactionStatus };
+    tx_status: { status: TransactionStatus; block_number: Hex };
     transaction: JsonRpcTransaction;
   }): ClientTransactionResponse {
     return {
       transaction: JsonRpcTransformers.transactionTo(transaction),
       status,
+      blockNumber: numFrom(block_number),
+    };
+  }
+  static rangeFrom([a, b]: [NumLike, NumLike]): [Hex, Hex] {
+    return [numToHex(a), numToHex(b)];
+  }
+  static indexerSearchKeyFrom(
+    keyLike: ClientIndexerSearchKeyLike,
+  ): JsonRpcIndexerSearchKey {
+    const key = ClientIndexerSearchKey.from(keyLike);
+    return {
+      script: JsonRpcTransformers.scriptFrom(key.script),
+      script_type: key.scriptType,
+      script_search_mode: key.scriptSearchMode,
+      filter: apply(
+        (filter: NonNullable<ClientIndexerSearchKey["filter"]>) => ({
+          script: apply(JsonRpcTransformers.scriptFrom, filter.script),
+          script_len_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.scriptLenRange,
+          ),
+          output_data: filter.outputData,
+          output_data_filter_mode: filter.outputDataSearchMode,
+          output_data_len_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputDataLenRange,
+          ),
+          output_capacity_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputCapacityRange,
+          ),
+          block_range: apply(JsonRpcTransformers.rangeFrom, filter.blockRange),
+        }),
+        key.filter,
+      ),
+      with_data: key.withData,
+    };
+  }
+  static findCellsResponseTo({
+    last_cursor,
+    objects,
+  }: {
+    last_cursor: string;
+    objects: {
+      block_number: Hex;
+      out_point: JsonRpcOutPoint;
+      output: JsonRpcCellOutput;
+      output_data: Hex;
+    }[];
+  }): ClientFindCellsResponse {
+    return {
+      lastCursor: last_cursor,
+      cells: objects.map((cell) =>
+        Cell.from({
+          blockNumber: cell.block_number,
+          outPoint: JsonRpcTransformers.outPointTo(cell.out_point),
+          cellOutput: JsonRpcTransformers.cellOutputTo(cell.output),
+          outputData: cell.output_data,
+        }),
+      ),
     };
   }
 }

package/src/client/jsonRpc/types.ts

@@ -46,3 +46,19 @@ export type JsonRpcTransaction = {
   outputs_data: Hex[];
   witnesses: Hex[];
 };
+
+export type JsonRpcIndexerSearchKey = {
+  script: JsonRpcScript;
+  script_type: "lock" | "type";
+  script_search_mode?: "prefix" | "exact" | "partial";
+  filter?: {
+    script?: JsonRpcScript;
+    script_len_range?: [Hex, Hex];
+    output_data?: Hex;
+    output_data_filter_mode?: "prefix" | "exact" | "partial";
+    output_data_len_range?: [Hex, Hex];
+    output_capacity_range?: [Hex, Hex];
+    block_range?: [Hex, Hex];
+  };
+  with_data?: boolean;
+};