@ckb-ccc/core 1.5.3 → 1.7.0

package/src/ckb/transaction.ts

@@ -1,6 +1,12 @@
 import { Bytes, BytesLike, bytesFrom } from "../bytes/index.js";
 import type { ClientCollectableSearchKeyFilterLike } from "../client/clientTypes.advanced.js";
-import type { CellDepInfoLike, Client, KnownScript } from "../client/index.js";
+import {
+  ClientBlockHeader,
+  type CellDepInfoLike,
+  type Client,
+  type ClientBlockHeaderLike,
+} from "../client/index.js";
+import { KnownScript } from "../client/knownScript.js";
 import {
   Zero,
   fixedPointFrom,
@@ -229,8 +235,12 @@ export const CellOutputVec = mol.vector(CellOutput);
 /**
  * @public
  */
-export type CellLike = {
-  outPoint: OutPointLike;
+export type CellLike = (
+  | {
+      outPoint: OutPointLike;
+    }
+  | { previousOutput: OutPointLike }
+) & {
   cellOutput: CellOutputLike;
   outputData: HexLike;
 };
@@ -265,12 +275,133 @@ export class Cell {
     }
 
     return new Cell(
-      OutPoint.from(cell.outPoint),
+      OutPoint.from("outPoint" in cell ? cell.outPoint : cell.previousOutput),
       CellOutput.from(cell.cellOutput),
       hexFrom(cell.outputData),
     );
   }
 
+  get capacityFree() {
+    const occupiedSize = fixedPointFrom(
+      this.cellOutput.occupiedSize + bytesFrom(this.outputData).length,
+    );
+    return this.cellOutput.capacity - occupiedSize;
+  }
+
+  /**
+   * Occupied bytes of a cell on chain
+   * It's CellOutput.occupiedSize + bytesFrom(outputData).byteLength
+   */
+  get occupiedSize() {
+    return this.cellOutput.occupiedSize + bytesFrom(this.outputData).byteLength;
+  }
+
+  /**
+   * Gets confirmed Nervos DAO profit of a Cell
+   * It returns non-zero value only when the cell is in withdrawal phase 2
+   * See https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md
+   *
+   * @param client - A client for searching DAO related headers
+   * @returns Profit
+   *
+   * @example
+   * ```typescript
+   * const profit = await cell.getDaoProfit(client);
+   * ```
+   */
+  async getDaoProfit(client: Client): Promise<Num> {
+    if (!(await this.isNervosDao(client, "withdrew"))) {
+      return Zero;
+    }
+
+    const { depositHeader, withdrawHeader } =
+      await this.getNervosDaoInfo(client);
+    if (!withdrawHeader || !depositHeader) {
+      throw new Error(
+        `Unable to get headers of a Nervos DAO cell ${this.outPoint.txHash}:${this.outPoint.index.toString()}`,
+      );
+    }
+
+    return calcDaoProfit(this.capacityFree, depositHeader, withdrawHeader);
+  }
+
+  async isNervosDao(
+    client: Client,
+    phase?: "deposited" | "withdrew",
+  ): Promise<boolean> {
+    const { type } = this.cellOutput;
+
+    const daoType = await client.getKnownScript(KnownScript.NervosDao);
+    if (
+      !type ||
+      type.codeHash !== daoType.codeHash ||
+      type.hashType !== daoType.hashType
+    ) {
+      // Non Nervos DAO cell
+      return false;
+    }
+
+    const hasWithdrew = numFrom(this.outputData) !== Zero;
+    return (
+      !phase ||
+      (phase === "deposited" && !hasWithdrew) ||
+      (phase === "withdrew" && hasWithdrew)
+    );
+  }
+
+  async getNervosDaoInfo(client: Client): Promise<
+    // Non Nervos DAO cell
+    | {
+        depositHeader?: undefined;
+        withdrawHeader?: undefined;
+      }
+    // Deposited Nervos DAO cell
+    | {
+        depositHeader: ClientBlockHeader;
+        withdrawHeader?: undefined;
+      }
+    // Withdrew Nervos DAO cell
+    | {
+        depositHeader: ClientBlockHeader;
+        withdrawHeader: ClientBlockHeader;
+      }
+  > {
+    if (!(await this.isNervosDao(client))) {
+      // Non Nervos DAO cell
+      return {};
+    }
+
+    if (numFrom(this.outputData) === Zero) {
+      // Deposited Nervos DAO cell
+      const depositRes = await client.getCellWithHeader(this.outPoint);
+      if (!depositRes?.header) {
+        throw new Error(
+          `Unable to get header of a Nervos DAO deposited cell ${this.outPoint.txHash}:${this.outPoint.index.toString()}`,
+        );
+      }
+
+      return {
+        depositHeader: depositRes.header,
+      };
+    }
+
+    // Withdrew Nervos DAO cell
+    const [depositHeader, withdrawRes] = await Promise.all([
+      client.getHeaderByNumber(numFromBytes(this.outputData)),
+      client.getCellWithHeader(this.outPoint),
+    ]);
+    if (!withdrawRes?.header || !depositHeader) {
+      throw new Error(
+        `Unable to get headers of a Nervos DAO withdrew cell ${this.outPoint.txHash}:${this.outPoint.index.toString()}`,
+      );
+    }
+
+    return {
+      depositHeader,
+      withdrawHeader: withdrawRes.header,
+    };
+  }
+
   /**
    * Clone a Cell
    *
@@ -450,8 +581,12 @@ export class Since extends mol.Entity.Base<SinceLike, Since>() {
 /**
  * @public
  */
-export type CellInputLike = {
-  previousOutput: OutPointLike;
+export type CellInputLike = (
+  | {
+      previousOutput: OutPointLike;
+    }
+  | { outPoint: OutPointLike }
+) & {
   since?: SinceLike | NumLike | null;
   cellOutput?: CellOutputLike | null;
   outputData?: HexLike | null;
@@ -465,10 +600,7 @@ export type CellInputLike = {
       since: Since,
       previousOutput: OutPoint,
     })
-    .mapIn((encodable: CellInputLike) => ({
-      ...encodable,
-      since: encodable.since ?? 0,
-    })),
+    .mapIn((encodable: CellInputLike) => CellInput.from(encodable)),
 )
 export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
   /**
@@ -509,21 +641,40 @@ export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
     }
 
     return new CellInput(
-      OutPoint.from(cellInput.previousOutput),
+      OutPoint.from(
+        "previousOutput" in cellInput
+          ? cellInput.previousOutput
+          : cellInput.outPoint,
+      ),
       Since.from(cellInput.since ?? 0).toNum(),
       apply(CellOutput.from, cellInput.cellOutput),
       apply(hexFrom, cellInput.outputData),
     );
   }
 
+  async getCell(client: Client): Promise<Cell> {
+    await this.completeExtraInfos(client);
+    if (!this.cellOutput || !this.outputData) {
+      throw new Error("Unable to complete input");
+    }
+
+    return Cell.from({
+      outPoint: this.previousOutput,
+      cellOutput: this.cellOutput,
+      outputData: this.outputData,
+    });
+  }
+
   /**
-   * Complete extra infos in the input. Like the output of the out point.
+   * Complete extra infos in the input. Including
+   * - Previous cell output
+   * - Previous cell data
    * The instance will be modified.
    *
    * @returns true if succeed.
    * @example
    * ```typescript
-   * await cellInput.completeExtraInfos();
+   * await cellInput.completeExtraInfos(client);
    * ```
    */
   async completeExtraInfos(client: Client): Promise<void> {
@@ -539,6 +690,23 @@ export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
     this.cellOutput = cell.cellOutput;
     this.outputData = cell.outputData;
   }
+
+  /**
+   * The extra capacity created when consume this input.
+   * This is usually NervosDAO interest, see https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0023-dao-deposit-withdraw/0023-dao-deposit-withdraw.md.
+   * And it can also be miners' income. (But this is not implemented yet)
+   */
+  async getExtraCapacity(client: Client): Promise<Num> {
+    return (await this.getCell(client)).getDaoProfit(client);
+  }
+
+  clone(): CellInput {
+    const cloned = super.clone();
+    cloned.cellOutput = this.cellOutput;
+    cloned.outputData = this.outputData;
+
+    return cloned;
+  }
 }
 export const CellInputVec = mol.vector(CellInput);
 
