@ckb-ccc/core 1.4.0 → 1.6.0

package/src/client/client.ts

@@ -9,11 +9,16 @@ import {
 } from "../ckb/index.js";
 import { Zero } from "../fixedPoint/index.js";
 import { Hex, HexLike, hexFrom } from "../hex/index.js";
-import { Num, NumLike, numFrom, numMax } from "../num/index.js";
+import { Num, NumLike, numFrom, numMax, numMin } from "../num/index.js";
 import { reduceAsync, sleep } from "../utils/index.js";
 import { ClientCache } from "./cache/index.js";
 import { ClientCacheMemory } from "./cache/memory.js";
-import { ClientCollectableSearchKeyLike } from "./clientTypes.advanced.js";
+import {
+  CONFIRMED_BLOCK_TIME,
+  ClientCollectableSearchKeyLike,
+  DEFAULT_MAX_FEE_RATE,
+  DEFAULT_MIN_FEE_RATE,
+} from "./clientTypes.advanced.js";
 import {
   CellDepInfo,
   CellDepInfoLike,
@@ -26,12 +31,17 @@ import {
   ClientIndexerSearchKeyLike,
   ClientIndexerSearchKeyTransactionLike,
   ClientTransactionResponse,
+  ErrorClientMaxFeeRateExceeded,
   ErrorClientWaitTransactionTimeout,
   KnownScript,
   OutputsValidator,
   ScriptInfo,
 } from "./clientTypes.js";
 
+function hasHeaderConfirmed(header: ClientBlockHeader): boolean {
+  return numFrom(Date.now()) - header.timestamp >= CONFIRMED_BLOCK_TIME;
+}
+
 /**
  * @public
  */
@@ -50,30 +60,113 @@ export abstract class Client {
   abstract getFeeRateStatistics(
     blockRange?: NumLike,
   ): Promise<{ mean: Num; median: Num }>;
-  async getFeeRate(blockRange?: NumLike): Promise<Num> {
-    return numMax((await this.getFeeRateStatistics(blockRange)).median, 1000);
+  async getFeeRate(
+    blockRange?: NumLike,
+    options?: { maxFeeRate?: NumLike },
+  ): Promise<Num> {
+    const feeRate = numMax(
+      (await this.getFeeRateStatistics(blockRange)).median,
+      DEFAULT_MIN_FEE_RATE,
+    );
+
+    const maxFeeRate = numFrom(options?.maxFeeRate ?? DEFAULT_MAX_FEE_RATE);
+    if (maxFeeRate === Zero) {
+      return feeRate;
+    }
+
+    return numMin(feeRate, maxFeeRate);
   }
 
   abstract getTip(): Promise<Num>;
   abstract getTipHeader(verbosity?: number | null): Promise<ClientBlockHeader>;
-  abstract getBlockByNumber(
+  abstract getBlockByNumberNoCache(
     blockNumber: NumLike,
     verbosity?: number | null,
     withCycles?: boolean | null,
   ): Promise<ClientBlock | undefined>;
-  abstract getBlockByHash(
+  abstract getBlockByHashNoCache(
     blockHash: HexLike,
     verbosity?: number | null,
     withCycles?: boolean | null,
   ): Promise<ClientBlock | undefined>;
-  abstract getHeaderByNumber(
+  abstract getHeaderByNumberNoCache(
     blockNumber: NumLike,
     verbosity?: number | null,
   ): Promise<ClientBlockHeader | undefined>;
-  abstract getHeaderByHash(
+  abstract getHeaderByHashNoCache(
     blockHash: HexLike,
     verbosity?: number | null,
   ): Promise<ClientBlockHeader | undefined>;
+  async getBlockByNumber(
+    blockNumber: NumLike,
+    verbosity?: number | null,
+    withCycles?: boolean | null,
+  ): Promise<ClientBlock | undefined> {
+    const block = await this.cache.getBlockByNumber(blockNumber);
+    if (block) {
+      return block;
+    }
+
+    const res = await this.getBlockByNumberNoCache(
+      blockNumber,
+      verbosity,
+      withCycles,
+    );
+    if (res && hasHeaderConfirmed(res.header)) {
+      await this.cache.recordBlocks(res);
+    }
+    return res;
+  }
+  async getBlockByHash(
+    blockHash: HexLike,
+    verbosity?: number | null,
+    withCycles?: boolean | null,
+  ): Promise<ClientBlock | undefined> {
+    const block = await this.cache.getBlockByHash(blockHash);
+    if (block) {
+      return block;
+    }
+
+    const res = await this.getBlockByHashNoCache(
+      blockHash,
+      verbosity,
+      withCycles,
+    );
+    if (res && hasHeaderConfirmed(res.header)) {
+      await this.cache.recordBlocks(res);
+    }
+    return res;
+  }
+  async getHeaderByNumber(
+    blockNumber: NumLike,
+    verbosity?: number | null,
+  ): Promise<ClientBlockHeader | undefined> {
+    const header = await this.cache.getHeaderByNumber(blockNumber);
+    if (header) {
+      return header;
+    }
+
+    const res = await this.getHeaderByNumberNoCache(blockNumber, verbosity);
+    if (res && hasHeaderConfirmed(res)) {
+      await this.cache.recordHeaders(res);
+    }
+    return res;
+  }
+  async getHeaderByHash(
+    blockHash: HexLike,
+    verbosity?: number | null,
+  ): Promise<ClientBlockHeader | undefined> {
+    const header = await this.cache.getHeaderByHash(blockHash);
+    if (header) {
+      return header;
+    }
+
+    const res = await this.getHeaderByHashNoCache(blockHash, verbosity);
+    if (res && hasHeaderConfirmed(res)) {
+      await this.cache.recordHeaders(res);
+    }
+    return res;
+  }
 
   abstract estimateCycles(transaction: TransactionLike): Promise<Num>;
   abstract sendTransactionDry(
@@ -97,25 +190,47 @@ export abstract class Client {
       return cached;
     }
 
-    const transaction = await this.getTransactionNoCache(outPoint.txHash);
+    const transaction = await this.getTransaction(outPoint.txHash);
     if (!transaction) {
       return;
     }
-
-    const index = Number(numFrom(outPoint.index));
-    if (index >= transaction.transaction.outputs.length) {
+    const output = transaction.transaction.getOutput(outPoint.index);
+    if (!output) {
       return;
     }
 
     const cell = Cell.from({
       outPoint,
-      cellOutput: transaction.transaction.outputs[index],
-      outputData: transaction.transaction.outputsData[index] ?? "0x",
+      ...output,
     });
     await this.cache.recordCells(cell);
     return cell;
   }
 
+  async getCellWithHeader(
+    outPointLike: OutPointLike,
+  ): Promise<{ cell: Cell; header?: ClientBlockHeader } | undefined> {
+    const outPoint = OutPoint.from(outPointLike);
+
+    const res = await this.getTransactionWithHeader(outPoint.txHash);
+    if (!res) {
+      return;
+    }
+    const { transaction, header } = res;
+
+    const output = transaction.transaction.getOutput(outPoint.index);
+    if (!output) {
+      return;
+    }
+
+    const cell = Cell.from({
+      outPoint,
+      ...output,
+    });
+    await this.cache.recordCells(cell);
+    return { cell, header };
+  }
+
   abstract getCellLiveNoCache(
     outPointLike: OutPointLike,
     withData?: boolean | null,
@@ -476,14 +591,19 @@ export abstract class Client {
   async sendTransaction(
     transaction: TransactionLike,
     validator?: OutputsValidator,
+    options?: { maxFeeRate?: NumLike },
   ): Promise<Hex> {
     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 txHash = await this.sendTransactionNoCache(tx, validator);
 
-    await this.cache.recordTransactions(tx);
     await this.cache.markTransactions(tx);
-
     return txHash;
   }
 
@@ -492,25 +612,48 @@ export abstract class Client {
   ): Promise<ClientTransactionResponse | undefined> {
     const txHash = hexFrom(txHashLike);
     const res = await this.getTransactionNoCache(txHash);
-    if (res?.transaction) {
+    if (res) {
+      await this.cache.recordTransactionResponses(res);
       return res;
     }
 
-    const tx = await this.cache.getTransaction(txHash);
-    if (!tx) {
-      return;
+    return this.cache.getTransactionResponse(txHash);
+  }
+
+  /**
+   * This method gets specified transaction with its block header (if existed).
+   * This is mainly for caching because we need the header to test if we can safely trust the cached tx status.
+   * @param txHashLike
+   */
+  async getTransactionWithHeader(
+    txHashLike: HexLike,
+  ): Promise<
+    | { transaction: ClientTransactionResponse; header?: ClientBlockHeader }
+    | undefined
+  > {
+    const txHash = hexFrom(txHashLike);
+    const tx = await this.cache.getTransactionResponse(txHash);
+    if (tx?.blockHash) {
+      const header = await this.getHeaderByHash(tx.blockHash);
+      if (header && hasHeaderConfirmed(header)) {
+        return {
+          transaction: tx,
+          header,
+        };
+      }
     }
 
+    const res = await this.getTransactionNoCache(txHash);
     if (!res) {
-      return {
-        transaction: tx,
-        status: "sent",
-      };
+      return;
     }
 
+    await this.cache.recordTransactionResponses(res);
     return {
-      ...res,
-      transaction: tx,
+      transaction: res,
+      header: res.blockHash
+        ? await this.getHeaderByHash(res.blockHash)
+        : undefined,
     };
   }
 
@@ -552,7 +695,7 @@ export abstract class Client {
       }
 
       if (Date.now() - startTime + interval >= timeout) {
-        throw new ErrorClientWaitTransactionTimeout();
+        throw new ErrorClientWaitTransactionTimeout(timeout);
       }
       await sleep(interval);
     }

package/src/client/clientPublicMainnet.ts

@@ -13,12 +13,24 @@ export class ClientPublicMainnet extends ClientJsonRpc {
       scripts?: Record<KnownScript, ScriptInfoLike | undefined>;
     },
   ) {
+    const hasWebSocket = typeof WebSocket !== "undefined";
     super(
       config?.url ??
-        (typeof WebSocket !== "undefined"
+        (hasWebSocket
           ? "wss://mainnet.ckb.dev/ws"
           : "https://mainnet.ckb.dev/"),
-      config,
+      {
+        ...config,
+        fallbacks:
+          config?.fallbacks ??
+          (hasWebSocket
+            ? [
+                "wss://mainnet.ckb.dev/ws",
+                "https://mainnet.ckb.dev/",
+                "https://mainnet.ckbapp.dev/",
+              ]
+            : ["https://mainnet.ckb.dev/", "https://mainnet.ckbapp.dev/"]),
+      },
     );
   }
 

package/src/client/clientPublicTestnet.ts

@@ -13,12 +13,24 @@ export class ClientPublicTestnet extends ClientJsonRpc {
       scripts?: Record<KnownScript, ScriptInfoLike | undefined>;
     },
   ) {
+    const hasWebSocket = typeof WebSocket !== "undefined";
     super(
       config?.url ??
-        (typeof WebSocket !== "undefined"
+        (hasWebSocket
           ? "wss://testnet.ckb.dev/ws"
           : "https://testnet.ckb.dev/"),
-      config,
+      {
+        ...config,
+        fallbacks:
+          config?.fallbacks ??
+          (hasWebSocket
+            ? [
+                "wss://testnet.ckb.dev/ws",
+                "https://testnet.ckb.dev/",
+                "https://testnet.ckbapp.dev/",
+              ]
+            : ["https://testnet.ckb.dev/", "https://testnet.ckbapp.dev/"]),
+      },
     );
   }
 

package/src/client/clientTypes.advanced.ts

@@ -2,6 +2,10 @@ import { ScriptLike } from "../ckb/index.js";
 import { HexLike } from "../hex/index.js";
 import { Num, numFrom, NumLike } from "../num/index.js";
 
+export const CONFIRMED_BLOCK_TIME = numFrom(1000 * 10 * 50); // 50 blocks * 10s
+export const DEFAULT_MAX_FEE_RATE = numFrom(10000000);
+export const DEFAULT_MIN_FEE_RATE = numFrom(1000);
+
 export function clientSearchKeyRangeFrom([a, b]: [NumLike, NumLike]): [
   Num,
   Num,