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

package/dist.commonjs/client/jsonRpc/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientJsonRpc = void 0;
-const index_js_1 = require("../../hex/index.js");
-const index_js_2 = require("../../num/index.js");
-const index_js_3 = require("../../utils/index.js");
+const index_js_1 = require("../../ckb/index.js");
+const index_js_2 = require("../../hex/index.js");
+const index_js_3 = require("../../num/index.js");
+const index_js_4 = require("../../utils/index.js");
 const client_js_1 = require("../client.js");
+const clientTypes_js_1 = require("../clientTypes.js");
 const advanced_js_1 = require("../transports/advanced.js");
 const advanced_js_2 = require("./advanced.js");
 /**
@@ -45,14 +47,14 @@ class ClientJsonRpc extends client_js_1.Client {
          *
          * @returns Tip block number
          */
-        this.getTip = this.buildSender("get_tip_block_number", [], index_js_2.numFrom);
+        this.getTip = this.buildSender("get_tip_block_number", [], index_js_3.numFrom);
         /**
          * Get tip block header
          *
          * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
          * @returns BlockHeader
          */
-        this.getTipHeader = this.buildSender("get_tip_header", [], (b) => (0, index_js_3.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
+        this.getTipHeader = this.buildSender("get_tip_header", [], (b) => (0, index_js_4.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
         /**
          * Get block by block number
          *
@@ -61,7 +63,7 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param withCycles - whether the return cycles of block transactions. (Optional, default false.)
          * @returns Block
          */
-        this.getBlockByNumber = this.buildSender("get_block_by_number", [(v) => (0, index_js_2.numToHex)((0, index_js_2.numFrom)(v))], (b) => (0, index_js_3.apply)(advanced_js_2.JsonRpcTransformers.blockTo, b));
+        this.getBlockByNumber = this.buildSender("get_block_by_number", [(v) => (0, index_js_3.numToHex)((0, index_js_3.numFrom)(v))], (b) => (0, index_js_4.apply)(advanced_js_2.JsonRpcTransformers.blockTo, b));
         /**
          * Get block by block hash
          *
@@ -70,7 +72,7 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param withCycles - whether the return cycles of block transactions. (Optional, default false.)
          * @returns Block
          */
-        this.getBlockByHash = this.buildSender("get_block", [index_js_1.hexFrom], (b) => (0, index_js_3.apply)(advanced_js_2.JsonRpcTransformers.blockTo, b));
+        this.getBlockByHash = this.buildSender("get_block", [index_js_2.hexFrom], (b) => (0, index_js_4.apply)(advanced_js_2.JsonRpcTransformers.blockTo, b));
         /**
          * Get header by block number
          *
@@ -78,7 +80,7 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
          * @returns BlockHeader
          */
-        this.getHeaderByNumber = this.buildSender("get_header_by_number", [(v) => (0, index_js_2.numToHex)((0, index_js_2.numFrom)(v))], (b) => (0, index_js_3.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
+        this.getHeaderByNumber = this.buildSender("get_header_by_number", [(v) => (0, index_js_3.numToHex)((0, index_js_3.numFrom)(v))], (b) => (0, index_js_4.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
         /**
          * Get header by block hash
          *
@@ -86,14 +88,14 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
          * @returns BlockHeader
          */
-        this.getHeaderByHash = this.buildSender("get_header", [index_js_1.hexFrom], (b) => (0, index_js_3.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
+        this.getHeaderByHash = this.buildSender("get_header", [index_js_2.hexFrom], (b) => (0, index_js_4.apply)(advanced_js_2.JsonRpcTransformers.blockHeaderTo, b));
         /**
          * Estimate cycles of a transaction.
          *
          * @param transaction - The transaction to estimate.
          * @returns Consumed cycles
          */
-        this.estimateCycles = this.buildSender("estimate_cycles", [advanced_js_2.JsonRpcTransformers.transactionFrom], ({ cycles }) => (0, index_js_2.numFrom)(cycles));
+        this.estimateCycles = this.buildSender("estimate_cycles", [advanced_js_2.JsonRpcTransformers.transactionFrom], ({ cycles }) => (0, index_js_3.numFrom)(cycles));
         /**
          * Test a transaction.
          *
@@ -101,7 +103,7 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param validator - "passthrough": Disable validation. "well_known_scripts_only": Only accept well known scripts in the transaction.
          * @returns Consumed cycles
          */
-        this.sendTransactionDry = this.buildSender("test_tx_pool_accept", [advanced_js_2.JsonRpcTransformers.transactionFrom], ({ cycles }) => (0, index_js_2.numFrom)(cycles));
+        this.sendTransactionDry = this.buildSender("test_tx_pool_accept", [advanced_js_2.JsonRpcTransformers.transactionFrom], ({ cycles }) => (0, index_js_3.numFrom)(cycles));
         /**
          * Send a transaction to node.
          *
@@ -109,14 +111,14 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param validator - "passthrough": Disable validation. "well_known_scripts_only": Only accept well known scripts in the transaction.
          * @returns Transaction hash.
          */
-        this.sendTransactionNoCache = this.buildSender("send_transaction", [advanced_js_2.JsonRpcTransformers.transactionFrom], index_js_1.hexFrom);
+        this.sendTransactionNoCache = this.buildSender("send_transaction", [advanced_js_2.JsonRpcTransformers.transactionFrom], index_js_2.hexFrom);
         /**
          * Get a transaction from node.
          *
          * @param txHash - The hash of the transaction.
          * @returns The transaction with status.
          */
-        this.getTransactionNoCache = this.buildSender("get_transaction", [index_js_1.hexFrom], advanced_js_2.JsonRpcTransformers.transactionResponseTo);
+        this.getTransactionNoCache = this.buildSender("get_transaction", [index_js_2.hexFrom], advanced_js_2.JsonRpcTransformers.transactionResponseTo);
         /**
          * find cells from node.
          *
@@ -129,7 +131,7 @@ class ClientJsonRpc extends client_js_1.Client {
         this.findCellsPagedNoCache = this.buildSender("get_cells", [
             advanced_js_2.JsonRpcTransformers.indexerSearchKeyFrom,
             (order) => order ?? "asc",
-            (limit) => (0, index_js_2.numToHex)(limit ?? 10),
+            (limit) => (0, index_js_3.numToHex)(limit ?? 10),
         ], advanced_js_2.JsonRpcTransformers.findCellsResponseTo);
         /**
          * find transactions from node.
@@ -143,7 +145,7 @@ class ClientJsonRpc extends client_js_1.Client {
         this.findTransactionsPaged = this.buildSender("get_transactions", [
             advanced_js_2.JsonRpcTransformers.indexerSearchKeyTransactionFrom,
             (order) => order ?? "asc",
-            (limit) => (0, index_js_2.numToHex)(limit ?? 10),
+            (limit) => (0, index_js_3.numToHex)(limit ?? 10),
         ], advanced_js_2.JsonRpcTransformers.findTransactionsResponseTo);
         /**
          * get cells capacity from node.
@@ -151,7 +153,7 @@ class ClientJsonRpc extends client_js_1.Client {
          * @param key - The search key of cells.
          * @returns The sum of cells capacity.
          */
-        this.getCellsCapacity = this.buildSender("get_cells_capacity", [advanced_js_2.JsonRpcTransformers.indexerSearchKeyFrom], ({ capacity }) => (0, index_js_2.numFrom)(capacity));
+        this.getCellsCapacity = this.buildSender("get_cells_capacity", [advanced_js_2.JsonRpcTransformers.indexerSearchKeyFrom], ({ capacity }) => (0, index_js_3.numFrom)(capacity));
         this.transport = (0, advanced_js_1.transportFromUri)(url_, config);
     }
     /**
@@ -162,6 +164,21 @@ class ClientJsonRpc extends client_js_1.Client {
     get url() {
         return this.url_;
     }
+    /**
+     * Get a live cell from node.
+     *
+     * @param outPoint - The out point of the cell.
+     * @param withData - Include data in the response.
+     * @param includeTxPool - Include cells in the tx pool.
+     * @returns The cell
+     */
+    getCellLiveNoCache(outPoint, withData, includeTxPool) {
+        return this.buildSender("get_live_cell", [advanced_js_2.JsonRpcTransformers.outPointFrom], ({ cell, }) => (0, index_js_4.apply)(({ output, data, }) => index_js_1.Cell.from({
+            cellOutput: advanced_js_2.JsonRpcTransformers.cellOutputTo(output),
+            outputData: data?.content ?? "0x",
+            outPoint,
+        }), cell))(outPoint, withData ?? true, includeTxPool);
+    }
     /**
      * Builds a sender function for a JSON-RPC method.
      *
@@ -175,7 +192,31 @@ class ClientJsonRpc extends client_js_1.Client {
             const payload = ClientJsonRpc.buildPayload(rpcMethod, await Promise.all(req
                 .concat(Array.from(new Array(Math.max(inTransformers.length - req.length, 0))))
                 .map((v, i) => transform(v, inTransformers[i]))));
-            return transform(await this.send(payload), outTransformer);
+            try {
+                return transform(await this.send(payload), outTransformer);
+            }
+            catch (errAny) {
+                if (typeof errAny !== "object" ||
+                    errAny === null ||
+                    !("data" in errAny) ||
+                    typeof errAny.data !== "string") {
+                    throw errAny;
+                }
+                const err = errAny;
+                const unknownOutPointMatch = err.data.match(new RegExp("Resolve\\(Unknown\\(OutPoint\\((0x.*)\\)\\)\\)"))?.[1];
+                if (unknownOutPointMatch) {
+                    throw new clientTypes_js_1.ErrorClientResolveUnknown(err, index_js_1.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 clientTypes_js_1.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 clientTypes_js_1.ErrorClientBase(err);
+            }
         };
     }
     /**

package/dist.commonjs/fixedPoint/index.d.ts

@@ -20,8 +20,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"
  * ```
  */
 export declare function fixedPointToString(val: FixedPointLike, decimals?: number): string;
@@ -35,7 +35,7 @@ export declare function fixedPointToString(val: FixedPointLike, decimals?: numbe
  *
  * @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
  * ```

package/dist.commonjs/fixedPoint/index.js

@@ -16,8 +16,8 @@ exports.One = exports.Zero = exports.fixedPointFrom = exports.fixedPointToString
  * @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"
  * ```
  */
 function fixedPointToString(val, decimals = 8) {
@@ -43,7 +43,7 @@ exports.fixedPointToString = fixedPointToString;
  *
  * @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
  * ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckb-ccc/core",
-  "version": "0.0.13-alpha.7",
+  "version": "0.0.13",
   "description": "Core of CCC - CKBer's Codebase",
   "author": "Hanssen0 <hanssen0@hanssen0.com>",
   "license": "MIT",

package/src/client/cache/cache.ts

@@ -8,23 +8,68 @@ import {
 import { HexLike } from "../../hex/index.js";
 import { ClientCollectableSearchKeyLike } from "../clientTypes.advanced.js";
 
-export interface ClientCache {
-  markUsable(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
-  markUnusable(
+export abstract class ClientCache {
+  abstract markUsable(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
+  abstract markUnusable(
     ...outPointLike: (OutPointLike | OutPointLike[])[]
   ): Promise<void>;
-  markTransactions(
+  async markTransactions(
     ...transactionLike: (TransactionLike | TransactionLike[])[]
-  ): Promise<void>;
+  ): Promise<void> {
+    await Promise.all([
+      this.recordTransactions(...transactionLike),
+      ...transactionLike.flat().map((transactionLike) => {
+        const tx = Transaction.from(transactionLike);
+        const txHash = tx.hash();
 
-  isUnusable(outPointLike: OutPointLike): Promise<boolean>;
+        return Promise.all([
+          ...tx.inputs.map((i) => this.markUnusable(i.previousOutput)),
+          ...tx.outputs.map((o, i) =>
+            this.markUsable({
+              cellOutput: o,
+              outputData: tx.outputsData[i],
+              outPoint: {
+                txHash,
+                index: i,
+              },
+            }),
+          ),
+        ]);
+      }),
+    ]);
+  }
+  abstract clear(): Promise<void>;
+  abstract findCells(
+    filter: ClientCollectableSearchKeyLike,
+  ): AsyncGenerator<Cell>;
+  /**
+   * Get a known cell by out point
+   * @param _outPoint
+   */
+  abstract getCell(_outPoint: OutPointLike): Promise<Cell | undefined>;
+  abstract isUnusable(outPointLike: OutPointLike): Promise<boolean>;
 
-  recordTransactions(
-    ...transactions: (TransactionLike | TransactionLike[])[]
-  ): Promise<void>;
-  getTransaction(txHash: HexLike): Promise<Transaction | undefined>;
+  /**
+   * Record known transactions
+   * Implement this method to enable transactions query caching
+   * @param _transactions
+   */
+  async recordTransactions(
+    ..._transactions: (TransactionLike | TransactionLike[])[]
+  ): Promise<void> {}
+  /**
+   * Get a known transaction by hash
+   * Implement this method to enable transactions query caching
+   * @param _txHash
+   */
+  async getTransaction(_txHash: HexLike): Promise<Transaction | undefined> {
+    return;
+  }
 
-  recordCells(...cells: (CellLike | CellLike[])[]): Promise<void>;
-  getCell(outPoint: OutPointLike): Promise<Cell | undefined>;
-  findCells(filter: ClientCollectableSearchKeyLike): AsyncGenerator<Cell>;
+  /**
+   * Record known cells
+   * Implement this method to enable cells query caching
+   * @param _cells
+   */
+  async recordCells(..._cells: (CellLike | CellLike[])[]): Promise<void> {}
 }

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/client.ts

@@ -155,6 +155,27 @@ export abstract class Client {
     return cell;
   }
 
+  abstract getCellLiveNoCache(
+    outPointLike: OutPointLike,
+    withData?: boolean | null,
+    includeTxPool?: boolean | null,
+  ): Promise<Cell | undefined>;
+  async getCellLive(
+    outPointLike: OutPointLike,
+    withData?: boolean | null,
+    includeTxPool?: boolean | null,
+  ): Promise<Cell | undefined> {
+    const cell = await this.getCellLiveNoCache(
+      outPointLike,
+      withData,
+      includeTxPool,
+    );
+    if (withData && cell) {
+      await this.cache.recordCells(cell);
+    }
+    return cell;
+  }
+
   abstract findCellsPagedNoCache(
     key: ClientIndexerSearchKeyLike,
     order?: "asc" | "desc",

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,45 @@ export type ClientBlock = {
   transactions: Transaction[];
   uncles: ClientBlockUncle[];
 };
+
+export interface ErrorClientBaseLike {
+  message?: string;
+  code?: number;
+  data: string;
+}
+export class ErrorClientBase extends Error {
+  public readonly code?: number;
+  public readonly data: string;
+
+  constructor(origin: ErrorClientBaseLike) {
+    super(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);
+  }
+}