@ckb-ccc/core 0.1.1 → 1.0.0

package/dist.commonjs/molecule/codec.js

@@ -1,7 +1,21 @@
+"use strict";
 /* 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 {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Codec = void 0;
+exports.fixedItemVec = fixedItemVec;
+exports.dynItemVec = dynItemVec;
+exports.vector = vector;
+exports.option = option;
+exports.byteVec = byteVec;
+exports.table = table;
+exports.union = union;
+exports.struct = struct;
+exports.array = array;
+exports.uint = uint;
+exports.uintNumber = uintNumber;
+const index_js_1 = require("../bytes/index.js");
+const index_js_2 = require("../num/index.js");
+class Codec {
     constructor(encode, decode, byteLength) {
         this.encode = encode;
         this.decode = decode;
@@ -20,17 +34,18 @@ export class Codec {
         });
     }
 }
+exports.Codec = Codec;
 function uint32To(numLike) {
-    return numToBytes(numLike, 4);
+    return (0, index_js_2.numToBytes)(numLike, 4);
 }
 function uint32From(bytesLike) {
-    return Number(numFromBytes(bytesLike));
+    return Number((0, index_js_2.numFromBytes)(bytesLike));
 }
 /**
  * Vector with fixed size item codec
  * @param itemCodec fixed-size vector item codec
  */
