@ckb-ccc/core 1.0.0 → 1.1.0

package/src/bytes/index.ts

@@ -10,6 +10,41 @@ export type Bytes = Uint8Array;
  */
 export type BytesLike = string | Uint8Array | ArrayBuffer | ArrayLike<number>;
 
+/**
+ * Concatenates multiple byte-like arrays to the first number array.
+ * @public
+ *
+ * @param result - The number array as result
+ * @param args - The byte-like arrays to concatenate.
+ * @returns The first number array
+ *
+ * @example
+ * ```typescript
+ * const concatenatedBytes = [1, 2];
+ * bytesConcatTo(
+ *   concatenatedBytes
+ *   new Uint8Array([3, 4]),
+ *   "hello",
+ *   [5, 6, 7]
+ * );
+ * console.log(concatenatedBytes); // Outputs [1, 2, 3, 4, /* bytes of "hello" *\/, 5, 6, 7]
+ * ```
+ */
+
+export function bytesConcatTo(
+  result: number[],
+  ...args: BytesLike[]
+): number[] {
+  return args.reduce((acc: number[], v) => {
+    const bytes = bytesFrom(v);
+    // Spread operator will cause call stack size exceeded
+    for (const byte of bytes) {
+      result.push(byte);
+    }
+    return acc;
+  }, result);
+}
+
 /**
  * Concatenates multiple byte-like arrays into a single byte array.
  * @public
@@ -30,12 +65,7 @@ export type BytesLike = string | Uint8Array | ArrayBuffer | ArrayLike<number>;
  */
 
 export function bytesConcat(...args: BytesLike[]): Bytes {
-  return new Uint8Array(
-    args.reduce((acc: number[], v) => {
-      acc.push(...bytesFrom(v));
-      return acc;
-    }, []),
-  );
+  return new Uint8Array(bytesConcatTo([], ...args));
 }
 
 /**

package/src/ckb/script.ts

@@ -108,13 +108,11 @@ export type ScriptLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      codeHash: mol.Byte32,
-      hashType: HashTypeCodec,
-      args: mol.Bytes,
-    })
-    .map({ outMap: (decoded) => Script.from(decoded) }),
+  mol.table({
+    codeHash: mol.Byte32,
+    hashType: HashTypeCodec,
+    args: mol.Bytes,
+  }),
 )
 export class Script extends mol.Entity.Base<ScriptLike, Script>() {
   /**

package/src/ckb/transaction.ts

@@ -1,6 +1,6 @@
-import { ClientCollectableSearchKeyFilterLike } from "../advancedBarrel.js";
 import { Bytes, BytesLike, bytesFrom } from "../bytes/index.js";
-import { CellDepInfoLike, Client, KnownScript } from "../client/index.js";
+import type { ClientCollectableSearchKeyFilterLike } from "../client/clientTypes.advanced.js";
+import type { CellDepInfoLike, Client, KnownScript } from "../client/index.js";
 import {
   Zero,
   fixedPointFrom,
@@ -17,11 +17,11 @@ import {
   numToBytes,
   numToHex,
 } from "../num/index.js";
-import { Signer } from "../signer/index.js";
+import type { Signer } from "../signer/index.js";
 import { apply, reduceAsync } from "../utils/index.js";
 import { Script, ScriptLike, ScriptOpt } from "./script.js";
 import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced.js";
-import { LumosTransactionSkeletonType } from "./transactionLumos.js";
+import type { LumosTransactionSkeletonType } from "./transactionLumos.js";
 
 export const DepTypeCodec: mol.Codec<DepTypeLike, DepType> = mol.Codec.from({
   byteLength: 1,
@@ -119,12 +119,10 @@ export type OutPointLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .struct({
-      txHash: mol.Byte32,
-      index: mol.Uint32,
-    })
-    .map({ outMap: (decoded) => OutPoint.from(decoded) }),
+  mol.struct({
+    txHash: mol.Byte32,
+    index: mol.Uint32,
+  }),
 )
 export class OutPoint extends mol.Entity.Base<OutPointLike, OutPoint>() {
   /**
@@ -172,13 +170,11 @@ export type CellOutputLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      capacity: mol.Uint64,
-      lock: Script,
-      type: ScriptOpt,
-    })
-    .map({ outMap: (decoded) => CellOutput.from(decoded) }),
+  mol.table({
+    capacity: mol.Uint64,
+    lock: Script,
+    type: ScriptOpt,
+  }),
 )
 export class CellOutput extends mol.Entity.Base<CellOutputLike, CellOutput>() {
   /**
@@ -347,10 +343,7 @@ export type SinceLike =
  * @public
  */
 @mol.codec(
-  mol.Uint64.map<SinceLike, Since>({
-    inMap: (encodable) => Since.from(encodable).toNum(),
-    outMap: (decoded) => Since.from(decoded),
-  }),
+  mol.Uint64.mapIn((encodable: SinceLike) => Since.from(encodable).toNum()),
 )
 export class Since extends mol.Entity.Base<SinceLike, Since>() {
   /**
@@ -472,10 +465,10 @@ export type CellInputLike = {
       since: Since,
       previousOutput: OutPoint,
     })
-    .map<CellInputLike, CellInput>({
-      inMap: (encodable) => ({ ...encodable, since: encodable.since ?? 0 }),
-      outMap: (decoded) => CellInput.from(decoded),
-    }),
+    .mapIn((encodable: CellInputLike) => ({
+      ...encodable,
+      since: encodable.since ?? 0,
+    })),
 )
 export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
   /**
@@ -560,12 +553,10 @@ export type CellDepLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .struct({
-      outPoint: OutPoint,
-      depType: DepTypeCodec,
-    })
-    .map({ outMap: (decoded) => CellDep.from(decoded) }),
+  mol.struct({
+    outPoint: OutPoint,
+    depType: DepTypeCodec,
+  }),
 )
 export class CellDep extends mol.Entity.Base<CellDepLike, CellDep>() {
   /**
@@ -637,13 +628,11 @@ export type WitnessArgsLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      lock: mol.BytesOpt,
-      inputType: mol.BytesOpt,
-      outputType: mol.BytesOpt,
-    })
-    .map({ outMap: (decoded) => WitnessArgs.from(decoded) }),
+  mol.table({
+    lock: mol.BytesOpt,
+    inputType: mol.BytesOpt,
+    outputType: mol.BytesOpt,
+  }),
 )
 export class WitnessArgs extends mol.Entity.Base<
   WitnessArgsLike,
@@ -706,16 +695,14 @@ export function udtBalanceFrom(dataLike: BytesLike): Num {
   return numFromBytes(data);
 }
 
-export const RawTransaction = mol
-  .table({
-    version: mol.Uint32,
-    cellDeps: CellDepVec,
-    headerDeps: mol.Byte32Vec,
-    inputs: CellInputVec,
-    outputs: CellOutputVec,
-    outputsData: mol.BytesVec,
-  })
-  .map({ outMap: (decoded) => Transaction.from(decoded) });
+export const RawTransaction = mol.table({
+  version: mol.Uint32,
+  cellDeps: CellDepVec,
+  headerDeps: mol.Byte32Vec,
+  inputs: CellInputVec,
+  outputs: CellOutputVec,
+  outputsData: mol.BytesVec,
+});
 
 /**
  * @public
@@ -741,16 +728,14 @@ export type TransactionLike = {
       raw: RawTransaction,
       witnesses: mol.BytesVec,
     })
-    .map<TransactionLike, Transaction>({
-      inMap: (txLike) => {
-        const tx = Transaction.from(txLike);
-        return {
-          raw: tx,
-          witnesses: tx.witnesses,
-        };
-      },
-      outMap: (tx) => Transaction.from({ ...tx.raw, witnesses: tx.witnesses }),
-    }),
+    .mapIn((txLike: TransactionLike) => {
+      const tx = Transaction.from(txLike);
+      return {
+        raw: tx,
+        witnesses: tx.witnesses,
+      };
+    })
+    .mapOut((tx) => Transaction.from({ ...tx.raw, witnesses: tx.witnesses })),
 )
 export class Transaction extends mol.Entity.Base<
   TransactionLike,

package/src/client/clientPublicMainnet.ts

@@ -1,7 +1,7 @@
 import WebSocket from "isomorphic-ws";
 import { ClientCache } from "./cache/index.js";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced.js";
-import { KnownScript, ScriptInfo } from "./clientTypes.js";
+import { KnownScript, ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc } from "./jsonRpc/index.js";
 
 /**
@@ -12,7 +12,8 @@ export class ClientPublicMainnet extends ClientJsonRpc {
     private readonly config?: {
       url?: string;
       timeout?: number;
-      scripts?: typeof MAINNET_SCRIPTS;
+      maxConcurrent?: number;
+      scripts?: Record<KnownScript, ScriptInfoLike | undefined>;
       cache?: ClientCache;
     },
   ) {
@@ -25,7 +26,7 @@ export class ClientPublicMainnet extends ClientJsonRpc {
     );
   }
 
-  get scripts(): typeof MAINNET_SCRIPTS {
+  get scripts(): Record<KnownScript, ScriptInfoLike | undefined> {
     return this.config?.scripts ?? MAINNET_SCRIPTS;
   }
 

package/src/client/clientPublicTestnet.ts

@@ -1,7 +1,7 @@
 import WebSocket from "isomorphic-ws";
 import { ClientCache } from "./cache/index.js";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced.js";
-import { KnownScript, ScriptInfo } from "./clientTypes.js";
+import { KnownScript, ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc } from "./jsonRpc/index.js";
 
 /**
@@ -12,7 +12,8 @@ export class ClientPublicTestnet extends ClientJsonRpc {
     private readonly config?: {
       url?: string;
       timeout?: number;
-      scripts?: typeof TESTNET_SCRIPTS;
+      maxConcurrent?: number;
+      scripts?: Record<KnownScript, ScriptInfoLike | undefined>,
       cache?: ClientCache;
     },
   ) {
@@ -25,7 +26,7 @@ export class ClientPublicTestnet extends ClientJsonRpc {
     );
   }
 
-  get scripts(): typeof TESTNET_SCRIPTS {
+  get scripts(): Record<KnownScript, ScriptInfoLike | undefined> {
     return this.config?.scripts ?? TESTNET_SCRIPTS;
   }
 
@@ -35,6 +36,11 @@ export class ClientPublicTestnet extends ClientJsonRpc {
 
   async getKnownScript(script: KnownScript): Promise<ScriptInfo> {
     const found = this.scripts[script];
+    if (!found) {
+      throw new Error(
+        `No script information was found for ${script} on ${this.addressPrefix}`,
+      );
+    }
     return ScriptInfo.from(found);
   }
 }

package/src/client/jsonRpc/index.ts

@@ -95,6 +95,10 @@ const ERROR_PARSERS: [
  */
 
 export abstract class ClientJsonRpc extends Client {
+  private readonly maxConcurrent?: number;
+  private concurrent = 0;
+  private readonly pending: (() => void)[] = [];
+
   private id = 0;
   private readonly transport: Transport;
 
@@ -107,10 +111,15 @@ export abstract class ClientJsonRpc extends Client {
 
   constructor(
     private readonly url_: string,
-    config?: { timeout?: number; cache?: ClientCache },
+    config?: {
+      timeout?: number;
+      cache?: ClientCache;
+      maxConcurrent?: number;
+    },
   ) {
     super(config);
 
+    this.maxConcurrent = config?.maxConcurrent;
     this.transport = transportFromUri(url_, config);
   }
 
@@ -433,11 +442,25 @@ export abstract class ClientJsonRpc extends Client {
    * @throws Will throw an error if the response ID does not match the request ID, or if the response contains an error.
    */
   async send(payload: JsonRpcPayload): Promise<unknown> {
+    if (
+      this.maxConcurrent !== undefined &&
+      this.concurrent >= this.maxConcurrent
+    ) {
+      const pending = new Promise<void>((resolve) =>
+        this.pending.push(resolve),
+      );
+      await pending;
+    }
+
+    this.concurrent += 1;
     const res = (await this.transport.request(payload)) as {
       id: number;
       error: unknown;
       result: unknown;
     };
+    this.concurrent -= 1;
+    this.pending.pop()?.();
+
     if (res.id !== payload.id) {
       throw new Error(`Id mismatched, got ${res.id}, expected ${payload.id}`);
     }

package/src/molecule/codec.ts

@@ -1,6 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Bytes, bytesConcat, bytesFrom, BytesLike } from "../bytes/index.js";
+import {
+  Bytes,
+  bytesConcat,
+  bytesConcatTo,
+  bytesFrom,
+  BytesLike,
+} from "../bytes/index.js";
 import {
   Num,
   numBeFromBytes,
@@ -47,6 +53,18 @@ export class Codec<Encodable, Decoded = Encodable> {
           : this.decode(buffer)) as NewDecoded,
     });
   }
+
+  mapIn<NewEncodable>(
+    map: (encodable: NewEncodable) => Encodable,
+  ): Codec<NewEncodable, Decoded> {
+    return this.map({ inMap: map });
+  }
+
+  mapOut<NewDecoded>(
+    map: (decoded: Decoded) => NewDecoded,
+  ): Codec<Encodable, NewDecoded> {
+    return this.map({ outMap: map });
+  }
 }
 
 export type EncodableType<T extends CodecLike<any, any>> =
@@ -77,10 +95,12 @@ export function fixedItemVec<Encodable, Decoded>(
   return Codec.from({
     encode(userDefinedItems) {
       try {
-        return userDefinedItems.reduce(
-          (concatted, item) => bytesConcat(concatted, itemCodec.encode(item)),
-          uint32To(userDefinedItems.length),
-        );
+        const concatted: number[] = [];
+        bytesConcatTo(concatted, uint32To(userDefinedItems.length));
+        for (const item of userDefinedItems) {
+          bytesConcatTo(concatted, itemCodec.encode(item));
+        }
+        return bytesFrom(concatted);
       } catch (e: unknown) {
         throw new Error(`fixedItemVec(${e?.toString()})`);
       }
@@ -125,26 +145,19 @@ export function dynItemVec<Encodable, Decoded>(
   return Codec.from({
     encode(userDefinedItems) {
       try {
-        const encoded = userDefinedItems.reduce(
-          ({ offset, header, body }, item) => {
-            const encodedItem = itemCodec.encode(item);
-            const packedHeader = uint32To(offset);
-            return {
-              header: bytesConcat(header, packedHeader),
-              body: bytesConcat(body, encodedItem),
-              offset: offset + bytesFrom(encodedItem).byteLength,
-            };
-          },
-          {
-            header: bytesFrom([]),
-            body: bytesFrom([]),
-            offset: 4 + userDefinedItems.length * 4,
-          },
-        );
-        const packedTotalSize = uint32To(
-          encoded.header.byteLength + encoded.body.byteLength + 4,
-        );
-        return bytesConcat(packedTotalSize, encoded.header, encoded.body);
+        let offset = 4 + userDefinedItems.length * 4;
+        const header: number[] = [];
+        const body: number[] = [];
+
+        for (const item of userDefinedItems) {
+          const encoded = itemCodec.encode(item);
+          bytesConcatTo(header, uint32To(offset));
+          bytesConcatTo(body, encoded);
+          offset += encoded.byteLength;
+        }
+
+        const packedTotalSize = uint32To(header.length + body.length + 4);
+        return bytesConcat(packedTotalSize, header, body);
       } catch (e) {
         throw new Error(`dynItemVec(${e?.toString()})`);
       }
@@ -317,29 +330,22 @@ export function table<
 
   return Codec.from({
     encode(object) {
-      const headerLength = 4 + keys.length * 4;
-
-      const { header, body } = keys.reduce(
-        (result, key) => {
-          try {
-            const encodedItem = codecLayout[key].encode((object as any)[key]);
-            const packedOffset = uint32To(result.offset);
-            return {
-              header: bytesConcat(result.header, packedOffset),
-              body: bytesConcat(result.body, encodedItem),
-              offset: result.offset + bytesFrom(encodedItem).byteLength,
-            };
-          } catch (e: unknown) {
-            throw new Error(`table.${key}(${e?.toString()})`);
-          }
-        },
-        {
-          header: bytesFrom([]),
-          body: bytesFrom([]),
-          offset: headerLength,
-        },
-      );
-      const packedTotalSize = uint32To(header.byteLength + body.byteLength + 4);
+      let offset = 4 + keys.length * 4;
+      const header: number[] = [];
+      const body: number[] = [];
+
+      for (const key of keys) {
+        try {
+          const encoded = codecLayout[key].encode((object as any)[key]);
+          bytesConcatTo(header, uint32To(offset));
+          bytesConcatTo(body, encoded);
+          offset += encoded.byteLength;
+        } catch (e: unknown) {
+          throw new Error(`table.${key}(${e?.toString()})`);
+        }
+      }
+
+      const packedTotalSize = uint32To(header.length + body.length + 4);
       return bytesConcat(packedTotalSize, header, body);
     },
     decode(buffer) {
@@ -482,23 +488,27 @@ export function struct<
   Decoded extends DecodedRecord<T>,
 >(codecLayout: T): Codec<Encodable, Decoded> {
   const codecArray = Object.values(codecLayout);
-  if (codecArray.some((codec) => codec.byteLength === undefined)) {
-    throw new Error("struct: all fields must be fixed-size");
-  }
-
   const keys = Object.keys(codecLayout);
 
   return Codec.from({
-    byteLength: codecArray.reduce((sum, codec) => sum + codec.byteLength!, 0),
+    byteLength: codecArray.reduce((acc, codec) => {
+      if (codec.byteLength === undefined) {
+        throw new Error("struct: all fields must be fixed-size");
+      }
+      return acc + codec.byteLength;
+    }, 0),
     encode(object) {
-      return keys.reduce((result, key) => {
+      const bytes: number[] = [];
+      for (const key of keys) {
         try {
-          const encodedItem = codecLayout[key].encode((object as any)[key]);
-          return bytesConcat(result, encodedItem);
+          const encoded = codecLayout[key].encode((object as any)[key]);
+          bytesConcatTo(bytes, encoded);
         } catch (e: unknown) {
           throw new Error(`struct.${key}(${e?.toString()})`);
         }
-      }, bytesFrom([]));
+      }
+
+      return bytesFrom(bytes);
     },
     decode(buffer) {
       const value = bytesFrom(buffer);
@@ -538,10 +548,12 @@ export function array<Encodable, Decoded>(
     byteLength,
     encode(items) {
       try {
-        return items.reduce(
-          (concatted, item) => bytesConcat(concatted, itemCodec.encode(item)),
-          bytesFrom([]),
-        );
+        const bytes: number[] = [];
+        for (const item of items) {
+          bytesConcatTo(bytes, itemCodec.encode(item));
+        }
+
+        return bytesFrom(bytes);
       } catch (e: unknown) {
         throw new Error(`array(${e?.toString()})`);
       }

package/src/molecule/entity.ts

@@ -1,13 +1,19 @@
 import { Bytes, bytesEq, BytesLike } from "../bytes/index.js";
 import { hashCkb } from "../hasher/index.js";
 import { Hex } from "../hex/index.js";
+import { Constructor } from "../utils/index.js";
 import { Codec } from "./codec.js";
 
 /**
- * The base class of CCC to create a serializable instance
+ * The base class of CCC to create a serializable instance. This should be used with the {@link codec} decorator.
  * @public
  */
 export abstract class Entity {
+  /**
+   * Generate a base class of CCC to create a serializable instance.
+   * This should be used with the {@link codec} decorator.
+   * @public
+   */
   static Base<SubTypeLike, SubType = SubTypeLike>() {
     abstract class Impl {
       /**
@@ -97,7 +103,7 @@ export abstract class Entity {
        * @param other - The other entity to compare with
        * @returns True if the entities are equal, false otherwise
        */
-      eq(other: SubTypeLike | SubType): boolean {
+      eq(other: SubTypeLike): boolean {
         if (this === (other as unknown as this)) {
           return true;
         }
@@ -130,14 +136,28 @@ export abstract class Entity {
   abstract clone(): Entity;
 }
 
+/**
+ * A class decorator to add methods implementation on the {@link Entity.Base} class
+ * @example
+ * ```typescript
+ * @mol.codec(
+ *   mol.table({
+ *     codeHash: mol.Byte32,
+ *     hashType: HashTypeCodec,
+ *     args: mol.Bytes,
+ *   }),
+ * )
+ * export class Script extends mol.Entity.Base<ScriptLike, Script>() {
+ *   from(scriptLike: ScriptLike): Script {}
+ * }
+ * ```
+ */
 export function codec<
   Encodable,
   TypeLike extends Encodable,
   Decoded extends TypeLike,
   Type extends object & TypeLike,
-  ConstructorType extends {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new (...args: any[]): Type;
+  ConstructorType extends Constructor<Type> & {
     from(decoded: TypeLike): Type;
     byteLength?: number;
     encode(encodable: TypeLike): Bytes;

package/src/num/index.ts

@@ -155,10 +155,7 @@ export function numBeToBytes(val: NumLike, bytes?: number): Bytes {
     return rawBytes;
   }
 
-  return bytesConcat(
-    Array.from(Array(bytes - rawBytes.length), () => 0),
-    rawBytes,
-  );
+  return bytesConcat("00".repeat(bytes - rawBytes.length), rawBytes);
 }
 
 /**
@@ -190,7 +187,7 @@ export function numFromBytes(val: BytesLike): Num {
  * ```
  */
 export function numLeFromBytes(val: BytesLike): Num {
-  return numBeFromBytes([...bytesFrom(val)].reverse());
+  return numBeFromBytes(bytesFrom(val).reverse());
 }
 
 /**

package/src/signer/btc/verify.ts

@@ -43,7 +43,7 @@ export function verifyMessageBtcEcdsa(
   const challenge =
     typeof message === "string" ? message : hexFrom(message).slice(2);
 
-  const [_, ...rawSign] = bytesFrom(signature, "base64");
+  const rawSign = bytesFrom(signature, "base64").slice(1);
 
   return secp256k1.verify(bytesFrom(rawSign), magicHash(challenge), publicKey);
 }

package/src/signer/doge/verify.ts

@@ -17,7 +17,9 @@ export function verifyMessageDogeEcdsa(
 ): boolean {
   const challenge =
     typeof message === "string" ? message : hexFrom(message).slice(2);
-  const [recoveryBit, ...rawSign] = bytesFrom(signature, "base64");
+  const signatureBytes = bytesFrom(signature, "base64");
+  const recoveryBit = signatureBytes[0];
+  const rawSign = signatureBytes.slice(1);
 
   const sig = secp256k1.Signature.fromCompact(
     hexFrom(rawSign).slice(2),