@ckb-ccc/core 1.4.0 → 1.6.0

package/src/client/clientTypes.ts

@@ -3,6 +3,7 @@ import {
   CellDep,
   CellDepLike,
   Epoch,
+  EpochLike,
   HashType,
   HashTypeLike,
   OutPoint,
@@ -10,6 +11,8 @@ import {
   Script,
   ScriptLike,
   Transaction,
+  TransactionLike,
+  epochFrom,
   hashTypeFrom,
 } from "../ckb/index.js";
 import { Hex, HexLike, hexFrom } from "../hex/index.js";
@@ -67,6 +70,10 @@ export class CellDepInfo {
   ) {}
 
   static from(cellDepInfoLike: CellDepInfoLike): CellDepInfo {
+    if (cellDepInfoLike instanceof CellDepInfo) {
+      return cellDepInfoLike;
+    }
+
     return new CellDepInfo(
       CellDep.from(cellDepInfoLike.cellDep),
       apply(Script.from, cellDepInfoLike.type),
@@ -94,6 +101,10 @@ export class ScriptInfo {
   ) {}
 
   static from(scriptInfoLike: ScriptInfoLike): ScriptInfo {
+    if (scriptInfoLike instanceof ScriptInfo) {
+      return scriptInfoLike;
+    }
+
     return new ScriptInfo(
       hexFrom(scriptInfoLike.codeHash),
       hashTypeFrom(scriptInfoLike.hashType),
@@ -120,15 +131,59 @@ export type TransactionStatus =
 /**
  * @public
  */
-export type ClientTransactionResponse = {
-  transaction: Transaction;
+export type ClientTransactionResponseLike = {
+  transaction: TransactionLike;
   status: TransactionStatus;
-  cycles?: Num;
-  blockHash?: Hex;
-  blockNumber?: Num;
-  txIndex?: Num;
+  cycles?: NumLike;
+  blockHash?: HexLike;
+  blockNumber?: NumLike;
+  txIndex?: NumLike;
   reason?: string;
 };
+/**
+ * @public
+ */
+export class ClientTransactionResponse {
+  constructor(
+    public transaction: Transaction,
+    public status: TransactionStatus,
+    public cycles?: Num,
+    public blockHash?: Hex,
+    public blockNumber?: Num,
+    public txIndex?: Num,
+    public reason?: string,
+  ) {}
+
+  static from(
+    responseLike: ClientTransactionResponseLike,
+  ): ClientTransactionResponse {
+    if (responseLike instanceof ClientTransactionResponse) {
+      return responseLike;
+    }
+
+    return new ClientTransactionResponse(
+      Transaction.from(responseLike.transaction),
+      responseLike.status,
+      apply(numFrom, responseLike.cycles),
+      apply(hexFrom, responseLike.blockHash),
+      apply(numFrom, responseLike.blockNumber),
+      apply(numFrom, responseLike.txIndex),
+      responseLike.reason,
+    );
+  }
+
+  clone() {
+    return new ClientTransactionResponse(
+      this.transaction.clone(),
+      this.status,
+      this.cycles,
+      this.blockHash,
+      this.blockNumber,
+      this.txIndex,
+      this.reason,
+    );
+  }
+}
 
 /**
  * @public
@@ -154,6 +209,10 @@ export class ClientIndexerSearchKeyFilter {
   static from(
     filterLike: ClientIndexerSearchKeyFilterLike,
   ): ClientIndexerSearchKeyFilter {
+    if (filterLike instanceof ClientIndexerSearchKeyFilter) {
+      return filterLike;
+    }
+
     return new ClientIndexerSearchKeyFilter(
       apply(Script.from, filterLike.script),
       apply(clientSearchKeyRangeFrom, filterLike.scriptLenRange),
@@ -186,6 +245,10 @@ export class ClientIndexerSearchKey {
   ) {}
 
   static from(keyLike: ClientIndexerSearchKeyLike): ClientIndexerSearchKey {
+    if (keyLike instanceof ClientIndexerSearchKey) {
+      return keyLike;
+    }
+
     return new ClientIndexerSearchKey(
       Script.from(keyLike.script),
       keyLike.scriptType,
@@ -230,6 +293,10 @@ export class ClientIndexerSearchKeyTransaction {
   static from(
     keyLike: ClientIndexerSearchKeyTransactionLike,
   ): ClientIndexerSearchKeyTransaction {
+    if (keyLike instanceof ClientIndexerSearchKeyTransaction) {
+      return keyLike;
+    }
+
     return new ClientIndexerSearchKeyTransaction(
       Script.from(keyLike.script),
       keyLike.scriptType,
@@ -273,58 +340,167 @@ export type ClientFindTransactionsGroupedResponse = {
 /**
  * @public
  */
-export type ClientBlockHeader = {
-  compactTarget: Num;
+export type ClientBlockHeaderLike = {
+  compactTarget: NumLike;
   dao: {
     /**
      * C_i: the total issuance up to and including block i.
      */
-    c: Num;
+    c: NumLike;
     /**
      * 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;
+    ar: NumLike;
     /**
      * S_i: the total unissued secondary issuance up to and including block i,
      * including unclaimed Nervos DAO compensation and treasury funds.
      */
-    s: Num;
+    s: NumLike;
     /**
      * 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;
+    u: NumLike;
   };
-  epoch: Epoch;
-  extraHash: Hex;
-  hash: Hex;
-  nonce: Num;
-  number: Num;
-  parentHash: Hex;
-  proposalsHash: Hex;
-  timestamp: Num;
-  transactionsRoot: Hex;
-  version: Num;
+  epoch: EpochLike;
+  extraHash: HexLike;
+  hash: HexLike;
+  nonce: NumLike;
+  number: NumLike;
+  parentHash: HexLike;
+  proposalsHash: HexLike;
+  timestamp: NumLike;
+  transactionsRoot: HexLike;
+  version: NumLike;
 };
+/**
+ * @public
+ */
+export class ClientBlockHeader {
+  constructor(
+    public compactTarget: Num,
+    public 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;
+    },
+    public epoch: Epoch,
+    public extraHash: Hex,
+    public hash: Hex,
+    public nonce: Num,
+    public number: Num,
+    public parentHash: Hex,
+    public proposalsHash: Hex,
+    public timestamp: Num,
+    public transactionsRoot: Hex,
+    public version: Num,
+  ) {}
+
+  static from(headerLike: ClientBlockHeaderLike): ClientBlockHeader {
+    if (headerLike instanceof ClientBlockHeader) {
+      return headerLike;
+    }
+
+    return new ClientBlockHeader(
+      numFrom(headerLike.compactTarget),
+      {
+        c: numFrom(headerLike.dao.c),
+        ar: numFrom(headerLike.dao.ar),
+        s: numFrom(headerLike.dao.s),
+        u: numFrom(headerLike.dao.u),
+      },
+      epochFrom(headerLike.epoch),
+      hexFrom(headerLike.extraHash),
+      hexFrom(headerLike.hash),
+      numFrom(headerLike.nonce),
+      numFrom(headerLike.number),
+      hexFrom(headerLike.parentHash),
+      hexFrom(headerLike.proposalsHash),
+      numFrom(headerLike.timestamp),
+      hexFrom(headerLike.transactionsRoot),
+      numFrom(headerLike.version),
+    );
+  }
+}
 
 /**
  * @public
  */
-export type ClientBlockUncle = {
-  header: ClientBlockHeader;
-  proposals: Hex[];
+export type ClientBlockUncleLike = {
+  header: ClientBlockHeaderLike;
+  proposals: HexLike[];
 };
+/**
+ * @public
+ */
+export class ClientBlockUncle {
+  constructor(
+    public header: ClientBlockHeader,
+    public proposals: Hex[],
+  ) {}
+
+  static from(uncleLike: ClientBlockUncleLike): ClientBlockUncle {
+    if (uncleLike instanceof ClientBlockUncle) {
+      return uncleLike;
+    }
+
+    return new ClientBlockUncle(
+      ClientBlockHeader.from(uncleLike.header),
+      uncleLike.proposals.map(hexFrom),
+    );
+  }
+}
 
 /**
  * @public
  */
-export type ClientBlock = {
-  header: ClientBlockHeader;
-  proposals: Hex[];
-  transactions: Transaction[];
-  uncles: ClientBlockUncle[];
+export type ClientBlockLike = {
+  header: ClientBlockHeaderLike;
+  proposals: HexLike[];
+  transactions: TransactionLike[];
+  uncles: ClientBlockUncleLike[];
 };
+/**
+ * @public
+ */
+export class ClientBlock {
+  constructor(
+    public header: ClientBlockHeader,
+    public proposals: Hex[],
+    public transactions: Transaction[],
+    public uncles: ClientBlockUncle[],
+  ) {}
+
+  static from(blockLike: ClientBlockLike): ClientBlock {
+    if (blockLike instanceof ClientBlock) {
+      return blockLike;
+    }
+
+    return new ClientBlock(
+      ClientBlockHeader.from(blockLike.header),
+      blockLike.proposals.map(hexFrom),
+      blockLike.transactions.map(Transaction.from),
+      blockLike.uncles.map(ClientBlockUncle.from),
+    );
+  }
+}
 
 export interface ErrorClientBaseLike {
   message?: string;
@@ -392,8 +568,23 @@ export class ErrorClientRBFRejected extends ErrorClientBase {
   }
 }
 
-export class ErrorClientWaitTransactionTimeout extends Error {
-  constructor() {
-    super("Wait transaction timeout");
+export class ErrorClientWaitTransactionTimeout extends ErrorClientBase {
+  constructor(timeoutLike: NumLike) {
+    const timeout = numFrom(timeoutLike).toString();
+    super({
+      message: `Wait transaction timeout ${timeout}ms`,
+      data: JSON.stringify({ timeout }),
+    });
+  }
+}
+
+export class ErrorClientMaxFeeRateExceeded extends ErrorClientBase {
+  constructor(limitLike: NumLike, actualLike: NumLike) {
+    const limit = numFrom(limitLike).toString();
+    const actual = numFrom(actualLike).toString();
+    super({
+      message: `Max fee rate exceeded limit ${limit}, actual ${actual}. Developer might forgot to complete transaction fee before sending. See https://docs.ckbccc.com/classes/_ckb_ccc_core.index.ccc.Transaction.html#completeFeeBy.`,
+      data: JSON.stringify({ limit, actual }),
+    });
   }
 }

package/src/client/jsonRpc/client.ts

@@ -169,11 +169,11 @@ export abstract class ClientJsonRpc extends Client {
    * @param withCycles - whether the return cycles of block transactions. (Optional, default false.)
    * @returns Block
    */
-  getBlockByNumber = this.buildSender(
+  getBlockByNumberNoCache = this.buildSender(
     "get_block_by_number",
     [(v: NumLike) => numToHex(numFrom(v))],
     (b: JsonRpcBlock) => apply(JsonRpcTransformers.blockTo, b),
-  ) as Client["getBlockByNumber"];
+  ) as Client["getBlockByNumberNoCache"];
 
   /**
    * Get block by block hash
@@ -183,9 +183,11 @@ export abstract class ClientJsonRpc extends Client {
    * @param withCycles - whether the return cycles of block transactions. (Optional, default false.)
    * @returns Block
    */
-  getBlockByHash = this.buildSender("get_block", [hexFrom], (b: JsonRpcBlock) =>
-    apply(JsonRpcTransformers.blockTo, b),
-  ) as Client["getBlockByHash"];
+  getBlockByHashNoCache = this.buildSender(
+    "get_block",
+    [hexFrom],
+    (b: JsonRpcBlock) => apply(JsonRpcTransformers.blockTo, b),
+  ) as Client["getBlockByHashNoCache"];
 
   /**
    * Get header by block number
@@ -194,11 +196,11 @@ export abstract class ClientJsonRpc extends Client {
    * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
    * @returns BlockHeader
    */
-  getHeaderByNumber = this.buildSender(
+  getHeaderByNumberNoCache = this.buildSender(
     "get_header_by_number",
     [(v: NumLike) => numToHex(numFrom(v))],
     (b: JsonRpcBlockHeader) => apply(JsonRpcTransformers.blockHeaderTo, b),
-  ) as Client["getHeaderByNumber"];
+  ) as Client["getHeaderByNumberNoCache"];
 
   /**
    * Get header by block hash
@@ -207,11 +209,11 @@ export abstract class ClientJsonRpc extends Client {
    * @param verbosity - result format which allows 0 and 1. (Optional, the default is 1.)
    * @returns BlockHeader
    */
-  getHeaderByHash = this.buildSender(
+  getHeaderByHashNoCache = this.buildSender(
     "get_header",
     [hexFrom],
     (b: JsonRpcBlockHeader) => apply(JsonRpcTransformers.blockHeaderTo, b),
-  ) as Client["getHeaderByHash"];
+  ) as Client["getHeaderByHashNoCache"];
 
   /**
    * Estimate cycles of a transaction.

package/src/client/jsonRpc/transformers.ts

@@ -192,7 +192,7 @@ export class JsonRpcTransformers {
       return;
     }
 
-    return {
+    return ClientTransactionResponse.from({
       transaction: JsonRpcTransformers.transactionTo(transaction),
       status,
       cycles: apply(numFrom, cycles),
@@ -200,7 +200,7 @@ export class JsonRpcTransformers {
       blockNumber: apply(numFrom, block_number),
       txIndex: apply(numFrom, tx_index),
       reason,
-    };
+    });
   }
   static blockHeaderTo(header: JsonRpcBlockHeader): ClientBlockHeader {
     const dao = bytesFrom(header.dao);

package/src/jsonRpc/requestor.ts

@@ -1,6 +1,7 @@
 import {
   JsonRpcPayload,
   Transport,
+  TransportFallback,
   transportFromUri,
 } from "./transports/advanced.js";
 
@@ -25,6 +26,7 @@ function transform(value: unknown, transformer?: (i: unknown) => unknown) {
 }
 
 export type RequestorJsonRpcConfig = {
+  fallbacks?: string[];
   timeout?: number;
   maxConcurrent?: number;
   transport?: Transport;
@@ -51,7 +53,14 @@ export class RequestorJsonRpc {
     private readonly onError?: (err: unknown) => Promise<void> | void,
   ) {
     this.maxConcurrent = config?.maxConcurrent;
-    this.transport = config?.transport ?? transportFromUri(url_, config);
+    this.transport =
+      config?.transport ??
+      new TransportFallback(
+        Array.from(
+          new Set([url_, ...(config?.fallbacks ?? [])]).values(),
+          (url) => transportFromUri(url, config),
+        ),
+      );
   }
 
   /**

package/src/jsonRpc/transports/advanced.ts

@@ -1,4 +1,5 @@
 export * from "./factory.js";
+export * from "./fallback.js";
 export * from "./http.js";
 export * from "./transport.js";
 export * from "./webSocket.js";

package/src/jsonRpc/transports/fallback.ts

@@ -0,0 +1,27 @@
+import { JsonRpcPayload, Transport } from "./transport.js";
+
+export class TransportFallback implements Transport {
+  // Current transport index
+  private i = 0;
+
+  constructor(private readonly transports: Transport[]) {}
+
+  async request(data: JsonRpcPayload): Promise<unknown> {
+    let triedCount = 0;
+
+    while (true) {
+      try {
+        return await this.transports[this.i % this.transports.length].request(
+          data,
+        );
+      } catch (err) {
+        triedCount += 1;
+        this.i += 1;
+
+        if (triedCount >= this.transports.length) {
+          throw err;
+        }
+      }
+    }
+  }
+}

package/src/jsonRpc/transports/webSocket.ts

@@ -87,24 +87,28 @@ export class TransportWebSocket implements Transport {
         reject,
         setTimeout(() => {
           this.ongoing.delete(data.id);
-          void socket.then((socket) => socket.close());
+          void socket
+            .then((socket) => socket.close())
+            .catch((err) => reject(err));
           reject(new Error("Request timeout"));
         }, this.timeout),
       ];
       this.ongoing.set(data.id, req);
 
-      void socket.then((socket) => {
-        if (
-          socket.readyState === socket.CLOSED ||
-          socket.readyState === socket.CLOSING
-        ) {
-          clearTimeout(req[2]);
-          this.ongoing.delete(data.id);
-          reject(new Error("Connection closed"));
-        } else {
-          socket.send(JSON.stringify(data));
-        }
-      });
+      void socket
+        .then((socket) => {
+          if (
+            socket.readyState === socket.CLOSED ||
+            socket.readyState === socket.CLOSING
+          ) {
+            clearTimeout(req[2]);
+            this.ongoing.delete(data.id);
+            reject(new Error("Connection closed"));
+          } else {
+            socket.send(JSON.stringify(data));
+          }
+        })
+        .catch((err) => reject(err));
     });
   }
 }

package/src/utils/index.ts

@@ -1,4 +1,4 @@
-import { NumLike, numFrom } from "../num/index.js";
+import { NumLike, numFrom, numToHex } from "../num/index.js";
 
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
@@ -183,3 +183,16 @@ export type Constructor<T> = {
 export function isWebview(userAgent: string): boolean {
   return /webview|wv|ip((?!.*Safari)|(?=.*like Safari))/i.test(userAgent);
 }
+
+/**
+ * @public
+ */
+export function stringify(val: unknown) {
+  return JSON.stringify(val, (_, value) => {
+    if (typeof value === "bigint") {
+      return numToHex(value);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return value;
+  });
+}