@ckb-ccc/core 1.12.5 → 1.14.0

package/src/{molecule → codec}/entity.ts

@@ -1,6 +1,6 @@
 import { Bytes, bytesEq, BytesLike } from "../bytes/index.js";
 import { hashCkb } from "../hasher/index.js";
-import { Hex } from "../hex/index.js";
+import { Hex, hexFrom } from "../hex/index.js";
 import { Constructor } from "../utils/index.js";
 import { Codec } from "./codec.js";
 
@@ -32,7 +32,7 @@ export abstract class Entity {
        */
       static encode(_: SubTypeLike): Bytes {
         throw new Error(
-          "encode not implemented, use @ccc.mol.codec to decorate your type",
+          "encode not implemented, use @ccc.codec to decorate your type",
         );
       }
       /**
@@ -45,7 +45,7 @@ export abstract class Entity {
        */
       static decode(_: BytesLike): SubType {
         throw new Error(
-          "decode not implemented, use @ccc.mol.codec to decorate your type",
+          "decode not implemented, use @ccc.codec to decorate your type",
         );
       }
 
@@ -59,7 +59,7 @@ export abstract class Entity {
        */
       static fromBytes(_bytes: BytesLike): SubType {
         throw new Error(
-          "fromBytes not implemented, use @ccc.mol.codec to decorate your type",
+          "fromBytes not implemented, use @ccc.codec to decorate your type",
         );
       }
 
@@ -92,9 +92,7 @@ export abstract class Entity {
        * @returns A clone of the entity
        */
       clone(): SubType {
-        return (this.constructor as typeof Impl).fromBytes(
-          this.toBytes(),
-        ) as unknown as SubType;
+        return (this.constructor as typeof Impl).fromBytes(this.toBytes());
       }
 
       /**
@@ -126,6 +124,15 @@ export abstract class Entity {
       hash(): Hex {
         return hashCkb(this.toBytes());
       }
+
+      /**
+       * Convert the entity to a full-byte untrimmed Hex representation
+       * @public
+       * @returns The entity full-byte untrimmed hexadecimal representation
+       */
+      toHex(): Hex {
+        return hexFrom(this.toBytes());
+      }
     }
 
     /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
@@ -139,6 +146,7 @@ export abstract class Entity {
 
   abstract toBytes(): Bytes;
   abstract hash(): Hex;
+  abstract toHex(): Hex;
   abstract clone(): Entity;
 }
 
@@ -146,14 +154,14 @@ export abstract class Entity {
  * A class decorator to add methods implementation on the {@link Entity.Base} class
  * @example
  * ```typescript
- * @mol.codec(
+ * @codec(
  *   mol.table({
  *     codeHash: mol.Byte32,
  *     hashType: HashTypeCodec,
  *     args: mol.Bytes,
  *   }),
  * )
- * export class Script extends mol.Entity.Base<ScriptLike, Script>() {
+ * export class Script extends Entity.Base<ScriptLike, Script>() {
  *   from(scriptLike: ScriptLike): Script {}
  * }
  * ```
@@ -176,7 +184,7 @@ export function codec<
     Constructor.byteLength = codec.byteLength;
     if (Constructor.encode === undefined) {
       Constructor.encode = function (encodable: TypeLike) {
-        return codec.encode(encodable);
+        return codec.encode(Constructor.from(encodable));
       };
     }
     if (Constructor.decode === undefined) {

package/src/codec/predefined.ts

@@ -0,0 +1,145 @@
+import { Bytes, bytesFrom, BytesLike } from "../bytes/index.js";
+import { Hex, hexFrom, HexLike } from "../hex/index.js";
+import {
+  Num,
+  numBeFromBytes,
+  numBeToBytes,
+  numFromBytes,
+  NumLike,
+  numToBytes,
+} from "../num/index.js";
+import { Codec } from "./codec.js";
+
+/**
+ * Create a codec to deal with fixed LE or BE bytes.
+ * @param byteLength
+ * @param littleEndian
+ */
+export function codecUint(
+  byteLength: number,
+  littleEndian = false,
+): Codec<NumLike, Num> {
+  return Codec.from({
+    byteLength,
+    encode: (numLike) => {
+      if (littleEndian) {
+        return numToBytes(numLike, byteLength);
+      } else {
+        return numBeToBytes(numLike, byteLength);
+      }
+    },
+    decode: (buffer) => {
+      if (littleEndian) {
+        return numFromBytes(buffer);
+      } else {
+        return numBeFromBytes(buffer);
+      }
+    },
+  });
+}
+
+/**
+ * Create a codec to deal with fixed LE or BE bytes.
+ * @param byteLength
+ * @param littleEndian
+ */
+export function codecUintNumber(
+  byteLength: number,
+  littleEndian = false,
+): Codec<NumLike, number> {
+  if (byteLength > 4) {
+    throw new Error("uintNumber: byteLength must be less than or equal to 4");
+  }
+  return codecUint(byteLength, littleEndian).map({
+    outMap: (num) => Number(num),
+  });
+}
+
+/**
+ * Create a codec for padding bytes.
+ * The padding bytes are zero-filled when encoding and ignored when decoding.
+ * @param byteLength The length of the padding in bytes.
+ */
+export function codecPadding(
+  byteLength: number,
+): Codec<void | undefined | null, void> {
+  return Codec.from({
+    byteLength,
+    encode: () => {
+      return new Uint8Array(byteLength);
+    },
+    decode: () => {},
+  });
+}
+
+export const CodecRaw: Codec<BytesLike, Bytes> = Codec.from({
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => bytesFrom(buffer),
+});
+
+export const CodecBytes: Codec<HexLike, Hex> = Codec.from({
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+
+export const CodecUint8 = codecUintNumber(1, true);
+
+export const CodecUint16LE = codecUintNumber(2, true);
+export const CodecUint16BE = codecUintNumber(2);
+export const CodecUint16 = CodecUint16LE;
+
+export const CodecUint32LE = codecUintNumber(4, true);
+export const CodecUint32BE = codecUintNumber(4);
+export const CodecUint32 = CodecUint32LE;
+
+export const CodecUint64LE = codecUint(8, true);
+export const CodecUint64BE = codecUint(8);
+export const CodecUint64 = CodecUint64LE;
+
+export const CodecUint128LE = codecUint(16, true);
+export const CodecUint128BE = codecUint(16);
+export const CodecUint128 = CodecUint128LE;
+
+export const CodecUint256LE = codecUint(32, true);
+export const CodecUint256BE = codecUint(32);
+export const CodecUint256 = CodecUint256LE;
+
+export const CodecUint512LE = codecUint(64, true);
+export const CodecUint512BE = codecUint(64);
+export const CodecUint512 = CodecUint512LE;
+
+export const CodecBool: Codec<boolean> = Codec.from({
+  byteLength: 1,
+  encode: (value) => bytesFrom(value ? [1] : [0]),
+  decode: (buffer) => bytesFrom(buffer)[0] !== 0,
+});
+
+export const CodecByte: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 1,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+
+export const CodecByte4: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 4,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+
+export const CodecByte8: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 8,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+
+export const CodecByte16: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 16,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+
+export const CodecByte32: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 32,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});

package/src/hasher/advanced.ts

@@ -1 +1,3 @@
-export const CKB_BLAKE2B_PERSONAL = "ckb-default-hash";
+import { bytesFrom } from "../bytes/index.js";
+
+export const CKB_BLAKE2B_PERSONAL = bytesFrom("ckb-default-hash", "utf8");

package/src/hasher/hasherCkb.ts

@@ -1,4 +1,4 @@
-import { blake2b } from "@noble/hashes/blake2b";
+import { blake2b } from "@noble/hashes/blake2.js";
 import { BytesLike, bytesFrom } from "../bytes/index.js";
 import { Hex, hexFrom } from "../hex/index.js";
 import { CKB_BLAKE2B_PERSONAL } from "./advanced.js";

package/src/hasher/hasherKeecak256.ts

@@ -1,4 +1,4 @@
-import { keccak_256 } from "@noble/hashes/sha3";
+import { keccak_256 } from "@noble/hashes/sha3.js";
 import { BytesLike, bytesFrom } from "../bytes/index.js";
 import { Hex, hexFrom } from "../hex/index.js";
 import { Hasher } from "./hasher.js";

package/src/keystore/index.ts

@@ -1,7 +1,7 @@
-import { ctr } from "@noble/ciphers/aes";
-import { scryptAsync } from "@noble/hashes/scrypt";
-import { keccak_256 } from "@noble/hashes/sha3";
-import { randomBytes } from "@noble/hashes/utils";
+import { ctr } from "@noble/ciphers/aes.js";
+import { scryptAsync } from "@noble/hashes/scrypt.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { randomBytes } from "@noble/hashes/utils.js";
 import { Bytes, BytesLike, bytesConcat, bytesFrom } from "../bytes/index.js";
 import { hexFrom } from "../hex/index.js";
 

package/src/molecule/barrel.ts

@@ -1,3 +1,12 @@
+export {
+  /**
+   * @deprecated Use ccc.Entity instead
+   */
+  Entity,
+  /**
+   * @deprecated Use ccc.codec instead
+   */
+  codec,
+} from "../codec/entity.js";
 export * from "./codec.js";
-export * from "./entity.js";
 export * from "./predefined.js";

package/src/molecule/codec.ts

@@ -1,105 +1,45 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import {
-  Bytes,
   bytesConcat,
   bytesConcatTo,
   bytesFrom,
   BytesLike,
 } from "../bytes/index.js";
 import {
-  Num,
-  numBeFromBytes,
-  numBeToBytes,
-  numFromBytes,
-  NumLike,
-  numToBytes,
-} from "../num/index.js";
-
-export type CodecLike<Encodable, Decoded = Encodable> = {
-  readonly encode: (encodable: Encodable) => Bytes;
-  readonly decode: (
-    decodable: BytesLike,
-    config?: { isExtraFieldIgnored?: boolean },
-  ) => Decoded;
-  readonly byteLength?: number;
-};
-export class Codec<Encodable, Decoded = Encodable> {
-  constructor(
-    public readonly encode: (encodable: Encodable) => Bytes,
-    public readonly decode: (
-      decodable: BytesLike,
-      config?: { isExtraFieldIgnored?: boolean }, // This is equivalent to "compatible" in the Rust implementation of Molecule.
-    ) => Decoded,
-    public readonly byteLength?: number, // if provided, treat codec as fixed length
-  ) {}
-
-  static from<Encodable, Decoded = Encodable>({
-    encode,
-    decode,
-    byteLength,
-  }: CodecLike<Encodable, Decoded>): Codec<Encodable, Decoded> {
-    return new Codec(
-      (encodable: Encodable) => {
-        const encoded = encode(encodable);
-        if (byteLength !== undefined && encoded.byteLength !== byteLength) {
-          throw new Error(
-            `Codec.encode: expected byte length ${byteLength}, got ${encoded.byteLength}`,
-          );
-        }
-        return encoded;
-      },
-      (decodable, config) => {
-        const decodableBytes = bytesFrom(decodable);
-        if (
-          byteLength !== undefined &&
-          decodableBytes.byteLength !== byteLength
-        ) {
-          throw new Error(
-            `Codec.decode: expected byte length ${byteLength}, got ${decodableBytes.byteLength}`,
-          );
-        }
-        return decode(decodable, config);
-      },
-      byteLength,
-    );
-  }
-
-  map<NewEncodable = Encodable, NewDecoded = Decoded>({
-    inMap,
-    outMap,
-  }: {
-    inMap?: (encodable: NewEncodable) => Encodable;
-    outMap?: (decoded: Decoded) => NewDecoded;
-  }): Codec<NewEncodable, NewDecoded> {
-    return new Codec(
-      (encodable) =>
-        this.encode((inMap ? inMap(encodable) : encodable) as Encodable),
-      (buffer, config) =>
-        (outMap
-          ? outMap(this.decode(buffer, config))
-          : this.decode(buffer, config)) as NewDecoded,
-      this.byteLength,
-    );
-  }
-
-  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>> =
-  T extends CodecLike<infer Encodable, unknown> ? Encodable : never;
-export type DecodedType<T extends CodecLike<any, any>> =
-  T extends CodecLike<any, infer Decoded> ? Decoded : never;
+  Codec,
+  CodecLike,
+  DecodedType,
+  EncodableType,
+} from "../codec/index.js";
+import { numFromBytes, NumLike, numToBytes } from "../num/index.js";
+
+export {
+  /**
+   * @deprecated Use ccc.Codec instead
+   */
+  Codec,
+  /**
+   * @deprecated Use ccc.codecUint instead
+   */
+  codecUint as uint,
+  /**
+   * @deprecated Use ccc.codecUintNumber instead
+   */
+  codecUintNumber as uintNumber,
+  /**
+   * @deprecated Use ccc.CodecLike instead
+   */
+  type CodecLike,
+  /**
+   * @deprecated Use ccc.DecodedType instead
+   */
+  type DecodedType,
+  /**
+   * @deprecated Use ccc.EncodableType instead
+   */
+  type EncodableType,
+} from "../codec/index.js";
 
 function uint32To(numLike: NumLike) {
   return numToBytes(numLike, 4);
@@ -131,7 +71,7 @@ export function fixedItemVec<Encodable, Decoded>(
         }
         return bytesFrom(concatted);
       } catch (e: unknown) {
-        throw new Error(`fixedItemVec(${e?.toString()})`);
+        throw new Error("fixedItemVec failed", { cause: e });
       }
     },
     decode(buffer, config) {
@@ -161,7 +101,7 @@ export function fixedItemVec<Encodable, Decoded>(
         }
         return decodedArray;
       } catch (e) {
-        throw new Error(`fixedItemVec(${e?.toString()})`);
+        throw new Error("fixedItemVec failed", { cause: e });
       }
     },
   });
