@ckb-ccc/core 1.22.0 → 2.0.0-next.1

package/src/codec/codec.ts

@@ -3,12 +3,13 @@
 import { Bytes, bytesFrom, BytesLike } from "../bytes/index.js";
 
 export type CodecLike<Encodable, Decoded = Encodable> = {
-  readonly encode: (encodable: Encodable) => Bytes;
-  readonly decode: (
-    decodable: BytesLike,
+  encode: (encodable: Encodable) => BytesLike;
+  decode: (
+    decodable: Bytes,
     config?: { isExtraFieldIgnored?: boolean },
   ) => Decoded;
-  readonly byteLength?: number;
+  from?: ((encoded: Encodable) => Decoded) | null;
+  byteLength?: number;
 };
 export class Codec<Encodable, Decoded = Encodable> {
   constructor(
@@ -17,6 +18,7 @@ export class Codec<Encodable, Decoded = Encodable> {
       decodable: BytesLike,
       config?: { isExtraFieldIgnored?: boolean }, // This is equivalent to "compatible" in the Rust implementation of Molecule.
     ) => Decoded,
+    public readonly from: (encodable: Encodable) => Decoded,
     public readonly byteLength?: number, // if provided, treat codec as fixed length
   ) {}
 
@@ -40,53 +42,76 @@ export class Codec<Encodable, Decoded = Encodable> {
     }
   }
 
-  static from<Encodable, Decoded = Encodable>({
-    encode,
-    decode,
-    byteLength,
-  }: CodecLike<Encodable, Decoded>): Codec<Encodable, Decoded> {
+  static from<Encodable, Decoded = Encodable>(
+    codecLike: CodecLike<Encodable, Decoded>,
+  ): Codec<Encodable, Decoded> {
+    const newEncode = function (encodable: Encodable) {
+      const encoded = bytesFrom(codecLike.encode(encodable));
+      if (
+        codecLike.byteLength !== undefined &&
+        encoded.byteLength !== codecLike.byteLength
+      ) {
+        throw new Error(
+          `Codec.encode: expected byte length ${codecLike.byteLength}, got ${encoded.byteLength}`,
+        );
+      }
+      return encoded;
+    };
+    const newDecode = function (
+      decodable: BytesLike,
+      config?: { isExtraFieldIgnored?: boolean },
+    ) {
+      const decodableBytes = bytesFrom(decodable);
+      if (
+        codecLike.byteLength !== undefined &&
+        decodableBytes.byteLength !== codecLike.byteLength
+      ) {
+        throw new Error(
+          `Codec.decode: expected byte length ${codecLike.byteLength}, got ${decodableBytes.byteLength}`,
+        );
+      }
+      return codecLike.decode(decodableBytes, config);
+    };
     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,
+      newEncode,
+      newDecode,
+      codecLike.from?.bind(codecLike) ??
+        function (encodable: Encodable) {
+          return newDecode(newEncode(encodable));
+        },
+      codecLike.byteLength,
     );
   }
 
   map<NewEncodable = Encodable, NewDecoded = Decoded>({
     inMap,
     outMap,
+    from,
   }: {
     inMap?: (encodable: NewEncodable) => Encodable;
     outMap?: (decoded: Decoded) => NewDecoded;
+    from?: (encodable: NewEncodable) => 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,
-    );
+    const encode = inMap
+      ? (encodable: NewEncodable) => this.encode(inMap(encodable))
+      : (this.encode as unknown as (encodable: NewEncodable) => Bytes);
+    const decode = outMap
+      ? (buffer: BytesLike, config?: { isExtraFieldIgnored?: boolean }) =>
+          outMap(this.decode(buffer, config))
+      : (this.decode as unknown as (
+          buffer: BytesLike,
+          config?: { isExtraFieldIgnored?: boolean },
+        ) => NewDecoded);
+    const newFrom =
+      from ??
+      ((encodable: NewEncodable): NewDecoded => {
+        const toEncode = (inMap ? inMap(encodable) : encodable) as Encodable;
+        return (
+          outMap ? outMap(this.from(toEncode)) : this.from(toEncode)
+        ) as NewDecoded;
+      });
+
+    return new Codec(encode, decode, newFrom, this.byteLength);
   }
 
   mapIn<NewEncodable>(

package/src/codec/entity.ts

@@ -3,7 +3,7 @@ import { hashCkb } from "../hasher/index.js";
 import { Hex, hexFrom } from "../hex/index.js";
 import type { UnionDecoded, UnionMatchHandlers } from "../molecule/codec.js";
 import { Constructor } from "../utils/index.js";
-import type { CodecLike, DecodedType } from "./codec.js";
+import { Codec, CodecLike, DecodedType } from "./codec.js";
 
 /**
  * The base class of CCC to create a serializable instance. This should be used with the {@link codec} decorator.
@@ -16,6 +16,13 @@ export abstract class Entity {
    * @public
    */
   static Base<SubTypeLike, SubType = SubTypeLike>() {
+    // Static methods in this class are written in function syntax not method syntax
+    // to enable strictFunctionTypes to catch more errors.
+    // This protects when the class is extended and the static methods are overridden with incompatible types.
+    // See https://www.typescriptlang.org/tsconfig/#strictFunctionTypes
+    // >> During development of this feature, we discovered a large number of inherently unsafe class hierarchies,
+    // >> including some in the DOM. Because of this, the setting only applies to functions written in function syntax,
+    // >> not to those in method syntax
     abstract class Impl extends Entity {
       /**
        * The bytes length of the entity, if it is fixed, otherwise undefined
@@ -31,38 +38,34 @@ export abstract class Entity {
        * @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.codec to decorate your type",
-        );
-      }
+      static encode: (_: SubTypeLike) => Bytes;
       /**
        * Decode the entity from bytes
        * @public
        * @static
        * @param _ - The bytes to decode
+       * @param _config - The configuration for decoding, including whether to ignore extra fields
        * @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.codec to decorate your type",
-        );
-      }
+      static decode: (
+        _: BytesLike,
+        _config?: { isExtraFieldIgnored?: boolean },
+      ) => SubType;
 
       /**
        * Create an entity from bytes
        * @public
        * @static
        * @param _ - The bytes to create the entity from
+       * @param _config - The configuration for decoding, including whether to ignore extra fields
        * @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.codec to decorate your type",
-        );
-      }
+      static fromBytes: (
+        _bytes: BytesLike,
+        _config?: { isExtraFieldIgnored?: boolean },
+      ) => SubType;
 
       /**
        * Create an entity from a serializable object
@@ -72,9 +75,7 @@ export abstract class Entity {
        * @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");
-      }
+      static from: (_: SubTypeLike) => SubType;
 
       /**
        * Convert the entity to bytes
@@ -110,11 +111,9 @@ export abstract class Entity {
 
         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
+            (this.constructor as typeof Impl).from(other) as unknown as Impl
           ).toBytes(),
-          /* eslint-enable @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any */
         );
       }
 
@@ -137,12 +136,6 @@ export abstract class Entity {
       }
     }
 
-    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
-    Impl.encode = undefined as any;
-    Impl.decode = undefined as any;
-    Impl.fromBytes = undefined as any;
-    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
-
     return Impl;
   }
 
