@ckb-ccc/core 0.0.6-alpha.0 → 0.0.7-alpha.1

package/src/client/clientPublicTestnet.advanced.ts

@@ -1,43 +1,212 @@
 import { Script } from "../ckb";
-import { KnownScript } from "./client";
+import { CellDepInfoLike, KnownScript } from "./client";
 
 export const TESTNET_SCRIPTS: Record<
   KnownScript,
-  Pick<Script, "codeHash" | "hashType">
+  Pick<Script, "codeHash" | "hashType"> & { cellDeps: CellDepInfoLike[] }
 > = {
   [KnownScript.Secp256k1Blake160]: {
     codeHash:
       "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.Secp256k1Multisig]: {
     codeHash:
       "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37",
+            index: 1,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.AnyoneCanPay]: {
     codeHash:
       "0x3419a1c09eb2567f6552ee7a8ecffd64155cffe0f1796e6e61ec088d740c1356",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xec26b0f85ed839ece5f11c4c4e837ec359f5adc4420410f6453b1f6b60fb96a6",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
+  },
+  [KnownScript.TypeId]: {
+    codeHash:
+      "0x00000000000000000000000000000000000000000000000000545950455f4944",
+    hashType: "type",
+    cellDeps: [],
+  },
+  [KnownScript.XUdt]: {
+    codeHash:
+      "0x25c29dc317811a6f6f3985a7a9ebc4838bd388d19d0feeecf0bcd60f6c0975bb",
+    hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xbf6fb538763efec2a70a6a3dcb7242787087e1030c4e7d86585bc63a9d337f5f",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0x44ec8b96663e06cc94c8c468a4d46d7d9af69eaf418f6390c9f11bb763dda0ae",
+        },
+      },
+    ],
   },
   [KnownScript.JoyId]: {
     codeHash:
       "0xd23761b364210735c19c60561d213fb3beae2fd6172743719eff6920e020baac",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x4dcf3f3b09efac8995d6cbee87c5345e812d310094651e0c3d9a730f32dc9263",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.COTA]: {
     codeHash:
       "0x89cd8003a0eaf8e65e0c31525b7d1d5c1becefd2ea75bb4cff87810ae37764d8",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x636a786001f87cb615acfcf408be0f9a1f077001f0bbc75ca54eadfe7e221713",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.OmniLock]: {
     codeHash:
       "0xf329effd1c475a2978453c8600e1eaf0bc2087ee093c3ee64cc96ec6847752cb",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xec18bf0d857c981c3d1f4e17999b9b90c484b303378e94de1a57b0872f5d4602",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0x761f51fc9cd6a504c32c6ae64b3746594d1af27629b427c5ccf6c9a725a89144",
+        },
+      },
+    ],
   },
   [KnownScript.NostrLock]: {
     codeHash:
       "0x6ae5ee0cb887b2df5a9a18137315b9bdc55be8d52637b2de0624092d5f0c91d5",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xa2a434dcdbe280b9ed75bb7d6c7d68186a842456aba0fc506657dc5ed7c01d68",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0x8dc56c6f35f0c535e23ded1629b1f20535477a1b43e59f14617d11e32c50e0aa",
+        },
+      },
+    ],
+  },
+  [KnownScript.SingleUseLock]: {
+    codeHash:
+      "0x8290467a512e5b9a6b816469b0edabba1f4ac474e28ffdd604c2a7c76446bbaf",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x968c326f7a418f07a128f30d9a415251beaa2ec8bd6bbfda65780c94bebb2a85",
+            index: 4,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
+  [KnownScript.OutputTypeProxyLock]: {
+    codeHash:
+      "0xc0382e4109cff68a4f536441c0266d2e22f2808e61573129c9289ee0e5e5ed43",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x968c326f7a418f07a128f30d9a415251beaa2ec8bd6bbfda65780c94bebb2a85",
+            index: 2,
+          },
+          depType: "code",
+        },
+      },
+    ],
   },
 };

package/src/client/clientPublicTestnet.ts

@@ -1,5 +1,5 @@
 import { Script } from "../ckb";
-import { KnownScript } from "./client";
+import { CellDepInfo, KnownScript } from "./client";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
 
