@ckb-ccc/core 1.10.0 → 1.11.1

package/dist.commonjs/signer/signer/index.js

@@ -134,6 +134,29 @@ class Signer {
     async getAddresses() {
         return this.getAddressObjs().then((addresses) => addresses.map((address) => address.toString()));
     }
+    /**
+     * 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, withData, order, limit) {
+        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
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckb-ccc/core",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "description": "Core of CCC - CKBer's Codebase",
   "author": "Hanssen0 <hanssen0@hanssen0.com>",
   "license": "MIT",

package/prettier.config.mjs

@@ -7,7 +7,7 @@
 const config = {
   singleQuote: false,
   trailingComma: "all",
-  plugins: [import.meta.resolve("prettier-plugin-organize-imports")],
+  plugins: ["prettier-plugin-organize-imports"],
 };
 
 export default config;

package/src/ckb/hash.ts

@@ -0,0 +1,28 @@
+import { hashCkb } from "../hasher/hasherCkb.js";
+import { Hex } from "../hex/index.js";
+import { NumLike, numLeToBytes } from "../num/index.js";
+import { CellInput, CellInputLike } from "./transaction.js";
+
+/**
+ * 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/ckb/index.ts

@@ -1,3 +1,4 @@
+export * from "./hash.js";
 export * from "./script.js";
 export * from "./transaction.js";
 export * from "./transactionErrors.js";

package/src/ckb/transaction.ts

@@ -235,29 +235,58 @@ export class CellOutput extends mol.Entity.Base<CellOutputLike, CellOutput>() {
 
   /**
    * Creates a CellOutput instance from a CellOutputLike object.
+   * This method supports automatic capacity calculation when capacity is 0 or omitted.
    *
    * @param cellOutput - A CellOutputLike object or an instance of CellOutput.
+   *                     Can also be an object without capacity when outputData is provided.
+   * @param outputData - Optional output data used for automatic capacity calculation.
+   *                     When provided and capacity is 0, the capacity will be calculated
+   *                     as occupiedSize + outputData.length.
    * @returns A CellOutput instance.
    *
    * @example
    * ```typescript
-   * const cellOutput = CellOutput.from({
+   * // Basic usage with explicit capacity
+   * const cellOutput1 = CellOutput.from({
    *   capacity: 1000n,
    *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." },
    *   type: { codeHash: "0x...", hashType: "type", args: "0x..." }
    * });
+   *
+   * // Automatic capacity calculation
+   * const cellOutput2 = CellOutput.from({
+   *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   * }, "0x1234"); // Capacity will be calculated automatically
    * ```
    */
-  static from(cellOutput: CellOutputLike): CellOutput {
+  static from(cellOutput: CellOutputLike, outputData?: HexLike): CellOutput;
+  static from(
+    cellOutput: Omit<CellOutputLike, "capacity"> &
+      Partial<Pick<CellOutputLike, "capacity">>,
+    outputData: HexLike,
+  ): CellOutput;
+  static from(
+    cellOutput: Omit<CellOutputLike, "capacity"> &
+      Partial<Pick<CellOutputLike, "capacity">>,
+    outputData?: HexLike,
+  ): CellOutput {
     if (cellOutput instanceof CellOutput) {
       return cellOutput;
     }
 
-    return new CellOutput(
-      numFrom(cellOutput.capacity),
+    const output = new CellOutput(
+      numFrom(cellOutput.capacity ?? 0),
       Script.from(cellOutput.lock),
       apply(Script.from, cellOutput.type),
     );
+
+    if (output.capacity === Zero) {
+      output.capacity = fixedPointFrom(
+        output.occupiedSize + bytesFrom(outputData ?? "0x").length,
+      );
+    }
+
+    return output;
   }
 
   /**
@@ -308,9 +337,37 @@ export class Cell {
 
   /**
    * Creates a Cell instance from a CellLike object.
+   * This method accepts either `outPoint` or `previousOutput` to specify the cell's location,
+   * and supports automatic capacity calculation for the cell output.
    *
-   * @param cell - A CellLike object or an instance of Cell.
+   * @param cell - A CellLike object or an instance of Cell. The object can use either:
+   *               - `outPoint`: For referencing a cell output
+   *               - `previousOutput`: For referencing a cell input (alternative name for outPoint)
+   *               The cellOutput can omit capacity for automatic calculation.
    * @returns A Cell instance.
+   *
+   * @example
+   * ```typescript
+   * // Using outPoint with explicit capacity
+   * const cell1 = Cell.from({
+   *   outPoint: { txHash: "0x...", index: 0 },
+   *   cellOutput: {
+   *     capacity: 1000n,
+   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   *   },
+   *   outputData: "0x"
+   * });
+   *
+   * // Using previousOutput with automatic capacity calculation
+   * const cell2 = Cell.from({
+   *   previousOutput: { txHash: "0x...", index: 0 },
+   *   cellOutput: {
+   *     lock: { codeHash: "0x...", hashType: "type", args: "0x..." }
+   *     // capacity will be calculated automatically
+   *   },
+   *   outputData: "0x1234"
+   * });
+   * ```
    */
 
   static from(cell: CellLike): Cell {
@@ -320,7 +377,7 @@ export class Cell {
 
     return new Cell(
       OutPoint.from("outPoint" in cell ? cell.outPoint : cell.previousOutput),
-      CellOutput.from(cell.cellOutput),
+      CellOutput.from(cell.cellOutput, cell.outputData),
       hexFrom(cell.outputData),
     );
   }
@@ -1001,6 +1058,9 @@ export class Transaction extends mol.Entity.Base<
 
   /**
    * Copy every properties from another transaction.
+   * This method replaces all properties of the current transaction with those from the provided transaction.
+   *
+   * @param txLike - The transaction-like object to copy properties from.
    *
    * @example
    * ```typescript
@@ -1092,19 +1152,9 @@ export class Transaction extends mol.Entity.Base<
       return tx;
     }
     const outputs =
-      tx.outputs?.map((output, i) => {
-        const o = CellOutput.from({
-          ...output,
-          capacity: output.capacity ?? 0,
-        });
-        if (o.capacity === Zero) {
-          o.capacity = fixedPointFrom(
-            o.occupiedSize +
-              (apply(bytesFrom, tx.outputsData?.[i])?.length ?? 0),
-          );
-        }
-        return o;
-      }) ?? [];
+      tx.outputs?.map((output, i) =>
+        CellOutput.from(output, tx.outputsData?.[i] ?? []),
+      ) ?? [];
     const outputsData = outputs.map((_, i) =>
       hexFrom(tx.outputsData?.[i] ?? "0x"),
     );
@@ -1332,7 +1382,7 @@ export class Transaction extends mol.Entity.Base<
    *
    * @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
+   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
    *
    * @example
    * ```typescript
@@ -1359,7 +1409,7 @@ export class Transaction extends mol.Entity.Base<
    *
    * @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
+   * @returns A promise that resolves to the found index, or undefined if no matching input is found.
    *
    * @example
    * ```typescript
@@ -1472,14 +1522,14 @@ export class Transaction extends mol.Entity.Base<
    * Set output data at index.
    *
    * @param index - The index of the output data.
-   * @param witness - The data to set.
+   * @param data - The data to set.
    *
    * @example
    * ```typescript
-   * await tx.setOutputDataAt(0, "0x00");
+   * tx.setOutputDataAt(0, "0x00");
    * ```
    */
-  setOutputDataAt(index: number, witness: HexLike): void {
+  setOutputDataAt(index: number, data: HexLike): void {
     if (this.outputsData.length < index) {
       this.outputsData.push(
         ...Array.from(
@@ -1489,7 +1539,7 @@ export class Transaction extends mol.Entity.Base<
       );
     }
 
-    this.outputsData[index] = hexFrom(witness);
+    this.outputsData[index] = hexFrom(data);
   }
 
   /**
@@ -1564,16 +1614,7 @@ export class Transaction extends mol.Entity.Base<
       Partial<Pick<CellOutputLike, "capacity">>,
     outputData: HexLike = "0x",
   ): number {
-    const output = CellOutput.from({
-      ...outputLike,
-      capacity: outputLike.capacity ?? 0,
-    });
-    if (output.capacity === Zero) {
-      output.capacity = fixedPointFrom(
-        output.occupiedSize + bytesFrom(outputData).length,
-      );
-    }
-    const len = this.outputs.push(output);
+    const len = this.outputs.push(CellOutput.from(outputLike, outputData));
     this.setOutputDataAt(len - 1, outputData);
 
     return len;
@@ -1998,21 +2039,22 @@ export class Transaction extends mol.Entity.Base<
 
     let leastFee = Zero;
     let leastExtraCapacity = Zero;
-
+    let collected = 0;
+
+    // ===
+    // Usually, for the worst situation, three iterations are needed
+    // 1. First attempt to complete the transaction.
+    // 2. Not enough capacity for the change cell.
+    // 3. Fee increased by the change cell.
+    // ===
     while (true) {
-      const tx = this.clone();
-      const collected = await (async () => {
+      collected += await (async () => {
         if (!(options?.shouldAddInputs ?? true)) {
-          const fee =
-            (await tx.getFee(from.client)) - leastFee - leastExtraCapacity;
-          if (fee < Zero) {
-            throw new ErrorTransactionInsufficientCapacity(-fee);
-          }
           return 0;
         }
 
         try {
-          return await tx.completeInputsByCapacity(
+          return await this.completeInputsByCapacity(
             from,
             leastFee + leastExtraCapacity,
             filter,
@@ -2031,21 +2073,33 @@ export class Transaction extends mol.Entity.Base<
         }
       })();
 
-      await from.prepareTransaction(tx);
+      const fee = await this.getFee(from.client);
+      if (fee < leastFee + leastExtraCapacity) {
+        // Not enough capacity are collected, it should only happens when shouldAddInputs is false
+        throw new ErrorTransactionInsufficientCapacity(
+          leastFee + leastExtraCapacity - fee,
+          { isForChange: leastExtraCapacity !== Zero },
+        );
+      }
+
+      await from.prepareTransaction(this);
       if (leastFee === Zero) {
         // The initial fee is calculated based on prepared transaction
-        leastFee = tx.estimateFee(feeRate);
+        // This should only happens during the first iteration
+        leastFee = this.estimateFee(feeRate);
       }
-      const fee = await tx.getFee(from.client);
       // The extra capacity paid the fee without a change
+      // leastExtraCapacity should be 0 here, otherwise we should failed in the previous check
+      // So this only happens in the first iteration
       if (fee === leastFee) {
-        this.copy(tx);
         return [collected, false];
       }
 
+      // Invoke the change function on a transaction multiple times may cause problems, so we clone it
+      const tx = this.clone();
       const needed = numFrom(await Promise.resolve(change(tx, fee - leastFee)));
-      // No enough extra capacity to create new cells for change
       if (needed > Zero) {
+        // No enough extra capacity to create new cells for change, collect inputs again
         leastExtraCapacity = needed;
         continue;
       }
@@ -2073,6 +2127,38 @@ export class Transaction extends mol.Entity.Base<
     }
   }
 
+  /**
+   * Completes the transaction fee by adding inputs and creating a change output with the specified lock script.
+   * This is a convenience method that automatically creates a change cell with the provided lock script
+   * when there's excess capacity after paying the transaction fee.
+   *
+   * @param from - The signer to complete inputs from and prepare the transaction.
+   * @param change - The lock script for the change output cell.
+   * @param feeRate - Optional fee rate in shannons per 1000 bytes. If not provided, it will be fetched from the client.
+   * @param filter - Optional filter for selecting cells when adding inputs.
+   * @param options - Optional configuration object.
+   * @param options.feeRateBlockRange - Block range for fee rate calculation when feeRate is not provided.
+   * @param options.maxFeeRate - Maximum allowed fee rate.
+   * @param options.shouldAddInputs - Whether to add inputs automatically. Defaults to true.
+   * @returns A promise that resolves to a tuple containing:
+   *          - The number of inputs added during the process
+   *          - A boolean indicating whether change outputs were created (true) or fee was paid without change (false)
+   *
+   * @example
+   * ```typescript
+   * const changeScript = Script.from({
+   *   codeHash: "0x...",
+   *   hashType: "type",
+   *   args: "0x..."
+   * });
+   *
+   * const [addedInputs, hasChange] = await tx.completeFeeChangeToLock(
+   *   signer,
+   *   changeScript,
+   *   1000n // 1000 shannons per 1000 bytes
+   * );
+   * ```
+   */
   completeFeeChangeToLock(
     from: Signer,
     change: ScriptLike,
@@ -2104,6 +2190,33 @@ export class Transaction extends mol.Entity.Base<
     );
   }
 
+  /**
+   * Completes the transaction fee using the signer's recommended address for change.
+   * This is a convenience method that automatically uses the signer's recommended
+   * address as the change destination, making it easier to complete transactions
+   * without manually specifying a change address.
+   *
+   * @param from - The signer to complete inputs from and prepare the transaction.
+   * @param feeRate - Optional fee rate in shannons per 1000 bytes. If not provided, it will be fetched from the client.
+   * @param filter - Optional filter for selecting cells when adding inputs.
+   * @param options - Optional configuration object.
+   * @param options.feeRateBlockRange - Block range for fee rate calculation when feeRate is not provided.
+   * @param options.maxFeeRate - Maximum allowed fee rate.
+   * @param options.shouldAddInputs - Whether to add inputs automatically. Defaults to true.
+   * @returns A promise that resolves to a tuple containing:
+   *          - The number of inputs added during the process
+   *          - A boolean indicating whether change outputs were created (true) or fee was paid without change (false)
+   *
+   * @example
+   * ```typescript
+   * const [addedInputs, hasChange] = await tx.completeFeeBy(
+   *   signer,
+   *   1000n // 1000 shannons per 1000 bytes
+   * );
+   *
+   * // Change will automatically go to signer's recommended address
+   * ```
+   */
   async completeFeeBy(
     from: Signer,
     feeRate?: NumLike,
@@ -2119,6 +2232,35 @@ export class Transaction extends mol.Entity.Base<
     return this.completeFeeChangeToLock(from, script, feeRate, filter, options);
   }
 
+  /**
+   * Completes the transaction fee by adding excess capacity to an existing output.
+   * Instead of creating a new change output, this method adds any excess capacity
+   * to the specified existing output in the transaction.
+   *
+   * @param from - The signer to complete inputs from and prepare the transaction.
+   * @param index - The index of the existing output to add excess capacity to.
+   * @param feeRate - Optional fee rate in shannons per 1000 bytes. If not provided, it will be fetched from the client.
+   * @param filter - Optional filter for selecting cells when adding inputs.
+   * @param options - Optional configuration object.
+   * @param options.feeRateBlockRange - Block range for fee rate calculation when feeRate is not provided.
+   * @param options.maxFeeRate - Maximum allowed fee rate.
+   * @param options.shouldAddInputs - Whether to add inputs automatically. Defaults to true.
+   * @returns A promise that resolves to a tuple containing:
+   *          - The number of inputs added during the process
+   *          - A boolean indicating whether change was applied (true) or fee was paid without change (false)
+   *
+   * @throws {Error} When the specified output index doesn't exist.
+   *
+   * @example
+   * ```typescript
+   * // Add excess capacity to the first output (index 0)
+   * const [addedInputs, hasChange] = await tx.completeFeeChangeToOutput(
+   *   signer,
+   *   0, // Output index
+   *   1000n // 1000 shannons per 1000 bytes
+   * );
+   * ```
+   */
   completeFeeChangeToOutput(
     from: Signer,
     index: NumLike,
@@ -2148,7 +2290,26 @@ export class Transaction extends mol.Entity.Base<
 }
 
 /**
- * Calculate Nervos DAO profit between two blocks
+ * Calculate Nervos DAO profit between two blocks.
+ * This function computes the profit earned from a Nervos DAO deposit
+ * based on the capacity and the time period between deposit and withdrawal.
+ *
+ * @param profitableCapacity - The capacity that earns profit (total capacity minus occupied capacity).
+ * @param depositHeaderLike - The block header when the DAO deposit was made.
+ * @param withdrawHeaderLike - The block header when the DAO withdrawal is made.
+ * @returns The profit amount in CKB (capacity units).
+ *
+ * @example
+ * ```typescript
+ * const profit = calcDaoProfit(
+ *   ccc.fixedPointFrom(100), // 100 CKB profitable capacity
+ *   depositHeader,
+ *   withdrawHeader
+ * );
+ * console.log(`Profit: ${profit} shannons`);
+ * ```
+ *
+ * @see {@link https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md | Nervos DAO RFC}
  */
 export function calcDaoProfit(
   profitableCapacity: NumLike,
@@ -2167,8 +2328,26 @@ export function calcDaoProfit(
 }
 
 /**
- * Calculate claimable epoch for Nervos DAO withdrawal
- * See https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md
+ * Calculate claimable epoch for Nervos DAO withdrawal.
+ * This function determines the earliest epoch when a Nervos DAO withdrawal
+ * can be claimed based on the deposit and withdrawal epochs.
+ *
+ * @param depositHeader - The block header when the DAO deposit was made.
+ * @param withdrawHeader - The block header when the DAO withdrawal was initiated.
+ * @returns The epoch when the withdrawal can be claimed, represented as [number, index, length].
+ *
+ * @example
+ * ```typescript
+ * const claimEpoch = calcDaoClaimEpoch(depositHeader, withdrawHeader);
+ * console.log(`Can claim at epoch: ${claimEpoch[0]}, index: ${claimEpoch[1]}, length: ${claimEpoch[2]}`);
+ * ```
+ *
+ * @remarks
+ * The Nervos DAO has a minimum lock period of 180 epochs (~30 days).
+ * This function calculates the exact epoch when the withdrawal becomes claimable
+ * based on the deposit epoch and withdrawal epoch timing.
+ *
+ * @see {@link https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md | Nervos DAO RFC}
  */
 export function calcDaoClaimEpoch(
   depositHeader: ClientBlockHeaderLike,

package/src/client/clientPublicMainnet.advanced.ts

@@ -120,10 +120,80 @@ export const MAINNET_SCRIPTS: Record<KnownScript, ScriptInfoLike | undefined> =
           cellDep: {
             outPoint: {
               txHash:
-                "0xf05188e5f3a6767fc4687faf45ba5f1a6e25d3ada6129dae8722cb282f262493",
+                "0xbdc3153fcb7c256d007be758c0b50c8da60b5ac0e44ae9e11d3dcc5b73d2b347",
               index: 0,
             },
-            depType: "depGroup",
+            depType: "code",
+          },
+          type: {
+            codeHash:
+              "0x00000000000000000000000000000000000000000000000000545950455f4944",
+            hashType: "type",
+            args: "0xd00c84f0ec8fd441c38bc3f87a371f547190f2fcff88e642bc5bf54b9e318323",
+          },
+        },
+        {
+          cellDep: {
+            outPoint: {
+              txHash:
+                "0xbac0f6f0a177a03974870df47ab0c3e761c5dd19e9ca165358d0b72bd7f433f5",
+              index: 1,
+            },
+            depType: "code",
+          },
+          type: {
+            codeHash:
+              "0x00000000000000000000000000000000000000000000000000545950455f4944",
+            hashType: "type",
+            args: "0xaede124e8eca8ea4a0029d5f0999299a3f9a4090c6fd6f83d88c41707cc8aa75",
+          },
+        },
+        {
+          cellDep: {
+            outPoint: {
+              txHash:
+                "0xbac0f6f0a177a03974870df47ab0c3e761c5dd19e9ca165358d0b72bd7f433f5",
+              index: 2,
+            },
+            depType: "code",
+          },
+          type: {
+            codeHash:
+              "0x00000000000000000000000000000000000000000000000000545950455f4944",
+            hashType: "type",
+            args: "0x2409a9568c2ae67e73e12b1f0193c9a44c782ec1c73627b3c92ad2d0fb6128ed",
+          },
+        },
+        {
+          cellDep: {
+            outPoint: {
+              txHash:
+                "0xbac0f6f0a177a03974870df47ab0c3e761c5dd19e9ca165358d0b72bd7f433f5",
+              index: 3,
+            },
+            depType: "code",
+          },
+          type: {
+            codeHash:
+              "0x00000000000000000000000000000000000000000000000000545950455f4944",
+            hashType: "type",
+            args: "0xaf96ed62f5997c4a4814058545bc958124bada97fcd42955756e3c078da64523",
+          },
+        },
+        {
+          cellDep: {
+            outPoint: {
+              txHash:
+                "0xbac0f6f0a177a03974870df47ab0c3e761c5dd19e9ca165358d0b72bd7f433f5",
+              index: 4,
+            },
+            depType: "code",
+          },
+          type: {
+            codeHash:
+              "0x00000000000000000000000000000000000000000000000000545950455f4944",
+            hashType: "type",
+            args: "0xfa9f0c3599dc23b9489a11dfedb11489c7ad342982848495856966ed23a6bc7d",
           },
         },
       ],
@@ -387,72 +457,4 @@ export const MAINNET_SCRIPTS: Record<KnownScript, ScriptInfoLike | undefined> =
         },
       ],
     },
-    [KnownScript.RgbppLock]: {
-      codeHash:
-        "0xbc6c568a1a0d0a09f6844dc9d74ddb4343c32143ff25f727c59edf4fb72d6936",
-      hashType: "type",
-      cellDeps: [
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0x04c5c3e69f1aa6ee27fb9de3d15a81704e387ab3b453965adbe0b6ca343c6f41",
-              index: 0,
-            },
-            depType: "code",
-          },
-          type: {
-            codeHash:
-              "0x00000000000000000000000000000000000000000000000000545950455f4944",
-            hashType: "type",
-            args: "0x68ad3d9e0bb9ea841a5d1fcd600137bd3f45401e759e353121f26cd0d981452f",
-          },
-        },
-        // Rgbpp lock config cell dep
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0x04c5c3e69f1aa6ee27fb9de3d15a81704e387ab3b453965adbe0b6ca343c6f41",
-              index: 1,
-            },
-            depType: "code",
-          },
-        },
-      ],
-    },
-    [KnownScript.BtcTimeLock]: {
-      codeHash:
-        "0x70d64497a075bd651e98ac030455ea200637ee325a12ad08aff03f1a117e5a62",
-      hashType: "type",
-      cellDeps: [
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0x6257bf4297ee75fcebe2654d8c5f8d93bc9fc1b3dc62b8cef54ffe166162e996",
-              index: 0,
-            },
-            depType: "code",
-          },
-          type: {
-            codeHash:
-              "0x00000000000000000000000000000000000000000000000000545950455f4944",
-            hashType: "type",
-            args: "0x44b8253ae18e913a2845b0d548eaf6b3ba1099ed26835888932a754194028a8a",
-          },
-        },
-        // btc time lock config cell dep
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0x6257bf4297ee75fcebe2654d8c5f8d93bc9fc1b3dc62b8cef54ffe166162e996",
-              index: 1,
-            },
-            depType: "code",
-          },
-        },
-      ],
-    },
   });