@ckb-ccc/core 0.1.0-alpha.6 → 0.1.0-alpha.7

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @ckb-ccc/core
 
+## 0.1.0-alpha.7
+
+### Patch Changes
+
+- [#88](https://github.com/ckb-devrel/ccc/pull/88) [`f07a506`](https://github.com/ckb-devrel/ccc/commit/f07a506bd6fc27fe659a17d2f7baaeec54716d81) Thanks [@ashuralyk](https://github.com/ashuralyk)! - feat: molecule codec
+  feat: spore searcher
+
 ## 0.1.0-alpha.6
 
 ### Patch Changes

package/dist/barrel.d.ts

@@ -6,6 +6,7 @@ export * from "./fixedPoint/index.js";
 export * from "./hasher/index.js";
 export * from "./hex/index.js";
 export * from "./keystore/index.js";
+export * as mol from "./molecule/index.js";
 export * from "./num/index.js";
 export * from "./signer/index.js";
 export * from "./utils/index.js";

package/dist/barrel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barrel.d.ts","sourceRoot":"","sources":["../src/barrel.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"barrel.d.ts","sourceRoot":"","sources":["../src/barrel.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAC3C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/barrel.js

@@ -6,6 +6,7 @@ export * from "./fixedPoint/index.js";
 export * from "./hasher/index.js";
 export * from "./hex/index.js";
 export * from "./keystore/index.js";
+export * as mol from "./molecule/index.js";
 export * from "./num/index.js";
 export * from "./signer/index.js";
 export * from "./utils/index.js";

package/dist/molecule/codec.d.ts

@@ -0,0 +1,118 @@
+import { Bytes, BytesLike } from "../bytes/index.js";
+import { Num, NumLike } from "../num/index.js";
+export type CodecLike<Encodable, Decoded = Encodable> = {
+    readonly encode: (encodable: Encodable) => Bytes;
+    readonly decode: (decodable: BytesLike) => Decoded;
+    readonly byteLength?: number;
+};
+export declare class Codec<Encodable, Decoded = Encodable> {
+    readonly encode: (encodable: Encodable) => Bytes;
+    readonly decode: (decodable: BytesLike) => Decoded;
+    readonly byteLength?: number | undefined;
+    constructor(encode: (encodable: Encodable) => Bytes, decode: (decodable: BytesLike) => Decoded, byteLength?: number | undefined);
+    static from<Encodable, Decoded = Encodable>({ encode, decode, byteLength, }: CodecLike<Encodable, Decoded>): Codec<Encodable, Decoded>;
+    map<NewEncodable = Encodable, NewDecoded = Decoded>({ inMap, outMap, }: {
+        inMap?: (encodable: NewEncodable) => Encodable;
+        outMap?: (decoded: Decoded) => NewDecoded;
+    }): Codec<NewEncodable, NewDecoded>;
+}
+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;
+/**
+ * Vector with fixed size item codec
+ * @param itemCodec fixed-size vector item codec
+ */
+export declare function fixedItemVec<Encodable, Decoded>(itemCodec: CodecLike<Encodable, Decoded>): Codec<Array<Encodable>, Array<Decoded>>;
+/**
+ * Vector with dynamic size item codec, you can create a recursive vector with this function
+ * @param itemCodec the vector item codec. It can be fixed-size or dynamic-size.
+ */
+export declare function dynItemVec<Encodable, Decoded>(itemCodec: CodecLike<Encodable, Decoded>): Codec<Array<Encodable>, Array<Decoded>>;
+/**
+ * General vector codec, if `itemCodec` is fixed size type, it will create a fixvec codec, otherwise a dynvec codec will be created.
+ * @param itemCodec
+ */
+export declare function vector<Encodable, Decoded>(itemCodec: CodecLike<Encodable, Decoded>): Codec<Array<Encodable>, Array<Decoded>>;
+/**
+ * Option is a dynamic-size type.
+ * Serializing an option depends on whether it is empty or not:
+ * - if it's empty, there is zero bytes (the size is 0).
+ * - if it's not empty, just serialize the inner item (the size is same as the inner item's size).
+ * @param innerCodec
+ */
+export declare function option<Encodable, Decoded>(innerCodec: CodecLike<Encodable, Decoded>): Codec<Encodable | undefined | null, Decoded | undefined>;
+/**
+ * Wrap the encoded value with a fixed-length buffer
+ * @param codec
+ */
+export declare function byteVec<Encodable, Decoded>(codec: CodecLike<Encodable, Decoded>): Codec<Encodable, Decoded>;
+export type EncodableRecordOptionalKeys<T extends Record<string, CodecLike<any, any>>> = {
+    [K in keyof T]: Extract<EncodableType<T[K]>, undefined> extends never ? never : K;
+}[keyof T];
+export type EncodableRecord<T extends Record<string, CodecLike<any, any>>> = {
+    [key in keyof Pick<T, EncodableRecordOptionalKeys<T>>]+?: EncodableType<T[key]>;
+} & {
+    [key in keyof Omit<T, EncodableRecordOptionalKeys<T>>]: EncodableType<T[key]>;
+};
+export type DecodedRecordOptionalKeys<T extends Record<string, CodecLike<any, any>>> = {
+    [K in keyof T]: Extract<DecodedType<T[K]>, undefined> extends never ? never : K;
+}[keyof T];
+export type DecodedRecord<T extends Record<string, CodecLike<any, any>>> = {
+    [key in keyof Pick<T, DecodedRecordOptionalKeys<T>>]+?: DecodedType<T[key]>;
+} & {
+    [key in keyof Omit<T, DecodedRecordOptionalKeys<T>>]: DecodedType<T[key]>;
+};
+/**
+ * Table is a dynamic-size type. It can be considered as a dynvec but the length is fixed.
+ * @param codecLayout
+ */
+export declare function table<T extends Record<string, CodecLike<any, any>>, Encodable extends EncodableRecord<T>, Decoded extends DecodedRecord<T>>(codecLayout: T): Codec<Encodable, Decoded>;
+type UnionEncodable<T extends Record<string, CodecLike<any, any>>, K extends keyof T = keyof T> = K extends unknown ? {
+    type: K;
+    value: EncodableType<T[K]>;
+} : never;
+type UnionDecoded<T extends Record<string, CodecLike<any, any>>, K extends keyof T = keyof T> = K extends unknown ? {
+    type: K;
+    value: DecodedType<T[K]>;
+} : never;
+/**
+ * Union is a dynamic-size type.
+ * Serializing a union has two steps:
+ * - Serialize an item type id in bytes as a 32 bit unsigned integer in little-endian. The item type id is the index of the inner items, and it's starting at 0.
+ * - Serialize the inner item.
+ * @param codecLayout the union item record
+ * @param fields the custom item type id record
+ * @example
+ * // without custom id
+ * union({ cafe: Uint8, bee: Uint8 })
+ * // with custom id
+ * union({ cafe: Uint8, bee: Uint8 }, { cafe: 0xcafe, bee: 0xbee })
+ */
+export declare function union<T extends Record<string, CodecLike<any, any>>>(codecLayout: T, fields?: Record<keyof T, number | undefined | null>): Codec<UnionEncodable<T>, UnionDecoded<T>>;
+/**
+ * Struct is a fixed-size type: all fields in struct are fixed-size and it has a fixed quantity of fields.
+ * The size of a struct is the sum of all fields' size.
+ * @param codecLayout a object contains all fields' codec
+ */
+export declare function struct<T extends Record<string, CodecLike<any, any>>, Encodable extends EncodableRecord<T>, Decoded extends DecodedRecord<T>>(codecLayout: T): Codec<Encodable, Decoded>;
+/**
+ * The array is a fixed-size type: it has a fixed-size inner type and a fixed length.
+ * The size of an array is the size of inner type times the length.
+ * @param itemCodec the fixed-size array item codec
+ * @param itemCount
+ */
+export declare function array<Encodable, Decoded>(itemCodec: CodecLike<Encodable, Decoded>, itemCount: number): Codec<Array<Encodable>, Array<Decoded>>;
+/**
+ * Create a codec to deal with fixed LE or BE bytes.
+ * @param byteLength
+ * @param littleEndian
+ */
+export declare function uint(byteLength: number, littleEndian?: boolean): Codec<NumLike, Num>;
+/**
+ * Create a codec to deal with fixed LE or BE bytes.
+ * @param byteLength
+ * @param littleEndian
+ */
+export declare function uintNumber(byteLength: number, littleEndian?: boolean): Codec<NumLike, number>;
+export {};
+//# sourceMappingURL=codec.d.ts.map

package/dist/molecule/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/molecule/codec.ts"],"names":[],"mappings":"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"}

package/dist/molecule/codec.js

@@ -0,0 +1,446 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { bytesConcat, bytesFrom } from "../bytes/index.js";
+import { numBeFromBytes, numBeToBytes, numFromBytes, numToBytes, } from "../num/index.js";
+export class Codec {
+    constructor(encode, decode, byteLength) {
+        this.encode = encode;
+        this.decode = decode;
+        this.byteLength = byteLength;
+    }
+    static from({ encode, decode, byteLength, }) {
+        return new Codec(encode, decode, byteLength);
+    }
+    map({ inMap, outMap, }) {
+        return Codec.from({
+            byteLength: this.byteLength,
+            encode: (encodable) => this.encode((inMap ? inMap(encodable) : encodable)),
+            decode: (buffer) => (outMap
+                ? outMap(this.decode(buffer))
+                : this.decode(buffer)),
+        });
+    }
+}
+function uint32To(numLike) {
+    return numToBytes(numLike, 4);
+}
+function uint32From(bytesLike) {
+    return Number(numFromBytes(bytesLike));
+}
+/**
+ * Vector with fixed size item codec
+ * @param itemCodec fixed-size vector item codec
+ */
+export function fixedItemVec(itemCodec) {
+    const itemByteLength = itemCodec.byteLength;
+    if (itemByteLength === undefined) {
+        throw new Error("fixedItemVec: itemCodec requires a byte length");
+    }
+    return Codec.from({
+        encode(userDefinedItems) {
+            try {
+                return userDefinedItems.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
+            }
+            catch (e) {
+                throw new Error(`fixedItemVec(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            if (value.byteLength < 4) {
+                throw new Error(`fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
+            }
+            const itemCount = uint32From(value.slice(0, 4));
+            const byteLength = 4 + itemCount * itemByteLength;
+            if (value.byteLength !== byteLength) {
+                throw new Error(`fixedItemVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
+            }
+            try {
+                const decodedArray = [];
+                for (let offset = 0; offset < byteLength; offset += itemByteLength) {
+                    decodedArray.push(itemCodec.decode(value.slice(offset, offset + itemByteLength)));
+                }
+                return decodedArray;
+            }
+            catch (e) {
+                throw new Error(`fixedItemVec(${e?.toString()})`);
+            }
+        },
+    });
+}
+/**
+ * Vector with dynamic size item codec, you can create a recursive vector with this function
+ * @param itemCodec the vector item codec. It can be fixed-size or dynamic-size.
+ */
+export function dynItemVec(itemCodec) {
+    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);
+            }
+            catch (e) {
+                throw new Error(`dynItemVec(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            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}`);
+            }
+            const offset = uint32From(value.slice(4, 8));
+            const itemCount = (offset - 4) / 4;
+            const offsets = Array.from(new Array(itemCount), (_, index) => uint32From(value.slice(4 + index * 4, 8 + index * 4)));
+            offsets.push(byteLength);
+            try {
+                const decodedArray = [];
+                for (let index = 0; index < offsets.length - 1; index++) {
+                    const start = offsets[index];
+                    const end = offsets[index + 1];
+                    const itemBuffer = value.slice(start, end);
+                    decodedArray.push(itemCodec.decode(itemBuffer));
+                }
+                return decodedArray;
+            }
+            catch (e) {
+                throw new Error(`dynItemVec(${e?.toString()})`);
+            }
+        },
+    });
+}
+/**
+ * General vector codec, if `itemCodec` is fixed size type, it will create a fixvec codec, otherwise a dynvec codec will be created.
+ * @param itemCodec
+ */
+export function vector(itemCodec) {
+    if (itemCodec.byteLength !== undefined) {
+        return fixedItemVec(itemCodec);
+    }
+    return dynItemVec(itemCodec);
+}
+/**
+ * Option is a dynamic-size type.
+ * Serializing an option depends on whether it is empty or not:
+ * - if it's empty, there is zero bytes (the size is 0).
+ * - if it's not empty, just serialize the inner item (the size is same as the inner item's size).
+ * @param innerCodec
+ */
+export function option(innerCodec) {
+    return Codec.from({
+        encode(userDefinedOrNull) {
+            if (!userDefinedOrNull) {
+                return bytesFrom([]);
+            }
+            try {
+                return innerCodec.encode(userDefinedOrNull);
+            }
+            catch (e) {
+                throw new Error(`option(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            if (value.byteLength === 0) {
+                return undefined;
+            }
+            try {
+                return innerCodec.decode(buffer);
+            }
+            catch (e) {
+                throw new Error(`option(${e?.toString()})`);
+            }
+        },
+    });
+}
+/**
+ * Wrap the encoded value with a fixed-length buffer
+ * @param codec
+ */
+export function byteVec(codec) {
+    return Codec.from({
+        encode(userDefined) {
+            try {
+                const payload = bytesFrom(codec.encode(userDefined));
+                const byteLength = uint32To(payload.byteLength);
+                return bytesConcat(byteLength, payload);
+            }
+            catch (e) {
+                throw new Error(`byteVec(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            if (value.byteLength < 4) {
+                throw new Error(`byteVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
+            }
+            const byteLength = uint32From(value.slice(0, 4));
+            if (byteLength !== value.byteLength - 4) {
+                throw new Error(`byteVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
+            }
+            try {
+                return codec.decode(value.slice(4));
+            }
+            catch (e) {
+                throw new Error(`byteVec(${e?.toString()})`);
+            }
+        },
+    });
+}
+/**
+ * Table is a dynamic-size type. It can be considered as a dynvec but the length is fixed.
+ * @param codecLayout
+ */
+export function table(codecLayout) {
+    const keys = Object.keys(codecLayout);
+    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[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) {
+                    throw new Error(`table.${key}(${e?.toString()})`);
+                }
+            }, {
+                header: bytesFrom([]),
+                body: bytesFrom([]),
+                offset: headerLength,
+            });
+            const packedTotalSize = uint32To(header.byteLength + body.byteLength + 4);
+            return bytesConcat(packedTotalSize, header, body);
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            const byteLength = uint32From(value.slice(0, 4));
+            if (byteLength !== value.byteLength) {
+                throw new Error(`table: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
+            }
+            if (byteLength <= 4) {
+                throw new Error("table: empty buffer");
+            }
+            const offsets = keys.map((_, index) => uint32From(value.slice(4 + index * 4, 8 + index * 4)));
+            offsets.push(byteLength);
+            const object = {};
+            for (let i = 0; i < offsets.length - 1; i++) {
+                const start = offsets[i];
+                const end = offsets[i + 1];
+                const field = keys[i];
+                const codec = codecLayout[field];
+                const payload = value.slice(start, end);
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    Object.assign(object, { [field]: codec.decode(payload) });
+                }
+                catch (e) {
+                    throw new Error(`table.${field}(${e?.toString()})`);
+                }
+            }
+            return object;
+        },
+    });
+}
+/**
+ * Union is a dynamic-size type.
+ * Serializing a union has two steps:
+ * - Serialize an item type id in bytes as a 32 bit unsigned integer in little-endian. The item type id is the index of the inner items, and it's starting at 0.
+ * - Serialize the inner item.
+ * @param codecLayout the union item record
+ * @param fields the custom item type id record
+ * @example
+ * // without custom id
+ * union({ cafe: Uint8, bee: Uint8 })
+ * // with custom id
+ * union({ cafe: Uint8, bee: Uint8 }, { cafe: 0xcafe, bee: 0xbee })
+ */
+export function union(codecLayout, fields) {
+    const keys = Object.keys(codecLayout);
+    return Codec.from({
+        encode({ type, value }) {
+            const typeStr = type.toString();
+            const codec = codecLayout[typeStr];
+            if (!codec) {
+                throw new Error(`union: invalid type, expected ${keys.toString()}, but got ${typeStr}`);
+            }
+            const fieldId = fields ? (fields[typeStr] ?? -1) : keys.indexOf(typeStr);
+            if (fieldId < 0) {
+                throw new Error(`union: invalid field id ${fieldId} of ${typeStr}`);
+            }
+            const header = uint32To(fieldId);
+            try {
+                const body = codec.encode(value);
+                return bytesConcat(header, body);
+            }
+            catch (e) {
+                throw new Error(`union.(${typeStr})(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            const fieldIndex = uint32From(value.slice(0, 4));
+            const keys = Object.keys(codecLayout);
+            const field = (() => {
+                if (!fields) {
+                    return keys[fieldIndex];
+                }
+                const entry = Object.entries(fields).find(([, id]) => id === fieldIndex);
+                return entry?.[0];
+            })();
+            if (!field) {
+                if (!fields) {
+                    throw new Error(`union: unknown union field index ${fieldIndex}, only ${keys.toString()} are allowed`);
+                }
+                const fieldKeys = Object.keys(fields);
+                throw new Error(`union: unknown union field index ${fieldIndex}, only ${fieldKeys.toString()} and ${keys.toString()} are allowed`);
+            }
+            return {
+                type: field,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                value: codecLayout[field].decode(value.slice(4)),
+            };
+        },
+    });
+}
+/**
+ * Struct is a fixed-size type: all fields in struct are fixed-size and it has a fixed quantity of fields.
+ * The size of a struct is the sum of all fields' size.
+ * @param codecLayout a object contains all fields' codec
+ */
+export function struct(codecLayout) {
+    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),
+        encode(object) {
+            return keys.reduce((result, key) => {
+                try {
+                    const encodedItem = codecLayout[key].encode(object[key]);
+                    return bytesConcat(result, encodedItem);
+                }
+                catch (e) {
+                    throw new Error(`struct.${key}(${e?.toString()})`);
+                }
+            }, bytesFrom([]));
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            const object = {};
+            let offset = 0;
+            Object.entries(codecLayout).forEach(([key, codec]) => {
+                const payload = value.slice(offset, offset + codec.byteLength);
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    Object.assign(object, { [key]: codec.decode(payload) });
+                }
+                catch (e) {
+                    throw new Error(`struct.${key}(${e.toString()})`);
+                }
+                offset = offset + codec.byteLength;
+            });
+            return object;
+        },
+    });
+}
+/**
+ * The array is a fixed-size type: it has a fixed-size inner type and a fixed length.
+ * The size of an array is the size of inner type times the length.
+ * @param itemCodec the fixed-size array item codec
+ * @param itemCount
+ */
+export function array(itemCodec, itemCount) {
+    if (itemCodec.byteLength === undefined) {
+        throw new Error("array: itemCodec requires a byte length");
+    }
+    const byteLength = itemCodec.byteLength * itemCount;
+    return Codec.from({
+        byteLength,
+        encode(items) {
+            try {
+                return items.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), bytesFrom([]));
+            }
+            catch (e) {
+                throw new Error(`array(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = bytesFrom(buffer);
+            if (value.byteLength != byteLength) {
+                throw new Error(`array: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
+            }
+            try {
+                const result = [];
+                for (let i = 0; i < value.byteLength; i += itemCodec.byteLength) {
+                    result.push(itemCodec.decode(value.slice(i, i + itemCodec.byteLength)));
+                }
+                return result;
+            }
+            catch (e) {
+                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, littleEndian = false) {
+    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, littleEndian = false) {
+    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/dist/molecule/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./codec.js";
+export * from "./predefined.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/molecule/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/molecule/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/molecule/index.js

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