@@ -191,7 +131,7 @@ export function dynItemVec<Encodable, Decoded>(
         const packedTotalSize = uint32To(header.length + body.length + 4);
         return bytesConcat(packedTotalSize, header, body);
       } catch (e) {
-        throw new Error(`dynItemVec(${e?.toString()})`);
+        throw new Error("dynItemVec failed", { cause: e });
       }
     },
     decode(buffer, config) {
@@ -228,7 +168,7 @@ export function dynItemVec<Encodable, Decoded>(
         }
         return decodedArray;
       } catch (e) {
-        throw new Error(`dynItemVec(${e?.toString()})`);
+        throw new Error("dynItemVec failed", { cause: e });
       }
     },
   });
@@ -265,7 +205,7 @@ export function option<Encodable, Decoded>(
       try {
         return innerCodec.encode(userDefinedOrNull);
       } catch (e) {
-        throw new Error(`option(${e?.toString()})`);
+        throw new Error("option failed", { cause: e });
       }
     },
     decode(buffer, config) {
@@ -276,7 +216,7 @@ export function option<Encodable, Decoded>(
       try {
         return innerCodec.decode(buffer, config);
       } catch (e) {
-        throw new Error(`option(${e?.toString()})`);
+        throw new Error("option failed", { cause: e });
       }
     },
   });
