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

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

@@ -18,6 +18,7 @@ import { ClientCacheMemory } from "./cache/memory.js";
 import { ClientCollectableSearchKeyLike } from "./clientTypes.advanced.js";
 import {
   ClientBlock,
+  ClientBlockHeader,
   ClientFindCellsResponse,
   ClientFindTransactionsGroupedResponse,
   ClientFindTransactionsResponse,
@@ -45,6 +46,7 @@ export enum KnownScript {
   UniqueType = "UniqueType",
   SingleUseLock = "SingleUseLock",
   OutputTypeProxyLock = "OutputTypeProxyLock",
+  NervosDao = "NervosDao",
 }
 
 /**
@@ -92,6 +94,7 @@ export abstract class Client {
   >;
 
   abstract getTip(): Promise<Num>;
+  abstract getTipHeader(verbosity?: number | null): Promise<ClientBlockHeader>;
   abstract getBlockByNumber(
     blockNumber: NumLike,
     verbosity?: number | null,
@@ -102,6 +105,20 @@ export abstract class Client {
     verbosity?: number | null,
     withCycles?: boolean | null,
   ): Promise<ClientBlock | undefined>;
+  abstract getHeaderByNumber(
+    blockNumber: NumLike,
+    verbosity?: number | null,
+  ): Promise<ClientBlockHeader | undefined>;
+  abstract getHeaderByHash(
+    blockHash: HexLike,
+    verbosity?: number | null,
+  ): Promise<ClientBlockHeader | undefined>;
+
+  abstract estimateCycles(transaction: TransactionLike): Promise<Num>;
+  abstract sendTransactionDry(
+    transaction: TransactionLike,
+    validator?: OutputsValidator,
+  ): Promise<Num>;
 
   abstract sendTransactionNoCache(
     transaction: TransactionLike,
@@ -155,7 +172,7 @@ export abstract class Client {
     return res;
   }
 
-  async *findCells(
+  async *findCellsOnChin(
     key: ClientIndexerSearchKeyLike,
     order?: "asc" | "desc",
     limit = 10,
@@ -185,7 +202,7 @@ export abstract class Client {
    * @param keyLike - The search key.
    * @returns A async generator for yielding cells.
    */
-  async *findCellsByCollectableSearchKey(
+  async *findCells(
     keyLike: ClientCollectableSearchKeyLike,
     order?: "asc" | "desc",
     limit = 10,
@@ -198,7 +215,7 @@ export abstract class Client {
       yield cell;
     }
 
-    for await (const cell of this.findCells(key, order, limit)) {
+    for await (const cell of this.findCellsOnChin(key, order, limit)) {
       if (
         (await this.cache.isUnusable(cell.outPoint)) ||
         foundedOutPoints.some((founded) => founded.eq(cell.outPoint))
@@ -217,7 +234,7 @@ export abstract class Client {
     order?: "asc" | "desc",
     limit = 10,
   ): AsyncGenerator<Cell> {
-    return this.findCellsByCollectableSearchKey(
+    return this.findCells(
       {
         script: lock,
         scriptType: "lock",
@@ -238,7 +255,7 @@ export abstract class Client {
     order?: "asc" | "desc",
     limit = 10,
   ): AsyncGenerator<Cell> {
-    return this.findCellsByCollectableSearchKey(
+    return this.findCells(
       {
         script: type,
         scriptType: "type",

package/src/client/clientPublicMainnet.advanced.ts

@@ -254,4 +254,21 @@ export const MAINNET_SCRIPTS: Record<
       },
     ],
   },
+  [KnownScript.NervosDao]: {
+    codeHash:
+      "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
+    hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xe2fb199810d49a4d8beec56718ba2593b665db9d52299a0f9e6e75416d73ff5c",
+            index: 2,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
 });

package/src/client/clientPublicTestnet.advanced.ts

@@ -265,4 +265,21 @@ export const TESTNET_SCRIPTS: Record<
       },
     ],
   },
+  [KnownScript.NervosDao]: {
+    codeHash:
+      "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
+    hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x8f8c79eb6671709633fe6a46de93c0fedc9c1b8a6527a18d3983879542635c9f",
+            index: 2,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
 });

package/src/client/clientTypes.ts

@@ -1,6 +1,13 @@
-import { Cell, 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,
@@ -181,8 +188,28 @@ export type ClientFindTransactionsGroupedResponse = {
  */
 export type ClientBlockHeader = {
   compactTarget: Num;
-  dao: Hex;
-  epoch: Num;
+  dao: {
+    /**
+     * C_i: the total issuance up to and including block i.
+     */
+    c: Num;
+    /**
+     * AR_i: the current accumulated rate at block i.
+     * AR_j / AR_i reflects the CKByte amount if one deposit 1 CKB to Nervos DAO at block i, and withdraw at block j.
+     */
+    ar: Num;
+    /**
+     * S_i: the total unissued secondary issuance up to and including block i,
+     * including unclaimed Nervos DAO compensation and treasury funds.
+     */
+    s: Num;
+    /**
+     * U_i: the total occupied capacities currently in the blockchain up to and including block i.
+     * Occupied capacity is the sum of capacities used to store all cells.
+     */
+    u: Num;
+  };
+  epoch: Epoch;
   extraHash: Hex;
   hash: Hex;
   nonce: Num;
@@ -211,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 {
@@ -88,7 +92,17 @@ export abstract class ClientJsonRpc extends Client {
   ) as () => Promise<Num>;
 
   /**
-   * Get block by block hash
+   * Get tip block header
+   *
+   * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
+   * @returns BlockHeader
+   */
+  getTipHeader = this.buildSender("get_tip_header", [], (b) =>
+    apply(JsonRpcTransformers.blockHeaderTo, b),
+  ) as Client["getTipHeader"];
+
+  /**
+   * Get block by block number
    *
    * @param blockNumber - The block number.
    * @param verbosity - result format which allows 0 and 2. (Optional, the default is 2.)
@@ -113,6 +127,56 @@ export abstract class ClientJsonRpc extends Client {
     apply(JsonRpcTransformers.blockTo, b),
   ) as Client["getBlockByHash"];
 
+  /**
+   * Get header by block number
+   *
+   * @param blockNumber - The block number.
+   * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
+   * @returns BlockHeader
+   */
+  getHeaderByNumber = this.buildSender(
+    "get_header_by_number",
+    [(v: NumLike) => numToHex(numFrom(v))],
+    (b) => apply(JsonRpcTransformers.blockHeaderTo, b),
+  ) as Client["getHeaderByNumber"];
+
+  /**
+   * Get header by block hash
+   *
+   * @param blockHash - The block hash.
+   * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
+   * @returns BlockHeader
+   */
+  getHeaderByHash = this.buildSender("get_header", [hexFrom], (b) =>
+    apply(JsonRpcTransformers.blockHeaderTo, b),
+  ) as Client["getHeaderByHash"];
+
+  /**
+   * Estimate cycles of a transaction.
+   *
+   * @param transaction - The transaction to estimate.
+   * @returns Consumed cycles
+   */
+  estimateCycles = this.buildSender(
+    "estimate_cycles",
+    [JsonRpcTransformers.transactionFrom],
+    ({ cycles }: { cycles: NumLike }) => numFrom(cycles),
+  ) as Client["estimateCycles"];
+
+  /**
+   * Test a transaction.
+   *
+   * @param transaction - The transaction to test.
+   * @param validator - "passthrough": Disable validation. "well_known_scripts_only": Only accept well known scripts in the transaction.
+   * @returns Consumed cycles
+   */
+
+  sendTransactionDry = this.buildSender(
+    "test_tx_pool_accept",
+    [JsonRpcTransformers.transactionFrom],
+    ({ cycles }: { cycles: NumLike }) => numFrom(cycles),
+  ) as Client["sendTransactionDry"];
+
   /**
    * Send a transaction to node.
    *
@@ -229,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/client/jsonRpc/transformers.ts

@@ -1,3 +1,4 @@
+import { bytesFrom } from "../../bytes/index.js";
 import {
   Cell,
   CellDep,
@@ -17,10 +18,11 @@ import {
   Transaction,
   TransactionLike,
   depTypeFrom,
+  epochFromHex,
   hashTypeFrom,
 } from "../../ckb/index.js";
 import { Hex, HexLike, hexFrom } from "../../hex/index.js";
-import { NumLike, numFrom, numToHex } from "../../num/index.js";
+import { NumLike, numFrom, numLeFromBytes, numToHex } from "../../num/index.js";
 import { apply } from "../../utils/index.js";
 import {
   ClientBlock,
@@ -201,10 +203,16 @@ export class JsonRpcTransformers {
     };
   }
   static blockHeaderTo(header: JsonRpcBlockHeader): ClientBlockHeader {
+    const dao = bytesFrom(header.dao);
     return {
       compactTarget: numFrom(header.compact_target),
-      dao: header.dao,
-      epoch: numFrom(header.epoch),
+      dao: {
+        c: numLeFromBytes(dao.slice(0, 8)),
+        ar: numLeFromBytes(dao.slice(8, 16)),
+        s: numLeFromBytes(dao.slice(16, 24)),
+        u: numLeFromBytes(dao.slice(24, 32)),
+      },
+      epoch: epochFromHex(header.epoch),
       extraHash: header.extra_hash,
       hash: header.hash,
       nonce: numFrom(header.nonce),

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
  * ```