@ckb-ccc/core 0.1.2 → 1.0.1

package/src/molecule/barrel.ts

@@ -0,0 +1,3 @@
+export * from "./codec.js";
+export * from "./entity.js";
+export * from "./predefined.js";

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()})`);
       }
@@ -102,7 +122,7 @@ export function fixedItemVec<Encodable, Decoded>(
 
       try {
         const decodedArray: Array<Decoded> = [];
-        for (let offset = 0; offset < byteLength; offset += itemByteLength) {
+        for (let offset = 4; offset < byteLength; offset += itemByteLength) {
           decodedArray.push(
             itemCodec.decode(value.slice(offset, offset + itemByteLength)),
           );
@@ -125,42 +145,39 @@ 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()})`);
       }
     },
     decode(buffer) {
       const value = bytesFrom(buffer);
+      if (value.byteLength < 4) {
+        throw new Error(
+          `dynItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
+        );
+      }
       const byteLength = uint32From(value.slice(0, 4));
       if (byteLength !== value.byteLength) {
         throw new Error(
           `dynItemVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`,
         );
       }
-      if (value.byteLength < 4) {
-        throw new Error(
-          `fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
-        );
+
+      if (byteLength === 4) {
+        return [];
       }
 
       const offset = uint32From(value.slice(4, 8));
@@ -313,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) {
@@ -478,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);
@@ -534,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

@@ -0,0 +1,183 @@
+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. 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 {
+      /**
+       * The bytes length of the entity, if it is fixed, otherwise undefined
+       * @public
+       * @static
+       */
+      static byteLength?: number;
+      /**
+       * Encode the entity into bytes
+       * @public
+       * @static
+       * @param _ - The entity to encode
+       * @returns The encoded bytes
+       * @throws Will throw an error if the entity is not serializable
+       */
+      static encode(_: SubTypeLike): Bytes {
+        throw new Error(
+          "encode not implemented, use @ccc.mol.codec to decorate your type",
+        );
+      }
+      /**
+       * Decode the entity from bytes
+       * @public
+       * @static
+       * @param _ - The bytes to decode
+       * @returns The decoded entity
+       * @throws Will throw an error if the entity is not serializable
+       */
+      static decode(_: BytesLike): SubType {
+        throw new Error(
+          "decode not implemented, use @ccc.mol.codec to decorate your type",
+        );
+      }
+
+      /**
+       * Create an entity from bytes
+       * @public
+       * @static
+       * @param _ - The bytes to create the entity from
+       * @returns The created entity
+       * @throws Will throw an error if the entity is not serializable
+       */
+      static fromBytes(_bytes: BytesLike): SubType {
+        throw new Error(
+          "fromBytes not implemented, use @ccc.mol.codec to decorate your type",
+        );
+      }
+
+      /**
+       * Create an entity from a serializable object
+       * @public
+       * @static
+       * @param _ - The serializable object to create the entity from
+       * @returns The created entity
+       * @throws Will throw an error if the entity is not serializable
+       */
+      static from(_: SubTypeLike): SubType {
+        throw new Error("from not implemented");
+      }
+
+      /**
+       * Convert the entity to bytes
+       * @public
+       * @returns The bytes representation of the entity
+       */
+      toBytes(): Bytes {
+        return (this.constructor as typeof Impl).encode(
+          this as unknown as SubTypeLike,
+        );
+      }
+
+      /**
+       * Create a clone of the entity
+       * @public
+       * @returns A clone of the entity
+       */
+      clone(): SubType {
+        return (this.constructor as typeof Impl).fromBytes(
+          this.toBytes(),
+        ) as unknown as SubType;
+      }
+
+      /**
+       * Check if the entity is equal to another entity
+       * @public
+       * @param other - The other entity to compare with
+       * @returns True if the entities are equal, false otherwise
+       */
+      eq(other: SubTypeLike): boolean {
+        if (this === (other as unknown as this)) {
+          return true;
+        }
+
+        return bytesEq(
+          this.toBytes(),
+          /* eslint-disable @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any */
+          (
+            ((this.constructor as any)?.from(other) ?? other) as unknown as Impl
+          ).toBytes(),
+          /* eslint-enable @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any */
+        );
+      }
+
+      /**
+       * Calculate the hash of the entity
+       * @public
+       * @returns The hash of the entity
+       */
+      hash(): Hex {
+        return hashCkb(this.toBytes());
+      }
+    }
+
+    return Impl;
+  }
+
+  abstract toBytes(): Bytes;
+  abstract hash(): Hex;
+  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 Constructor<Type> & {
+    from(decoded: TypeLike): Type;
+    byteLength?: number;
+    encode(encodable: TypeLike): Bytes;
+    decode(bytesLike: BytesLike): TypeLike;
+    fromBytes(bytes: BytesLike): Type;
+  },
+>(codec: Codec<Encodable, Decoded>) {
+  return function (Constructor: ConstructorType) {
+    return class Extended extends Constructor {
+      static byteLength = codec.byteLength;
+      static encode(encodable: TypeLike): Bytes {
+        return codec.encode(encodable);
+      }
+      static decode(bytesLike: BytesLike): Type {
+        return Constructor.from(codec.decode(bytesLike));
+      }
+
+      static fromBytes(bytes: BytesLike): Type {
+        return Constructor.from(codec.decode(bytes));
+      }
+    };
+  };
+}