@@ -296,7 +236,7 @@ export function byteVec<Encodable, Decoded>(
         const byteLength = uint32To(payload.byteLength);
         return bytesConcat(byteLength, payload);
       } catch (e) {
-        throw new Error(`byteVec(${e?.toString()})`);
+        throw new Error("byteVec failed", { cause: e });
       }
     },
     decode(buffer, config) {
@@ -315,7 +255,7 @@ export function byteVec<Encodable, Decoded>(
       try {
         return codec.decode(value.slice(4), config);
       } catch (e: unknown) {
-        throw new Error(`byteVec(${e?.toString()})`);
+        throw new Error("byteVec failed", { cause: e });
       }
     },
   });
@@ -373,7 +313,7 @@ export function table<
           bytesConcatTo(body, encoded);
           offset += encoded.byteLength;
         } catch (e: unknown) {
-          throw new Error(`table.${key}(${e?.toString()})`);
+          throw new Error(`table.${key} failed`, { cause: e });
         }
       }
 
@@ -431,7 +371,7 @@ export function table<
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [field]: codec.decode(payload, config) });
         } catch (e: unknown) {
-          throw new Error(`table.${field}(${e?.toString()})`);
+          throw new Error(`table.${field} failed`, { cause: e });
         }
       }
       return object as Decoded;
