@ckb-ccc/core 0.0.13-alpha.7 → 0.0.13-alpha.8

package/src/client/cache/memory.ts

@@ -11,24 +11,32 @@ import { ClientCollectableSearchKeyLike } from "../clientTypes.advanced.js";
 import { ClientCache } from "./cache.js";
 import { filterCell } from "./memory.advanced.js";
 
-export class ClientCacheMemory implements ClientCache {
-  private readonly unusableOutPoints: OutPoint[] = [];
-  private readonly usableCells: Cell[] = [];
-  private readonly knownTransactions: Transaction[] = [];
-  private readonly knownCells: Cell[] = [];
+export class ClientCacheMemory extends ClientCache {
+  /**
+   * OutPoint => [isLive, Cell | OutPoint]
+   */
+  private readonly cells: Map<
+    string,
+    | [
+        false,
+        Pick<Cell, "outPoint"> &
+          Partial<Pick<Cell, "cellOutput" | "outputData">>,
+      ]
+    | [true, Cell]
+    | [undefined, Cell]
+  > = new Map();
+
+  /**
+   * TX Hash => Transaction
+   */
+  private readonly knownTransactions: Map<string, Transaction> = new Map();
 
   async markUsable(...cellLikes: (CellLike | CellLike[])[]): Promise<void> {
     cellLikes.flat().forEach((cellLike) => {
       const cell = Cell.from(cellLike).clone();
-      this.usableCells.push(cell);
-      this.knownCells.push(cell);
+      const outPointStr = hexFrom(cell.outPoint.toBytes());
 
-      const index = this.unusableOutPoints.findIndex((o) =>
-        cell.outPoint.eq(o),
-      );
-      if (index !== -1) {
-        this.unusableOutPoints.splice(index, 1);
-      }
+      this.cells.set(outPointStr, [true, cell]);
     });
   }
 
@@ -37,74 +45,74 @@ export class ClientCacheMemory implements ClientCache {
   ): Promise<void> {
     outPointLikes.flat().forEach((outPointLike) => {
       const outPoint = OutPoint.from(outPointLike);
-      this.unusableOutPoints.push(outPoint.clone());
+      const outPointStr = hexFrom(outPoint.toBytes());
 
-      const index = this.usableCells.findIndex((c) => c.outPoint.eq(outPoint));
-      if (index !== -1) {
-        this.usableCells.splice(index, 1);
+      const existed = this.cells.get(outPointStr);
+      if (existed) {
+        existed[0] = false;
+        return;
       }
+      this.cells.set(outPointStr, [false, { outPoint }]);
     });
   }
 
-  async markTransactions(
-    ...transactionLike: (TransactionLike | TransactionLike[])[]
-  ): Promise<void> {
-    await Promise.all(
-      transactionLike.flat().map(async (transactionLike) => {
-        const tx = Transaction.from(transactionLike);
-        const txHash = tx.hash();
-
-        await Promise.all(
-          tx.inputs.map((i) => this.markUnusable(i.previousOutput)),
-        );
-        await Promise.all(
-          tx.outputs.map((o, i) =>
-            this.markUsable({
-              cellOutput: o,
-              outputData: tx.outputsData[i],
-              outPoint: {
-                txHash,
-                index: i,
-              },
-            }),
-          ),
-        );
-      }),
-    );
+  async clear(): Promise<void> {
+    for (const val of this.cells.values()) {
+      val[0] = undefined;
+    }
   }
 
   async *findCells(
     keyLike: ClientCollectableSearchKeyLike,
   ): AsyncGenerator<Cell> {
-    for (const cell of this.usableCells) {
+    for (const [isLive, cell] of this.cells.values()) {
+      if (!isLive) {
+        continue;
+      }
       if (!filterCell(keyLike, cell)) {
         continue;
       }
 
-      yield cell;
+      yield cell.clone();
+    }
+  }
+  async getCell(outPointLike: OutPointLike): Promise<Cell | undefined> {
+    const outPoint = OutPoint.from(outPointLike);
+
+    const cell = this.cells.get(hexFrom(outPoint.toBytes()))?.[1];
+    if (cell && cell.cellOutput && cell.outputData) {
+      return Cell.from((cell as Cell).clone());
     }
   }
 
   async isUnusable(outPointLike: OutPointLike): Promise<boolean> {
     const outPoint = OutPoint.from(outPointLike);
-    return this.unusableOutPoints.find((o) => o.eq(outPoint)) !== undefined;
+
+    return !(this.cells.get(hexFrom(outPoint.toBytes()))?.[0] ?? true);
   }
 
   async recordTransactions(
     ...transactions: (TransactionLike | TransactionLike[])[]
   ): Promise<void> {
-    this.knownTransactions.push(...transactions.flat().map(Transaction.from));
+    transactions.flat().map((txLike) => {
+      const tx = Transaction.from(txLike);
+      this.knownTransactions.set(tx.hash(), tx);
+    });
   }
   async getTransaction(txHashLike: HexLike): Promise<Transaction | undefined> {
     const txHash = hexFrom(txHashLike);
-    return this.knownTransactions.find((tx) => tx.hash() === txHash);
+    return this.knownTransactions.get(txHash)?.clone();
   }
 
   async recordCells(...cells: (CellLike | CellLike[])[]): Promise<void> {
-    this.knownCells.push(...cells.flat().map(Cell.from));
-  }
-  async getCell(outPointLike: OutPointLike): Promise<Cell | undefined> {
-    const outPoint = OutPoint.from(outPointLike);
-    return this.knownCells.find((cell) => cell.outPoint.eq(outPoint));
+    cells.flat().map((cellLike) => {
+      const cell = Cell.from(cellLike);
+      const outPointStr = hexFrom(cell.outPoint.toBytes());
+
+      if (this.cells.get(outPointStr)) {
+        return;
+      }
+      this.cells.set(outPointStr, [undefined, cell]);
+    });
   }
 }

package/src/client/clientTypes.ts

@@ -1,6 +1,13 @@
-import { Cell, Epoch, Script, Transaction } from "../ckb/index.js";
-import { Hex, hexFrom } from "../hex/index.js";
-import { Num, NumLike } from "../num/index.js";
+import {
+  Cell,
+  Epoch,
+  OutPoint,
+  OutPointLike,
+  Script,
+  Transaction,
+} from "../ckb/index.js";
+import { Hex, HexLike, hexFrom } from "../hex/index.js";
+import { Num, NumLike, numFrom } from "../num/index.js";
 import { apply } from "../utils/index.js";
 import {
   ClientCollectableSearchKeyFilterLike,
@@ -231,3 +238,47 @@ export type ClientBlock = {
   transactions: Transaction[];
   uncles: ClientBlockUncle[];
 };
+
+export interface ErrorClientBaseLike {
+  message: string;
+  code: number;
+  data: string;
+}
+export class ErrorClientBase extends Error {
+  public readonly message: string;
+  public readonly code: number;
+  public readonly data: string;
+
+  constructor(origin: ErrorClientBaseLike) {
+    super(origin.message);
+    this.message = origin.message;
+    this.code = origin.code;
+    this.data = origin.data;
+  }
+}
+
+export class ErrorClientResolveUnknown extends ErrorClientBase {
+  public readonly outPoint: OutPoint;
+  constructor(origin: ErrorClientBaseLike, outPointLike: OutPointLike) {
+    super(origin);
+    this.outPoint = OutPoint.from(outPointLike);
+  }
+}
+
+export class ErrorClientVerification extends ErrorClientBase {
+  public readonly sourceIndex: Num;
+  public readonly scriptCodeHash: Hex;
+
+  constructor(
+    origin: ErrorClientBaseLike,
+    public readonly source: "lock" | "inputType" | "outputType",
+    sourceIndex: NumLike,
+    public readonly errorCode: number,
+    public readonly scriptHashType: "data" | "type",
+    scriptCodeHash: HexLike,
+  ) {
+    super(origin);
+    this.sourceIndex = numFrom(sourceIndex);
+    this.scriptCodeHash = hexFrom(scriptCodeHash);
+  }
+}

package/src/client/jsonRpc/index.ts

@@ -1,4 +1,4 @@
-import { TransactionLike } from "../../ckb/index.js";
+import { OutPoint, TransactionLike } from "../../ckb/index.js";
 import { Hex, HexLike, hexFrom } from "../../hex/index.js";
 import { Num, NumLike, numFrom, numToHex } from "../../num/index.js";
 import { apply } from "../../utils/index.js";
@@ -8,6 +8,10 @@ import {
   ClientFindCellsResponse,
   ClientIndexerSearchKeyLike,
   ClientTransactionResponse,
+  ErrorClientBase,
+  ErrorClientBaseLike,
+  ErrorClientResolveUnknown,
+  ErrorClientVerification,
   OutputsValidator,
 } from "../clientTypes.js";
 import {
@@ -289,7 +293,45 @@ export abstract class ClientJsonRpc extends Client {
         ),
       );
 
-      return transform(await this.send(payload), outTransformer);
+      try {
+        return transform(await this.send(payload), outTransformer);
+      } catch (errAny: unknown) {
+        if (typeof errAny !== "object" || errAny === null) {
+          throw errAny;
+        }
+        const err = errAny as ErrorClientBaseLike;
+
+        const unknownOutPointMatch = err.data.match(
+          new RegExp("Resolve\\(Unknown\\(OutPoint\\((0x.*)\\)\\)\\)"),
+        )?.[1];
+        if (unknownOutPointMatch) {
+          throw new ErrorClientResolveUnknown(
+            err,
+            OutPoint.fromBytes(unknownOutPointMatch),
+          );
+        }
+        const verificationFailedMatch = err.data.match(
+          new RegExp(
+            "Verification\\(Error { kind: Script, inner: TransactionScriptError { source: (Inputs|Outputs)\\[([0-9]*)\\].(Lock|Type), cause: ValidationFailure: see error code (-?[0-9])* on page https://nervosnetwork\\.github\\.io/ckb-script-error-codes/by-(type|data)-hash/(.*)\\.html",
+          ),
+        );
+        if (verificationFailedMatch) {
+          throw new ErrorClientVerification(
+            err,
+            verificationFailedMatch[3] === "Lock"
+              ? "lock"
+              : verificationFailedMatch[1] === "Inputs"
+                ? "inputType"
+                : "outputType",
+            verificationFailedMatch[2],
+            Number(verificationFailedMatch[4]),
+            verificationFailedMatch[5] === "data" ? "data" : "type",
+            verificationFailedMatch[6],
+          );
+        }
+
+        throw new ErrorClientBase(err);
+      }
     };
   }
 

package/src/fixedPoint/index.ts

@@ -24,8 +24,8 @@ export type FixedPointLike = bigint | string | number;
  * @example
  * ```typescript
  * const str = fixedPointToString(123456789n, 8); // Outputs "1.23456789"
- * const strFromString = fixedPointToString("123456789", 8); // Outputs "1.23456789"
- * const strFromNumber = fixedPointToString(123456789, 8); // Outputs "1.23456789"
+ * const strFromString = fixedPointToString("1.23456789", 8); // Outputs "1.23456789"
+ * const strFromNumber = fixedPointToString(1.23456789, 8); // Outputs "1.23456789"
  * ```
  */
 
@@ -54,7 +54,7 @@ export function fixedPointToString(val: FixedPointLike, decimals = 8): string {
  *
  * @example
  * ```typescript
- * const fixedPoint = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
+ * const fixedPoint = fixedPointFrom(123456789n, 8); // Outputs 123456789n
  * const fixedPointFromString = fixedPointFrom("1.23456789", 8); // Outputs 123456789n
  * const fixedPointFromNumber = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
  * ```