@ckb-ccc/core 1.10.0 → 1.11.1

package/dist/ckb/transaction.js

@@ -172,26 +172,15 @@ let CellOutput = CellOutput_1 = class CellOutput extends mol.Entity.Base() {
     get occupiedSize() {
         return 8 + this.lock.occupiedSize + (this.type?.occupiedSize ?? 0);
     }
-    /**
-     * Creates a CellOutput instance from a CellOutputLike object.
-     *
-     * @param cellOutput - A CellOutputLike object or an instance of CellOutput.
-     * @returns A CellOutput instance.
-     *
-     * @example
-     * ```typescript
-     * const cellOutput = CellOutput.from({
-     *   capacity: 1000n,
-     *   lock: { codeHash: "0x...", hashType: "type", args: "0x..." },
-     *   type: { codeHash: "0x...", hashType: "type", args: "0x..." }
-     * });
-     * ```
-     */
-    static from(cellOutput) {
+    static from(cellOutput, outputData) {
         if (cellOutput instanceof CellOutput_1) {
             return cellOutput;
         }
-        return new CellOutput_1(numFrom(cellOutput.capacity), Script.from(cellOutput.lock), apply(Script.from, cellOutput.type));
+        const output = new CellOutput_1(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;
     }
     /**
      * Clone a CellOutput.
@@ -234,15 +223,43 @@ 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) {
         if (cell instanceof Cell) {
             return cell;
         }
-        return new Cell(OutPoint.from("outPoint" in cell ? cell.outPoint : cell.previousOutput), CellOutput.from(cell.cellOutput), hexFrom(cell.outputData));
+        return new Cell(OutPoint.from("outPoint" in cell ? cell.outPoint : cell.previousOutput), CellOutput.from(cell.cellOutput, cell.outputData), hexFrom(cell.outputData));
     }
     get capacityFree() {
         const occupiedSize = fixedPointFrom(this.cellOutput.occupiedSize + bytesFrom(this.outputData).length);
@@ -720,6 +737,9 @@ let Transaction = Transaction_1 = 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
@@ -799,17 +819,7 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
         if (tx instanceof Transaction_1) {
             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;
-        }) ?? [];
+        const outputs = tx.outputs?.map((output, i) => CellOutput.from(output, tx.outputsData?.[i] ?? [])) ?? [];
         const outputsData = outputs.map((_, i) => hexFrom(tx.outputsData?.[i] ?? "0x"));
         if (tx.outputsData != null && outputsData.length < tx.outputsData.length) {
             outputsData.push(...tx.outputsData.slice(outputsData.length).map((d) => hexFrom(d)));
@@ -992,7 +1002,7 @@ let Transaction = Transaction_1 = 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
@@ -1013,7 +1023,7 @@ let Transaction = Transaction_1 = 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
@@ -1101,18 +1111,18 @@ let Transaction = Transaction_1 = 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, witness) {
+    setOutputDataAt(index, data) {
         if (this.outputsData.length < index) {
             this.outputsData.push(...Array.from(new Array(index - this.outputsData.length), () => "0x"));
         }
-        this.outputsData[index] = hexFrom(witness);
+        this.outputsData[index] = hexFrom(data);
     }
     /**
      * get input
@@ -1175,14 +1185,7 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
      * ```
      */
     addOutput(outputLike, outputData = "0x") {
-        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;
     }
@@ -1454,18 +1457,20 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
         await this.getInputsCapacity(from.client);
         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(from, leastFee + leastExtraCapacity, filter);
+                    return await this.completeInputsByCapacity(from, leastFee + leastExtraCapacity, filter);
                 }
                 catch (err) {
                     if (err instanceof ErrorTransactionInsufficientCapacity &&
@@ -1477,20 +1482,28 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
                     throw err;
                 }
             })();
-            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;
             }
@@ -1512,6 +1525,38 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
             leastFee = changedFee;
         }
     }
+    /**
+     * 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, change, feeRate, filter, options) {
         const script = Script.from(change);
         return this.completeFee(from, (tx, capacity) => {
@@ -1525,10 +1570,66 @@ let Transaction = Transaction_1 = class Transaction extends mol.Entity.Base() {
             return 0;
         }, feeRate, filter, options);
     }
+    /**
+     * 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, feeRate, filter, options) {
         const { script } = await from.getRecommendedAddressObj();
         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, index, feeRate, filter, options) {
         const change = Number(numFrom(index));
         if (!this.outputs[change]) {
@@ -1557,7 +1658,26 @@ Transaction = Transaction_1 = __decorate([
 ], Transaction);
 export { Transaction };
 /**
- * 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, depositHeaderLike, withdrawHeaderLike) {
     const depositHeader = ClientBlockHeader.from(depositHeaderLike);
@@ -1567,8 +1687,26 @@ export function calcDaoProfit(profitableCapacity, depositHeaderLike, withdrawHea
         profitableSize);
 }
 /**
- * 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, withdrawHeader) {
     const depositEpoch = ClientBlockHeader.from(depositHeader).epoch;

package/dist/client/clientPublicMainnet.advanced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clientPublicMainnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicMainnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,GAAG,SAAS,CAscxE,CAAC"}
+{"version":3,"file":"clientPublicMainnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicMainnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,GAAG,SAAS,CAwcxE,CAAC"}

package/dist/client/clientPublicMainnet.advanced.js

@@ -102,10 +102,71 @@ export const MAINNET_SCRIPTS = Object.freeze({
             {
                 cellDep: {
                     outPoint: {
-                        txHash: "0xf05188e5f3a6767fc4687faf45ba5f1a6e25d3ada6129dae8722cb282f262493",
+                        txHash: "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",
                 },
             },
         ],
@@ -338,64 +399,4 @@ export const MAINNET_SCRIPTS = Object.freeze({
             },
         ],
     },
-    [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/dist/client/clientPublicTestnet.advanced.d.ts

@@ -1,27 +1,4 @@
 import { ScriptInfoLike } from "./clientTypes.js";
 import { KnownScript } from "./knownScript.js";
 export declare const TESTNET_SCRIPTS: Record<KnownScript, ScriptInfoLike>;
-/**
- * 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 declare const TESTNET_SCRIPTS_BTC_SIGNET_OVERRIDES: Partial<Record<KnownScript, ScriptInfoLike>>;
 //# sourceMappingURL=clientPublicTestnet.advanced.d.ts.map

package/dist/client/clientPublicTestnet.advanced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clientPublicTestnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicTestnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,CAkd5D,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oCAAoC,EAAE,OAAO,CACxD,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,CAsEnC,CAAC"}
+{"version":3,"file":"clientPublicTestnet.advanced.d.ts","sourceRoot":"","sources":["../../src/client/clientPublicTestnet.advanced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,CAod5D,CAAC"}