package/src/molecule/index.ts

@@ -1,2 +1 @@
-export * from "./codec.js";
-export * from "./predefined.js";
+export * as mol from "./barrel.js";

package/src/molecule/predefined.ts

@@ -1,44 +1,46 @@
 import { bytesFrom, bytesTo } from "../bytes/index.js";
-import * as ckb from "../ckb/index.js";
 import { Hex, hexFrom, HexLike } from "../hex/index.js";
-import {
-  byteVec,
-  Codec,
-  option,
-  struct,
-  table,
-  uint,
-  uintNumber,
-  vector,
-} from "./codec.js";
+import { byteVec, Codec, option, uint, uintNumber, vector } from "./codec.js";
 
 export const Uint8 = uintNumber(1, true);
+export const Uint8Opt = option(Uint8);
+export const Uint8Vec = vector(Uint8);
+
 export const Uint16LE = uintNumber(2, true);
 export const Uint16BE = uintNumber(2);
 export const Uint16 = Uint16LE;
+export const Uint16Opt = option(Uint16);
+export const Uint16Vec = vector(Uint16);
+
 export const Uint32LE = uintNumber(4, true);
 export const Uint32BE = uintNumber(4);
 export const Uint32 = Uint32LE;
+export const Uint32Opt = option(Uint32);
+export const Uint32Vec = vector(Uint32);
+
 export const Uint64LE = uint(8, true);
 export const Uint64BE = uint(8);
 export const Uint64 = Uint64LE;
+export const Uint64Opt = option(Uint64);
+export const Uint64Vec = vector(Uint64);
+
 export const Uint128LE = uint(16, true);
 export const Uint128BE = uint(16);
 export const Uint128 = Uint128LE;
+export const Uint128Opt = option(Uint128);
+export const Uint128Vec = vector(Uint128);
+
 export const Uint256LE = uint(32, true);
 export const Uint256BE = uint(32);
 export const Uint256 = Uint256LE;
+export const Uint256Opt = option(Uint256);
+export const Uint256Vec = vector(Uint256);
+
 export const Uint512LE = uint(64, true);
 export const Uint512BE = uint(64);
 export const Uint512 = Uint512LE;
-
-export const Uint8Opt = option(Uint8);
-export const Uint16Opt = option(Uint16);
-export const Uint32Opt = option(Uint32);
-export const Uint64Opt = option(Uint64);
-export const Uint128Opt = option(Uint128);
-export const Uint256Opt = option(Uint256);
 export const Uint512Opt = option(Uint512);
+export const Uint512Vec = vector(Uint512);
 
 export const Bytes: Codec<HexLike, Hex> = byteVec({
   encode: (value) => bytesFrom(value),
@@ -61,54 +63,3 @@ export const String = byteVec({
 });
 export const StringVec = vector(String);
 export const StringOpt = option(String);
-
-export const Hash = Byte32;
-export const HashType: Codec<ckb.HashTypeLike, ckb.HashType> = Codec.from({
-  byteLength: 1,
-  encode: ckb.hashTypeToBytes,
-  decode: ckb.hashTypeFromBytes,
-});
-export const Script: Codec<ckb.ScriptLike, ckb.Script> = table({
-  codeHash: Hash,
-  hashType: HashType,
-  args: Bytes,
-}).map({ outMap: ckb.Script.from });
-export const ScriptOpt = option(Script);
-
-export const OutPoint: Codec<ckb.OutPointLike, ckb.OutPoint> = struct({
-  txHash: Hash,
-  index: Uint32,
-}).map({ outMap: ckb.OutPoint.from });
-export const CellInput: Codec<ckb.CellInputLike, ckb.CellInput> = struct({
-  previousOutput: OutPoint,
-  since: Uint64,
-}).map({ outMap: ckb.CellInput.from });
-export const CellInputVec = vector(CellInput);
-
-export const CellOutput: Codec<ckb.CellOutputLike, ckb.CellOutput> = table({
-  capacity: Uint64,
-  lock: Script,
-  type: ScriptOpt,
-}).map({ outMap: ckb.CellOutput.from });
-export const CellOutputVec = vector(CellOutput);
-
-export const DepType: Codec<ckb.DepTypeLike, ckb.DepType> = Codec.from({
-  byteLength: 1,
-  encode: ckb.depTypeToBytes,
-  decode: ckb.depTypeFromBytes,
-});
-export const CellDep: Codec<ckb.CellDepLike, ckb.CellDep> = struct({
-  outPoint: OutPoint,
-  depType: DepType,
-}).map({ outMap: ckb.CellDep.from });
-export const CellDepVec = vector(CellDep);
-
-export const Transaction: Codec<ckb.TransactionLike, ckb.Transaction> = table({
-  version: Uint32,
-  cellDeps: CellDepVec,
-  headerDeps: Byte32Vec,
-  inputs: CellInputVec,
-  outputs: CellOutputVec,
-  outputsData: BytesVec,
-  witnesses: BytesVec,
-}).map({ outMap: ckb.Transaction.from });

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

package/src/utils/index.ts

@@ -172,6 +172,11 @@ export function sleep(ms: NumLike) {
   return new Promise((resolve) => setTimeout(resolve, Number(numFrom(ms))));
 }
 
+export type Constructor<T> = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new (...args: any[]): T;
+};
+
 /**
  * @public
  */