@ckb-ccc/core 1.5.3 → 1.7.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";
@@ -21,34 +24,6 @@ import {
   clientSearchKeyRangeFrom,
 } from "./clientTypes.advanced.js";
 
-/**
- * @public
- */
-export enum KnownScript {
-  NervosDao = "NervosDao",
-  Secp256k1Blake160 = "Secp256k1Blake160",
-  Secp256k1Multisig = "Secp256k1Multisig",
-  AnyoneCanPay = "AnyoneCanPay",
-  TypeId = "TypeId",
-  XUdt = "XUdt",
-  JoyId = "JoyId",
-  COTA = "COTA",
-  PWLock = "PWLock",
-  OmniLock = "OmniLock",
-  NostrLock = "NostrLock",
-  UniqueType = "UniqueType",
-
-  // ckb-proxy-locks https://github.com/ckb-devrel/ckb-proxy-locks
-  AlwaysSuccess = "AlwaysSuccess",
-  InputTypeProxyLock = "InputTypeProxyLock",
-  OutputTypeProxyLock = "OutputTypeProxyLock",
-  LockProxyLock = "LockProxyLock",
-  SingleUseLock = "SingleUseLock",
-  TypeBurnLock = "TypeBurnLock",
-  EasyToDiscoverType = "EasyToDiscoverType",
-  TimeLock = "TimeLock",
-}
-
 /**
  * @public
  */
@@ -67,6 +42,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 +73,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 +103,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 +181,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 +217,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 +265,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 +312,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 +540,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/index.ts

@@ -4,3 +4,4 @@ export * from "./clientPublicMainnet.js";
 export * from "./clientPublicTestnet.js";
 export * from "./clientTypes.js";
 export * from "./jsonRpc/index.js";
+export * from "./knownScript.js";

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

@@ -0,0 +1,27 @@
+/**
+ * @public
+ */
+export enum KnownScript {
+  NervosDao = "NervosDao",
+  Secp256k1Blake160 = "Secp256k1Blake160",
+  Secp256k1Multisig = "Secp256k1Multisig",
+  AnyoneCanPay = "AnyoneCanPay",
+  TypeId = "TypeId",
+  XUdt = "XUdt",
+  JoyId = "JoyId",
+  COTA = "COTA",
+  PWLock = "PWLock",
+  OmniLock = "OmniLock",
+  NostrLock = "NostrLock",
+  UniqueType = "UniqueType",
+
+  // ckb-proxy-locks https://github.com/ckb-devrel/ckb-proxy-locks
+  AlwaysSuccess = "AlwaysSuccess",
+  InputTypeProxyLock = "InputTypeProxyLock",
+  OutputTypeProxyLock = "OutputTypeProxyLock",
+  LockProxyLock = "LockProxyLock",
+  SingleUseLock = "SingleUseLock",
+  TypeBurnLock = "TypeBurnLock",
+  EasyToDiscoverType = "EasyToDiscoverType",
+  TimeLock = "TimeLock",
+}

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/num/index.ts

