@ckb-ccc/core 1.0.0 → 1.0.1

package/dist.commonjs/molecule/codec.js

@@ -33,6 +33,12 @@ class Codec {
                 : this.decode(buffer)),
         });
     }
+    mapIn(map) {
+        return this.map({ inMap: map });
+    }
+    mapOut(map) {
+        return this.map({ outMap: map });
+    }
 }
 exports.Codec = Codec;
 function uint32To(numLike) {
@@ -53,7 +59,12 @@ function fixedItemVec(itemCodec) {
     return Codec.from({
         encode(userDefinedItems) {
             try {
-                return userDefinedItems.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
+                const concatted = [];
+                (0, index_js_1.bytesConcatTo)(concatted, uint32To(userDefinedItems.length));
+                for (const item of userDefinedItems) {
+                    (0, index_js_1.bytesConcatTo)(concatted, itemCodec.encode(item));
+                }
+                return (0, index_js_1.bytesFrom)(concatted);
             }
             catch (e) {
                 throw new Error(`fixedItemVec(${e?.toString()})`);
@@ -90,21 +101,17 @@ 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);
+                let offset = 4 + userDefinedItems.length * 4;
+                const header = [];
+                const body = [];
+                for (const item of userDefinedItems) {
+                    const encoded = itemCodec.encode(item);
+                    (0, index_js_1.bytesConcatTo)(header, uint32To(offset));
+                    (0, index_js_1.bytesConcatTo)(body, encoded);
+                    offset += encoded.byteLength;
+                }
+                const packedTotalSize = uint32To(header.length + body.length + 4);
+                return (0, index_js_1.bytesConcat)(packedTotalSize, header, body);
             }
             catch (e) {
                 throw new Error(`dynItemVec(${e?.toString()})`);
@@ -228,26 +235,21 @@ 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) => {
+            let offset = 4 + keys.length * 4;
+            const header = [];
+            const body = [];
+            for (const key of keys) {
                 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,
-                    };
+                    const encoded = codecLayout[key].encode(object[key]);
+                    (0, index_js_1.bytesConcatTo)(header, uint32To(offset));
+                    (0, index_js_1.bytesConcatTo)(body, encoded);
+                    offset += encoded.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);
+            }
+            const packedTotalSize = uint32To(header.length + body.length + 4);
             return (0, index_js_1.bytesConcat)(packedTotalSize, header, body);
         },
         decode(buffer) {
@@ -348,22 +350,26 @@ function union(codecLayout, fields) {
  */
 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),
+        byteLength: codecArray.reduce((acc, codec) => {
+            if (codec.byteLength === undefined) {
+                throw new Error("struct: all fields must be fixed-size");
+            }
+            return acc + codec.byteLength;
+        }, 0),
         encode(object) {
-            return keys.reduce((result, key) => {
+            const bytes = [];
+            for (const key of keys) {
                 try {
-                    const encodedItem = codecLayout[key].encode(object[key]);
-                    return (0, index_js_1.bytesConcat)(result, encodedItem);
+                    const encoded = codecLayout[key].encode(object[key]);
+                    (0, index_js_1.bytesConcatTo)(bytes, encoded);
                 }
                 catch (e) {
                     throw new Error(`struct.${key}(${e?.toString()})`);
                 }
-            }, (0, index_js_1.bytesFrom)([]));
+            }
+            return (0, index_js_1.bytesFrom)(bytes);
         },
         decode(buffer) {
             const value = (0, index_js_1.bytesFrom)(buffer);
@@ -399,7 +405,11 @@ function array(itemCodec, itemCount) {
         byteLength,
         encode(items) {
             try {
-                return items.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), (0, index_js_1.bytesFrom)([]));
+                const bytes = [];
+                for (const item of items) {
+                    (0, index_js_1.bytesConcatTo)(bytes, itemCodec.encode(item));
+                }
+                return (0, index_js_1.bytesFrom)(bytes);
             }
             catch (e) {
                 throw new Error(`array(${e?.toString()})`);

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

@@ -1,11 +1,17 @@
 import { Bytes, BytesLike } from "../bytes/index.js";
 import { Hex } from "../hex/index.js";
+import { Constructor } from "../utils/index.js";
 import { Codec } from "./codec.js";
 /**
- * The base class of CCC to create a serializable instance
+ * The base class of CCC to create a serializable instance. This should be used with the {@link codec} decorator.
  * @public
  */
 export declare abstract class Entity {
+    /**
+     * Generate a base class of CCC to create a serializable instance.
+     * This should be used with the {@link codec} decorator.
+     * @public
+     */
     static Base<SubTypeLike, SubType = SubTypeLike>(): (abstract new () => {
         /**
          * Convert the entity to bytes
@@ -25,7 +31,7 @@ export declare abstract class Entity {
          * @param other - The other entity to compare with
          * @returns True if the entities are equal, false otherwise
          */
-        eq(other: SubTypeLike | SubType): boolean;
+        eq(other: SubTypeLike): boolean;
         /**
          * Calculate the hash of the entity
          * @public
@@ -80,8 +86,23 @@ export declare abstract class Entity {
     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;
+/**
+ * A class decorator to add methods implementation on the {@link Entity.Base} class
+ * @example
+ * ```typescript
+ * @mol.codec(
+ *   mol.table({
+ *     codeHash: mol.Byte32,
+ *     hashType: HashTypeCodec,
+ *     args: mol.Bytes,
+ *   }),
+ * )
+ * export class Script extends mol.Entity.Base<ScriptLike, Script>() {
+ *   from(scriptLike: ScriptLike): Script {}
+ * }
+ * ```
+ */
+export declare function codec<Encodable, TypeLike extends Encodable, Decoded extends TypeLike, Type extends object & TypeLike, ConstructorType extends Constructor<Type> & {
     from(decoded: TypeLike): Type;
     byteLength?: number;
     encode(encodable: TypeLike): Bytes;

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

@@ -1 +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"}
+{"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,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;GAGG;AACH,8BAAsB,MAAM;IAC1B;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW;QA6D1C;;;;WAIG;mBACQ,KAAK;QAMhB;;;;WAIG;iBACM,OAAO;QAMhB;;;;;WAKG;kBACO,WAAW,GAAG,OAAO;QAe/B;;;;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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CACnB,SAAS,EACT,QAAQ,SAAS,SAAS,EAC1B,OAAO,SAAS,QAAQ,EACxB,IAAI,SAAS,MAAM,GAAG,QAAQ,EAC9B,eAAe,SAAS,WAAW,CAAC,IAAI,CAAC,GAAG;IAC1C,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;;;sBAGhB,QAAQ,GAAG,KAAK;sBAGhB,SAAS,GAAG,IAAI;qBAIjB,SAAS,GAAG,IAAI;kBAjB5B,QAAQ,GAAG,IAAI;oBAsBhC"}

package/dist.commonjs/molecule/entity.js

@@ -5,10 +5,15 @@ 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
+ * The base class of CCC to create a serializable instance. This should be used with the {@link codec} decorator.
  * @public
  */
 class Entity {
+    /**
+     * Generate a base class of CCC to create a serializable instance.
+     * This should be used with the {@link codec} decorator.
+     * @public
+     */
     static Base() {
         class Impl {
             /**
@@ -98,6 +103,22 @@ class Entity {
     }
 }
 exports.Entity = Entity;
+/**
+ * A class decorator to add methods implementation on the {@link Entity.Base} class
+ * @example
+ * ```typescript
+ * @mol.codec(
+ *   mol.table({
+ *     codeHash: mol.Byte32,
+ *     hashType: HashTypeCodec,
+ *     args: mol.Bytes,
+ *   }),
+ * )
+ * export class Script extends mol.Entity.Base<ScriptLike, Script>() {
+ *   from(scriptLike: ScriptLike): Script {}
+ * }
+ * ```
+ */
 function codec(codec) {
     return function (Constructor) {
         var _a;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/num/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAA0B,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,OAAO,EAAW,MAAM,iBAAiB,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AAEzB;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,GAAG,CAS7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,GAAG,CAS7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAUzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAE1C;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAEhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAUhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAEhD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/num/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAA0B,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,OAAO,EAAW,MAAM,iBAAiB,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AAEzB;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,GAAG,CAS7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,GAAG,GAAG,CAS7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAUzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAE1C;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAEhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAOhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAEhD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD"}

package/dist.commonjs/num/index.js

@@ -143,7 +143,7 @@ function numBeToBytes(val, bytes) {
     if (bytes == null) {
         return rawBytes;
     }
-    return (0, index_js_1.bytesConcat)(Array.from(Array(bytes - rawBytes.length), () => 0), rawBytes);
+    return (0, index_js_1.bytesConcat)("00".repeat(bytes - rawBytes.length), rawBytes);
 }
 /**
  * Converts a byte array to a Num (bigint) assuming little-endian order.
@@ -173,7 +173,7 @@ function numFromBytes(val) {
  * ```
  */
 function numLeFromBytes(val) {
-    return numBeFromBytes([...(0, index_js_1.bytesFrom)(val)].reverse());
+    return numBeFromBytes((0, index_js_1.bytesFrom)(val).reverse());
 }
 /**
  * Converts a byte array to a Num (bigint) assuming big-endian order.

package/dist.commonjs/signer/btc/verify.js

@@ -37,6 +37,6 @@ function btcPublicKeyFromP2pkhAddress(address) {
  */
 function verifyMessageBtcEcdsa(message, signature, publicKey) {
     const challenge = typeof message === "string" ? message : (0, index_js_2.hexFrom)(message).slice(2);
-    const [_, ...rawSign] = (0, index_js_1.bytesFrom)(signature, "base64");
+    const rawSign = (0, index_js_1.bytesFrom)(signature, "base64").slice(1);
     return secp256k1_1.secp256k1.verify((0, index_js_1.bytesFrom)(rawSign), (0, bitcoinjs_message_1.magicHash)(challenge), publicKey);
 }

package/dist.commonjs/signer/doge/verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/signer/doge/verify.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAO5D;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAqBT"}
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/signer/doge/verify.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAO5D;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAuBT"}

package/dist.commonjs/signer/doge/verify.js

@@ -11,7 +11,9 @@ const verify_js_1 = require("../btc/verify.js");
  */
 function verifyMessageDogeEcdsa(message, signature, address) {
     const challenge = typeof message === "string" ? message : (0, index_js_2.hexFrom)(message).slice(2);
-    const [recoveryBit, ...rawSign] = (0, index_js_1.bytesFrom)(signature, "base64");
+    const signatureBytes = (0, index_js_1.bytesFrom)(signature, "base64");
+    const recoveryBit = signatureBytes[0];
+    const rawSign = signatureBytes.slice(1);
     const sig = secp256k1_1.secp256k1.Signature.fromCompact((0, index_js_2.hexFrom)(rawSign).slice(2)).addRecoveryBit(recoveryBit - 31);
     return ((0, verify_js_1.btcPublicKeyFromP2pkhAddress)(address) ===
         (0, index_js_2.hexFrom)((0, verify_js_1.btcEcdsaPublicKeyHash)(sig

package/package.json

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

package/src/address/address.advanced.ts

@@ -29,7 +29,9 @@ export function addressPayloadFromString(address: string): {
   // Try parse full format address
   try {
     const { words, prefix } = bech32m.decode(address, ADDRESS_BECH32_LIMIT);
-    const [formatType, ...payload] = bech32m.fromWords(words);
+    const decoded = bech32m.fromWords(words);
+    const formatType = decoded[0];
+    const payload = decoded.slice(1);
 
     if (formatType === (AddressFormat.Full as number)) {
       return { prefix, format: AddressFormat.Full, payload };
@@ -39,7 +41,9 @@ export function addressPayloadFromString(address: string): {
   // Try parse legacy 2019 format address
   try {
     const { prefix, words } = bech32.decode(address, ADDRESS_BECH32_LIMIT);
-    const [formatType, ...payload] = bech32.fromWords(words);
+    const decoded = bech32.fromWords(words);
+    const formatType = decoded[0];
+    const payload = decoded.slice(1);
     if (
       [
         AddressFormat.FullData,

package/src/bytes/index.ts

@@ -10,6 +10,41 @@ export type Bytes = Uint8Array;
  */
 export type BytesLike = string | Uint8Array | ArrayBuffer | ArrayLike<number>;
 
+/**
+ * Concatenates multiple byte-like arrays to the first number array.
+ * @public
+ *
+ * @param result - The number array as result
+ * @param args - The byte-like arrays to concatenate.
+ * @returns The first number array
+ *
+ * @example
+ * ```typescript
+ * const concatenatedBytes = [1, 2];
+ * bytesConcatTo(
+ *   concatenatedBytes
+ *   new Uint8Array([3, 4]),
+ *   "hello",
+ *   [5, 6, 7]
+ * );
+ * console.log(concatenatedBytes); // Outputs [1, 2, 3, 4, /* bytes of "hello" *\/, 5, 6, 7]
+ * ```
+ */
+
+export function bytesConcatTo(
+  result: number[],
+  ...args: BytesLike[]
+): number[] {
+  return args.reduce((acc: number[], v) => {
+    const bytes = bytesFrom(v);
+    // Spread operator will cause call stack size exceeded
+    for (const byte of bytes) {
+      result.push(byte);
+    }
+    return acc;
+  }, result);
+}
+
 /**
  * Concatenates multiple byte-like arrays into a single byte array.
  * @public
@@ -30,12 +65,7 @@ export type BytesLike = string | Uint8Array | ArrayBuffer | ArrayLike<number>;
  */
 
 export function bytesConcat(...args: BytesLike[]): Bytes {
-  return new Uint8Array(
-    args.reduce((acc: number[], v) => {
-      acc.push(...bytesFrom(v));
-      return acc;
-    }, []),
-  );
+  return new Uint8Array(bytesConcatTo([], ...args));
 }
 
 /**

package/src/ckb/script.ts

@@ -108,13 +108,11 @@ export type ScriptLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      codeHash: mol.Byte32,
-      hashType: HashTypeCodec,
-      args: mol.Bytes,
-    })
-    .map({ outMap: (decoded) => Script.from(decoded) }),
+  mol.table({
+    codeHash: mol.Byte32,
+    hashType: HashTypeCodec,
+    args: mol.Bytes,
+  }),
 )
 export class Script extends mol.Entity.Base<ScriptLike, Script>() {
   /**

package/src/ckb/transaction.ts

@@ -1,6 +1,6 @@
-import { ClientCollectableSearchKeyFilterLike } from "../advancedBarrel.js";
 import { Bytes, BytesLike, bytesFrom } from "../bytes/index.js";
-import { CellDepInfoLike, Client, KnownScript } from "../client/index.js";
+import type { ClientCollectableSearchKeyFilterLike } from "../client/clientTypes.advanced.js";
+import type { CellDepInfoLike, Client, KnownScript } from "../client/index.js";
 import {
   Zero,
   fixedPointFrom,
@@ -17,11 +17,11 @@ import {
   numToBytes,
   numToHex,
 } from "../num/index.js";
-import { Signer } from "../signer/index.js";
+import type { Signer } from "../signer/index.js";
 import { apply, reduceAsync } from "../utils/index.js";
 import { Script, ScriptLike, ScriptOpt } from "./script.js";
 import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced.js";
-import { LumosTransactionSkeletonType } from "./transactionLumos.js";
+import type { LumosTransactionSkeletonType } from "./transactionLumos.js";
 
 export const DepTypeCodec: mol.Codec<DepTypeLike, DepType> = mol.Codec.from({
   byteLength: 1,
@@ -119,12 +119,10 @@ export type OutPointLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .struct({
-      txHash: mol.Byte32,
-      index: mol.Uint32,
-    })
-    .map({ outMap: (decoded) => OutPoint.from(decoded) }),
+  mol.struct({
+    txHash: mol.Byte32,
+    index: mol.Uint32,
+  }),
 )
 export class OutPoint extends mol.Entity.Base<OutPointLike, OutPoint>() {
   /**
@@ -172,13 +170,11 @@ export type CellOutputLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      capacity: mol.Uint64,
-      lock: Script,
-      type: ScriptOpt,
-    })
-    .map({ outMap: (decoded) => CellOutput.from(decoded) }),
+  mol.table({
+    capacity: mol.Uint64,
+    lock: Script,
+    type: ScriptOpt,
+  }),
 )
 export class CellOutput extends mol.Entity.Base<CellOutputLike, CellOutput>() {
   /**
@@ -347,10 +343,7 @@ export type SinceLike =
  * @public
  */
 @mol.codec(
-  mol.Uint64.map<SinceLike, Since>({
-    inMap: (encodable) => Since.from(encodable).toNum(),
-    outMap: (decoded) => Since.from(decoded),
-  }),
+  mol.Uint64.mapIn((encodable: SinceLike) => Since.from(encodable).toNum()),
 )
 export class Since extends mol.Entity.Base<SinceLike, Since>() {
   /**
@@ -472,10 +465,10 @@ export type CellInputLike = {
       since: Since,
       previousOutput: OutPoint,
     })
-    .map<CellInputLike, CellInput>({
-      inMap: (encodable) => ({ ...encodable, since: encodable.since ?? 0 }),
-      outMap: (decoded) => CellInput.from(decoded),
-    }),
+    .mapIn((encodable: CellInputLike) => ({
+      ...encodable,
+      since: encodable.since ?? 0,
+    })),
 )
 export class CellInput extends mol.Entity.Base<CellInputLike, CellInput>() {
   /**
@@ -560,12 +553,10 @@ export type CellDepLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .struct({
-      outPoint: OutPoint,
-      depType: DepTypeCodec,
-    })
-    .map({ outMap: (decoded) => CellDep.from(decoded) }),
+  mol.struct({
+    outPoint: OutPoint,
+    depType: DepTypeCodec,
+  }),
 )
 export class CellDep extends mol.Entity.Base<CellDepLike, CellDep>() {
   /**
@@ -637,13 +628,11 @@ export type WitnessArgsLike = {
  * @public
  */
 @mol.codec(
-  mol
-    .table({
-      lock: mol.BytesOpt,
-      inputType: mol.BytesOpt,
-      outputType: mol.BytesOpt,
-    })
-    .map({ outMap: (decoded) => WitnessArgs.from(decoded) }),
+  mol.table({
+    lock: mol.BytesOpt,
+    inputType: mol.BytesOpt,
+    outputType: mol.BytesOpt,
+  }),
 )
 export class WitnessArgs extends mol.Entity.Base<
   WitnessArgsLike,
@@ -706,16 +695,14 @@ export function udtBalanceFrom(dataLike: BytesLike): Num {
   return numFromBytes(data);
 }
 
-export const RawTransaction = mol
-  .table({
-    version: mol.Uint32,
-    cellDeps: CellDepVec,
-    headerDeps: mol.Byte32Vec,
-    inputs: CellInputVec,
-    outputs: CellOutputVec,
-    outputsData: mol.BytesVec,
-  })
-  .map({ outMap: (decoded) => Transaction.from(decoded) });
+export const RawTransaction = mol.table({
+  version: mol.Uint32,
+  cellDeps: CellDepVec,
+  headerDeps: mol.Byte32Vec,
+  inputs: CellInputVec,
+  outputs: CellOutputVec,
+  outputsData: mol.BytesVec,
+});
 
 /**
  * @public
@@ -741,16 +728,14 @@ export type TransactionLike = {
       raw: RawTransaction,
       witnesses: mol.BytesVec,
     })
-    .map<TransactionLike, Transaction>({
-      inMap: (txLike) => {
-        const tx = Transaction.from(txLike);
-        return {
-          raw: tx,
-          witnesses: tx.witnesses,
-        };
-      },
-      outMap: (tx) => Transaction.from({ ...tx.raw, witnesses: tx.witnesses }),
-    }),
+    .mapIn((txLike: TransactionLike) => {
+      const tx = Transaction.from(txLike);
+      return {
+        raw: tx,
+        witnesses: tx.witnesses,
+      };
+    })
+    .mapOut((tx) => Transaction.from({ ...tx.raw, witnesses: tx.witnesses })),
 )
 export class Transaction extends mol.Entity.Base<
   TransactionLike,