@@ -247,57 +240,92 @@ export abstract class Entity {
  * A class decorator to add methods implementation on the {@link Entity.Base} class
  * @example
  * ```typescript
- * @codec(
- *   mol.table({
- *     codeHash: mol.Byte32,
- *     hashType: HashTypeCodec,
- *     args: mol.Bytes,
- *   }),
- * )
+ * const ScriptCodec = mol.table({
+ *   codeHash: mol.Byte32,
+ *   hashType: HashTypeCodec,
+ *   args: mol.Bytes,
+ * });
+ * export type ScriptLike = EncodableType<typeof ScriptCodec>;
+ * @codec(ScriptCodec)
  * export class Script extends Entity.Base<ScriptLike, Script>() {
- *   from(scriptLike: ScriptLike): Script {}
+ *   public codeHash: Hex;
+ *   public hashType: HashType;
+ *   public args: Hex;
+ *
+ *   constructor({ codeHash, hashType, args }: DecodedType<typeof ScriptCodec>) {
+ *     super();
+ *
+ *     this.codeHash = codeHash;
+ *     this.hashType = hashType;
+ *     this.args = args;
+ *   }
  * }
  * ```
  */
-export function codec<
-  Encodable,
-  TypeLike extends Encodable,
-  Decoded extends TypeLike,
->(codec: {
-  encode: (encodable: Encodable) => Bytes;
-  decode: (
-    decodable: Bytes,
-    config?: { isExtraFieldIgnored?: boolean },
-  ) => Decoded;
-  byteLength?: number;
-}) {
+export function codec<Encodable, Decoded>(
+  codecLike: CodecLike<Encodable, Decoded>,
+) {
+  const codec = Codec.from(codecLike);
+
   return function <
+    TypeLike extends Encodable,
     Type extends TypeLike,
-    ConstructorType extends Constructor<Type> & {
-      from(decoded: TypeLike): Type;
-      byteLength?: number;
-      encode(encodable: TypeLike): Bytes;
-      decode(bytesLike: BytesLike): Type;
-      fromBytes(bytes: BytesLike): Type;
-    },
-  >(Constructor: ConstructorType, ..._: unknown[]) {
-    Constructor.byteLength = codec.byteLength;
-    if (Constructor.encode === undefined) {
-      Constructor.encode = function (encodable: TypeLike) {
-        return codec.encode(Constructor.from(encodable));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ConstructorType extends Constructor<Type, [Decoded, ...any[]]>,
+  >(
+    Constructor: ConstructorType &
+      Omit<CodecLike<TypeLike, Type>, "from"> & {
+        // Since Base.from only accepts TypeLike,
+        // passing this check actually tells us that Decoded extends TypeLike
+        from: (encodable: TypeLike | Decoded) => Type;
+        fromBytes: (bytes: BytesLike) => Type;
+      },
+    ..._: unknown[]
+  ): void {
+    const Base = Object.getPrototypeOf(Constructor) as Omit<
+      CodecLike<TypeLike, Type>,
+      "from"
+    > & {
+      // See above, we already know that Decoded extends TypeLike, so we can safely cast the type here.
+      from: (encodable: TypeLike) => Type;
+      fromBytes: (bytes: BytesLike) => Type;
+    };
+
+    Base.byteLength = codec.byteLength;
+    if (Base.encode === undefined) {
+      Base.encode = function (this: typeof Constructor, encodable: TypeLike) {
+        // Theoretically, the type allows us to codec.encode(encodable) directly.
+        // However, Constructor.from usually does more than just casting the type,
+        // so we need to call it to ensure the correct data is passed to codec.encode.
+        return codec.encode(this.from(encodable));
       };
     }
-    if (Constructor.decode === undefined) {
-      Constructor.decode = function (bytesLike: BytesLike) {
-        return Constructor.from(codec.decode(bytesFrom(bytesLike)));
+    if (Base.decode === undefined) {
+      Base.decode = function (
+        this: typeof Constructor,
+        bytesLike: BytesLike,
+        config?: { isExtraFieldIgnored?: boolean },
+      ) {
+        return this.from(codec.decode(bytesFrom(bytesLike), config));
       };
     }
-    if (Constructor.fromBytes === undefined) {
-      Constructor.fromBytes = function (bytes: BytesLike) {
-        return Constructor.from(codec.decode(bytesFrom(bytes)));
+    if (Base.fromBytes === undefined) {
+      Base.fromBytes = function (
+        this: typeof Constructor,
+        bytes: BytesLike,
+        config?: { isExtraFieldIgnored?: boolean },
+      ) {
+        return this.from(codec.decode(bytesFrom(bytes), config));
       };
     }
+    if (Base.from === undefined) {
+      Base.from = function (encodable: TypeLike) {
+        if (encodable instanceof Constructor) {
+          return encodable;
+        }
 
-    return Constructor;
+        return new Constructor(codec.from(encodable));
+      };
+    }
   };
 }

package/src/codec/predefined.ts

@@ -4,6 +4,7 @@ import {
   Num,
   numBeFromBytes,
   numBeToBytes,
+  numFrom,
   numFromBytes,
   NumLike,
   numToBytes,
@@ -35,6 +36,7 @@ export function codecUint(
         return numBeFromBytes(buffer);
       }
     },
+    from: numFrom,
   });
 }
 
@@ -69,17 +71,20 @@ export function codecPadding(
       return new Uint8Array(byteLength);
     },
     decode: () => {},
+    from: () => {},
   });
 }
 
 export const CodecRaw: Codec<BytesLike, Bytes> = Codec.from({
   encode: (value) => bytesFrom(value),
   decode: (buffer) => bytesFrom(buffer),
+  from: bytesFrom,
 });
 
 export const CodecBytes: Codec<HexLike, Hex> = Codec.from({
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });
 
 export const CodecUint8 = codecUintNumber(1, true);
@@ -112,34 +117,40 @@ export const CodecBool: Codec<boolean> = Codec.from({
   byteLength: 1,
   encode: (value) => bytesFrom(value ? [1] : [0]),
   decode: (buffer) => bytesFrom(buffer)[0] !== 0,
+  from: Boolean,
 });
 
 export const CodecByte: Codec<HexLike, Hex> = Codec.from({
   byteLength: 1,
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });
 
 export const CodecByte4: Codec<HexLike, Hex> = Codec.from({
   byteLength: 4,
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });
 
 export const CodecByte8: Codec<HexLike, Hex> = Codec.from({
   byteLength: 8,
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });
 
 export const CodecByte16: Codec<HexLike, Hex> = Codec.from({
   byteLength: 16,
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });
 
 export const CodecByte32: Codec<HexLike, Hex> = Codec.from({
   byteLength: 32,
   encode: (value) => bytesFrom(value),
   decode: (buffer) => hexFrom(buffer),
+  from: hexFrom,
 });

package/src/molecule/codec.ts

@@ -58,8 +58,9 @@ function getMessage(e: unknown): string {
  * @param itemCodec fixed-size vector item codec
  */
 export function fixedItemVec<Encodable, Decoded>(
-  itemCodec: CodecLike<Encodable, Decoded>,
+  itemCodecLike: CodecLike<Encodable, Decoded>,
 ): Codec<Array<Encodable>, Array<Decoded>> {
+  const itemCodec = Codec.from(itemCodecLike);
   const itemByteLength = itemCodec.byteLength;
   if (itemByteLength === undefined) {
     throw new Error("fixedItemVec: itemCodec requires a byte length");
@@ -108,6 +109,13 @@ export function fixedItemVec<Encodable, Decoded>(
         throw new Error(`fixedItemVec - ${getMessage(e)}`, { cause: e });
       }
     },
+    from(userDefinedItems) {
+      try {
+        return userDefinedItems.map((item) => itemCodec.from(item));
+      } catch (e: unknown) {
+        throw new Error(`fixedItemVec - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }
 
@@ -116,8 +124,10 @@ export function fixedItemVec<Encodable, Decoded>(
  * @param itemCodec the vector item codec. It can be fixed-size or dynamic-size.
  */
 export function dynItemVec<Encodable, Decoded>(
-  itemCodec: CodecLike<Encodable, Decoded>,
+  itemCodecLike: CodecLike<Encodable, Decoded>,
 ): Codec<Array<Encodable>, Array<Decoded>> {
+  const itemCodec = Codec.from(itemCodecLike);
+
   return Codec.from({
     encode(userDefinedItems) {
       try {
@@ -175,6 +185,13 @@ export function dynItemVec<Encodable, Decoded>(
         throw new Error(`dynItemVec - ${getMessage(e)}`, { cause: e });
       }
     },
+    from(userDefinedItems) {
+      try {
+        return userDefinedItems.map((item) => itemCodec.from(item));
+      } catch (e: unknown) {
+        throw new Error(`dynItemVec - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }
 
@@ -199,8 +216,10 @@ export function vector<Encodable, Decoded>(
  * @param innerCodec
  */
 export function option<Encodable, Decoded>(
-  innerCodec: CodecLike<Encodable, Decoded>,
+  innerCodecLike: CodecLike<Encodable, Decoded>,
 ): Codec<Encodable | undefined | null, Decoded | undefined> {
+  const innerCodec = Codec.from(innerCodecLike);
+
   return Codec.from({
     encode(userDefinedOrNull) {
       if (userDefinedOrNull == null) {
@@ -223,6 +242,16 @@ export function option<Encodable, Decoded>(
         throw new Error(`option - ${getMessage(e)}`, { cause: e });
       }
     },
+    from(userDefinedOrNull) {
+      try {
+        if (userDefinedOrNull == null) {
+          return undefined;
+        }
+        return innerCodec.from(userDefinedOrNull);
+      } catch (e: unknown) {
+        throw new Error(`option - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }
 
@@ -231,8 +260,10 @@ export function option<Encodable, Decoded>(
  * @param codec
  */
 export function byteVec<Encodable, Decoded>(
-  codec: CodecLike<Encodable, Decoded>,
+  codecLike: CodecLike<Encodable, Decoded>,
 ): Codec<Encodable, Decoded> {
+  const codec = Codec.from(codecLike);
+
   return Codec.from({
     encode(userDefined) {
       try {
@@ -262,6 +293,13 @@ export function byteVec<Encodable, Decoded>(
         throw new Error(`byteVec - ${getMessage(e)}`, { cause: e });
       }
     },
+    from(userDefined) {
+      try {
+        return codec.from(userDefined);
+      } catch (e: unknown) {
+        throw new Error(`byteVec - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }
 
@@ -301,7 +339,13 @@ export function table<
   T extends Record<string, CodecLike<any, any>>,
   Encodable extends EncodableRecord<T>,
   Decoded extends DecodedRecord<T>,
->(codecLayout: T): Codec<Encodable, Decoded> {
+>(codecLayoutLike: T): Codec<Encodable, Decoded> {
+  const codecLayout = Object.fromEntries(
+    Object.entries(codecLayoutLike).map(([key, codec]) => [
+      key,
+      Codec.from(codec),
+    ]),
+  );
   const keys = Object.keys(codecLayout);
 
   return Codec.from({
@@ -380,6 +424,18 @@ export function table<
       }
       return object as Decoded;
     },
+    from(object) {
+      const result: any = {};
+      for (const key of keys) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          result[key] = codecLayout[key].from((object as any)[key]);
+        } catch (e: unknown) {
+          throw new Error(`table.${key} - ${getMessage(e)}`, { cause: e });
+        }
+      }
+      return result as Decoded;
+    },
   });
 }
 
@@ -446,9 +502,15 @@ export type UnionMatchHandlers<
  */
 
 export function union<T extends Record<string, CodecLike<any, any>>>(
-  codecLayout: T,
+  codecLayoutLike: T,
   fields?: Record<keyof T, number | undefined | null>,
 ): Codec<UnionEncodable<T> | { inner: UnionEncodable<T> }, UnionDecoded<T>> {
+  const codecLayout = Object.fromEntries(
+    Object.entries(codecLayoutLike).map(([key, codec]) => [
+      key,
+      Codec.from(codec),
+    ]),
+  );
   const entries = Object.entries(codecLayout);
 
   // Determine if all variants have a fixed and equal byteLength.
@@ -532,6 +594,25 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
         value: codecLayout[field].decode(value.subarray(4), config),
       } as UnionDecoded<T>;
     },
+    from(encodable) {
+      const { type, value } = extract(encodable);
+      const typeStr = type.toString();
+      const codec = codecLayout[typeStr];
+      if (!codec) {
+        throw new Error(
+          `union: invalid type, expected ${entries.map((e) => e[0]).toString()}, but got ${typeStr}`,
+        );
+      }
+      try {
+        return {
+          type,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          value: codec.from(value),
+        } as UnionDecoded<T>;
+      } catch (e: unknown) {
+        throw new Error(`union.(${typeStr}) - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }
 
@@ -544,7 +625,13 @@ export function struct<
   T extends Record<string, CodecLike<any, any>>,
   Encodable extends EncodableRecord<T>,
   Decoded extends DecodedRecord<T>,
->(codecLayout: T): Codec<Encodable, Decoded> {
+>(codecLayoutLike: T): Codec<Encodable, Decoded> {
+  const codecLayout = Object.fromEntries(
+    Object.entries(codecLayoutLike).map(([key, codec]) => [
+      key,
+      Codec.from(codec),
+    ]),
+  );
   const codecArray = Object.values(codecLayout);
   const keys = Object.keys(codecLayout);
 
@@ -584,6 +671,18 @@ export function struct<
       });
       return object as Decoded;
     },
+    from(object) {
+      const result: any = {};
+      for (const key of keys) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          result[key] = codecLayout[key].from((object as any)[key]);
+        } catch (e: unknown) {
+          throw new Error(`struct.${key} - ${getMessage(e)}`, { cause: e });
+        }
+      }
+      return result as Decoded;
+    },
   });
 }
 
@@ -594,9 +693,11 @@ export function struct<
  * @param itemCount
  */
 export function array<Encodable, Decoded>(
-  itemCodec: CodecLike<Encodable, Decoded>,
+  itemCodecLike: CodecLike<Encodable, Decoded>,
   itemCount: number,
 ): Codec<Array<Encodable>, Array<Decoded>> {
+  const itemCodec = Codec.from(itemCodecLike);
+
   if (itemCodec.byteLength === undefined) {
     throw new Error("array: itemCodec requires a byte length");
   }
@@ -638,5 +739,12 @@ export function array<Encodable, Decoded>(
         throw new Error(`array - ${getMessage(e)}`, { cause: e });
       }
     },
+    from(userDefinedItems) {
+      try {
+        return userDefinedItems.map((item) => itemCodec.from(item));
+      } catch (e: unknown) {
+        throw new Error(`array - ${getMessage(e)}`, { cause: e });
+      }
+    },
   });
 }