@ckb-ccc/core 1.0.0 → 1.0.1

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),