@ckb-ccc/core 1.10.0 → 1.11.0

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

@@ -387,72 +387,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",
-          },
-        },
-      ],
-    },
   });

package/src/client/clientPublicTestnet.advanced.ts

@@ -399,167 +399,4 @@ export const TESTNET_SCRIPTS: Record<KnownScript, ScriptInfoLike> =
         },
       ],
     },
-    [KnownScript.RgbppLock]: {
-      codeHash:
-        "0x61ca7a4796a4eb19ca4f0d065cb9b10ddcf002f10f7cbb810c706cb6bb5c3248",
-      hashType: "type",
-      cellDeps: [
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0xf1de59e973b85791ec32debbba08dff80c63197e895eb95d67fc1e9f6b413e00",
-              index: 0,
-            },
-            depType: "code",
-          },
-          type: {
-            codeHash:
-              "0x00000000000000000000000000000000000000000000000000545950455f4944",
-            hashType: "type",
-            args: "0xa3bc8441df149def76cfe15fec7b1e51d949548bc27fb7a75e9d4b3ef1c12c7f",
-          },
-        },
-        // Rgbpp lock config cell dep for Bitcoin Testnet3
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0xf1de59e973b85791ec32debbba08dff80c63197e895eb95d67fc1e9f6b413e00",
-              index: 1,
-            },
-            depType: "code",
-          },
-        },
-      ],
-    },
-    [KnownScript.BtcTimeLock]: {
-      codeHash:
-        "0x00cdf8fab0f8ac638758ebf5ea5e4052b1d71e8a77b9f43139718621f6849326",
-      hashType: "type",
-      cellDeps: [
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0xde0f87878a97500f549418e5d46d2f7704c565a262aa17036c9c1c13ad638529",
-              index: 0,
-            },
-            depType: "code",
-          },
-          type: {
-            codeHash:
-              "0x00000000000000000000000000000000000000000000000000545950455f4944",
-            hashType: "type",
-            args: "0xc9828585e6dd2afacb9e6e8ca7deb0975121aabee5c7983178a45509ffaec984",
-          },
-        },
-        // btc time lock config cell dep for Bitcoin Testnet3
-        {
-          cellDep: {
-            outPoint: {
-              txHash:
-                "0xde0f87878a97500f549418e5d46d2f7704c565a262aa17036c9c1c13ad638529",
-              index: 1,
-            },
-            depType: "code",
-          },
-        },
-      ],
-    },
   });
-
-/**
- * Bitcoin Signet specific script overrides for testnet
- *
- * Contains script configurations that differ when using Bitcoin Signet
- * instead of Bitcoin Testnet3. Only RgbppLock and BtcTimeLock are affected.
- *
- * @example
- * ```typescript
- * import { ClientPublicTestnet } from "@ckb-ccc/core";
- * import { TESTNET_SCRIPTS, TESTNET_SCRIPTS_BTC_SIGNET_OVERRIDES } from "@ckb-ccc/core/advanced";
- *
- * // Use Bitcoin Testnet3 scripts (default)
- * const testnet3Client = new ClientPublicTestnet();
- *
- * // Use Bitcoin Signet scripts by merging overrides
- * const signetClient = new ClientPublicTestnet({
- *   scripts: {
- *     ...TESTNET_SCRIPTS,
- *     ...TESTNET_SCRIPTS_BTC_SIGNET_OVERRIDES
- *   }
- * });
- */
-export const TESTNET_SCRIPTS_BTC_SIGNET_OVERRIDES: Partial<
-  Record<KnownScript, ScriptInfoLike>
-> = Object.freeze({
-  [KnownScript.RgbppLock]: {
-    codeHash:
-      "0xd07598deec7ce7b5665310386b4abd06a6d48843e953c5cc2112ad0d5a220364",
-    hashType: "type",
-    cellDeps: [
-      {
-        cellDep: {
-          outPoint: {
-            txHash:
-              "0x61efdeddbaa0bb4132c0eb174b3e8002ff5ec430f61ba46f30768d683c516eec",
-            index: 0,
-          },
-          depType: "code",
-        },
-        type: {
-          codeHash:
-            "0x00000000000000000000000000000000000000000000000000545950455f4944",
-          hashType: "type",
-          args: "0xb69fe766ce3b7014a2a78ad1fe688d82f1679325805371d2856c3b8d18ebfa5a",
-        },
-      },
-      // Rgbpp lock config cell dep for Bitcoin Signet
-      {
-        cellDep: {
-          outPoint: {
-            txHash:
-              "0x61efdeddbaa0bb4132c0eb174b3e8002ff5ec430f61ba46f30768d683c516eec",
-            index: 1,
-          },
-          depType: "code",
-        },
-      },
-    ],
-  },
-  [KnownScript.BtcTimeLock]: {
-    codeHash:
-      "0x80a09eca26d77cea1f5a69471c59481be7404febf40ee90f886c36a948385b55",
-    hashType: "type",
-    cellDeps: [
-      {
-        cellDep: {
-          outPoint: {
-            txHash:
-              "0x5364b3535965e9eac9a35dd7af8e9e45a61d30a16e115923c032f80b28783e21",
-            index: 0,
-          },
-          depType: "code",
-        },
-        type: {
-          codeHash:
-            "0x00000000000000000000000000000000000000000000000000545950455f4944",
-          hashType: "type",
-          args: "0x32fc8c70a6451a1439fd91e214bba093f9cdd9276bc4ab223430dab5940aff92",
-        },
-      },
-      // btc time lock config cell dep for Bitcoin Signet
-      {
-        cellDep: {
-          outPoint: {
-            txHash:
-              "0x5364b3535965e9eac9a35dd7af8e9e45a61d30a16e115923c032f80b28783e21",
-            index: 1,
-          },
-          depType: "code",
-        },
-      },
-    ],
-  },
-});

package/src/client/knownScript.ts

@@ -25,9 +25,4 @@ export enum KnownScript {
   TypeBurnLock = "TypeBurnLock",
   EasyToDiscoverType = "EasyToDiscoverType",
   TimeLock = "TimeLock",
-
-  // RGB++ related scripts (default using Bitcoin Testnet3)
-  // For Bitcoin Signet, use TESTNET_SCRIPTS_BTC_SIGNET_OVERRIDES from @ckb-ccc/core/advanced
-  RgbppLock = "RgbppLock",
-  BtcTimeLock = "BtcTimeLock",
 }