@@ -154,11 +154,31 @@ export function numLeToBytes(val: NumLike, bytes?: number): Bytes {
  * ```
  */
 export function numBeToBytes(val: NumLike, bytes?: number): Bytes {
-  const rawBytes = bytesFrom(numFrom(val).toString(16));
+  let num = numFrom(val);
+  if (num < numFrom(0)) {
+    if (bytes == null) {
+      throw Error(
+        "negative number can not be serialized without knowing bytes length",
+      );
+    }
+
+    // 0x100............00 - abs(num)
+    //    | . bytes * 8 .|
+    // 2's complement for negative number
+    num = (numFrom(1) << (numFrom(8) * numFrom(bytes))) + num;
+    if (num < 0) {
+      throw Error("negative number underflow");
+    }
+  }
+
+  const rawBytes = bytesFrom(num.toString(16));
   if (bytes == null) {
     return rawBytes;
   }
 
+  if (rawBytes.length > bytes) {
+    throw Error("number overflow");
+  }
   return bytesConcat("00".repeat(bytes - rawBytes.length), rawBytes);
 }
 

package/src/signer/ckb/signerCkbPublicKey.ts

@@ -104,12 +104,10 @@ export class SignerCkbPublicKey extends Signer {
 
     const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
     for (const input of tx.inputs) {
-      await input.completeExtraInfos(this.client);
-      if (!input.cellOutput) {
-        throw new Error("Unable to complete input");
-      }
+      const {
+        cellOutput: { lock },
+      } = await input.getCell(this.client);
 
-      const { lock } = input.cellOutput;
       if (scripts.some(({ script }) => script.eq(lock))) {
         continue;
       }

package/src/signer/nostr/index.ts

@@ -1,3 +1,4 @@
 export * from "./signerNostr.js";
 export * from "./signerNostrPrivateKey.js";
+export * from "./signerNostrPublicKeyReadonly.js";
 export * from "./verify.js";

package/src/signer/nostr/signerNostr.ts

@@ -50,7 +50,9 @@ export abstract class SignerNostr extends Signer {
    *
    * @returns A promise that resolves to the signed event.
    */
-  abstract signNostrEvent(event: NostrEvent): Promise<Required<NostrEvent>>;
+  async signNostrEvent(_event: NostrEvent): Promise<Required<NostrEvent>> {
+    throw Error("SignerNostr.signNostrEvent not implemented");
+  }
 
   /**
    * Sign a message.

package/src/signer/nostr/signerNostrPrivateKey.ts

@@ -1,25 +1,18 @@
 import { schnorr } from "@noble/curves/secp256k1";
 import { Client } from "../../client/index.js";
 import { Hex, hexFrom, HexLike } from "../../hex/index.js";
-import { NostrEvent, SignerNostr } from "./signerNostr.js";
+import { NostrEvent } from "./signerNostr.js";
+import { SignerNostrPublicKeyReadonly } from "./signerNostrPublicKeyReadonly.js";
 import { nostrEventHash } from "./verify.js";
 
-export class SignerNostrPrivateKey extends SignerNostr {
+export class SignerNostrPrivateKey extends SignerNostrPublicKeyReadonly {
   private readonly privateKey: Hex;
 
-  constructor(client: Client, privateKey: HexLike) {
-    super(client);
-    this.privateKey = hexFrom(privateKey);
-  }
-
-  async connect(): Promise<void> {}
-
-  async isConnected(): Promise<boolean> {
-    return true;
-  }
+  constructor(client: Client, privateKeyLike: HexLike) {
+    const privateKey = hexFrom(privateKeyLike);
+    super(client, schnorr.getPublicKey(privateKey.slice(2)));
 
-  async getNostrPublicKey(): Promise<Hex> {
-    return hexFrom(schnorr.getPublicKey(this.privateKey.slice(2)));
+    this.privateKey = privateKey;
   }
 
   async signNostrEvent(event: NostrEvent): Promise<Required<NostrEvent>> {

package/src/signer/nostr/signerNostrPublicKeyReadonly.ts

@@ -0,0 +1,29 @@
+import { bech32 } from "bech32";
+import { Client } from "../../client/index.js";
+import { Hex, hexFrom, HexLike } from "../../hex/index.js";
+import { SignerNostr } from "./signerNostr.js";
+
+export class SignerNostrPublicKeyReadonly extends SignerNostr {
+  public readonly publicKey: Hex;
+
+  constructor(client: Client, publicKey: HexLike) {
+    super(client);
+
+    if (typeof publicKey === "string" && publicKey.startsWith("npub")) {
+      const { words } = bech32.decode(publicKey);
+      this.publicKey = hexFrom(bech32.fromWords(words));
+    } else {
+      this.publicKey = hexFrom(publicKey);
+    }
+  }
+
+  async connect(): Promise<void> {}
+
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
+  async getNostrPublicKey(): Promise<Hex> {
+    return this.publicKey;
+  }
+}