@@ -14,7 +14,13 @@ export class ClientPublicTestnet extends ClientJsonRpc {
 
   async getKnownScript(
     script: KnownScript,
-  ): Promise<Pick<Script, "codeHash" | "hashType">> {
-    return { ...TESTNET_SCRIPTS[script] };
+  ): Promise<
+    Pick<Script, "codeHash" | "hashType"> & { cellDeps: CellDepInfo[] }
+  > {
+    const found = TESTNET_SCRIPTS[script];
+    return {
+      ...found,
+      cellDeps: found.cellDeps.map((c) => CellDepInfo.from(c)),
+    };
   }
 }

package/src/client/clientTypes.advanced.ts

@@ -0,0 +1,26 @@
+import { ScriptLike } from "../ckb";
+import { HexLike } from "../hex";
+import { Num, numFrom, NumLike } from "../num";
+
+export function clientSearchKeyRangeFrom([a, b]: [NumLike, NumLike]): [
+  Num,
+  Num,
+] {
+  return [numFrom(a), numFrom(b)];
+}
+
+export type ClientCollectableSearchKeyFilterLike = {
+  script?: ScriptLike;
+  scriptLenRange?: [NumLike, NumLike];
+  outputData?: HexLike;
+  outputDataSearchMode?: "prefix" | "exact" | "partial";
+  outputDataLenRange?: [NumLike, NumLike];
+  outputCapacityRange?: [NumLike, NumLike];
+};
+export type ClientCollectableSearchKeyLike = {
+  script: ScriptLike;
+  scriptType: "lock" | "type";
+  scriptSearchMode: "prefix" | "exact" | "partial";
+  filter?: ClientCollectableSearchKeyFilterLike;
+  withData?: boolean;
+};

package/src/client/clientTypes.ts

@@ -1,7 +1,12 @@
-import { Cell, Script, ScriptLike, Transaction } from "../ckb";
-import { Hex, HexLike, hexFrom } from "../hex";
-import { Num, NumLike, numFrom } from "../num";
+import { Cell, Script, Transaction } from "../ckb";
+import { Hex, hexFrom } from "../hex";
+import { Num, NumLike } from "../num";
 import { apply } from "../utils";
+import {
+  ClientCollectableSearchKeyFilterLike,
+  ClientCollectableSearchKeyLike,
+  clientSearchKeyRangeFrom,
+} from "./clientTypes.advanced";
 
 export type OutputsValidator = "passthrough" | "well_known_scripts_only";
 
@@ -14,44 +19,48 @@ 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];
+export type ClientIndexerSearchKeyFilterLike =
+  ClientCollectableSearchKeyFilterLike & {
     blockRange?: [NumLike, NumLike];
   };
-  withData?: boolean;
-};
+export class ClientIndexerSearchKeyFilter {
+  constructor(
+    public script: Script | undefined,
+    public scriptLenRange: [Num, Num] | undefined,
+    public outputData: Hex | undefined,
+    public outputDataSearchMode: "prefix" | "exact" | "partial" | undefined,
+    public outputDataLenRange: [Num, Num] | undefined,
+    public outputCapacityRange: [Num, Num] | undefined,
+    public blockRange: [Num, Num] | undefined,
+  ) {}
 
-function rangeFrom([a, b]: [NumLike, NumLike]): [Num, Num] {
-  return [numFrom(a), numFrom(b)];
+  static from(
+    filterLike: ClientIndexerSearchKeyFilterLike,
+  ): ClientIndexerSearchKeyFilter {
+    return new ClientIndexerSearchKeyFilter(
+      apply(Script.from, filterLike.script),
+      apply(clientSearchKeyRangeFrom, filterLike.scriptLenRange),
+      apply(hexFrom, filterLike.outputData),
+      filterLike.outputDataSearchMode,
+      apply(clientSearchKeyRangeFrom, filterLike.outputDataLenRange),
+      apply(clientSearchKeyRangeFrom, filterLike.outputCapacityRange),
+      apply(clientSearchKeyRangeFrom, filterLike.blockRange),
+    );
+  }
 }
+
+export type ClientIndexerSearchKeyLike = ClientCollectableSearchKeyLike & {
+  filter?: ClientIndexerSearchKeyFilterLike;
+};
+
 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 scriptSearchMode: "prefix" | "exact" | "partial",
+    public filter: ClientIndexerSearchKeyFilter | undefined,
     public withData: boolean | undefined,
   ) {}
 
