@ckb-ccc/core 1.6.0 → 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,
@@ -275,6 +281,127 @@ export class Cell {
     );
   }
 
+  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
    *
@@ -525,14 +652,29 @@ export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
     );
   }
 
+  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> {
@@ -549,6 +691,15 @@ export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
     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;
@@ -701,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({
@@ -1013,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);
-
-        if (!input.cellOutput) {
-          throw new Error("Unable to complete input");
-        }
+        const { cellOutput } = await input.getCell(client);
 
-        if (!script.eq(input.cellOutput.lock)) {
+        if (!script.eq(cellOutput.lock)) {
           continue;
         }
 
@@ -1064,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;
       }
@@ -1098,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;
       }
     }
@@ -1129,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;
       }
     }
@@ -1276,6 +1413,10 @@ export class Transaction extends mol.Entity.Base<
    * ```
    */
   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));
   }
 
@@ -1365,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(
@@ -1374,7 +1530,7 @@ export class Transaction extends mol.Entity.Base<
       );
     }
 
-    this.witnesses[index] = hexFrom(witness.toBytes());
+    this.witnesses[index] = hexFrom(witness);
   }
 
   /**
@@ -1405,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,
@@ -1430,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),
     );
@@ -1594,25 +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.addInput(cell);
-      return 1;
+    if (accumulated === undefined) {
+      return addedCount;
     }
 
     throw new Error(`Insufficient CKB, need at least one new cell`);
@@ -1629,13 +1786,13 @@ export class Transaction extends mol.Entity.Base<
     return this.completeInputsAddOne(from, filter);
   }
 
-  async fee(client: Client): Promise<Num> {
+  async getFee(client: Client): Promise<Num> {
     return (await this.getInputsCapacity(client)) - this.getOutputsCapacity();
   }
 
-  async feeRate(client: Client): Promise<Num> {
+  async getFeeRate(client: Client): Promise<Num> {
     return (
-      ((await this.fee(client)) * numFrom(1000)) /
+      ((await this.getFee(client)) * numFrom(1000)) /
       numFrom(this.toBytes().length + 4)
     );
   }
@@ -1686,7 +1843,7 @@ export class Transaction extends mol.Entity.Base<
         // The initial fee is calculated based on prepared transaction
         leastFee = tx.estimateFee(feeRate);
       }
-      const fee = await tx.fee(from.client);
+      const fee = await tx.getFee(from.client);
       // The extra capacity paid the fee without a change
       if (fee === leastFee) {
         this.copy(tx);
@@ -1700,7 +1857,7 @@ export class Transaction extends mol.Entity.Base<
         continue;
       }
 
-      if ((await tx.fee(from.client)) !== leastFee) {
+      if ((await tx.getFee(from.client)) !== leastFee) {
         throw new Error(
           "The change function doesn't use all available capacity",
         );
@@ -1779,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],
+  ];
+}

package/src/client/client.ts

@@ -33,10 +33,10 @@ import {
   ClientTransactionResponse,
   ErrorClientMaxFeeRateExceeded,
   ErrorClientWaitTransactionTimeout,
-  KnownScript,
   OutputsValidator,
   ScriptInfo,
 } from "./clientTypes.js";
+import { KnownScript } from "./knownScript.js";
 
 function hasHeaderConfirmed(header: ClientBlockHeader): boolean {
   return numFrom(Date.now()) - header.timestamp >= CONFIRMED_BLOCK_TIME;
@@ -295,6 +295,7 @@ export abstract class Client {
 
   /**
    * Find cells by search key designed for collectable cells.
+   * The result also includes cached cells, the order param only works for cells fetched from RPC.
    *
    * @param keyLike - The search key.
    * @returns A async generator for yielding cells.
@@ -596,9 +597,9 @@ export abstract class Client {
     const tx = Transaction.from(transaction);
 
     const maxFeeRate = numFrom(options?.maxFeeRate ?? DEFAULT_MAX_FEE_RATE);
-    const fee = await tx.feeRate(this);
-    if (maxFeeRate > Zero && fee > maxFeeRate) {
-      throw new ErrorClientMaxFeeRateExceeded(maxFeeRate, fee);
+    const feeRate = await tx.getFeeRate(this);
+    if (maxFeeRate > Zero && feeRate > maxFeeRate) {
+      throw new ErrorClientMaxFeeRateExceeded(maxFeeRate, feeRate);
     }
 
     const txHash = await this.sendTransactionNoCache(tx, validator);

package/src/client/clientPublicMainnet.advanced.ts

@@ -1,4 +1,5 @@
-import { KnownScript, ScriptInfoLike } from "./clientTypes.js";
+import { ScriptInfoLike } from "./clientTypes.js";
+import { KnownScript } from "./knownScript.js";
 
 export const MAINNET_SCRIPTS: Record<KnownScript, ScriptInfoLike | undefined> =
   Object.freeze({

package/src/client/clientPublicMainnet.ts

@@ -1,7 +1,8 @@
 import WebSocket from "isomorphic-ws";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced.js";
-import { KnownScript, ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
+import { ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc, ClientJsonRpcConfig } from "./jsonRpc/index.js";
+import { KnownScript } from "./knownScript.js";
 
 /**
  * @public

package/src/client/clientPublicTestnet.advanced.ts

@@ -1,4 +1,5 @@
-import { KnownScript, ScriptInfoLike } from "./clientTypes.js";
+import { ScriptInfoLike } from "./clientTypes.js";
+import { KnownScript } from "./knownScript.js";
 
 export const TESTNET_SCRIPTS: Record<KnownScript, ScriptInfoLike> =
   Object.freeze({

package/src/client/clientPublicTestnet.ts

@@ -1,7 +1,8 @@
 import WebSocket from "isomorphic-ws";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced.js";
-import { KnownScript, ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
+import { ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc, ClientJsonRpcConfig } from "./jsonRpc/index.js";
+import { KnownScript } from "./knownScript.js";
 
 /**
  * @public

package/src/client/clientTypes.ts

@@ -24,34 +24,6 @@ import {
   clientSearchKeyRangeFrom,
 } from "./clientTypes.advanced.js";
 
-/**
- * @public
- */
-export enum KnownScript {
-  NervosDao = "NervosDao",
-  Secp256k1Blake160 = "Secp256k1Blake160",
-  Secp256k1Multisig = "Secp256k1Multisig",
-  AnyoneCanPay = "AnyoneCanPay",
-  TypeId = "TypeId",
-  XUdt = "XUdt",
-  JoyId = "JoyId",
-  COTA = "COTA",
-  PWLock = "PWLock",
-  OmniLock = "OmniLock",
-  NostrLock = "NostrLock",
-  UniqueType = "UniqueType",
-
-  // ckb-proxy-locks https://github.com/ckb-devrel/ckb-proxy-locks
-  AlwaysSuccess = "AlwaysSuccess",
-  InputTypeProxyLock = "InputTypeProxyLock",
-  OutputTypeProxyLock = "OutputTypeProxyLock",
-  LockProxyLock = "LockProxyLock",
-  SingleUseLock = "SingleUseLock",
-  TypeBurnLock = "TypeBurnLock",
-  EasyToDiscoverType = "EasyToDiscoverType",
-  TimeLock = "TimeLock",
-}
-
 /**
  * @public
  */

package/src/client/index.ts

@@ -4,3 +4,4 @@ export * from "./clientPublicMainnet.js";
 export * from "./clientPublicTestnet.js";
 export * from "./clientTypes.js";
 export * from "./jsonRpc/index.js";
+export * from "./knownScript.js";

package/src/client/knownScript.ts

@@ -0,0 +1,27 @@
+/**
+ * @public
+ */
+export enum KnownScript {
+  NervosDao = "NervosDao",
+  Secp256k1Blake160 = "Secp256k1Blake160",
+  Secp256k1Multisig = "Secp256k1Multisig",
+  AnyoneCanPay = "AnyoneCanPay",
+  TypeId = "TypeId",
+  XUdt = "XUdt",
+  JoyId = "JoyId",
+  COTA = "COTA",
+  PWLock = "PWLock",
+  OmniLock = "OmniLock",
+  NostrLock = "NostrLock",
+  UniqueType = "UniqueType",
+
+  // ckb-proxy-locks https://github.com/ckb-devrel/ckb-proxy-locks
+  AlwaysSuccess = "AlwaysSuccess",
+  InputTypeProxyLock = "InputTypeProxyLock",
+  OutputTypeProxyLock = "OutputTypeProxyLock",
+  LockProxyLock = "LockProxyLock",
+  SingleUseLock = "SingleUseLock",
+  TypeBurnLock = "TypeBurnLock",
+  EasyToDiscoverType = "EasyToDiscoverType",
+  TimeLock = "TimeLock",
+}

package/src/num/index.ts

@@ -154,11 +154,31 @@ export function numLeToBytes(val: NumLike, bytes?: number): Bytes {
  * ```
  */
 export function numBeToBytes(val: NumLike, bytes?: number): Bytes {
-  const rawBytes = bytesFrom(numFrom(val).toString(16));
+  let num = numFrom(val);
+  if (num < numFrom(0)) {
+    if (bytes == null) {
+      throw Error(
+        "negative number can not be serialized without knowing bytes length",
+      );
+    }
+
+    // 0x100............00 - abs(num)
+    //    | . bytes * 8 .|
+    // 2's complement for negative number
+    num = (numFrom(1) << (numFrom(8) * numFrom(bytes))) + num;
+    if (num < 0) {
+      throw Error("negative number underflow");
+    }
+  }
+
+  const rawBytes = bytesFrom(num.toString(16));
   if (bytes == null) {
     return rawBytes;
   }
 
+  if (rawBytes.length > bytes) {
+    throw Error("number overflow");
+  }
   return bytesConcat("00".repeat(bytes - rawBytes.length), rawBytes);
 }
 

package/src/signer/ckb/signerCkbPublicKey.ts

@@ -104,12 +104,10 @@ export class SignerCkbPublicKey extends Signer {
 
     const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
     for (const input of tx.inputs) {
-      await input.completeExtraInfos(this.client);
-      if (!input.cellOutput) {
-        throw new Error("Unable to complete input");
-      }
+      const {
+        cellOutput: { lock },
+      } = await input.getCell(this.client);
 
-      const { lock } = input.cellOutput;
       if (scripts.some(({ script }) => script.eq(lock))) {
         continue;
       }

package/src/signer/nostr/index.ts

@@ -1,3 +1,4 @@
 export * from "./signerNostr.js";
 export * from "./signerNostrPrivateKey.js";
+export * from "./signerNostrPublicKeyReadonly.js";
 export * from "./verify.js";