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

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";

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

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

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

@@ -10,10 +10,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __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);
 };
+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;
 __exportStar(require("./address/index.js"), exports);
 __exportStar(require("./bytes/index.js"), exports);
 __exportStar(require("./ckb/index.js"), exports);
@@ -22,6 +35,7 @@ __exportStar(require("./fixedPoint/index.js"), exports);
 __exportStar(require("./hasher/index.js"), exports);
 __exportStar(require("./hex/index.js"), exports);
 __exportStar(require("./keystore/index.js"), exports);
+exports.mol = __importStar(require("./molecule/index.js"));
 __exportStar(require("./num/index.js"), exports);
 __exportStar(require("./signer/index.js"), exports);
 __exportStar(require("./utils/index.js"), exports);