@ckb-ccc/core 1.12.5 → 1.13.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",
         );
       }
 
@@ -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),
-  });
-}

package/src/molecule/predefined.ts

@@ -1,91 +1,104 @@
 import { bytesFrom, bytesTo } from "../bytes/index.js";
-import { Hex, hexFrom, HexLike } from "../hex/index.js";
-import { byteVec, Codec, option, uint, uintNumber, vector } from "./codec.js";
+import { Codec, CodecBytes } from "../codec/index.js";
+import { Hex, HexLike } from "../hex/index.js";
+import { byteVec, option, vector } from "./codec.js";
+
+import {
+  CodecBool as Bool,
+  CodecByte as Byte,
+  CodecByte16 as Byte16,
+  CodecByte32 as Byte32,
+  CodecByte4 as Byte4,
+  CodecByte8 as Byte8,
+  CodecUint128 as Uint128,
+  CodecUint128BE as Uint128BE,
+  CodecUint128LE as Uint128LE,
+  CodecUint16 as Uint16,
+  CodecUint16BE as Uint16BE,
+  CodecUint16LE as Uint16LE,
+  CodecUint256 as Uint256,
+  CodecUint256BE as Uint256BE,
+  CodecUint256LE as Uint256LE,
+  CodecUint32 as Uint32,
+  CodecUint32BE as Uint32BE,
+  CodecUint32LE as Uint32LE,
+  CodecUint512 as Uint512,
+  CodecUint512BE as Uint512BE,
+  CodecUint512LE as Uint512LE,
+  CodecUint64 as Uint64,
+  CodecUint64BE as Uint64BE,
+  CodecUint64LE as Uint64LE,
+  CodecUint8 as Uint8,
+} from "../codec/index.js";
+
+export {
+  Bool,
+  Byte,
+  Byte16,
+  Byte32,
+  Byte4,
+  Byte8,
+  Uint128,
+  Uint128BE,
+  Uint128LE,
+  Uint16,
+  Uint16BE,
+  Uint16LE,
+  Uint256,
+  Uint256BE,
+  Uint256LE,
+  Uint32,
+  Uint32BE,
+  Uint32LE,
+  Uint512,
+  Uint512BE,
+  Uint512LE,
+  Uint64,
+  Uint64BE,
+  Uint64LE,
+  Uint8,
+};
 
-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 Uint512Opt = option(Uint512);
 export const Uint512Vec = vector(Uint512);
 
-export const Bytes: Codec<HexLike, Hex> = byteVec({
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
+export const Bytes: Codec<HexLike, Hex> = byteVec(CodecBytes);
 export const BytesOpt = option(Bytes);
 export const BytesVec = vector(Bytes);
 
-export const Bool: Codec<boolean> = Codec.from({
-  byteLength: 1,
-  encode: (value) => bytesFrom(value ? [1] : [0]),
-  decode: (buffer) => bytesFrom(buffer)[0] !== 0,
-});
 export const BoolOpt = option(Bool);
 export const BoolVec = vector(Bool);
 
-export const Byte4: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 4,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
+export const ByteOpt = option(Byte);
+export const ByteVec = vector(Byte);
+
 export const Byte4Opt = option(Byte4);
 export const Byte4Vec = vector(Byte4);
 
-export const Byte8: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 8,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte8Opt = option(Byte8);
 export const Byte8Vec = vector(Byte8);
 
-export const Byte16: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 16,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte16Opt = option(Byte16);
 export const Byte16Vec = vector(Byte16);
 
-export const Byte32: Codec<HexLike, Hex> = Codec.from({
-  byteLength: 32,
-  encode: (value) => bytesFrom(value),
-  decode: (buffer) => hexFrom(buffer),
-});
 export const Byte32Opt = option(Byte32);
 export const Byte32Vec = vector(Byte32);
 

package/src/signer/btc/index.ts

@@ -1,3 +1,4 @@
+export * from "./psbt.js";
 export * from "./signerBtc.js";
 export * from "./signerBtcPublicKeyReadonly.js";
 export * from "./verify.js";