@@ -60,18 +69,7 @@ export class 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,
-      ),
+      apply(ClientIndexerSearchKeyFilter.from, keyLike.filter),
       keyLike.withData,
     );
   }

package/src/client/jsonRpc/index.ts

@@ -73,7 +73,7 @@ export abstract class ClientJsonRpc extends Client {
    * @returns Transaction hash.
    */
 
-  sendTransaction = this.buildSender(
+  sendTransactionNoCache = this.buildSender(
     "send_transaction",
     [JsonRpcTransformers.transactionFrom],
     hexFrom,
@@ -89,11 +89,11 @@ export abstract class ClientJsonRpc extends Client {
    * @returns The transaction with status.
    */
 
-  getTransaction = this.buildSender(
+  getTransactionNoCache = this.buildSender(
     "get_transaction",
     [hexFrom],
     JsonRpcTransformers.transactionResponseTo,
-  ) as (txHash: HexLike) => Promise<ClientTransactionResponse>;
+  ) as (txHash: HexLike) => Promise<ClientTransactionResponse | null>;
 
   /**
    * find cells from node.
@@ -105,7 +105,7 @@ export abstract class ClientJsonRpc extends Client {
    * @returns The found cells.
    */
 
-  findCellsPaged = this.buildSender(
+  findCellsPagedNoCache = this.buildSender(
     "get_cells",
     [
       JsonRpcTransformers.indexerSearchKeyFrom,

package/src/client/jsonRpc/transformers.ts

@@ -20,7 +20,7 @@ import {
   hashTypeFrom,
 } from "../../ckb";
 import { Hex } from "../../hex";
-import { NumLike, numFrom, numToHex } from "../../num";
+import { NumLike, numToHex } from "../../num";
 import { apply } from "../../utils";
 import {
   ClientFindCellsResponse,
@@ -92,7 +92,8 @@ export class JsonRpcTransformers {
       txHash: outPoint.tx_hash,
     });
   }
-  static cellInputFrom(cellInput: CellInputLike): JsonRpcCellInput {
+  static cellInputFrom(cellInputLike: CellInputLike): JsonRpcCellInput {
+    const cellInput = CellInput.from(cellInputLike);
     return {
       previous_output: JsonRpcTransformers.outPointFrom(
         cellInput.previousOutput,
@@ -156,16 +157,19 @@ export class JsonRpcTransformers {
     });
   }
   static transactionResponseTo({
-    tx_status: { status, block_number },
+    tx_status: { status },
     transaction,
   }: {
-    tx_status: { status: TransactionStatus; block_number: Hex };
-    transaction: JsonRpcTransaction;
-  }): ClientTransactionResponse {
+    tx_status: { status: TransactionStatus };
+    transaction: JsonRpcTransaction | null;
+  }): ClientTransactionResponse | null {
+    if (transaction == null) {
+      return null;
+    }
+
     return {
       transaction: JsonRpcTransformers.transactionTo(transaction),
       status,
-      blockNumber: numFrom(block_number),
     };
   }
   static rangeFrom([a, b]: [NumLike, NumLike]): [Hex, Hex] {
@@ -209,20 +213,18 @@ export class JsonRpcTransformers {
   }: {
     last_cursor: string;
     objects: {
-      block_number: Hex;
       out_point: JsonRpcOutPoint;
       output: JsonRpcCellOutput;
-      output_data: Hex;
+      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,
+          outputData: cell.output_data ?? "0x",
         }),
       ),
     };

package/src/hasher/index.ts

@@ -71,6 +71,8 @@ export class Hasher {
  * ```
  */
 
-export function ckbHash(data: BytesLike): Hex {
-  return new Hasher().update(data).digest();
+export function ckbHash(...data: BytesLike[]): Hex {
+  const hasher = new Hasher();
+  data.forEach((d) => hasher.update(d));
+  return hasher.digest();
 }

package/src/num/index.ts

@@ -12,6 +12,28 @@ export type Num = bigint;
  */
 export type NumLike = string | number | bigint | HexLike;
 
+/**
+ * Get the max among all numbers.
+ *
+ * @param numbers - numbers.
+ * @returns The max numbers among them.
+ *
+ * @example
+ * ```typescript
+ * numMax(1, 2, 3); // Outputs 3n
+ * ```
+ */
+export function numMax(a: NumLike, ...numbers: NumLike[]): Num {
+  let max = numFrom(a);
+  numbers.forEach((nLike) => {
+    const n = numFrom(nLike);
+    if (n > max) {
+      max = n;
+    }
+  });
+  return max;
+}
+
 /**
  * Converts a NumLike value to a Num (bigint).
  *

package/src/signer/btc/signerBtc.ts

@@ -65,9 +65,9 @@ export abstract class SignerBtc extends Signer {
 
     return [
       await Address.fromKnownScript(
+        this.client,
         KnownScript.OmniLock,
         hexFrom([0x04, ...hash, 0x00]),
-        this.client,
       ),
     ];
   }
@@ -81,6 +81,7 @@ export abstract class SignerBtc extends Signer {
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const { script } = await this.getRecommendedAddressObj();
+    await tx.addCellDepsOfKnownScripts(this.client, KnownScript.OmniLock);
     await tx.prepareSighashAllWitness(script, 85, this.client);
     return tx;
   }

package/src/signer/evm/signerEvm.ts

@@ -51,17 +51,17 @@ export abstract class SignerEvm extends Signer {
 
   async _getOmniLockEvmAddressObj(account: string): Promise<Address> {
     return Address.fromKnownScript(
+      this.client,
       KnownScript.OmniLock,
       hexFrom([0x12, ...bytesFrom(account), 0x00]),
-      this.client,
     );
   }
 
   async _getOmniLockOldEvmAddressObj(account: string): Promise<Address> {
     return Address.fromKnownScript(
+      this.client,
       KnownScript.OmniLock,
       hexFrom([0x1, ...bytesFrom(account), 0x00]),
-      this.client,
     );
   }
 
@@ -72,11 +72,13 @@ export abstract class SignerEvm extends Signer {
    * @returns A promise that resolves to the prepared Transaction object.
    */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    await tx.addCellDepsOfKnownScripts(this.client, KnownScript.OmniLock);
     return reduceAsync(
       await this.getAddressObjs(),
       (tx: Transaction, { script }) =>
         tx.prepareSighashAllWitness(script, 85, this.client),
-      Transaction.from(txLike),
+      tx,
     );
   }
 

package/src/signer/nostr/signerNostr.ts

@@ -78,9 +78,9 @@ export abstract class SignerNostr extends Signer {
     const publicKey = await this.getNostrPublicKey();
     return [
       await Address.fromKnownScript(
+        this.client,
         KnownScript.NostrLock,
         hexFrom(bytesConcat([0x00], ckbHash(publicKey).slice(0, 42))),
-        this.client,
       ),
     ];
   }
@@ -94,6 +94,7 @@ export abstract class SignerNostr extends Signer {
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const { script } = await this.getRecommendedAddressObj();
+    await tx.addCellDepsOfKnownScripts(this.client, KnownScript.NostrLock);
     await tx.prepareSighashAllWitness(script, 572, this.client);
     return tx;
   }

package/src/utils/index.ts

@@ -103,6 +103,8 @@ export async function reduceAsync<T, V>(
   accumulator: (
     a: T,
     b: V,
+    i: number,
+    values: V[],
   ) => Promise<T | undefined | null | void> | T | undefined | null | void,
   init: T,
 ): Promise<T>;
@@ -111,6 +113,8 @@ export async function reduceAsync<T, V>(
   accumulator: (
     a: T,
     b: T | V,
+    i: number,
+    values: (V | T)[],
   ) => Promise<T | undefined | null | void> | T | undefined | null | void,
   init?: T,
 ): Promise<T> {
@@ -123,9 +127,9 @@ export async function reduceAsync<T, V>(
   }
 
   return values.reduce(
-    (current: Promise<T>, b: T | V) =>
+    (current: Promise<T>, b: T | V, i, array) =>
       current.then((v) =>
-        Promise.resolve(accumulator(v, b)).then((r) => r ?? v),
+        Promise.resolve(accumulator(v, b, i, array)).then((r) => r ?? v),
       ),
     Promise.resolve(init),
   );