@ckb-ccc/core 0.0.5-alpha.8 → 0.0.7-alpha.0

package/src/ckb/transaction.ts

@@ -1,6 +1,8 @@
 import type { TransactionSkeletonType } from "@ckb-lumos/helpers";
+import { ClientCollectableSearchKeyFilterLike } from "../advancedBarrel";
 import { Bytes, BytesLike, bytesFrom } from "../bytes";
-import { Client } from "../client";
+import { CellDepInfoLike, Client, KnownScript } from "../client";
+import { Zero, fixedPointFrom } from "../fixedPoint";
 import { Hasher, ckbHash } from "../hasher";
 import { Hex, HexLike, hexFrom } from "../hex";
 import {
@@ -11,7 +13,8 @@ import {
   numToBytes,
   numToHex,
 } from "../num";
-import { apply } from "../utils";
+import { Signer } from "../signer";
+import { apply, reduceAsync } from "../utils";
 import * as mol from "./molecule.advanced";
 import { Script, ScriptLike } from "./script";
 import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced";
@@ -103,6 +106,20 @@ export class OutPoint {
     public index: Num,
   ) {}
 
+  /**
+   * Clone an OutPoint.
+   *
+   * @returns A cloned OutPoint instance.
+   *
+   * @example
+   * ```typescript
+   * const outPoint1 = outPoint0.clone();
+   * ```
+   */
+  clone(): OutPoint {
+    return new OutPoint(this.txHash, this.index);
+  }
+
   /**
    * Creates an OutPoint instance from an OutPointLike object.
    *
@@ -114,7 +131,6 @@ export class OutPoint {
    * const outPoint = OutPoint.from({ txHash: "0x...", index: 0 });
    * ```
    */
-
   static from(outPoint: OutPointLike): OutPoint {
     if (outPoint instanceof OutPoint) {
       return outPoint;
@@ -142,11 +158,11 @@ export class OutPoint {
    *
    * @example
    * ```typescript
-   * const outPointBytes = outPoint.encode();
+   * const outPointBytes = outPoint.toBytes();
    * ```
    */
 
-  encode(): Bytes {
+  toBytes(): Bytes {
     return bytesFrom(mol.SerializeOutPoint(this._toMolData()));
   }
 
@@ -173,6 +189,22 @@ export class OutPoint {
       numFromBytes(view.getIndex().raw()),
     );
   }
+
+  /**
+   * Compares the current OutPoint instance with another OutPointLike object for equality.
+   *
+   * @param val - The OutPointLike object to compare with.
+   * @returns True if the out points are equal, otherwise false.
+   *
+   * @example
+   * ```typescript
+   * const isEqual = outPoint.eq(anotherOutPoint);
+   * ```
+   */
+  eq(val: OutPointLike): boolean {
+    const outPoint = OutPoint.from(val);
+    return this.txHash === outPoint.txHash && this.index === outPoint.index;
+  }
 }
 
 export type CellOutputLike = {
@@ -195,6 +227,24 @@ export class CellOutput {
     public type?: Script,
   ) {}
 
+  get occupiedSize(): number {
+    return 8 + this.lock.occupiedSize + (this.type?.occupiedSize ?? 0);
+  }
+
+  /**
+   * Clone a CellOutput.
+   *
+   * @returns A cloned CellOutput instance.
+   *
+   * @example
+   * ```typescript
+   * const cellOutput1 = cellOutput0.clone();
+   * ```
+   */
+  clone(): CellOutput {
+    return new CellOutput(this.capacity, this.lock.clone(), this.type?.clone());
+  }
+
   /**
    * Creates a CellOutput instance from a CellOutputLike object.
    *
@@ -210,7 +260,6 @@ export class CellOutput {
    * });
    * ```
    */
-
   static from(cellOutput: CellOutputLike): CellOutput {
     if (cellOutput instanceof CellOutput) {
       return cellOutput;
@@ -282,7 +331,6 @@ export type CellLike = {
   outPoint: OutPointLike;
   cellOutput: CellOutputLike;
   outputData: HexLike;
-  blockNumber: NumLike;
 };
 export class Cell {
   /**
@@ -291,14 +339,12 @@ export class 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(
     public outPoint: OutPoint,
     public cellOutput: CellOutput,
     public outputData: Hex,
-    public blockNumber: Num,
   ) {}
 
   /**
@@ -317,17 +363,33 @@ export class Cell {
       OutPoint.from(cell.outPoint),
       CellOutput.from(cell.cellOutput),
       hexFrom(cell.outputData),
-      numFrom(cell.blockNumber),
+    );
+  }
+
+  /**
+   * Clone a Cell
+   *
+   * @returns A cloned Cell instance.
+   *
+   * @example
+   * ```typescript
+   * const cell1 = cell0.clone();
+   * ```
+   */
+  clone(): Cell {
+    return new Cell(
+      this.outPoint.clone(),
+      this.cellOutput.clone(),
+      this.outputData,
     );
   }
 }
 
 export type CellInputLike = {
   previousOutput: OutPointLike;
-  since: NumLike;
+  since?: NumLike;
   cellOutput?: CellOutputLike;
   outputData?: HexLike;
-  blockNumber?: NumLike;
 };
 export class CellInput {
   /**
@@ -337,7 +399,6 @@ export class CellInput {
    * @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(
@@ -345,9 +406,27 @@ export class CellInput {
     public since: Num,
     public cellOutput?: CellOutput,
     public outputData?: Hex,
-    public blockNumber?: Num,
   ) {}
 
+  /**
+   * Clone a CellInput.
+   *
+   * @returns A cloned CellInput instance.
+   *
+   * @example
+   * ```typescript
+   * const cellInput1 = cellInput0.clone();
+   * ```
+   */
+  clone(): CellInput {
+    return new CellInput(
+      this.previousOutput.clone(),
+      this.since,
+      this.cellOutput?.clone(),
+      this.outputData,
+    );
+  }
+
   /**
    * Creates a CellInput instance from a CellInputLike object.
    *
@@ -362,7 +441,6 @@ export class CellInput {
    * });
    * ```
    */
-
   static from(cellInput: CellInputLike): CellInput {
     if (cellInput instanceof CellInput) {
       return cellInput;
@@ -370,10 +448,9 @@ export class CellInput {
 
     return new CellInput(
       OutPoint.from(cellInput.previousOutput),
-      numFrom(cellInput.since),
+      numFrom(cellInput.since ?? 0),
       apply(CellOutput.from, cellInput.cellOutput),
       apply(hexFrom, cellInput.outputData),
-      apply(numFrom, cellInput.blockNumber),
     );
   }
 
@@ -381,27 +458,24 @@ export class CellInput {
    * Complete extra infos in the input. Like the output of the out point.
    * The instance will be modified.
    *
-   * @returns The completed instance.
+   * @returns true if succeed.
    * @example
    * ```typescript
-   * if (!cellInput.cellOutput) {
-   *   await cellInput.completeExtraInfos();
-   * }
+   * await cellInput.completeExtraInfos();
    * ```
    */
-
-  async completeExtraInfos(client: Client): Promise<CellInput> {
-    if (this.cellOutput && this.outputData && this.blockNumber) {
-      return this;
+  async completeExtraInfos(client: Client): Promise<void> {
+    if (this.cellOutput && this.outputData) {
+      return;
     }
 
     const cell = await client.getCell(this.previousOutput);
-    if (cell) {
-      this.cellOutput = cell.cellOutput;
-      this.outputData = cell.outputData;
-      this.blockNumber = cell.blockNumber;
+    if (!cell) {
+      return;
     }
-    return this;
+
+    this.cellOutput = cell.cellOutput;
+    this.outputData = cell.outputData;
   }
 
   /**
@@ -474,6 +548,21 @@ export class CellDep {
     public depType: DepType,
   ) {}
 
+  /**
+   * Clone a CellDep.
+   *
+   * @returns A cloned CellDep instance.
+   *
+   * @example
+   * ```typescript
+   * const cellDep1 = cellDep0.clone();
+   * ```
+   */
+
+  clone(): CellDep {
+    return new CellDep(this.outPoint.clone(), this.depType);
+  }
+
   /**
    * Creates a CellDep instance from a CellDepLike object.
    *
@@ -549,6 +638,24 @@ export class CellDep {
       depTypeFromBytes([view.getDepType()]),
     );
   }
+
+  /**
+   * Compares the current CellDep instance with another CellDepLike object for equality.
+   *
+   * @param val - The CellDepLike object to compare with.
+   * @returns True if the cell deps are equal, otherwise false.
+   *
+   * @example
+   * ```typescript
+   * const isEqual = cellDep.eq(anotherCellDep);
+   * ```
+   */
+  eq(val: CellDepLike): boolean {
+    const cellDep = CellDep.from(val);
+    return (
+      this.outPoint.eq(cellDep.outPoint) && this.depType === cellDep.depType
+    );
+  }
 }
 
 export type WitnessArgsLike = {
@@ -654,14 +761,24 @@ export class WitnessArgs {
   }
 }
 
+export function udtBalanceFrom(dataLike: BytesLike) {
+  const data = bytesFrom(dataLike).slice(0, 16);
+  if (data.length !== 16) {
+    throw new Error("Invalid UDT cell data");
+  }
+
+  return numFromBytes(data);
+}
+
 export type TransactionLike = {
-  version: NumLike;
-  cellDeps: CellDepLike[];
-  headerDeps: HexLike[];
-  inputs: CellInputLike[];
-  outputs: CellOutputLike[];
-  outputsData: HexLike[];
-  witnesses: HexLike[];
+  version?: NumLike;
+  cellDeps?: CellDepLike[];
+  headerDeps?: HexLike[];
+  inputs?: CellInputLike[];
+  outputs?: (Omit<CellOutputLike, "capacity"> &
+    Partial<Pick<CellOutputLike, "capacity">>)[];
+  outputsData?: HexLike[];
+  witnesses?: HexLike[];
 };
 export class Transaction {
   /**
@@ -696,11 +813,51 @@ export class Transaction {
    * const defaultTx = Transaction.default();
    * ```
    */
-
   static default(): Transaction {
     return new Transaction(0n, [], [], [], [], [], []);
   }
 
+  /**
+   * Copy every properties from another transaction.
+   *
+   * @example
+   * ```typescript
+   * this.copy(Transaction.default());
+   * ```
+   */
+  copy(txLike: TransactionLike) {
+    const tx = Transaction.from(txLike);
+    this.version = tx.version;
+    this.cellDeps = tx.cellDeps;
+    this.headerDeps = tx.headerDeps;
+    this.inputs = tx.inputs;
+    this.outputs = tx.outputs;
+    this.outputsData = tx.outputsData;
+    this.witnesses = tx.witnesses;
+  }
+
+  /**
+   * Clone a Transaction.
+   *
+   * @returns A cloned instance
+   *
+   * @example
+   * ```typescript
+   * const tx1 = tx0.clone();
+   * ```
+   */
+  clone(): Transaction {
+    return new Transaction(
+      0n,
+      this.cellDeps.map((c) => c.clone()),
+      [...this.headerDeps],
+      this.inputs.map((i) => i.clone()),
+      this.outputs.map((o) => o.clone()),
+      [...this.outputsData],
+      [...this.witnesses],
+    );
+  }
+
   /**
    * Creates a Transaction instance from a TransactionLike object.
    *
@@ -725,15 +882,37 @@ export class Transaction {
     if (tx instanceof Transaction) {
       return tx;
     }
+    const outputs =
+      tx.outputs?.map((output, i) => {
+        const o = CellOutput.from({
+          ...output,
+          capacity: output.capacity ?? 0,
+        });
+        o.capacity = fixedPointFrom(
+          o.occupiedSize + (apply(bytesFrom, tx.outputsData?.[i])?.length ?? 0),
+        );
+        return o;
+      }) ?? [];
+    const outputsData = outputs.map((_, i) =>
+      hexFrom(tx.outputsData?.[i] ?? "0x"),
+    );
+    if (
+      tx.outputsData !== undefined &&
+      outputsData.length < tx.outputsData.length
+    ) {
+      outputsData.push(
+        ...tx.outputsData.slice(outputsData.length).map((d) => hexFrom(d)),
+      );
+    }
 
     return new Transaction(
-      numFrom(tx.version),
-      tx.cellDeps.map((cellDep) => CellDep.from(cellDep)),
-      tx.headerDeps.map(hexFrom),
-      tx.inputs.map((input) => CellInput.from(input)),
-      tx.outputs.map((output) => CellOutput.from(output)),
-      tx.outputsData.map(hexFrom),
-      tx.witnesses.map(hexFrom),
+      numFrom(tx.version ?? 0),
+      tx.cellDeps?.map((cellDep) => CellDep.from(cellDep)) ?? [],
+      tx.headerDeps?.map(hexFrom) ?? [],
+      tx.inputs?.map((input) => CellInput.from(input)) ?? [],
+      outputs,
+      outputsData,
+      tx.witnesses?.map(hexFrom) ?? [],
     );
   }
 
@@ -793,7 +972,6 @@ export class Transaction {
    * const rawTxBytes = transaction.rawToBytes();
    * ```
    */
-
   rawToBytes(): Bytes {
     return bytesFrom(
       mol.SerializeRawTransaction({
@@ -807,6 +985,32 @@ export class Transaction {
     );
   }
 
+  /**
+   * Converts the whole transaction data to bytes.
+   *
+   * @returns A Uint8Array containing the full transaction bytes.
+   *
+   * @example
+   * ```typescript
+   * const txBytes = transaction.toBytes();
+   * ```
+   */
+  toBytes(): Bytes {
+    return bytesFrom(
+      mol.SerializeTransaction({
+        raw: {
+          version: numToBytes(this.version, 4),
+          cellDeps: this.cellDeps.map((d) => d._toMolData()),
+          headerDeps: this.headerDeps.map((header) => bytesFrom(header)),
+          inputs: this.inputs.map((i) => i._toMolData()),
+          outputs: this.outputs.map((o) => o._toMolData()),
+          outputsData: this.outputsData.map((header) => bytesFrom(header)),
+        },
+        witnesses: this.witnesses.map((witness) => bytesFrom(witness)),
+      }),
+    );
+  }
+
   /**
    * Calculates the hash of the transaction.
    *
@@ -867,11 +1071,11 @@ export class Transaction {
     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);
-
+      const input = await this.inputs[i];
+      await input.completeExtraInfos(client);
+      if (input) {
         if (!input.cellOutput) {
-          throw Error("Unable to resolve inputs info");
+          throw new Error("Unable to complete input");
         }
 
         if (!script.eq(input.cellOutput.lock)) {
@@ -919,10 +1123,41 @@ export class Transaction {
     const script = Script.from(scriptLike);
 
     for (let i = 0; i < this.inputs.length; i += 1) {
-      const input = await this.inputs[i].completeExtraInfos(client);
+      const input = this.inputs[i];
+      await input.completeExtraInfos(client);
+      if (!input.cellOutput) {
+        throw new Error("Unable to complete input");
+      }
+
+      if (script.eq(input.cellOutput.lock)) {
+        return i;
+      }
+    }
+  }
+
+  /**
+   * Find the last 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.findLastInputIndexByLock(scriptLike, client);
+   * ```
+   */
+  async findLastInputIndexByLock(
+    scriptLike: ScriptLike,
+    client: Client,
+  ): Promise<number | undefined> {
+    const script = Script.from(scriptLike);
 
+    for (let i = this.inputs.length - 1; i >= 0; i -= 1) {
+      const input = this.inputs[i];
+      await input.completeExtraInfos(client);
       if (!input.cellOutput) {
-        throw Error("Unable to resolve inputs info");
+        throw new Error("Unable to complete input");
       }
 
       if (script.eq(input.cellOutput.lock)) {
@@ -931,6 +1166,125 @@ export class Transaction {
     }
   }
 
+  /**
+   * Add cell deps if they are not existed
+   *
+   * @param cellDepLikes - The cell deps to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDeps(cellDep);
+   * ```
+   */
+  addCellDeps(...cellDepsLike: (CellDepLike | CellDepLike[])[]): void {
+    cellDepsLike.flat().forEach((cellDepLike) => {
+      const cellDep = CellDep.from(cellDepLike);
+      if (this.cellDeps.some((c) => c.eq(cellDep))) {
+        return;
+      }
+
+      this.cellDeps.push(cellDep);
+    });
+  }
+
+  /**
+   * Add cell dep from infos if they are not existed
+   *
+   * @param client - A client for searching cell deps
+   * @param cellDepLikes - The cell dep infos to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDepInfos(client, cellDepInfos);
+   * ```
+   */
+  async addCellDepInfos(
+    client: Client,
+    ...cellDepInfosLike: (CellDepInfoLike | CellDepInfoLike[])[]
+  ): Promise<void> {
+    this.addCellDeps(await client.getCellDeps(...cellDepInfosLike));
+  }
+
+  /**
+   * Add cell deps from known script
+   *
+   * @param client - The client for searching known script and cell deps
+   * @param scripts - The known scripts to add
+   *
+   * @example
+   * ```typescript
+   * tx.addCellDepsOfKnownScripts(client, KnownScript.OmniLock);
+   * ```
+   */
+  async addCellDepsOfKnownScripts(
+    client: Client,
+    ...scripts: (KnownScript | KnownScript[])[]
+  ): Promise<void> {
+    await Promise.all(
+      scripts
+        .flat()
+        .map(async (script) =>
+          this.addCellDepInfos(
+            client,
+            (await client.getKnownScript(script)).cellDeps,
+          ),
+        ),
+    );
+  }
+
+  /**
+   * Set output data at index.
+   *
+   * @param index - The index of the output data.
+   * @param witness - The data to set.
+   *
+   * @example
+   * ```typescript
+   * await tx.setOutputData(0, "0x00");
+   * ```
+   */
+  setOutputDataAt(index: number, data: HexLike): void {
+    if (this.outputsData.length < index) {
+      this.outputsData.push(
+        ...Array.from(
+          new Array(index - this.outputsData.length),
+          (): Hex => "0x",
+        ),
+      );
+    }
+
+    this.outputsData[index] = hexFrom(data);
+  }
+
+  /**
+   * Add output
+   *
+   * @param output - The cell output to add
+   * @param data - optional output data
+   *
+   * @example
+   * ```typescript
+   * await tx.addOutput(cellOutput, "0xabcd");
+   * ```
+   */
+  addOutput(
+    outputLike: Omit<CellOutputLike, "capacity"> &
+      Partial<Pick<CellOutputLike, "capacity">>,
+    outputData: HexLike = "0x",
+  ): void {
+    const output = CellOutput.from({
+      ...outputLike,
+      capacity: outputLike.capacity ?? 0,
+    });
+    if (output.capacity === Zero) {
+      output.capacity = fixedPointFrom(
+        output.occupiedSize + bytesFrom(outputData).length,
+      );
+    }
+    const i = this.outputs.push(output) - 1;
+    this.setOutputDataAt(i, outputData);
+  }
+
   /**
    * Get witness at index as WitnessArgs
    *
@@ -954,14 +1308,13 @@ export class Transaction {
    *
    * @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: number, witness: WitnessArgs): Transaction {
+  setWitnessArgsAt(index: number, witness: WitnessArgs): void {
     if (this.witnesses.length < index) {
       this.witnesses.push(
         ...Array.from(
@@ -972,7 +1325,6 @@ export class Transaction {
     }
 
     this.witnesses[index] = hexFrom(witness.toBytes());
-    return this;
   }
 
   /**
@@ -992,14 +1344,282 @@ export class Transaction {
     scriptLike: ScriptLike,
     lockLen: number,
     client: Client,
-  ): Promise<Transaction> {
+  ): Promise<void> {
     const position = await this.findInputIndexByLock(scriptLike, client);
     if (position === undefined) {
-      return this;
+      return;
     }
 
     const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
     witness.lock = hexFrom(Array.from(new Array(lockLen), () => 0));
-    return this.setWitnessArgsAt(position, witness);
+    this.setWitnessArgsAt(position, witness);
+  }
+
+  async getInputsCapacity(client: Client): Promise<Num> {
+    return reduceAsync(
+      this.inputs,
+      async (acc, input) => {
+        await input.completeExtraInfos(client);
+        if (!input.cellOutput) {
+          throw new Error("Unable to complete input");
+        }
+        return acc + input.cellOutput.capacity;
+      },
+      numFrom(0),
+    );
+  }
+
+  getOutputsCapacity(): Num {
+    return this.outputs.reduce(
+      (acc, { capacity }) => acc + capacity,
+      numFrom(0),
+    );
+  }
+
+  async getInputsUdtBalance(client: Client, type: ScriptLike): Promise<Num> {
+    return reduceAsync(
+      this.inputs,
+      async (acc, input) => {
+        await input.completeExtraInfos(client);
+        if (!input.cellOutput || !input.outputData) {
+          throw new Error("Unable to complete input");
+        }
+        if (!input.cellOutput.type?.eq(type)) {
+          return;
+        }
+
+        return acc + udtBalanceFrom(input.outputData);
+      },
+      numFrom(0),
+    );
+  }
+
+  getOutputsUdtBalance(type: ScriptLike): Num {
+    return this.outputs.reduce((acc, output, i) => {
+      if (!output.type?.eq(type)) {
+        return acc;
+      }
+
+      return acc + udtBalanceFrom(this.outputsData[i]);
+    }, numFrom(0));
+  }
+
+  async completeInputs<T>(
+    from: Signer,
+    filter: ClientCollectableSearchKeyFilterLike,
+    accumulator: (
+      acc: T,
+      v: Cell,
+      i: number,
+      array: Cell[],
+    ) => Promise<T | undefined> | T | undefined,
+    init: T,
+  ): Promise<number> {
+    const scripts = (await from.getAddressObjs()).map(({ script }) => script);
+    const collectedCells = [];
+    let acc: T = init;
+
+    for (const script of scripts) {
+      for await (const cell of from.client.findCellsByCollectableSearchKey({
+        script,
+        scriptType: "lock",
+        filter,
+        scriptSearchMode: "exact",
+        withData: true,
+      })) {
+        if (
+          this.inputs.some(({ previousOutput }) =>
+            previousOutput.eq(cell.outPoint),
+          )
+        ) {
+          continue;
+        }
+        const i = collectedCells.push(cell);
+        const next: T | undefined = await Promise.resolve(
+          accumulator(acc, cell, i - 1, collectedCells),
+        );
+        if (next === undefined) {
+          this.inputs.push(
+            ...collectedCells.map(({ outPoint, outputData, cellOutput }) =>
+              CellInput.from({
+                previousOutput: outPoint,
+                since: 0,
+                outputData,
+                cellOutput,
+              }),
+            ),
+          );
+          return collectedCells.length;
+        }
+        acc = next;
+      }
+    }
+
+    throw new Error("Failed to find enough cells for input");
+  }
+
+  async completeInputsByCapacity(
+    from: Signer,
+    capacityTweak?: NumLike,
+    filter?: ClientCollectableSearchKeyFilterLike,
+  ): Promise<number> {
+    const exceptedCapacity =
+      this.getOutputsCapacity() + numFrom(capacityTweak ?? 0);
+    const inputsCapacity = await this.getInputsCapacity(from.client);
+    if (inputsCapacity >= exceptedCapacity) {
+      return 0;
+    }
+
+    return this.completeInputs(
+      from,
+      filter ?? {
+        scriptLenRange: [0, 1],
+        outputDataLenRange: [0, 1],
+      },
+      (acc, { cellOutput: { capacity } }) => {
+        const sum = acc + capacity;
+        return sum > exceptedCapacity ? undefined : sum;
+      },
+      inputsCapacity,
+    );
+  }
+
+  async completeInputsByUdt(from: Signer, type: ScriptLike): Promise<number> {
+    const exceptedBalance = this.getOutputsUdtBalance(type);
+    const inputsBalance = await this.getInputsUdtBalance(from.client, type);
+    if (inputsBalance >= exceptedBalance) {
+      return 0;
+    }
+
+    return this.completeInputs(
+      from,
+      {
+        script: type,
+        outputDataLenRange: [16, numFrom("0xffffffff")],
+      },
+      (acc, { outputData }) => {
+        const balance = udtBalanceFrom(outputData);
+        const sum = acc + balance;
+        return sum > exceptedBalance ? undefined : sum;
+      },
+      inputsBalance,
+    );
+  }
+
+  estimateFee(feeRate: NumLike): Num {
+    const txSize = this.toBytes().length + 4;
+    return (numFrom(txSize) * numFrom(feeRate) + numFrom(1000)) / numFrom(1000);
+  }
+
+  async completeFee(
+    from: Signer,
+    change: (tx: Transaction, capacity: Num) => Promise<NumLike> | NumLike,
+    feeRate: NumLike,
+    filter?: ClientCollectableSearchKeyFilterLike,
+  ): Promise<[number, boolean]> {
+    // Complete all inputs extra infos for cache
+    await this.getInputsCapacity(from.client);
+
+    let leastFee = this.estimateFee(feeRate);
+    let leastExtraCapacity = Zero;
+
+    while (true) {
+      const prepared = await from.prepareTransaction(this.clone());
+      const collected = await prepared.completeInputsByCapacity(
+        from,
+        leastFee + leastExtraCapacity,
+        filter,
+      );
+
+      const extraCapacity =
+        (await prepared.getInputsCapacity(from.client)) -
+        prepared.getOutputsCapacity();
+      // The extra capacity paid the fee without a change
+      if (extraCapacity === leastFee) {
+        this.copy(prepared);
+        return [collected, false];
+      }
+
+      let changed = prepared.clone();
+      const needed = numFrom(
+        await Promise.resolve(change(changed, extraCapacity - leastFee)),
+      );
+      // No enough extra capacity to create new cells for change
+      if (needed > Zero) {
+        leastExtraCapacity = needed;
+        continue;
+      }
+
+      if (
+        (await changed.getInputsCapacity(from.client)) -
+          changed.getOutputsCapacity() !==
+        leastFee
+      ) {
+        throw new Error(
+          "The change function doesn't use all available capacity",
+        );
+      }
+
+      // New change cells created, update the fee
+      await from.prepareTransaction(changed);
+      const changedFee = changed.estimateFee(feeRate);
+      if (leastFee > changedFee) {
+        throw new Error("The change function removed existed transaction data");
+      }
+      // The fee has been paid
+      if (leastFee === changedFee) {
+        this.copy(changed);
+        return [collected, true];
+      }
+
+      // The fee after changing is more than the original fee
+      leastFee = changedFee;
+    }
+  }
+
+  completeFeeChangeToLock(
+    from: Signer,
+    change: ScriptLike,
+    feeRate: NumLike,
+    filter?: ClientCollectableSearchKeyFilterLike,
+  ): Promise<[number, boolean]> {
+    const script = Script.from(change);
+
+    return this.completeFee(
+      from,
+      (tx, capacity) => {
+        const changeCell = CellOutput.from({ capacity: 0, lock: script });
+        const occupiedCapacity = fixedPointFrom(changeCell.occupiedSize);
+        if (capacity < occupiedCapacity) {
+          return occupiedCapacity;
+        }
+        changeCell.capacity = capacity;
+        tx.addOutput(changeCell);
+        return 0;
+      },
+      feeRate,
+      filter,
+    );
+  }
+
+  completeFeeChangeToOutput(
+    from: Signer,
+    index: NumLike,
+    feeRate: NumLike,
+    filter?: ClientCollectableSearchKeyFilterLike,
+  ): Promise<[number, boolean]> {
+    const change = Number(numFrom(index));
+    if (!this.outputs[change]) {
+      throw new Error("Non-existed output to change");
+    }
+    return this.completeFee(
+      from,
+      (tx, capacity) => {
+        tx.outputs[change].capacity += capacity;
+        return 0;
+      },
+      feeRate,
+      filter,
+    );
   }
 }