-export function fixedItemVec(itemCodec) {
+function fixedItemVec(itemCodec) {
     const itemByteLength = itemCodec.byteLength;
     if (itemByteLength === undefined) {
         throw new Error("fixedItemVec: itemCodec requires a byte length");
@@ -38,14 +53,14 @@ export function fixedItemVec(itemCodec) {
     return Codec.from({
         encode(userDefinedItems) {
             try {
-                return userDefinedItems.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
+                return userDefinedItems.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
             }
             catch (e) {
                 throw new Error(`fixedItemVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             if (value.byteLength < 4) {
                 throw new Error(`fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
             }
@@ -56,7 +71,7 @@ export function fixedItemVec(itemCodec) {
             }
             try {
                 const decodedArray = [];
-                for (let offset = 0; offset < byteLength; offset += itemByteLength) {
+                for (let offset = 4; offset < byteLength; offset += itemByteLength) {
                     decodedArray.push(itemCodec.decode(value.slice(offset, offset + itemByteLength)));
                 }
                 return decodedArray;
@@ -71,7 +86,7 @@ export function fixedItemVec(itemCodec) {
  * 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) {
+function dynItemVec(itemCodec) {
     return Codec.from({
         encode(userDefinedItems) {
             try {
@@ -79,30 +94,33 @@ export function dynItemVec(itemCodec) {
                     const encodedItem = itemCodec.encode(item);
                     const packedHeader = uint32To(offset);
                     return {
-                        header: bytesConcat(header, packedHeader),
-                        body: bytesConcat(body, encodedItem),
-                        offset: offset + bytesFrom(encodedItem).byteLength,
+                        header: (0, index_js_1.bytesConcat)(header, packedHeader),
+                        body: (0, index_js_1.bytesConcat)(body, encodedItem),
+                        offset: offset + (0, index_js_1.bytesFrom)(encodedItem).byteLength,
                     };
                 }, {
-                    header: bytesFrom([]),
-                    body: bytesFrom([]),
+                    header: (0, index_js_1.bytesFrom)([]),
+                    body: (0, index_js_1.bytesFrom)([]),
                     offset: 4 + userDefinedItems.length * 4,
                 });
                 const packedTotalSize = uint32To(encoded.header.byteLength + encoded.body.byteLength + 4);
-                return bytesConcat(packedTotalSize, encoded.header, encoded.body);
+                return (0, index_js_1.bytesConcat)(packedTotalSize, encoded.header, encoded.body);
             }
             catch (e) {
                 throw new Error(`dynItemVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
+            if (value.byteLength < 4) {
+                throw new Error(`dynItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
+            }
             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}`);
+            if (byteLength === 4) {
+                return [];
             }
             const offset = uint32From(value.slice(4, 8));
             const itemCount = (offset - 4) / 4;
@@ -128,7 +146,7 @@ export function dynItemVec(itemCodec) {
  * 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) {
+function vector(itemCodec) {
     if (itemCodec.byteLength !== undefined) {
         return fixedItemVec(itemCodec);
     }
@@ -141,11 +159,11 @@ export function vector(itemCodec) {
  * - 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) {
+function option(innerCodec) {
     return Codec.from({
         encode(userDefinedOrNull) {
             if (!userDefinedOrNull) {
-                return bytesFrom([]);
+                return (0, index_js_1.bytesFrom)([]);
             }
             try {
                 return innerCodec.encode(userDefinedOrNull);
@@ -155,7 +173,7 @@ export function option(innerCodec) {
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             if (value.byteLength === 0) {
                 return undefined;
             }
@@ -172,20 +190,20 @@ export function option(innerCodec) {
  * Wrap the encoded value with a fixed-length buffer
  * @param codec
  */
-export function byteVec(codec) {
+function byteVec(codec) {
     return Codec.from({
         encode(userDefined) {
             try {
-                const payload = bytesFrom(codec.encode(userDefined));
+                const payload = (0, index_js_1.bytesFrom)(codec.encode(userDefined));
                 const byteLength = uint32To(payload.byteLength);
-                return bytesConcat(byteLength, payload);
+                return (0, index_js_1.bytesConcat)(byteLength, payload);
             }
             catch (e) {
                 throw new Error(`byteVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             if (value.byteLength < 4) {
                 throw new Error(`byteVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
             }
@@ -206,7 +224,7 @@ export function byteVec(codec) {
  * Table is a dynamic-size type. It can be considered as a dynvec but the length is fixed.
  * @param codecLayout
  */
-export function table(codecLayout) {
+function table(codecLayout) {
     const keys = Object.keys(codecLayout);
     return Codec.from({
         encode(object) {
@@ -216,24 +234,24 @@ export function table(codecLayout) {
                     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,
+                        header: (0, index_js_1.bytesConcat)(result.header, packedOffset),
+                        body: (0, index_js_1.bytesConcat)(result.body, encodedItem),
+                        offset: result.offset + (0, index_js_1.bytesFrom)(encodedItem).byteLength,
                     };
                 }
                 catch (e) {
                     throw new Error(`table.${key}(${e?.toString()})`);
                 }
             }, {
-                header: bytesFrom([]),
-                body: bytesFrom([]),
+                header: (0, index_js_1.bytesFrom)([]),
+                body: (0, index_js_1.bytesFrom)([]),
                 offset: headerLength,
             });
             const packedTotalSize = uint32To(header.byteLength + body.byteLength + 4);
-            return bytesConcat(packedTotalSize, header, body);
+            return (0, index_js_1.bytesConcat)(packedTotalSize, header, body);
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.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}`);
@@ -275,7 +293,7 @@ export function table(codecLayout) {
  * // with custom id
  * union({ cafe: Uint8, bee: Uint8 }, { cafe: 0xcafe, bee: 0xbee })
  */
-export function union(codecLayout, fields) {
+function union(codecLayout, fields) {
     const keys = Object.keys(codecLayout);
     return Codec.from({
         encode({ type, value }) {
@@ -291,14 +309,14 @@ export function union(codecLayout, fields) {
             const header = uint32To(fieldId);
             try {
                 const body = codec.encode(value);
-                return bytesConcat(header, body);
+                return (0, index_js_1.bytesConcat)(header, body);
             }
             catch (e) {
                 throw new Error(`union.(${typeStr})(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             const fieldIndex = uint32From(value.slice(0, 4));
             const keys = Object.keys(codecLayout);
             const field = (() => {
@@ -328,7 +346,7 @@ export function union(codecLayout, 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) {
+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");
@@ -340,15 +358,15 @@ export function struct(codecLayout) {
             return keys.reduce((result, key) => {
                 try {
                     const encodedItem = codecLayout[key].encode(object[key]);
-                    return bytesConcat(result, encodedItem);
+                    return (0, index_js_1.bytesConcat)(result, encodedItem);
                 }
                 catch (e) {
                     throw new Error(`struct.${key}(${e?.toString()})`);
                 }
-            }, bytesFrom([]));
+            }, (0, index_js_1.bytesFrom)([]));
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             const object = {};
             let offset = 0;
             Object.entries(codecLayout).forEach(([key, codec]) => {
@@ -372,7 +390,7 @@ export function struct(codecLayout) {
  * @param itemCodec the fixed-size array item codec
  * @param itemCount
  */
-export function array(itemCodec, itemCount) {
+function array(itemCodec, itemCount) {
     if (itemCodec.byteLength === undefined) {
         throw new Error("array: itemCodec requires a byte length");
     }
@@ -381,14 +399,14 @@ export function array(itemCodec, itemCount) {
         byteLength,
         encode(items) {
             try {
-                return items.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), bytesFrom([]));
+                return items.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), (0, index_js_1.bytesFrom)([]));
             }
             catch (e) {
                 throw new Error(`array(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = bytesFrom(buffer);
+            const value = (0, index_js_1.bytesFrom)(buffer);
             if (value.byteLength != byteLength) {
                 throw new Error(`array: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
             }
@@ -410,23 +428,23 @@ export function array(itemCodec, itemCount) {
  * @param byteLength
  * @param littleEndian
  */
-export function uint(byteLength, littleEndian = false) {
+function uint(byteLength, littleEndian = false) {
     return Codec.from({
         byteLength,
         encode: (numLike) => {
             if (littleEndian) {
-                return numToBytes(numLike, byteLength);
+                return (0, index_js_2.numToBytes)(numLike, byteLength);
             }
             else {
-                return numBeToBytes(numLike, byteLength);
+                return (0, index_js_2.numBeToBytes)(numLike, byteLength);
             }
         },
         decode: (buffer) => {
             if (littleEndian) {
-                return numFromBytes(buffer);
+                return (0, index_js_2.numFromBytes)(buffer);
             }
             else {
-                return numBeFromBytes(buffer);
+                return (0, index_js_2.numBeFromBytes)(buffer);
             }
         },
     });
@@ -436,7 +454,7 @@ export function uint(byteLength, littleEndian = false) {
  * @param byteLength
  * @param littleEndian
  */
-export function uintNumber(byteLength, littleEndian = false) {
+function uintNumber(byteLength, littleEndian = false) {
     if (byteLength > 4) {
         throw new Error("uintNumber: byteLength must be less than or equal to 4");
     }

package/dist.commonjs/molecule/entity.d.ts

@@ -0,0 +1,98 @@
+import { Bytes, BytesLike } from "../bytes/index.js";
+import { Hex } from "../hex/index.js";
+import { Codec } from "./codec.js";
+/**
+ * The base class of CCC to create a serializable instance
+ * @public
+ */
+export declare abstract class Entity {
+    static Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
+        /**
+         * Convert the entity to bytes
+         * @public
+         * @returns The bytes representation of the entity
+         */
+        toBytes(): Bytes;
+        /**
+         * Create a clone of the entity
+         * @public
+         * @returns A clone of the entity
+         */
+        clone(): SubType;
+        /**
+         * Check if the entity is equal to another entity
+         * @public
+         * @param other - The other entity to compare with
+         * @returns True if the entities are equal, false otherwise
+         */
+        eq(other: SubTypeLike | SubType): boolean;
+        /**
+         * Calculate the hash of the entity
+         * @public
+         * @returns The hash of the entity
+         */
+        hash(): Hex;
+    }) & {
+        /**
+         * The bytes length of the entity, if it is fixed, otherwise undefined
+         * @public
+         * @static
+         */
+        byteLength?: number;
+        /**
+         * Encode the entity into bytes
+         * @public
+         * @static
+         * @param _ - The entity to encode
+         * @returns The encoded bytes
+         * @throws Will throw an error if the entity is not serializable
+         */
+        encode(_: SubTypeLike): Bytes;
+        /**
+         * Decode the entity from bytes
+         * @public
+         * @static
+         * @param _ - The bytes to decode
+         * @returns The decoded entity
+         * @throws Will throw an error if the entity is not serializable
+         */
+        decode(_: BytesLike): SubType;
+        /**
+         * Create an entity from bytes
+         * @public
+         * @static
+         * @param _ - The bytes to create the entity from
+         * @returns The created entity
+         * @throws Will throw an error if the entity is not serializable
+         */
+        fromBytes(_bytes: BytesLike): SubType;
+        /**
+         * Create an entity from a serializable object
+         * @public
+         * @static
+         * @param _ - The serializable object to create the entity from
+         * @returns The created entity
+         * @throws Will throw an error if the entity is not serializable
+         */
+        from(_: SubTypeLike): SubType;
+    };
+    abstract toBytes(): Bytes;
+    abstract hash(): Hex;
+    abstract clone(): Entity;
+}
+export declare function codec<Encodable, TypeLike extends Encodable, Decoded extends TypeLike, Type extends object & TypeLike, ConstructorType extends {
+    new (...args: any[]): Type;
+    from(decoded: TypeLike): Type;
+    byteLength?: number;
+    encode(encodable: TypeLike): Bytes;
+    decode(bytesLike: BytesLike): TypeLike;
+    fromBytes(bytes: BytesLike): Type;
+}>(codec: Codec<Encodable, Decoded>): (Constructor: ConstructorType) => {
+    new (...args: any[]): {};
+    byteLength: number | undefined;
+    encode(encodable: TypeLike): Bytes;
+    decode(bytesLike: BytesLike): Type;
+    fromBytes(bytes: BytesLike): Type;
+    from(decoded: TypeLike): Type;
+} & ConstructorType;
+//# sourceMappingURL=entity.d.ts.map

package/dist.commonjs/molecule/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../src/molecule/entity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAW,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;GAGG;AACH,8BAAsB,MAAM;IAC1B,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW;QA6D1C;;;;WAIG;mBACQ,KAAK;QAMhB;;;;WAIG;iBACM,OAAO;QAMhB;;;;;WAKG;kBACO,WAAW,GAAG,OAAO,GAAG,OAAO;QAezC;;;;WAIG;gBACK,GAAG;;QA3GX;;;;WAIG;qBACiB,MAAM;QAC1B;;;;;;;WAOG;kBACc,WAAW,GAAG,KAAK;QAKpC;;;;;;;WAOG;kBACc,SAAS,GAAG,OAAO;QAMpC;;;;;;;WAOG;0BACsB,SAAS,GAAG,OAAO;QAM5C;;;;;;;WAOG;gBACY,WAAW,GAAG,OAAO;;IA4DxC,QAAQ,CAAC,OAAO,IAAI,KAAK;IACzB,QAAQ,CAAC,IAAI,IAAI,GAAG;IACpB,QAAQ,CAAC,KAAK,IAAI,MAAM;CACzB;AAED,wBAAgB,KAAK,CACnB,SAAS,EACT,QAAQ,SAAS,SAAS,EAC1B,OAAO,SAAS,QAAQ,EACxB,IAAI,SAAS,MAAM,GAAG,QAAQ,EAC9B,eAAe,SAAS;IAEtB,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,SAAS,EAAE,QAAQ,GAAG,KAAK,CAAC;IACnC,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,QAAQ,CAAC;IACvC,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACnC,EACD,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,iBACF,eAAe;kBAR7B,GAAG,EAAE;;sBAWQ,QAAQ,GAAG,KAAK;sBAGhB,SAAS,GAAG,IAAI;qBAIjB,SAAS,GAAG,IAAI;kBAjB5B,QAAQ,GAAG,IAAI;oBAsBhC"}

package/dist.commonjs/molecule/entity.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+exports.codec = codec;
+const index_js_1 = require("../bytes/index.js");
+const index_js_2 = require("../hasher/index.js");
+/**
+ * The base class of CCC to create a serializable instance
+ * @public
+ */
+class Entity {
+    static Base() {
+        class Impl {
+            /**
+             * Encode the entity into bytes
+             * @public
+             * @static
+             * @param _ - The entity to encode
+             * @returns The encoded bytes
+             * @throws Will throw an error if the entity is not serializable
+             */
+            static encode(_) {
+                throw new Error("encode not implemented, use @ccc.mol.codec to decorate your type");
+            }
+            /**
+             * Decode the entity from bytes
+             * @public
+             * @static
+             * @param _ - The bytes to decode
+             * @returns The decoded entity
+             * @throws Will throw an error if the entity is not serializable
+             */
+            static decode(_) {
+                throw new Error("decode not implemented, use @ccc.mol.codec to decorate your type");
+            }
+            /**
+             * Create an entity from bytes
+             * @public
+             * @static
+             * @param _ - The bytes to create the entity from
+             * @returns The created entity
+             * @throws Will throw an error if the entity is not serializable
+             */
+            static fromBytes(_bytes) {
+                throw new Error("fromBytes not implemented, use @ccc.mol.codec to decorate your type");
+            }
+            /**
+             * Create an entity from a serializable object
+             * @public
+             * @static
+             * @param _ - The serializable object to create the entity from
+             * @returns The created entity
+             * @throws Will throw an error if the entity is not serializable
+             */
+            static from(_) {
+                throw new Error("from not implemented");
+            }
+            /**
+             * Convert the entity to bytes
+             * @public
+             * @returns The bytes representation of the entity
+             */
+            toBytes() {
+                return this.constructor.encode(this);
+            }
+            /**
+             * Create a clone of the entity
+             * @public
+             * @returns A clone of the entity
+             */
+            clone() {
+                return this.constructor.fromBytes(this.toBytes());
+            }
+            /**
+             * Check if the entity is equal to another entity
+             * @public
+             * @param other - The other entity to compare with
+             * @returns True if the entities are equal, false otherwise
+             */
+            eq(other) {
+                if (this === other) {
+                    return true;
+                }
+                return (0, index_js_1.bytesEq)(this.toBytes(), 
+                /* eslint-disable @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any */
+                (this.constructor?.from(other) ?? other).toBytes());
+            }
+            /**
+             * Calculate the hash of the entity
+             * @public
+             * @returns The hash of the entity
+             */
+            hash() {
+                return (0, index_js_2.hashCkb)(this.toBytes());
+            }
+        }
+        return Impl;
+    }
+}
+exports.Entity = Entity;
+function codec(codec) {
+    return function (Constructor) {
+        var _a;
+        return _a = class Extended extends Constructor {
+                static encode(encodable) {
+                    return codec.encode(encodable);
+                }
+                static decode(bytesLike) {
+                    return Constructor.from(codec.decode(bytesLike));
+                }
+                static fromBytes(bytes) {
+                    return Constructor.from(codec.decode(bytes));
+                }
+            },
+            _a.byteLength = codec.byteLength,
+            _a;
+    };
+}

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

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

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

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

package/dist.commonjs/molecule/index.js

@@ -1,2 +1,27 @@
-export * from "./codec.js";
-export * from "./predefined.js";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mol = void 0;
+exports.mol = __importStar(require("./barrel.js"));

package/dist.commonjs/molecule/predefined.d.ts

@@ -1,32 +1,38 @@
-import * as ckb from "../ckb/index.js";
 import { Hex, HexLike } from "../hex/index.js";
 import { Codec } from "./codec.js";
 export declare const Uint8: Codec<import("../barrel.js").NumLike, number>;
+export declare const Uint8Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
+export declare const Uint8Vec: Codec<import("../barrel.js").NumLike[], number[]>;
 export declare const Uint16LE: Codec<import("../barrel.js").NumLike, number>;
 export declare const Uint16BE: Codec<import("../barrel.js").NumLike, number>;
 export declare const Uint16: Codec<import("../barrel.js").NumLike, number>;
+export declare const Uint16Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
+export declare const Uint16Vec: Codec<import("../barrel.js").NumLike[], number[]>;
 export declare const Uint32LE: Codec<import("../barrel.js").NumLike, number>;
 export declare const Uint32BE: Codec<import("../barrel.js").NumLike, number>;
 export declare const Uint32: Codec<import("../barrel.js").NumLike, number>;
+export declare const Uint32Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
+export declare const Uint32Vec: Codec<import("../barrel.js").NumLike[], number[]>;
 export declare const Uint64LE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint64BE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint64: Codec<import("../barrel.js").NumLike, bigint>;
+export declare const Uint64Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
+export declare const Uint64Vec: Codec<import("../barrel.js").NumLike[], bigint[]>;
 export declare const Uint128LE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint128BE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint128: Codec<import("../barrel.js").NumLike, bigint>;
+export declare const Uint128Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
+export declare const Uint128Vec: Codec<import("../barrel.js").NumLike[], bigint[]>;
 export declare const Uint256LE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint256BE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint256: Codec<import("../barrel.js").NumLike, bigint>;
+export declare const Uint256Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
+export declare const Uint256Vec: Codec<import("../barrel.js").NumLike[], bigint[]>;
 export declare const Uint512LE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint512BE: Codec<import("../barrel.js").NumLike, bigint>;
 export declare const Uint512: Codec<import("../barrel.js").NumLike, bigint>;
-export declare const Uint8Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
-export declare const Uint16Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
-export declare const Uint32Opt: Codec<import("../barrel.js").NumLike | null | undefined, number | undefined>;
-export declare const Uint64Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
-export declare const Uint128Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
-export declare const Uint256Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
 export declare const Uint512Opt: Codec<import("../barrel.js").NumLike | null | undefined, bigint | undefined>;
+export declare const Uint512Vec: Codec<import("../barrel.js").NumLike[], bigint[]>;
 export declare const Bytes: Codec<HexLike, Hex>;
 export declare const BytesOpt: Codec<import("../bytes/index.js").BytesLike | null | undefined, `0x${string}` | undefined>;
 export declare const BytesVec: Codec<import("../bytes/index.js").BytesLike[], `0x${string}`[]>;
@@ -36,17 +42,4 @@ export declare const Byte32Vec: Codec<import("../bytes/index.js").BytesLike[], `
 export declare const String: Codec<string, string>;
 export declare const StringVec: Codec<string[], string[]>;
 export declare const StringOpt: Codec<string | null | undefined, string | undefined>;
-export declare const Hash: Codec<import("../bytes/index.js").BytesLike, `0x${string}`>;
-export declare const HashType: Codec<ckb.HashTypeLike, ckb.HashType>;
-export declare const Script: Codec<ckb.ScriptLike, ckb.Script>;
-export declare const ScriptOpt: Codec<ckb.ScriptLike | null | undefined, ckb.Script | undefined>;
-export declare const OutPoint: Codec<ckb.OutPointLike, ckb.OutPoint>;
-export declare const CellInput: Codec<ckb.CellInputLike, ckb.CellInput>;
-export declare const CellInputVec: Codec<ckb.CellInputLike[], ckb.CellInput[]>;
-export declare const CellOutput: Codec<ckb.CellOutputLike, ckb.CellOutput>;
-export declare const CellOutputVec: Codec<ckb.CellOutputLike[], ckb.CellOutput[]>;
-export declare const DepType: Codec<ckb.DepTypeLike, ckb.DepType>;
-export declare const CellDep: Codec<ckb.CellDepLike, ckb.CellDep>;
-export declare const CellDepVec: Codec<ckb.CellDepLike[], ckb.CellDep[]>;
-export declare const Transaction: Codec<ckb.TransactionLike, ckb.Transaction>;
 //# sourceMappingURL=predefined.d.ts.map