@@ -532,7 +472,7 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
         const body = codec.encode(value);
         return bytesConcat(header, body);
       } catch (e: unknown) {
-        throw new Error(`union.(${typeStr})(${e?.toString()})`);
+        throw new Error(`union.${typeStr} failed`, { cause: e });
       }
     },
     decode(buffer, config) {
@@ -598,7 +538,7 @@ export function struct<
           const encoded = codecLayout[key].encode((object as any)[key]);
           bytesConcatTo(bytes, encoded);
         } catch (e: unknown) {
-          throw new Error(`struct.${key}(${e?.toString()})`);
+          throw new Error(`struct.${key} failed`, { cause: e });
         }
       }
 
@@ -614,7 +554,7 @@ export function struct<
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [key]: codec.decode(payload, config) });
         } catch (e: unknown) {
-          throw new Error(`struct.${key}(${(e as Error).toString()})`);
+          throw new Error(`struct.${key} failed`, { cause: e });
         }
         offset = offset + codec.byteLength!;
       });
@@ -649,7 +589,7 @@ export function array<Encodable, Decoded>(
 
         return bytesFrom(bytes);
       } catch (e: unknown) {
-        throw new Error(`array(${e?.toString()})`);
+        throw new Error("array failed", { cause: e });
       }
     },
     decode(buffer, config) {
@@ -668,53 +608,8 @@ export function array<Encodable, Decoded>(
         }
         return result;
       } catch (e: unknown) {
-        throw new Error(`array(${e?.toString()})`);
-      }
-    },
-  });
-}
-
-/**
- * Create a codec to deal with fixed LE or BE bytes.
- * @param byteLength
- * @param littleEndian
- */
-export function uint(
-  byteLength: number,
-  littleEndian = false,
-): Codec<NumLike, Num> {
-  return Codec.from({
-    byteLength,
-    encode: (numLike) => {
-      if (littleEndian) {
-        return numToBytes(numLike, byteLength);
-      } else {
-        return numBeToBytes(numLike, byteLength);
+        throw new Error("array failed", { cause: e });
       }
     },
-    decode: (buffer) => {
-      if (littleEndian) {
-        return numFromBytes(buffer);
-      } else {
-        return numBeFromBytes(buffer);
-      }
-    },
-  });
-}
-
-/**
- * Create a codec to deal with fixed LE or BE bytes.
- * @param byteLength
- * @param littleEndian
- */
-export function uintNumber(
-  byteLength: number,
-  littleEndian = false,
-): Codec<NumLike, number> {
-  if (byteLength > 4) {
-    throw new Error("uintNumber: byteLength must be less than or equal to 4");
-  }
-  return uint(byteLength, littleEndian).map({
-    outMap: (num) => Number(num),
   });
 }