@ckb-ccc/core 0.1.1 → 1.0.0

package/dist.commonjs/ckb/script.js

@@ -1,8 +1,25 @@
-import { bytesFrom } from "../bytes/index.js";
-import { hashCkb } from "../hasher/index.js";
-import { hexFrom } from "../hex/index.js";
-import * as mol from "./molecule.advanced/index.js";
-import { HASH_TYPES, HASH_TYPE_TO_NUM, NUM_TO_HASH_TYPE, } from "./script.advanced.js";
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Script_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptOpt = exports.Script = exports.HashTypeCodec = void 0;
+exports.hashTypeFrom = hashTypeFrom;
+exports.hashTypeToBytes = hashTypeToBytes;
+exports.hashTypeFromBytes = hashTypeFromBytes;
+const index_js_1 = require("../bytes/index.js");
+const index_js_2 = require("../hex/index.js");
+const index_js_3 = require("../molecule/index.js");
+const script_advanced_js_1 = require("./script.advanced.js");
+exports.HashTypeCodec = index_js_3.mol.Codec.from({
+    byteLength: 1,
+    encode: hashTypeToBytes,
+    decode: hashTypeFromBytes,
+});
 /**
  * Converts a HashTypeLike value to a HashType.
  * @public
@@ -18,15 +35,15 @@ import { HASH_TYPES, HASH_TYPE_TO_NUM, NUM_TO_HASH_TYPE, } from "./script.advanc
  * const hashType = hashTypeFrom("type"); // Outputs "type"
  * ```
  */
