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

package/dist.commonjs/molecule/codec.js

@@ -0,0 +1,461 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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;
+        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)),
+        });
+    }
+}
+exports.Codec = Codec;
+function uint32To(numLike) {
+    return (0, index_js_2.numToBytes)(numLike, 4);
+}
+function uint32From(bytesLike) {
+    return Number((0, index_js_2.numFromBytes)(bytesLike));
+}
+/**
+ * Vector with fixed size item codec
+ * @param itemCodec fixed-size vector item codec
+ */
+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) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
+            }
+            catch (e) {
+                throw new Error(`fixedItemVec(${e?.toString()})`);
+            }
+        },
+        decode(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}`);
+            }
+            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.
+ */
+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: (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: (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 (0, index_js_1.bytesConcat)(packedTotalSize, encoded.header, encoded.body);
+            }
+            catch (e) {
+                throw new Error(`dynItemVec(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = (0, index_js_1.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
+ */
+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
+ */
+function option(innerCodec) {
+    return Codec.from({
+        encode(userDefinedOrNull) {
+            if (!userDefinedOrNull) {
+                return (0, index_js_1.bytesFrom)([]);
+            }
+            try {
+                return innerCodec.encode(userDefinedOrNull);
+            }
+            catch (e) {
+                throw new Error(`option(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = (0, index_js_1.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
+ */
+function byteVec(codec) {
+    return Codec.from({
+        encode(userDefined) {
+            try {
+                const payload = (0, index_js_1.bytesFrom)(codec.encode(userDefined));
+                const byteLength = uint32To(payload.byteLength);
+                return (0, index_js_1.bytesConcat)(byteLength, payload);
+            }
+            catch (e) {
+                throw new Error(`byteVec(${e?.toString()})`);
+            }
+        },
+        decode(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}`);
+            }
+            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
+ */
+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: (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: (0, index_js_1.bytesFrom)([]),
+                body: (0, index_js_1.bytesFrom)([]),
+                offset: headerLength,
+            });
+            const packedTotalSize = uint32To(header.byteLength + body.byteLength + 4);
+            return (0, index_js_1.bytesConcat)(packedTotalSize, header, body);
+        },
+        decode(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}`);
+            }
+            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 })
+ */
+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 (0, index_js_1.bytesConcat)(header, body);
+            }
+            catch (e) {
+                throw new Error(`union.(${typeStr})(${e?.toString()})`);
+            }
+        },
+        decode(buffer) {
+            const value = (0, index_js_1.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
+ */
+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 (0, index_js_1.bytesConcat)(result, encodedItem);
+                }
+                catch (e) {
+                    throw new Error(`struct.${key}(${e?.toString()})`);
+                }
+            }, (0, index_js_1.bytesFrom)([]));
+        },
+        decode(buffer) {
+            const value = (0, index_js_1.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
+ */
+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) => (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 = (0, index_js_1.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
+ */
+function uint(byteLength, littleEndian = false) {
+    return Codec.from({
+        byteLength,
+        encode: (numLike) => {
+            if (littleEndian) {
+                return (0, index_js_2.numToBytes)(numLike, byteLength);
+            }
+            else {
+                return (0, index_js_2.numBeToBytes)(numLike, byteLength);
+            }
+        },
+        decode: (buffer) => {
+            if (littleEndian) {
+                return (0, index_js_2.numFromBytes)(buffer);
+            }
+            else {
+                return (0, index_js_2.numBeFromBytes)(buffer);
+            }
+        },
+    });
+}
+/**
+ * Create a codec to deal with fixed LE or BE bytes.
+ * @param byteLength
+ * @param littleEndian
+ */
+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.commonjs/molecule/index.d.ts

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

package/dist.commonjs/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.commonjs/molecule/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./codec.js"), exports);
+__exportStar(require("./predefined.js"), exports);

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

@@ -0,0 +1,52 @@
+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 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 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 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 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 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 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 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}`[]>;
+export declare const Byte32: Codec<HexLike, Hex>;
+export declare const Byte32Opt: Codec<import("../bytes/index.js").BytesLike | null | undefined, `0x${string}` | undefined>;
+export declare const Byte32Vec: Codec<import("../bytes/index.js").BytesLike[], `0x${string}`[]>;
+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

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

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

package/dist.commonjs/molecule/predefined.js

@@ -0,0 +1,121 @@
+"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.Transaction = exports.CellDepVec = exports.CellDep = exports.DepType = exports.CellOutputVec = exports.CellOutput = exports.CellInputVec = exports.CellInput = exports.OutPoint = exports.ScriptOpt = exports.Script = exports.HashType = exports.Hash = exports.StringOpt = exports.StringVec = exports.String = exports.Byte32Vec = exports.Byte32Opt = exports.Byte32 = exports.BytesVec = exports.BytesOpt = exports.Bytes = exports.Uint512Opt = exports.Uint256Opt = exports.Uint128Opt = exports.Uint64Opt = exports.Uint32Opt = exports.Uint16Opt = exports.Uint8Opt = exports.Uint512 = exports.Uint512BE = exports.Uint512LE = exports.Uint256 = exports.Uint256BE = exports.Uint256LE = exports.Uint128 = exports.Uint128BE = exports.Uint128LE = exports.Uint64 = exports.Uint64BE = exports.Uint64LE = exports.Uint32 = exports.Uint32BE = exports.Uint32LE = exports.Uint16 = exports.Uint16BE = exports.Uint16LE = exports.Uint8 = void 0;
+const index_js_1 = require("../bytes/index.js");
+const ckb = __importStar(require("../ckb/index.js"));
+const index_js_2 = require("../hex/index.js");
+const codec_js_1 = require("./codec.js");
+exports.Uint8 = (0, codec_js_1.uintNumber)(1, true);
+exports.Uint16LE = (0, codec_js_1.uintNumber)(2, true);
+exports.Uint16BE = (0, codec_js_1.uintNumber)(2);
+exports.Uint16 = exports.Uint16LE;
+exports.Uint32LE = (0, codec_js_1.uintNumber)(4, true);
+exports.Uint32BE = (0, codec_js_1.uintNumber)(4);
+exports.Uint32 = exports.Uint32LE;
+exports.Uint64LE = (0, codec_js_1.uint)(8, true);
+exports.Uint64BE = (0, codec_js_1.uint)(8);
+exports.Uint64 = exports.Uint64LE;
+exports.Uint128LE = (0, codec_js_1.uint)(16, true);
+exports.Uint128BE = (0, codec_js_1.uint)(16);
+exports.Uint128 = exports.Uint128LE;
+exports.Uint256LE = (0, codec_js_1.uint)(32, true);
+exports.Uint256BE = (0, codec_js_1.uint)(32);
+exports.Uint256 = exports.Uint256LE;
+exports.Uint512LE = (0, codec_js_1.uint)(64, true);
+exports.Uint512BE = (0, codec_js_1.uint)(64);
+exports.Uint512 = exports.Uint512LE;
+exports.Uint8Opt = (0, codec_js_1.option)(exports.Uint8);
+exports.Uint16Opt = (0, codec_js_1.option)(exports.Uint16);
+exports.Uint32Opt = (0, codec_js_1.option)(exports.Uint32);
+exports.Uint64Opt = (0, codec_js_1.option)(exports.Uint64);
+exports.Uint128Opt = (0, codec_js_1.option)(exports.Uint128);
+exports.Uint256Opt = (0, codec_js_1.option)(exports.Uint256);
+exports.Uint512Opt = (0, codec_js_1.option)(exports.Uint512);
+exports.Bytes = (0, codec_js_1.byteVec)({
+    encode: (value) => (0, index_js_1.bytesFrom)(value),
+    decode: (buffer) => (0, index_js_2.hexFrom)(buffer),
+});
+exports.BytesOpt = (0, codec_js_1.option)(exports.Bytes);
+exports.BytesVec = (0, codec_js_1.vector)(exports.Bytes);
+exports.Byte32 = codec_js_1.Codec.from({
+    byteLength: 32,
+    encode: (value) => (0, index_js_1.bytesFrom)(value),
+    decode: (buffer) => (0, index_js_2.hexFrom)(buffer),
+});
+exports.Byte32Opt = (0, codec_js_1.option)(exports.Byte32);
+exports.Byte32Vec = (0, codec_js_1.vector)(exports.Byte32);
+exports.String = (0, codec_js_1.byteVec)({
+    encode: (value) => (0, index_js_1.bytesFrom)(value, "utf8"),
+    decode: (buffer) => (0, index_js_1.bytesTo)(buffer, "utf8"),
+});
+exports.StringVec = (0, codec_js_1.vector)(exports.String);
+exports.StringOpt = (0, codec_js_1.option)(exports.String);
+exports.Hash = exports.Byte32;
+exports.HashType = codec_js_1.Codec.from({
+    byteLength: 1,
+    encode: ckb.hashTypeToBytes,
+    decode: ckb.hashTypeFromBytes,
+});
+exports.Script = (0, codec_js_1.table)({
+    codeHash: exports.Hash,
+    hashType: exports.HashType,
+    args: exports.Bytes,
+}).map({ outMap: ckb.Script.from });
+exports.ScriptOpt = (0, codec_js_1.option)(exports.Script);
+exports.OutPoint = (0, codec_js_1.struct)({
+    txHash: exports.Hash,
+    index: exports.Uint32,
+}).map({ outMap: ckb.OutPoint.from });
+exports.CellInput = (0, codec_js_1.struct)({
+    previousOutput: exports.OutPoint,
+    since: exports.Uint64,
+}).map({ outMap: ckb.CellInput.from });
+exports.CellInputVec = (0, codec_js_1.vector)(exports.CellInput);
+exports.CellOutput = (0, codec_js_1.table)({
+    capacity: exports.Uint64,
+    lock: exports.Script,
+    type: exports.ScriptOpt,
+}).map({ outMap: ckb.CellOutput.from });
+exports.CellOutputVec = (0, codec_js_1.vector)(exports.CellOutput);
+exports.DepType = codec_js_1.Codec.from({
+    byteLength: 1,
+    encode: ckb.depTypeToBytes,
+    decode: ckb.depTypeFromBytes,
+});
+exports.CellDep = (0, codec_js_1.struct)({
+    outPoint: exports.OutPoint,
+    depType: exports.DepType,
+}).map({ outMap: ckb.CellDep.from });
+exports.CellDepVec = (0, codec_js_1.vector)(exports.CellDep);
+exports.Transaction = (0, codec_js_1.table)({
+    version: exports.Uint32,
+    cellDeps: exports.CellDepVec,
+    headerDeps: exports.Byte32Vec,
+    inputs: exports.CellInputVec,
+    outputs: exports.CellOutputVec,
+    outputsData: exports.BytesVec,
+    witnesses: exports.BytesVec,
+}).map({ outMap: ckb.Transaction.from });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckb-ccc/core",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Core of CCC - CKBer's Codebase",
   "author": "Hanssen0 <hanssen0@hanssen0.com>",
   "license": "MIT",