@@ -684,11 +852,13 @@ export class WitnessArgs extends mol.Entity.Base<
 }
 
 /**
+ * Convert a bytes to a num.
+ *
  * @public
  */
 export function udtBalanceFrom(dataLike: BytesLike): Num {
   const data = bytesFrom(dataLike).slice(0, 16);
-  return numFromBytes(data);
+  return data.length === 0 ? Zero : numFromBytes(data);
 }
 
 export const RawTransaction = mol.table({
@@ -891,6 +1061,11 @@ export class Transaction extends mol.Entity.Base<
     });
   }
 
+  /**
+   * @deprecated
+   * Use ccc.stringify instead.
+   * stringify the tx to JSON string.
+   */
   stringify(): string {
     return JSON.stringify(this, (_, value) => {
       if (typeof value === "bigint") {
@@ -991,13 +1166,9 @@ export class Transaction extends mol.Entity.Base<
     for (let i = 0; i < this.witnesses.length; i += 1) {
       const input = this.inputs[i];
       if (input) {
-        await input.completeExtraInfos(client);
+        const { cellOutput } = await input.getCell(client);
 
-        if (!input.cellOutput) {
-          throw new Error("Unable to complete input");
-        }
-
-        if (!script.eq(input.cellOutput.lock)) {
+        if (!script.eq(cellOutput.lock)) {
           continue;
         }
 
@@ -1042,15 +1213,11 @@ export class Transaction extends mol.Entity.Base<
     const script = Script.from({ ...scriptIdLike, args: "0x" });
 
     for (let i = 0; i < this.inputs.length; i += 1) {
-      const input = this.inputs[i];
-      await input.completeExtraInfos(client);
-      if (!input.cellOutput) {
-        throw new Error("Unable to complete input");
-      }
+      const { cellOutput } = await this.inputs[i].getCell(client);
 
       if (
-        script.codeHash === input.cellOutput.lock.codeHash &&
-        script.hashType === input.cellOutput.lock.hashType
+        script.codeHash === cellOutput.lock.codeHash &&
+        script.hashType === cellOutput.lock.hashType
       ) {
         return i;
       }
@@ -1076,13 +1243,9 @@ export class Transaction extends mol.Entity.Base<
     const script = Script.from(scriptLike);
 
     for (let i = 0; i < this.inputs.length; i += 1) {
-      const input = this.inputs[i];
-      await input.completeExtraInfos(client);
-      if (!input.cellOutput) {
-        throw new Error("Unable to complete input");
-      }
+      const { cellOutput } = await this.inputs[i].getCell(client);
 
-      if (script.eq(input.cellOutput.lock)) {
+      if (script.eq(cellOutput.lock)) {
         return i;
       }
     }
@@ -1107,13 +1270,9 @@ export class Transaction extends mol.Entity.Base<
     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 new Error("Unable to complete input");
-      }
+      const { cellOutput } = await this.inputs[i].getCell(client);
 
-      if (script.eq(input.cellOutput.lock)) {
+      if (script.eq(cellOutput.lock)) {
         return i;
       }
     }
@@ -1230,6 +1389,62 @@ export class Transaction extends mol.Entity.Base<
     this.outputsData[index] = hexFrom(witness);
   }
 
+  /**
+   * get input
+   *
+   * @param index - The cell input index
+   *
+   * @example
+   * ```typescript
+   * await tx.getInput(0);
+   * ```
+   */
+  getInput(index: NumLike): CellInput | undefined {
+    return this.inputs[Number(numFrom(index))];
+  }
+  /**
+   * add input
+   *
+   * @param inputLike - The cell input.
+   *
+   * @example
+   * ```typescript
+   * await tx.addInput({ });
+   * ```
+   */
+  addInput(inputLike: CellInputLike): number {
+    if (this.witnesses.length > this.inputs.length) {
+      this.witnesses.splice(this.inputs.length, 0, "0x");
+    }
+
+    return this.inputs.push(CellInput.from(inputLike));
+  }
+
+  /**
+   * get output
+   *
+   * @param index - The cell output index
+   *
+   * @example
+   * ```typescript
+   * await tx.getOutput(0);
+   * ```
+   */
+  getOutput(index: NumLike):
+    | {
+        cellOutput: CellOutput;
+        outputData: Hex;
+      }
+    | undefined {
+    const i = Number(numFrom(index));
+    if (i >= this.outputs.length) {
+      return;
+    }
+    return {
+      cellOutput: this.outputs[i],
+      outputData: this.outputsData[i] ?? "0x",
+    };
+  }
   /**
    * Add output
    *
@@ -1245,7 +1460,7 @@ export class Transaction extends mol.Entity.Base<
     outputLike: Omit<CellOutputLike, "capacity"> &
       Partial<Pick<CellOutputLike, "capacity">>,
     outputData: HexLike = "0x",
-  ): void {
+  ): number {
     const output = CellOutput.from({
       ...outputLike,
       capacity: outputLike.capacity ?? 0,
@@ -1255,8 +1470,10 @@ export class Transaction extends mol.Entity.Base<
         output.occupiedSize + bytesFrom(outputData).length,
       );
     }
-    const i = this.outputs.push(output) - 1;
-    this.setOutputDataAt(i, outputData);
+    const len = this.outputs.push(output);
+    this.setOutputDataAt(len - 1, outputData);
+
+    return len;
   }
 
   /**
@@ -1289,6 +1506,21 @@ export class Transaction extends mol.Entity.Base<
    * ```
    */
   setWitnessArgsAt(index: number, witness: WitnessArgs): void {
+    this.setWitnessAt(index, witness.toBytes());
+  }
+
+  /**
+   * Set witness at index
+   *
+   * @param index - The index of the witness.
+   * @param witness - The witness to set.
+   *
+   * @example
+   * ```typescript
+   * await tx.setWitnessAt(0, witness);
+   * ```
+   */
+  setWitnessAt(index: number, witness: HexLike): void {
     if (this.witnesses.length < index) {
       this.witnesses.push(
         ...Array.from(
@@ -1298,7 +1530,7 @@ export class Transaction extends mol.Entity.Base<
       );
     }
 
-    this.witnesses[index] = hexFrom(witness.toBytes());
+    this.witnesses[index] = hexFrom(witness);
   }
 
   /**
@@ -1329,20 +1561,31 @@ export class Transaction extends mol.Entity.Base<
     this.setWitnessArgsAt(position, witness);
   }
 
-  async getInputsCapacity(client: Client): Promise<Num> {
+  async getInputsCapacityExtra(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;
-      },
+      async (acc, input) => acc + (await input.getExtraCapacity(client)),
       numFrom(0),
     );
   }
 
+  // This also includes extra amount
+  async getInputsCapacity(client: Client): Promise<Num> {
+    return (
+      (await reduceAsync(
+        this.inputs,
+        async (acc, input) => {
+          const {
+            cellOutput: { capacity },
+          } = await input.getCell(client);
+
+          return acc + capacity;
+        },
+        numFrom(0),
+      )) + (await this.getInputsCapacityExtra(client))
+    );
+  }
+
   getOutputsCapacity(): Num {
     return this.outputs.reduce(
       (acc, { capacity }) => acc + capacity,
@@ -1354,15 +1597,12 @@ export class Transaction extends mol.Entity.Base<
     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)) {
+        const { cellOutput, outputData } = await input.getCell(client);
+        if (!cellOutput.type?.eq(type)) {
           return;
         }
 
-        return acc + udtBalanceFrom(input.outputData);
+        return acc + udtBalanceFrom(outputData);
       },
       numFrom(0),
     );
@@ -1415,15 +1655,7 @@ export class Transaction extends mol.Entity.Base<
       acc = next;
     }
 
-    this.inputs.push(
-      ...collectedCells.map(({ outPoint, outputData, cellOutput }) =>
-        CellInput.from({
-          previousOutput: outPoint,
-          outputData,
-          cellOutput,
-        }),
-      ),
-    );
+    collectedCells.forEach((cell) => this.addInput(cell));
     if (fulfilled) {
       return {
         addedCount: collectedCells.length,
@@ -1526,31 +1758,18 @@ export class Transaction extends mol.Entity.Base<
     from: Signer,
     filter?: ClientCollectableSearchKeyFilterLike,
   ): Promise<number> {
-    for await (const cell of from.findCells(
+    const { addedCount, accumulated } = await this.completeInputs(
+      from,
       filter ?? {
         scriptLenRange: [0, 1],
         outputDataLenRange: [0, 1],
       },
+      () => undefined,
       true,
-      undefined,
-      1,
-    )) {
-      if (
-        this.inputs.some(({ previousOutput }) =>
-          previousOutput.eq(cell.outPoint),
-        )
-      ) {
-        continue;
-      }
+    );
 
-      this.inputs.push(
-        CellInput.from({
-          previousOutput: cell.outPoint,
-          outputData: cell.outputData,
-          cellOutput: cell.cellOutput,
-        }),
-      );
-      return 1;
+    if (accumulated === undefined) {
+      return addedCount;
     }
 
     throw new Error(`Insufficient CKB, need at least one new cell`);
@@ -1567,9 +1786,21 @@ export class Transaction extends mol.Entity.Base<
     return this.completeInputsAddOne(from, filter);
   }
 
+  async getFee(client: Client): Promise<Num> {
+    return (await this.getInputsCapacity(client)) - this.getOutputsCapacity();
+  }
+
+  async getFeeRate(client: Client): Promise<Num> {
+    return (
+      ((await this.getFee(client)) * numFrom(1000)) /
+      numFrom(this.toBytes().length + 4)
+    );
+  }
+
   estimateFee(feeRate: NumLike): Num {
     const txSize = this.toBytes().length + 4;
-    return (numFrom(txSize) * numFrom(feeRate) + numFrom(1000)) / numFrom(1000);
+    // + 999 then / 1000 to ceil the calculated fee
+    return (numFrom(txSize) * numFrom(feeRate) + numFrom(999)) / numFrom(1000);
   }
 
   async completeFee(
@@ -1577,8 +1808,11 @@ export class Transaction extends mol.Entity.Base<
     change: (tx: Transaction, capacity: Num) => Promise<NumLike> | NumLike,
     expectedFeeRate?: NumLike,
     filter?: ClientCollectableSearchKeyFilterLike,
+    options?: { feeRateBlockRange?: NumLike; maxFeeRate?: NumLike },
   ): Promise<[number, boolean]> {
-    const feeRate = expectedFeeRate ?? (await from.client.getFeeRate());
+    const feeRate =
+      expectedFeeRate ??
+      (await from.client.getFeeRate(options?.feeRateBlockRange, options));
 
     // Complete all inputs extra infos for cache
     await this.getInputsCapacity(from.client);
@@ -1609,27 +1843,21 @@ export class Transaction extends mol.Entity.Base<
         // The initial fee is calculated based on prepared transaction
         leastFee = tx.estimateFee(feeRate);
       }
-      const extraCapacity =
-        (await tx.getInputsCapacity(from.client)) - tx.getOutputsCapacity();
+      const fee = await tx.getFee(from.client);
       // The extra capacity paid the fee without a change
-      if (extraCapacity === leastFee) {
+      if (fee === leastFee) {
         this.copy(tx);
         return [collected, false];
       }
 
-      const needed = numFrom(
-        await Promise.resolve(change(tx, extraCapacity - leastFee)),
-      );
+      const needed = numFrom(await Promise.resolve(change(tx, fee - leastFee)));
       // No enough extra capacity to create new cells for change
       if (needed > Zero) {
         leastExtraCapacity = needed;
         continue;
       }
 
-      if (
-        (await tx.getInputsCapacity(from.client)) - tx.getOutputsCapacity() !==
-        leastFee
-      ) {
+      if ((await tx.getFee(from.client)) !== leastFee) {
         throw new Error(
           "The change function doesn't use all available capacity",
         );
@@ -1708,3 +1936,54 @@ export class Transaction extends mol.Entity.Base<
     );
   }
 }
+
+/**
+ * Calculate Nervos DAO profit between two blocks
+ */
+export function calcDaoProfit(
+  profitableCapacity: NumLike,
+  depositHeaderLike: ClientBlockHeaderLike,
+  withdrawHeaderLike: ClientBlockHeaderLike,
+): Num {
+  const depositHeader = ClientBlockHeader.from(depositHeaderLike);
+  const withdrawHeader = ClientBlockHeader.from(withdrawHeaderLike);
+
+  const profitableSize = numFrom(profitableCapacity);
+
+  return (
+    (profitableSize * withdrawHeader.dao.ar) / depositHeader.dao.ar -
+    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
+ */
+export function calcDaoClaimEpoch(
+  depositHeader: ClientBlockHeaderLike,
+  withdrawHeader: ClientBlockHeaderLike,
+): Epoch {
+  const depositEpoch = ClientBlockHeader.from(depositHeader).epoch;
+  const withdrawEpoch = ClientBlockHeader.from(withdrawHeader).epoch;
+  const intDiff = withdrawEpoch[0] - depositEpoch[0];
+  // deposit[1]    withdraw[1]
+  // ---------- <= -----------
+  // deposit[2]    withdraw[2]
+  if (
+    intDiff % numFrom(180) !== numFrom(0) ||
+    depositEpoch[1] * withdrawEpoch[2] <= depositEpoch[2] * withdrawEpoch[1]
+  ) {
+    return [
+      depositEpoch[0] + (intDiff / numFrom(180) + numFrom(1)) * numFrom(180),
+      depositEpoch[1],
+      depositEpoch[2],
+    ];
+  }
+
+  return [
+    depositEpoch[0] + (intDiff / numFrom(180)) * numFrom(180),
+    depositEpoch[1],
+    depositEpoch[2],
+  ];
+}