-export function hashTypeFrom(val) {
+function hashTypeFrom(val) {
     const hashType = (() => {
         if (typeof val === "number") {
-            return NUM_TO_HASH_TYPE[val];
+            return script_advanced_js_1.NUM_TO_HASH_TYPE[val];
         }
         if (typeof val === "bigint") {
-            return NUM_TO_HASH_TYPE[Number(val)];
+            return script_advanced_js_1.NUM_TO_HASH_TYPE[Number(val)];
         }
-        if (!HASH_TYPES.includes(val)) {
+        if (!script_advanced_js_1.HASH_TYPES.includes(val)) {
             return;
         }
         return val;
@@ -48,8 +65,8 @@ export function hashTypeFrom(val) {
  * const hashTypeBytes = hashTypeToBytes("type"); // Outputs Uint8Array [0]
  * ```
  */
-export function hashTypeToBytes(hashType) {
-    return bytesFrom([HASH_TYPE_TO_NUM[hashTypeFrom(hashType)]]);
+function hashTypeToBytes(hashType) {
+    return (0, index_js_1.bytesFrom)([script_advanced_js_1.HASH_TYPE_TO_NUM[hashTypeFrom(hashType)]]);
 }
 /**
  * Converts a byte-like value to a HashType.
@@ -65,13 +82,13 @@ export function hashTypeToBytes(hashType) {
  * const hashType = hashTypeFromBytes(new Uint8Array([0])); // Outputs "type"
  * ```
  */
-export function hashTypeFromBytes(bytes) {
-    return NUM_TO_HASH_TYPE[bytesFrom(bytes)[0]];
+function hashTypeFromBytes(bytes) {
+    return script_advanced_js_1.NUM_TO_HASH_TYPE[(0, index_js_1.bytesFrom)(bytes)[0]];
 }
 /**
  * @public
  */
-export class Script {
+let Script = Script_1 = class Script extends index_js_3.mol.Entity.Base() {
     /**
      * Creates an instance of Script.
      *
@@ -80,12 +97,13 @@ export class Script {
      * @param args - The arguments for the script.
      */
     constructor(codeHash, hashType, args) {
+        super();
         this.codeHash = codeHash;
         this.hashType = hashType;
         this.args = args;
     }
     get occupiedSize() {
-        return 33 + bytesFrom(this.args).length;
+        return 33 + (0, index_js_1.bytesFrom)(this.args).length;
     }
     /**
      * Clone a script.
@@ -98,7 +116,7 @@ export class Script {
      * ```
      */
     clone() {
-        return new Script(this.codeHash, this.hashType, this.args);
+        return new Script_1(this.codeHash, this.hashType, this.args);
     }
     /**
      * Creates a Script instance from a ScriptLike object.
@@ -116,10 +134,10 @@ export class Script {
      * ```
      */
     static from(script) {
-        if (script instanceof Script) {
+        if (script instanceof Script_1) {
             return script;
         }
-        return new Script(hexFrom(script.codeHash), hashTypeFrom(script.hashType), hexFrom(script.args));
+        return new Script_1((0, index_js_2.hexFrom)(script.codeHash), hashTypeFrom(script.hashType), (0, index_js_2.hexFrom)(script.args));
     }
     /**
      * Creates a Script instance from client and known script.
@@ -140,76 +158,17 @@ export class Script {
      */
     static async fromKnownScript(client, knownScript, args) {
         const script = await client.getKnownScript(knownScript);
-        return new Script(script.codeHash, script.hashType, hexFrom(args));
+        return new Script_1(script.codeHash, script.hashType, (0, index_js_2.hexFrom)(args));
     }
-    /**
-     * Converts the Script instance to molecule data format.
-     *
-     * @returns An object representing the script in molecule data format.
-     */
-    _toMolData() {
-        return {
-            codeHash: bytesFrom(this.codeHash),
-            hashType: hashTypeToBytes(this.hashType),
-            args: bytesFrom(this.args),
-        };
-    }
-    /**
-     * Converts the Script instance to bytes.
-     *
-     * @returns A Uint8Array containing the script bytes.
-     *
-     * @example
-     * ```typescript
-     * const scriptBytes = script.toBytes();
-     * ```
-     */
-    toBytes() {
-        return bytesFrom(mol.SerializeScript(this._toMolData()));
-    }
-    /**
-     * Get hash of a script
-     *
-     * @returns Hash of this script
-     *
-     * @example
-     * ```typescript
-     * const hash = script.hash();
-     * ```
-     */
-    hash() {
-        return hashCkb(this.toBytes());
-    }
-    /**
-     * Creates a Script instance from a byte-like value or molecule Script.
-     *
-     * @param bytes - The byte-like value or molecule Script to convert.
-     * @returns A Script instance.
-     *
-     * @example
-     * ```typescript
-     * const script = Script.fromBytes(new Uint8Array([/* script bytes *\/]));
-     * ```
-     */
-    static fromBytes(bytes) {
-        const view = bytes instanceof mol.Script ? bytes : new mol.Script(bytesFrom(bytes));
-        return new Script(hexFrom(view.getCodeHash().raw()), hashTypeFromBytes([view.getHashType()]), hexFrom(view.getArgs().raw()));
-    }
-    /**
-     * Compares the current Script instance with another ScriptLike object for equality.
-     *
-     * @param val - The ScriptLike object to compare with.
-     * @returns True if the scripts are equal, otherwise false.
-     *
-     * @example
-     * ```typescript
-     * const isEqual = script.eq(anotherScript);
-     * ```
-     */
-    eq(val) {
-        const script = Script.from(val);
-        return (this.codeHash === script.codeHash &&
-            this.args === script.args &&
-            this.hashType === script.hashType);
-    }
-}
+};
+exports.Script = Script;
+exports.Script = Script = Script_1 = __decorate([
+    index_js_3.mol.codec(index_js_3.mol
+        .table({
+        codeHash: index_js_3.mol.Byte32,
+        hashType: exports.HashTypeCodec,
+        args: index_js_3.mol.Bytes,
+    })
+        .map({ outMap: (decoded) => Script.from(decoded) }))
+], Script);
+exports.ScriptOpt = index_js_3.mol.option(Script);

package/dist.commonjs/ckb/transaction.advanced.js

@@ -1,9 +1,12 @@
-export const DEP_TYPE_TO_NUM = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEP_TYPES = exports.NUM_TO_DEP_TYPE = exports.DEP_TYPE_TO_NUM = void 0;
+exports.DEP_TYPE_TO_NUM = {
     code: 0x00,
     depGroup: 0x01,
 };
-export const NUM_TO_DEP_TYPE = {
+exports.NUM_TO_DEP_TYPE = {
     0x00: "code",
     0x01: "depGroup",
 };
-export const DEP_TYPES = Object.keys(DEP_TYPE_TO_NUM);
+exports.DEP_TYPES = Object.keys(exports.DEP_TYPE_TO_NUM);