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

package/dist.commonjs/ckb/transaction.js

@@ -1,29 +1,60 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o["default"] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null)
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
-};
+  };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.WitnessArgs = exports.CellDep = exports.CellInput = exports.Cell = exports.CellOutput = exports.OutPoint = exports.depTypeFromBytes = exports.depTypeToBytes = exports.depTypeFrom = void 0;
+exports.Transaction =
+  exports.WitnessArgs =
+  exports.CellDep =
+  exports.CellInput =
+  exports.Cell =
+  exports.CellOutput =
+  exports.OutPoint =
+  exports.depTypeFromBytes =
+  exports.depTypeToBytes =
+  exports.depTypeFrom =
+    void 0;
 const bytes_1 = require("../bytes");
 const hasher_1 = require("../hasher");
 const hex_1 = require("../hex");
@@ -47,19 +78,19 @@ const transaction_advanced_1 = require("./transaction.advanced");
  * ```
  */
 function depTypeFrom(val) {
-    const depType = (() => {
-        if (typeof val === "number") {
-            return transaction_advanced_1.NUM_TO_DEP_TYPE[val];
-        }
-        if (typeof val === "bigint") {
-            return transaction_advanced_1.NUM_TO_DEP_TYPE[Number(val)];
-        }
-        return val;
-    })();
-    if (depType === undefined) {
-        throw new Error(`Invalid dep type ${val}`);
-    }
-    return depType;
+  const depType = (() => {
+    if (typeof val === "number") {
+      return transaction_advanced_1.NUM_TO_DEP_TYPE[val];
+    }
+    if (typeof val === "bigint") {
+      return transaction_advanced_1.NUM_TO_DEP_TYPE[Number(val)];
+    }
+    return val;
+  })();
+  if (depType === undefined) {
+    throw new Error(`Invalid dep type ${val}`);
+  }
+  return depType;
 }
 exports.depTypeFrom = depTypeFrom;
 /**
@@ -74,7 +105,9 @@ exports.depTypeFrom = depTypeFrom;
  * ```
  */
 function depTypeToBytes(depType) {
-    return (0, bytes_1.bytesFrom)([transaction_advanced_1.DEP_TYPE_TO_NUM[depTypeFrom(depType)]]);
+  return (0, bytes_1.bytesFrom)([
+    transaction_advanced_1.DEP_TYPE_TO_NUM[depTypeFrom(depType)],
+  ]);
 }
 exports.depTypeToBytes = depTypeToBytes;
 /**
@@ -91,720 +124,803 @@ exports.depTypeToBytes = depTypeToBytes;
  * ```
  */
 function depTypeFromBytes(bytes) {
-    return transaction_advanced_1.NUM_TO_DEP_TYPE[(0, bytes_1.bytesFrom)(bytes)[0]];
+  return transaction_advanced_1.NUM_TO_DEP_TYPE[
+    (0, bytes_1.bytesFrom)(bytes)[0]
+  ];
 }
 exports.depTypeFromBytes = depTypeFromBytes;
 class OutPoint {
-    /**
-     * Creates an instance of OutPoint.
-     *
-     * @param txHash - The transaction hash.
-     * @param index - The index of the output in the transaction.
-     */
-    constructor(txHash, index) {
-        this.txHash = txHash;
-        this.index = index;
-    }
-    /**
-     * Creates an OutPoint instance from an OutPointLike object.
-     *
-     * @param outPoint - An OutPointLike object or an instance of OutPoint.
-     * @returns An OutPoint instance.
-     *
-     * @example
-     * ```typescript
-     * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
-     * ```
-     */
-    static from(outPoint) {
-        if (outPoint instanceof OutPoint) {
-            return outPoint;
-        }
-        return new OutPoint((0, hex_1.hexFrom)(outPoint.txHash), (0, num_1.numFrom)(outPoint.index));
-    }
-    /**
-     * Converts the OutPoint instance to molecule data format.
-     *
-     * @returns An object representing the outpoint in molecule data format.
-     */
-    _toMolData() {
-        return {
-            txHash: (0, bytes_1.bytesFrom)(this.txHash),
-            index: (0, num_1.numToBytes)(this.index, 4),
-        };
-    }
-    /**
-     * Converts the OutPoint instance to bytes.
-     *
-     * @returns A Uint8Array containing the outpoint bytes.
-     *
-     * @example
-     * ```typescript
-     * const outPointBytes = outPoint.encode();
-     * ```
-     */
-    encode() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeOutPoint(this._toMolData()));
-    }
-    /**
-     * Creates an OutPoint instance from a byte-like value or molecule OutPoint.
-     *
-     * @param bytes - The byte-like value or molecule OutPoint to convert.
-     * @returns An OutPoint instance.
-     *
-     * @example
-     * ```typescript
-     * const outPoint = OutPoint.fromBytes(new Uint8Array([/* outpoint bytes *\/]));
-     * ```
-     */
-    static fromBytes(bytes) {
-        const view = bytes instanceof mol.OutPoint
-            ? bytes
-            : new mol.OutPoint((0, bytes_1.bytesFrom)(bytes));
-        return new OutPoint((0, hex_1.hexFrom)(view.getTxHash().raw()), (0, num_1.numFromBytes)(view.getIndex().raw()));
-    }
+  /**
+   * Creates an instance of OutPoint.
+   *
+   * @param txHash - The transaction hash.
+   * @param index - The index of the output in the transaction.
+   */
+  constructor(txHash, index) {
+    this.txHash = txHash;
+    this.index = index;
+  }
+  /**
+   * Creates an OutPoint instance from an OutPointLike object.
+   *
+   * @param outPoint - An OutPointLike object or an instance of OutPoint.
+   * @returns An OutPoint instance.
+   *
+   * @example
+   * ```typescript
+   * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
+   * ```
+   */
+  static from(outPoint) {
+    if (outPoint instanceof OutPoint) {
+      return outPoint;
+    }
+    return new OutPoint(
+      (0, hex_1.hexFrom)(outPoint.txHash),
+      (0, num_1.numFrom)(outPoint.index),
+    );
+  }
+  /**
+   * Converts the OutPoint instance to molecule data format.
+   *
+   * @returns An object representing the outpoint in molecule data format.
+   */
+  _toMolData() {
+    return {
+      txHash: (0, bytes_1.bytesFrom)(this.txHash),
+      index: (0, num_1.numToBytes)(this.index, 4),
+    };
+  }
+  /**
+   * Converts the OutPoint instance to bytes.
+   *
+   * @returns A Uint8Array containing the outpoint bytes.
+   *
+   * @example
+   * ```typescript
+   * const outPointBytes = outPoint.encode();
+   * ```
+   */
+  encode() {
+    return (0, bytes_1.bytesFrom)(mol.SerializeOutPoint(this._toMolData()));
+  }
+  /**
+   * Creates an OutPoint instance from a byte-like value or molecule OutPoint.
+   *
+   * @param bytes - The byte-like value or molecule OutPoint to convert.
+   * @returns An OutPoint instance.
+   *
+   * @example
+   * ```typescript
+   * const outPoint = OutPoint.fromBytes(new Uint8Array([/* outpoint bytes *\/]));
+   * ```
+   */
+  static fromBytes(bytes) {
+    const view =
+      bytes instanceof mol.OutPoint
+        ? bytes
+        : new mol.OutPoint((0, bytes_1.bytesFrom)(bytes));
+    return new OutPoint(
+      (0, hex_1.hexFrom)(view.getTxHash().raw()),
+      (0, num_1.numFromBytes)(view.getIndex().raw()),
+    );
+  }
 }
 exports.OutPoint = OutPoint;
 class CellOutput {
-    /**
-     * Creates an instance of CellOutput.
-     *
-     * @param capacity - The capacity of the cell.
-     * @param lock - The lock script of the cell.
-     * @param type - The optional type script of the cell.
-     */
-    constructor(capacity, lock, type) {
-        this.capacity = capacity;
-        this.lock = lock;
-        this.type = type;
-    }
-    /**
-     * 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) {
-        if (cellOutput instanceof CellOutput) {
-            return cellOutput;
-        }
-        return new CellOutput((0, num_1.numFrom)(cellOutput.capacity), script_1.Script.from(cellOutput.lock), (0, utils_1.apply)(script_1.Script.from, cellOutput.type));
-    }
-    /**
-     * Converts the CellOutput instance to molecule data format.
-     *
-     * @returns An object representing the cell output in molecule data format.
-     */
-    _toMolData() {
-        return {
-            capacity: (0, num_1.numToBytes)(this.capacity, 8),
-            lock: this.lock._toMolData(),
-            type: this.type?._toMolData(),
-        };
-    }
-    /**
-     * Converts the CellOutput instance to bytes.
-     *
-     * @returns A Uint8Array containing the cell output bytes.
-     *
-     * @example
-     * ```typescript
-     * const cellOutputBytes = cellOutput.toBytes();
-     * ```
-     */
-    toBytes() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeCellOutput(this._toMolData()));
-    }
-    /**
-     * Creates a CellOutput instance from a byte-like value or molecule CellOutput.
-     *
-     * @param bytes - The byte-like value or molecule CellOutput to convert.
-     * @returns A CellOutput instance.
-     *
-     * @example
-     * ```typescript
-     * const cellOutput = CellOutput.fromBytes(new Uint8Array([/* cell output bytes *\/]));
-     * ```
-     */
-    static fromBytes(bytes) {
-        const view = bytes instanceof mol.CellOutput
-            ? bytes
-            : new mol.CellOutput((0, bytes_1.bytesFrom)(bytes));
-        return new CellOutput((0, num_1.numFromBytes)(view.getCapacity().raw()), script_1.Script.fromBytes(view.getLock()), (0, utils_1.apply)(script_1.Script.fromBytes, mol.molOptional(view.getType())));
-    }
+  /**
+   * Creates an instance of CellOutput.
+   *
+   * @param capacity - The capacity of the cell.
+   * @param lock - The lock script of the cell.
+   * @param type - The optional type script of the cell.
+   */
+  constructor(capacity, lock, type) {
+    this.capacity = capacity;
+    this.lock = lock;
+    this.type = type;
+  }
+  /**
+   * 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) {
+    if (cellOutput instanceof CellOutput) {
+      return cellOutput;
+    }
+    return new CellOutput(
+      (0, num_1.numFrom)(cellOutput.capacity),
+      script_1.Script.from(cellOutput.lock),
+      (0, utils_1.apply)(script_1.Script.from, cellOutput.type),
+    );
+  }
+  /**
+   * Converts the CellOutput instance to molecule data format.
+   *
+   * @returns An object representing the cell output in molecule data format.
+   */
+  _toMolData() {
+    return {
+      capacity: (0, num_1.numToBytes)(this.capacity, 8),
+      lock: this.lock._toMolData(),
+      type: this.type?._toMolData(),
+    };
+  }
+  /**
+   * Converts the CellOutput instance to bytes.
+   *
+   * @returns A Uint8Array containing the cell output bytes.
+   *
+   * @example
+   * ```typescript
+   * const cellOutputBytes = cellOutput.toBytes();
+   * ```
+   */
+  toBytes() {
+    return (0, bytes_1.bytesFrom)(mol.SerializeCellOutput(this._toMolData()));
+  }
+  /**
+   * Creates a CellOutput instance from a byte-like value or molecule CellOutput.
+   *
+   * @param bytes - The byte-like value or molecule CellOutput to convert.
+   * @returns A CellOutput instance.
+   *
+   * @example
+   * ```typescript
+   * const cellOutput = CellOutput.fromBytes(new Uint8Array([/* cell output bytes *\/]));
+   * ```
+   */
+  static fromBytes(bytes) {
+    const view =
+      bytes instanceof mol.CellOutput
+        ? bytes
+        : new mol.CellOutput((0, bytes_1.bytesFrom)(bytes));
+    return new CellOutput(
+      (0, num_1.numFromBytes)(view.getCapacity().raw()),
+      script_1.Script.fromBytes(view.getLock()),
+      (0, utils_1.apply)(
+        script_1.Script.fromBytes,
+        mol.molOptional(view.getType()),
+      ),
+    );
+  }
 }
 exports.CellOutput = CellOutput;
 class Cell {
-    /**
-     * Creates an instance of Cell.
-     *
-     * @param outPoint - The output point of the cell.
-     * @param cellOutput - The cell output of the cell.
-     * @param outputData - The output data of the cell.
-     * @param blockNumber - The block number of the cell.
-     */
-    constructor(outPoint, cellOutput, outputData, blockNumber) {
-        this.outPoint = outPoint;
-        this.cellOutput = cellOutput;
-        this.outputData = outputData;
-        this.blockNumber = blockNumber;
-    }
-    /**
-     * Creates a Cell instance from a CellLike object.
-     *
-     * @param cell - A CellLike object or an instance of Cell.
-     * @returns A Cell instance.
-     */
-    static from(cell) {
-        if (cell instanceof Cell) {
-            return cell;
-        }
-        return new Cell(OutPoint.from(cell.outPoint), CellOutput.from(cell.cellOutput), (0, hex_1.hexFrom)(cell.outputData), (0, num_1.numFrom)(cell.blockNumber));
-    }
+  /**
+   * Creates an instance of Cell.
+   *
+   * @param outPoint - The output point of the cell.
+   * @param cellOutput - The cell output of the cell.
+   * @param outputData - The output data of the cell.
+   * @param blockNumber - The block number of the cell.
+   */
+  constructor(outPoint, cellOutput, outputData, blockNumber) {
+    this.outPoint = outPoint;
+    this.cellOutput = cellOutput;
+    this.outputData = outputData;
+    this.blockNumber = blockNumber;
+  }
+  /**
+   * Creates a Cell instance from a CellLike object.
+   *
+   * @param cell - A CellLike object or an instance of Cell.
+   * @returns A Cell instance.
+   */
+  static from(cell) {
+    if (cell instanceof Cell) {
+      return cell;
+    }
+    return new Cell(
+      OutPoint.from(cell.outPoint),
+      CellOutput.from(cell.cellOutput),
+      (0, hex_1.hexFrom)(cell.outputData),
+      (0, num_1.numFrom)(cell.blockNumber),
+    );
+  }
 }
 exports.Cell = Cell;
 class CellInput {
-    /**
-     * Creates an instance of CellInput.
-     *
-     * @param previousOutput - The previous outpoint of the cell.
-     * @param since - The since value of the cell input.
-     * @param cellOutput - The optional cell output associated with the cell input.
-     * @param outputData - The optional output data associated with the cell input.
-     * @param blockNumber - The optional block number associated with the cell input.
-     */
-    constructor(previousOutput, since, cellOutput, outputData, blockNumber) {
-        this.previousOutput = previousOutput;
-        this.since = since;
-        this.cellOutput = cellOutput;
-        this.outputData = outputData;
-        this.blockNumber = blockNumber;
-    }
-    /**
-     * Creates a CellInput instance from a CellInputLike object.
-     *
-     * @param cellInput - A CellInputLike object or an instance of CellInput.
-     * @returns A CellInput instance.
-     *
-     * @example
-     * ```typescript
-     * const cellInput = CellInput.from({
-     *   previousOutput: { txHash: "0x...", index: 0 },
-     *   since: 0n
-     * });
-     * ```
-     */
-    static from(cellInput) {
-        if (cellInput instanceof CellInput) {
-            return cellInput;
-        }
-        return new CellInput(OutPoint.from(cellInput.previousOutput), (0, num_1.numFrom)(cellInput.since), (0, utils_1.apply)(CellOutput.from, cellInput.cellOutput), (0, utils_1.apply)(hex_1.hexFrom, cellInput.outputData), (0, utils_1.apply)(num_1.numFrom, cellInput.blockNumber));
-    }
-    /**
-     * Complete extra infos in the input. Like the output of the out point.
-     * The instance will be modified.
-     *
-     * @returns The completed instance.
-     * @example
-     * ```typescript
-     * if (!cellInput.cellOutput) {
-     *   await cellInput.completeExtraInfos();
-     * }
-     * ```
-     */
-    async completeExtraInfos(client) {
-        if (this.cellOutput && this.outputData && this.blockNumber) {
-            return this;
-        }
-        const cell = await client.getCell(this.previousOutput);
-        if (cell) {
-            this.cellOutput = cell.cellOutput;
-            this.outputData = cell.outputData;
-            this.blockNumber = cell.blockNumber;
-        }
-        return this;
-    }
-    /**
-     * Converts the CellInput instance to molecule data format.
-     *
-     * @returns An object representing the cell input in molecule data format.
-     */
-    _toMolData() {
-        return {
-            previousOutput: this.previousOutput._toMolData(),
-            since: (0, num_1.numToBytes)(this.since, 8),
-        };
-    }
-    /**
-     * Converts the CellInput instance to bytes.
-     *
-     * @returns A Uint8Array containing the cell input bytes.
-     *
-     * @example
-     * ```typescript
-     * const cellInputBytes = cellInput.toBytes();
-     * ```
-     */
-    toBytes() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeCellInput(this._toMolData()));
-    }
-    /**
-     * Creates a CellInput instance from a byte-like value or molecule CellInput.
-     *
-     * @param bytes - The byte-like value or molecule CellInput to convert.
-     * @returns A CellInput instance.
-     *
-     * @example
-     * ```typescript
-     * const cellInput = CellInput.fromBytes(new Uint8Array([/* cell input bytes *\/]));
-     * ```
-     */
-    static fromBytes(bytes) {
-        const view = bytes instanceof mol.CellInput
-            ? bytes
-            : new mol.CellInput((0, bytes_1.bytesFrom)(bytes));
-        return new CellInput(OutPoint.fromBytes(view.getPreviousOutput()), (0, num_1.numFromBytes)(view.getSince().raw()));
-    }
+  /**
+   * Creates an instance of CellInput.
+   *
+   * @param previousOutput - The previous outpoint of the cell.
+   * @param since - The since value of the cell input.
+   * @param cellOutput - The optional cell output associated with the cell input.
+   * @param outputData - The optional output data associated with the cell input.
+   * @param blockNumber - The optional block number associated with the cell input.
+   */
+  constructor(previousOutput, since, cellOutput, outputData, blockNumber) {
+    this.previousOutput = previousOutput;
+    this.since = since;
+    this.cellOutput = cellOutput;
+    this.outputData = outputData;
+    this.blockNumber = blockNumber;
+  }
+  /**
+   * Creates a CellInput instance from a CellInputLike object.
+   *
+   * @param cellInput - A CellInputLike object or an instance of CellInput.
+   * @returns A CellInput instance.
+   *
+   * @example
+   * ```typescript
+   * const cellInput = CellInput.from({
+   *   previousOutput: { txHash: "0x...", index: 0 },
+   *   since: 0n
+   * });
+   * ```
+   */
+  static from(cellInput) {
+    if (cellInput instanceof CellInput) {
+      return cellInput;
+    }
+    return new CellInput(
+      OutPoint.from(cellInput.previousOutput),
+      (0, num_1.numFrom)(cellInput.since),
+      (0, utils_1.apply)(CellOutput.from, cellInput.cellOutput),
+      (0, utils_1.apply)(hex_1.hexFrom, cellInput.outputData),
+      (0, utils_1.apply)(num_1.numFrom, cellInput.blockNumber),
+    );
+  }
+  /**
+   * Complete extra infos in the input. Like the output of the out point.
+   * The instance will be modified.
+   *
+   * @returns The completed instance.
+   * @example
+   * ```typescript
+   * if (!cellInput.cellOutput) {
+   *   await cellInput.completeExtraInfos();
+   * }
+   * ```
+   */
+  async completeExtraInfos(client) {
+    if (this.cellOutput && this.outputData && this.blockNumber) {
+      return this;
+    }
+    const cell = await client.getCell(this.previousOutput);
+    if (cell) {
+      this.cellOutput = cell.cellOutput;
+      this.outputData = cell.outputData;
+      this.blockNumber = cell.blockNumber;
+    }
+    return this;
+  }
+  /**
+   * Converts the CellInput instance to molecule data format.
+   *
+   * @returns An object representing the cell input in molecule data format.
+   */
+  _toMolData() {
+    return {
+      previousOutput: this.previousOutput._toMolData(),
+      since: (0, num_1.numToBytes)(this.since, 8),
+    };
+  }
+  /**
+   * Converts the CellInput instance to bytes.
+   *
+   * @returns A Uint8Array containing the cell input bytes.
+   *
+   * @example
+   * ```typescript
+   * const cellInputBytes = cellInput.toBytes();
+   * ```
+   */
+  toBytes() {
+    return (0, bytes_1.bytesFrom)(mol.SerializeCellInput(this._toMolData()));
+  }
+  /**
+   * Creates a CellInput instance from a byte-like value or molecule CellInput.
+   *
+   * @param bytes - The byte-like value or molecule CellInput to convert.
+   * @returns A CellInput instance.
+   *
+   * @example
+   * ```typescript
+   * const cellInput = CellInput.fromBytes(new Uint8Array([/* cell input bytes *\/]));
+   * ```
+   */
+  static fromBytes(bytes) {
+    const view =
+      bytes instanceof mol.CellInput
+        ? bytes
+        : new mol.CellInput((0, bytes_1.bytesFrom)(bytes));
+    return new CellInput(
+      OutPoint.fromBytes(view.getPreviousOutput()),
+      (0, num_1.numFromBytes)(view.getSince().raw()),
+    );
+  }
 }
 exports.CellInput = CellInput;
 class CellDep {
-    /**
-     * Creates an instance of CellDep.
-     *
-     * @param outPoint - The outpoint of the cell dependency.
-     * @param depType - The dependency type.
-     */
-    constructor(outPoint, depType) {
-        this.outPoint = outPoint;
-        this.depType = depType;
-    }
-    /**
-     * Creates a CellDep instance from a CellDepLike object.
-     *
-     * @param cellDep - A CellDepLike object or an instance of CellDep.
-     * @returns A CellDep instance.
-     *
-     * @example
-     * ```typescript
-     * const cellDep = CellDep.from({
-     *   outPoint: { txHash: "0x...", index: 0 },
-     *   depType: "depGroup"
-     * });
-     * ```
-     */
-    static from(cellDep) {
-        if (cellDep instanceof CellDep) {
-            return cellDep;
-        }
-        return new CellDep(OutPoint.from(cellDep.outPoint), depTypeFrom(cellDep.depType));
-    }
-    /**
-     * Converts the CellDep instance to molecule data format.
-     *
-     * @returns An object representing the cell dependency in molecule data format.
-     */
-    _toMolData() {
-        return {
-            outPoint: this.outPoint._toMolData(),
-            depType: depTypeToBytes(this.depType),
-        };
-    }
-    /**
-     * Converts the CellDep instance to bytes.
-     *
-     * @returns A Uint8Array containing the cell dependency bytes.
-     *
-     * @example
-     * ```typescript
-     * const cellDepBytes = cellDep.toBytes();
-     * ```
-     */
-    toBytes() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeCellDep(this._toMolData()));
-    }
-    /**
-     * Creates a CellDep instance from a byte-like value or molecule CellDep.
-     *
-     * @param bytes - The byte-like value or molecule CellDep to convert.
-     * @returns A CellDep instance.
-     *
-     * @example
-     * ```typescript
-     * const cellDep = CellDep.fromBytes(new Uint8Array([/* cell dep bytes *\/]));
-     * ```
-     */
-    fromBytes(bytes) {
-        const view = bytes instanceof mol.CellDep ? bytes : new mol.CellDep((0, bytes_1.bytesFrom)(bytes));
-        return new CellDep(OutPoint.fromBytes(view.getOutPoint()), depTypeFromBytes([view.getDepType()]));
-    }
+  /**
+   * Creates an instance of CellDep.
+   *
+   * @param outPoint - The outpoint of the cell dependency.
+   * @param depType - The dependency type.
+   */
+  constructor(outPoint, depType) {
+    this.outPoint = outPoint;
+    this.depType = depType;
+  }
+  /**
+   * Creates a CellDep instance from a CellDepLike object.
+   *
+   * @param cellDep - A CellDepLike object or an instance of CellDep.
+   * @returns A CellDep instance.
+   *
+   * @example
+   * ```typescript
+   * const cellDep = CellDep.from({
+   *   outPoint: { txHash: "0x...", index: 0 },
+   *   depType: "depGroup"
+   * });
+   * ```
+   */
+  static from(cellDep) {
+    if (cellDep instanceof CellDep) {
+      return cellDep;
+    }
+    return new CellDep(
+      OutPoint.from(cellDep.outPoint),
+      depTypeFrom(cellDep.depType),
+    );
+  }
+  /**
+   * Converts the CellDep instance to molecule data format.
+   *
+   * @returns An object representing the cell dependency in molecule data format.
+   */
+  _toMolData() {
+    return {
+      outPoint: this.outPoint._toMolData(),
+      depType: depTypeToBytes(this.depType),
+    };
+  }
+  /**
+   * Converts the CellDep instance to bytes.
+   *
+   * @returns A Uint8Array containing the cell dependency bytes.
+   *
+   * @example
+   * ```typescript
+   * const cellDepBytes = cellDep.toBytes();
+   * ```
+   */
+  toBytes() {
+    return (0, bytes_1.bytesFrom)(mol.SerializeCellDep(this._toMolData()));
+  }
+  /**
+   * Creates a CellDep instance from a byte-like value or molecule CellDep.
+   *
+   * @param bytes - The byte-like value or molecule CellDep to convert.
+   * @returns A CellDep instance.
+   *
+   * @example
+   * ```typescript
+   * const cellDep = CellDep.fromBytes(new Uint8Array([/* cell dep bytes *\/]));
+   * ```
+   */
+  fromBytes(bytes) {
+    const view =
+      bytes instanceof mol.CellDep
+        ? bytes
+        : new mol.CellDep((0, bytes_1.bytesFrom)(bytes));
+    return new CellDep(
+      OutPoint.fromBytes(view.getOutPoint()),
+      depTypeFromBytes([view.getDepType()]),
+    );
+  }
 }
 exports.CellDep = CellDep;
 class WitnessArgs {
-    /**
-     * Creates an instance of WitnessArgs.
-     *
-     * @param lock - The optional lock field of the witness.
-     * @param inputType - The optional input type field of the witness.
-     * @param outputType - The optional output type field of the witness.
-     */
-    constructor(lock, inputType, outputType) {
-        this.lock = lock;
-        this.inputType = inputType;
-        this.outputType = outputType;
-    }
-    /**
-     * Creates a WitnessArgs instance from a WitnessArgsLike object.
-     *
-     * @param witnessArgs - A WitnessArgsLike object or an instance of WitnessArgs.
-     * @returns A WitnessArgs instance.
-     *
-     * @example
-     * ```typescript
-     * const witnessArgs = WitnessArgs.from({
-     *   lock: "0x...",
-     *   inputType: "0x...",
-     *   outputType: "0x..."
-     * });
-     * ```
-     */
-    static from(witnessArgs) {
-        if (witnessArgs instanceof WitnessArgs) {
-            return witnessArgs;
-        }
-        return new WitnessArgs((0, utils_1.apply)(hex_1.hexFrom, witnessArgs.lock), (0, utils_1.apply)(hex_1.hexFrom, witnessArgs.inputType), (0, utils_1.apply)(hex_1.hexFrom, witnessArgs.outputType));
-    }
-    /**
-     * Converts the WitnessArgs instance to molecule data format.
-     *
-     * @returns An object representing the witness arguments in molecule data format.
-     */
-    _toMolData() {
-        return {
-            lock: (0, utils_1.apply)(bytes_1.bytesFrom, this.lock),
-            inputType: (0, utils_1.apply)(bytes_1.bytesFrom, this.inputType),
-            outputType: (0, utils_1.apply)(bytes_1.bytesFrom, this.outputType),
-        };
-    }
-    /**
-     * Converts the WitnessArgs instance to bytes.
-     *
-     * @returns A Uint8Array containing the witness arguments bytes.
-     *
-     * @example
-     * ```typescript
-     * const witnessArgsBytes = witnessArgs.toBytes();
-     * ```
-     */
-    toBytes() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeWitnessArgs(this._toMolData()));
-    }
-    /**
-     * Creates a WitnessArgs instance from a byte-like value or molecule WitnessArgs.
-     *
-     * @param bytes - The byte-like value or molecule WitnessArgs to convert.
-     * @returns A WitnessArgs instance.
-     *
-     * @example
-     * ```typescript
-     * const witnessArgs = WitnessArgs.fromBytes(new Uint8Array([/* witness args bytes *\/]));
-     * ```
-     */
-    static fromBytes(bytes) {
-        const view = bytes instanceof mol.WitnessArgs
-            ? bytes
-            : new mol.WitnessArgs((0, bytes_1.bytesFrom)(bytes));
-        return new WitnessArgs((0, utils_1.apply)(hex_1.hexFrom, mol.molOptional(view.getLock())?.raw()), (0, utils_1.apply)(hex_1.hexFrom, mol.molOptional(view.getInputType())?.raw()), (0, utils_1.apply)(hex_1.hexFrom, mol.molOptional(view.getOutputType())?.raw()));
-    }
+  /**
+   * Creates an instance of WitnessArgs.
+   *
+   * @param lock - The optional lock field of the witness.
+   * @param inputType - The optional input type field of the witness.
+   * @param outputType - The optional output type field of the witness.
+   */
+  constructor(lock, inputType, outputType) {
+    this.lock = lock;
+    this.inputType = inputType;
+    this.outputType = outputType;
+  }
+  /**
+   * Creates a WitnessArgs instance from a WitnessArgsLike object.
+   *
+   * @param witnessArgs - A WitnessArgsLike object or an instance of WitnessArgs.
+   * @returns A WitnessArgs instance.
+   *
+   * @example
+   * ```typescript
+   * const witnessArgs = WitnessArgs.from({
+   *   lock: "0x...",
+   *   inputType: "0x...",
+   *   outputType: "0x..."
+   * });
+   * ```
+   */
+  static from(witnessArgs) {
+    if (witnessArgs instanceof WitnessArgs) {
+      return witnessArgs;
+    }
+    return new WitnessArgs(
+      (0, utils_1.apply)(hex_1.hexFrom, witnessArgs.lock),
+      (0, utils_1.apply)(hex_1.hexFrom, witnessArgs.inputType),
+      (0, utils_1.apply)(hex_1.hexFrom, witnessArgs.outputType),
+    );
+  }
+  /**
+   * Converts the WitnessArgs instance to molecule data format.
+   *
+   * @returns An object representing the witness arguments in molecule data format.
+   */
+  _toMolData() {
+    return {
+      lock: (0, utils_1.apply)(bytes_1.bytesFrom, this.lock),
+      inputType: (0, utils_1.apply)(bytes_1.bytesFrom, this.inputType),
+      outputType: (0, utils_1.apply)(bytes_1.bytesFrom, this.outputType),
+    };
+  }
+  /**
+   * Converts the WitnessArgs instance to bytes.
+   *
+   * @returns A Uint8Array containing the witness arguments bytes.
+   *
+   * @example
+   * ```typescript
+   * const witnessArgsBytes = witnessArgs.toBytes();
+   * ```
+   */
+  toBytes() {
+    return (0, bytes_1.bytesFrom)(mol.SerializeWitnessArgs(this._toMolData()));
+  }
+  /**
+   * Creates a WitnessArgs instance from a byte-like value or molecule WitnessArgs.
+   *
+   * @param bytes - The byte-like value or molecule WitnessArgs to convert.
+   * @returns A WitnessArgs instance.
+   *
+   * @example
+   * ```typescript
+   * const witnessArgs = WitnessArgs.fromBytes(new Uint8Array([/* witness args bytes *\/]));
+   * ```
+   */
+  static fromBytes(bytes) {
+    const view =
+      bytes instanceof mol.WitnessArgs
+        ? bytes
+        : new mol.WitnessArgs((0, bytes_1.bytesFrom)(bytes));
+    return new WitnessArgs(
+      (0, utils_1.apply)(hex_1.hexFrom, mol.molOptional(view.getLock())?.raw()),
+      (0, utils_1.apply)(
+        hex_1.hexFrom,
+        mol.molOptional(view.getInputType())?.raw(),
+      ),
+      (0, utils_1.apply)(
+        hex_1.hexFrom,
+        mol.molOptional(view.getOutputType())?.raw(),
+      ),
+    );
+  }
 }
 exports.WitnessArgs = WitnessArgs;
 class Transaction {
-    /**
-     * Creates an instance of Transaction.
-     *
-     * @param version - The version of the transaction.
-     * @param cellDeps - The cell dependencies of the transaction.
-     * @param headerDeps - The header dependencies of the transaction.
-     * @param inputs - The inputs of the transaction.
-     * @param outputs - The outputs of the transaction.
-     * @param outputsData - The data associated with the outputs.
-     * @param witnesses - The witnesses of the transaction.
-     */
-    constructor(version, cellDeps, headerDeps, inputs, outputs, outputsData, witnesses) {
-        this.version = version;
-        this.cellDeps = cellDeps;
-        this.headerDeps = headerDeps;
-        this.inputs = inputs;
-        this.outputs = outputs;
-        this.outputsData = outputsData;
-        this.witnesses = witnesses;
-    }
-    /**
-     * Creates a default Transaction instance with empty fields.
-     *
-     * @returns A default Transaction instance.
-     *
-     * @example
-     * ```typescript
-     * const defaultTx = Transaction.default();
-     * ```
-     */
-    static default() {
-        return new Transaction(0n, [], [], [], [], [], []);
-    }
-    /**
-     * Creates a Transaction instance from a TransactionLike object.
-     *
-     * @param tx - A TransactionLike object or an instance of Transaction.
-     * @returns A Transaction instance.
-     *
-     * @example
-     * ```typescript
-     * const transaction = Transaction.from({
-     *   version: 0,
-     *   cellDeps: [],
-     *   headerDeps: [],
-     *   inputs: [],
-     *   outputs: [],
-     *   outputsData: [],
-     *   witnesses: []
-     * });
-     * ```
-     */
-    static from(tx) {
-        if (tx instanceof Transaction) {
-            return tx;
+  /**
+   * Creates an instance of Transaction.
+   *
+   * @param version - The version of the transaction.
+   * @param cellDeps - The cell dependencies of the transaction.
+   * @param headerDeps - The header dependencies of the transaction.
+   * @param inputs - The inputs of the transaction.
+   * @param outputs - The outputs of the transaction.
+   * @param outputsData - The data associated with the outputs.
+   * @param witnesses - The witnesses of the transaction.
+   */
+  constructor(
+    version,
+    cellDeps,
+    headerDeps,
+    inputs,
+    outputs,
+    outputsData,
+    witnesses,
+  ) {
+    this.version = version;
+    this.cellDeps = cellDeps;
+    this.headerDeps = headerDeps;
+    this.inputs = inputs;
+    this.outputs = outputs;
+    this.outputsData = outputsData;
+    this.witnesses = witnesses;
+  }
+  /**
+   * Creates a default Transaction instance with empty fields.
+   *
+   * @returns A default Transaction instance.
+   *
+   * @example
+   * ```typescript
+   * const defaultTx = Transaction.default();
+   * ```
+   */
+  static default() {
+    return new Transaction(0n, [], [], [], [], [], []);
+  }
+  /**
+   * Creates a Transaction instance from a TransactionLike object.
+   *
+   * @param tx - A TransactionLike object or an instance of Transaction.
+   * @returns A Transaction instance.
+   *
+   * @example
+   * ```typescript
+   * const transaction = Transaction.from({
+   *   version: 0,
+   *   cellDeps: [],
+   *   headerDeps: [],
+   *   inputs: [],
+   *   outputs: [],
+   *   outputsData: [],
+   *   witnesses: []
+   * });
+   * ```
+   */
+  static from(tx) {
+    if (tx instanceof Transaction) {
+      return tx;
+    }
+    return new Transaction(
+      (0, num_1.numFrom)(tx.version),
+      tx.cellDeps.map((cellDep) => CellDep.from(cellDep)),
+      tx.headerDeps.map(hex_1.hexFrom),
+      tx.inputs.map((input) => CellInput.from(input)),
+      tx.outputs.map((output) => CellOutput.from(output)),
+      tx.outputsData.map(hex_1.hexFrom),
+      tx.witnesses.map(hex_1.hexFrom),
+    );
+  }
+  /**
+   * Creates a Transaction instance from a Lumos skeleton.
+   *
+   * @param skeleton - The Lumos transaction skeleton.
+   * @returns A Transaction instance.
+   *
+   * @throws Will throw an error if an input's outPoint is missing.
+   *
+   * @example
+   * ```typescript
+   * const transaction = Transaction.fromLumosSkeleton(skeleton);
+   * ```
+   */
+  static fromLumosSkeleton(skeleton) {
+    return Transaction.from({
+      version: 0n,
+      cellDeps: skeleton.cellDeps.toArray(),
+      headerDeps: skeleton.headerDeps.toArray(),
+      inputs: skeleton.inputs.toArray().map((input, i) => {
+        if (!input.outPoint) {
+          throw new Error("outPoint is required in input");
         }
-        return new Transaction((0, num_1.numFrom)(tx.version), tx.cellDeps.map((cellDep) => CellDep.from(cellDep)), tx.headerDeps.map(hex_1.hexFrom), tx.inputs.map((input) => CellInput.from(input)), tx.outputs.map((output) => CellOutput.from(output)), tx.outputsData.map(hex_1.hexFrom), tx.witnesses.map(hex_1.hexFrom));
-    }
-    /**
-     * Creates a Transaction instance from a Lumos skeleton.
-     *
-     * @param skeleton - The Lumos transaction skeleton.
-     * @returns A Transaction instance.
-     *
-     * @throws Will throw an error if an input's outPoint is missing.
-     *
-     * @example
-     * ```typescript
-     * const transaction = Transaction.fromLumosSkeleton(skeleton);
-     * ```
-     */
-    static fromLumosSkeleton(skeleton) {
-        return Transaction.from({
-            version: 0n,
-            cellDeps: skeleton.cellDeps.toArray(),
-            headerDeps: skeleton.headerDeps.toArray(),
-            inputs: skeleton.inputs.toArray().map((input, i) => {
-                if (!input.outPoint) {
-                    throw new Error("outPoint is required in input");
-                }
-                return CellInput.from({
-                    previousOutput: input.outPoint,
-                    since: skeleton.inputSinces.get(i, "0x0"),
-                    cellOutput: input.cellOutput,
-                    outputData: input.data,
-                });
-            }),
-            outputs: skeleton.outputs.toArray().map((output) => output.cellOutput),
-            outputsData: skeleton.outputs.toArray().map((output) => output.data),
-            witnesses: skeleton.witnesses.toArray(),
+        return CellInput.from({
+          previousOutput: input.outPoint,
+          since: skeleton.inputSinces.get(i, "0x0"),
+          cellOutput: input.cellOutput,
+          outputData: input.data,
         });
-    }
-    stringify() {
-        return JSON.stringify(this, (_, value) => {
-            if (typeof value === "bigint") {
-                return (0, num_1.numToHex)(value);
-            }
-            return value;
-        });
-    }
-    /**
-     * Converts the raw transaction data to bytes.
-     *
-     * @returns A Uint8Array containing the raw transaction bytes.
-     *
-     * @example
-     * ```typescript
-     * const rawTxBytes = transaction.rawToBytes();
-     * ```
-     */
-    rawToBytes() {
-        return (0, bytes_1.bytesFrom)(mol.SerializeRawTransaction({
-            version: (0, num_1.numToBytes)(this.version, 4),
-            cellDeps: this.cellDeps.map((d) => d._toMolData()),
-            headerDeps: this.headerDeps.map((header) => (0, bytes_1.bytesFrom)(header)),
-            inputs: this.inputs.map((i) => i._toMolData()),
-            outputs: this.outputs.map((o) => o._toMolData()),
-            outputsData: this.outputsData.map((header) => (0, bytes_1.bytesFrom)(header)),
-        }));
-    }
-    /**
-     * Calculates the hash of the transaction.
-     *
-     * @returns The hash of the transaction.
-     *
-     * @example
-     * ```typescript
-     * const txHash = transaction.hash();
-     * ```
-     */
-    hash() {
-        return (0, hasher_1.ckbHash)(this.rawToBytes());
-    }
-    /**
-     * Hashes a witness and updates the hasher.
-     *
-     * @param witness - The witness to hash.
-     * @param hasher - The hasher instance to update.
-     *
-     * @example
-     * ```typescript
-     * Transaction.hashWitnessToHasher("0x...", hasher);
-     * ```
-     */
-    static hashWitnessToHasher(witness, hasher) {
-        const raw = (0, bytes_1.bytesFrom)((0, hex_1.hexFrom)(witness));
-        hasher.update((0, num_1.numToBytes)(raw.length, 8));
-        hasher.update(raw);
-    }
-    /**
-     * Computes the signing hash information for a given script.
-     *
-     * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-     * @param client - The client for complete extra infos in the transaction.
-     * @returns A promise that resolves to an object containing the signing message and the witness position,
-     *          or undefined if no matching input is found.
-     *
-     * @example
-     * ```typescript
-     * const signHashInfo = await tx.getSignHashInfo(scriptLike, client);
-     * if (signHashInfo) {
-     *   console.log(signHashInfo.message); // Outputs the signing message
-     *   console.log(signHashInfo.position); // Outputs the witness position
-     * }
-     * ```
-     */
-    async getSignHashInfo(scriptLike, client) {
-        const script = script_1.Script.from(scriptLike);
-        let position = -1;
-        const hasher = new hasher_1.Hasher();
-        hasher.update(this.hash());
-        for (let i = 0; i < this.witnesses.length; i += 1) {
-            if (this.inputs[i]) {
-                const input = await this.inputs[i].completeExtraInfos(client);
-                if (!input.cellOutput) {
-                    throw Error("Unable to resolve inputs info");
-                }
-                if (!script.eq(input.cellOutput.lock)) {
-                    continue;
-                }
-                if (position === -1) {
-                    position = i;
-                }
-            }
-            if (position === -1) {
-                return undefined;
-            }
-            Transaction.hashWitnessToHasher(this.witnesses[i], hasher);
-        }
-        if (position === -1) {
-            return undefined;
+      }),
+      outputs: skeleton.outputs.toArray().map((output) => output.cellOutput),
+      outputsData: skeleton.outputs.toArray().map((output) => output.data),
+      witnesses: skeleton.witnesses.toArray(),
+    });
+  }
+  stringify() {
+    return JSON.stringify(this, (_, value) => {
+      if (typeof value === "bigint") {
+        return (0, num_1.numToHex)(value);
+      }
+      return value;
+    });
+  }
+  /**
+   * Converts the raw transaction data to bytes.
+   *
+   * @returns A Uint8Array containing the raw transaction bytes.
+   *
+   * @example
+   * ```typescript
+   * const rawTxBytes = transaction.rawToBytes();
+   * ```
+   */
+  rawToBytes() {
+    return (0, bytes_1.bytesFrom)(
+      mol.SerializeRawTransaction({
+        version: (0, num_1.numToBytes)(this.version, 4),
+        cellDeps: this.cellDeps.map((d) => d._toMolData()),
+        headerDeps: this.headerDeps.map((header) =>
+          (0, bytes_1.bytesFrom)(header),
+        ),
+        inputs: this.inputs.map((i) => i._toMolData()),
+        outputs: this.outputs.map((o) => o._toMolData()),
+        outputsData: this.outputsData.map((header) =>
+          (0, bytes_1.bytesFrom)(header),
+        ),
+      }),
+    );
+  }
+  /**
+   * Calculates the hash of the transaction.
+   *
+   * @returns The hash of the transaction.
+   *
+   * @example
+   * ```typescript
+   * const txHash = transaction.hash();
+   * ```
+   */
+  hash() {
+    return (0, hasher_1.ckbHash)(this.rawToBytes());
+  }
+  /**
+   * Hashes a witness and updates the hasher.
+   *
+   * @param witness - The witness to hash.
+   * @param hasher - The hasher instance to update.
+   *
+   * @example
+   * ```typescript
+   * Transaction.hashWitnessToHasher("0x...", hasher);
+   * ```
+   */
+  static hashWitnessToHasher(witness, hasher) {
+    const raw = (0, bytes_1.bytesFrom)((0, hex_1.hexFrom)(witness));
+    hasher.update((0, num_1.numToBytes)(raw.length, 8));
+    hasher.update(raw);
+  }
+  /**
+   * Computes the signing hash information for a given script.
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to an object containing the signing message and the witness position,
+   *          or undefined if no matching input is found.
+   *
+   * @example
+   * ```typescript
+   * const signHashInfo = await tx.getSignHashInfo(scriptLike, client);
+   * if (signHashInfo) {
+   *   console.log(signHashInfo.message); // Outputs the signing message
+   *   console.log(signHashInfo.position); // Outputs the witness position
+   * }
+   * ```
+   */
+  async getSignHashInfo(scriptLike, client) {
+    const script = script_1.Script.from(scriptLike);
+    let position = -1;
+    const hasher = new hasher_1.Hasher();
+    hasher.update(this.hash());
+    for (let i = 0; i < this.witnesses.length; i += 1) {
+      if (this.inputs[i]) {
+        const input = await this.inputs[i].completeExtraInfos(client);
+        if (!input.cellOutput) {
+          throw Error("Unable to resolve inputs info");
         }
-        return {
-            message: hasher.digest(),
-            position,
-        };
-    }
-    /**
-     * Find the first occurrence of a input with the specified lock
-     *
-     * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-     * @param client - The client for complete extra infos in the transaction.
-     * @returns A promise that resolves to the prepared transaction
-     *
-     * @example
-     * ```typescript
-     * const index = await tx.findInputIndexByLock(scriptLike, client);
-     * ```
-     */
-    async findInputIndexByLock(scriptLike, client) {
-        const script = script_1.Script.from(scriptLike);
-        for (let i = 0; i < this.inputs.length; i += 1) {
-            const input = await this.inputs[i].completeExtraInfos(client);
-            if (!input.cellOutput) {
-                throw Error("Unable to resolve inputs info");
-            }
-            if (script.eq(input.cellOutput.lock)) {
-                return i;
-            }
-        }
-    }
-    /**
-     * Get witness at index as WitnessArgs
-     *
-     * @param index - The index of the witness.
-     * @returns The witness parsed as WitnessArgs.
-     *
-     * @example
-     * ```typescript
-     * const witnessArgs = await tx.getWitnessArgsAt(0);
-     * ```
-     */
-    getWitnessArgsAt(index) {
-        const rawWitness = this.witnesses[index];
-        return (rawWitness ?? "0x") !== "0x"
-            ? WitnessArgs.fromBytes(rawWitness)
-            : undefined;
-    }
-    /**
-     * Set witness at index by WitnessArgs
-     *
-     * @param index - The index of the witness.
-     * @param witness - The WitnessArgs to set.
-     * @returns The transaction itself.
-     *
-     * @example
-     * ```typescript
-     * await tx.setWitnessArgsAt(0, witnessArgs);
-     * ```
-     */
-    setWitnessArgsAt(index, witness) {
-        if (this.witnesses.length < index) {
-            this.witnesses.push(...Array.from(new Array(index - this.witnesses.length), () => "0x"));
+        if (!script.eq(input.cellOutput.lock)) {
+          continue;
         }
-        this.witnesses[index] = (0, hex_1.hexFrom)(witness.toBytes());
-        return this;
-    }
-    /**
-     * Prepare dummy witness for sighash all method
-     *
-     * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-     * @param lockLen - The length of dummy lock bytes.
-     * @param client - The client for complete extra infos in the transaction.
-     * @returns A promise that resolves to the prepared transaction
-     *
-     * @example
-     * ```typescript
-     * await tx.prepareSighashAllWitness(scriptLike, 85, client);
-     * ```
-     */
-    async prepareSighashAllWitness(scriptLike, lockLen, client) {
-        const position = await this.findInputIndexByLock(scriptLike, client);
-        if (position === undefined) {
-            return this;
+        if (position === -1) {
+          position = i;
         }
-        const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
-        witness.lock = (0, hex_1.hexFrom)(Array.from(new Array(lockLen), () => 0));
-        return this.setWitnessArgsAt(position, witness);
-    }
+      }
+      if (position === -1) {
+        return undefined;
+      }
+      Transaction.hashWitnessToHasher(this.witnesses[i], hasher);
+    }
+    if (position === -1) {
+      return undefined;
+    }
+    return {
+      message: hasher.digest(),
+      position,
+    };
+  }
+  /**
+   * Find the first occurrence of a input with the specified lock
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the prepared transaction
+   *
+   * @example
+   * ```typescript
+   * const index = await tx.findInputIndexByLock(scriptLike, client);
+   * ```
+   */
+  async findInputIndexByLock(scriptLike, client) {
+    const script = script_1.Script.from(scriptLike);
+    for (let i = 0; i < this.inputs.length; i += 1) {
+      const input = await this.inputs[i].completeExtraInfos(client);
+      if (!input.cellOutput) {
+        throw Error("Unable to resolve inputs info");
+      }
+      if (script.eq(input.cellOutput.lock)) {
+        return i;
+      }
+    }
+  }
+  /**
+   * Get witness at index as WitnessArgs
+   *
+   * @param index - The index of the witness.
+   * @returns The witness parsed as WitnessArgs.
+   *
+   * @example
+   * ```typescript
+   * const witnessArgs = await tx.getWitnessArgsAt(0);
+   * ```
+   */
+  getWitnessArgsAt(index) {
+    const rawWitness = this.witnesses[index];
+    return (rawWitness ?? "0x") !== "0x"
+      ? WitnessArgs.fromBytes(rawWitness)
+      : undefined;
+  }
+  /**
+   * Set witness at index by WitnessArgs
+   *
+   * @param index - The index of the witness.
+   * @param witness - The WitnessArgs to set.
+   * @returns The transaction itself.
+   *
+   * @example
+   * ```typescript
+   * await tx.setWitnessArgsAt(0, witnessArgs);
+   * ```
+   */
+  setWitnessArgsAt(index, witness) {
+    if (this.witnesses.length < index) {
+      this.witnesses.push(
+        ...Array.from(new Array(index - this.witnesses.length), () => "0x"),
+      );
+    }
+    this.witnesses[index] = (0, hex_1.hexFrom)(witness.toBytes());
+  }
+  /**
+   * Prepare dummy witness for sighash all method
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param lockLen - The length of dummy lock bytes.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the prepared transaction
+   *
+   * @example
+   * ```typescript
+   * await tx.prepareSighashAllWitness(scriptLike, 85, client);
+   * ```
+   */
+  async prepareSighashAllWitness(scriptLike, lockLen, client) {
+    const position = await this.findInputIndexByLock(scriptLike, client);
+    if (position === undefined) {
+      return;
+    }
+    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
+    witness.lock = (0, hex_1.hexFrom)(Array.from(new Array(lockLen), () => 0));
+    this.setWitnessArgsAt(position, witness);
+  }
 }
 exports.Transaction = Transaction;