@ckb-ccc/core 1.12.4 → 1.13.0

package/src/codec/codec.ts

@@ -0,0 +1,108 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { Bytes, bytesFrom, BytesLike } from "../bytes/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
+  ) {}
+
+  encodeOr<T>(encodable: Encodable, fallback: T): Bytes | T {
+    try {
+      return this.encode(encodable);
+    } catch (_) {
+      return fallback;
+    }
+  }
+
+  decodeOr<T>(
+    decodable: BytesLike,
+    fallback: T,
+    config?: { isExtraFieldIgnored?: boolean }, // This is equivalent to "compatible" in the Rust implementation of Molecule.
+  ) {
+    try {
+      return this.decode(decodable, config);
+    } catch (_) {
+      return fallback;
+    }
+  }
+
+  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;

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",
         );
       }
 
@@ -126,6 +126,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 +148,7 @@ export abstract class Entity {
 
   abstract toBytes(): Bytes;
   abstract hash(): Hex;
+  abstract toHex(): Hex;
   abstract clone(): Entity;
 }
 
@@ -146,14 +156,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 +186,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);
@@ -673,48 +613,3 @@ export function array<Encodable, Decoded>(
     },
   });
 }
-
-/**
- * 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);
-      }
-    },
-    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),
-  });
-}