@ckb-ccc/core 0.0.4-alpha.0 → 0.0.4-alpha.11

package/src/ckb/script.ts

@@ -9,6 +9,22 @@ import {
 
 export type HashTypeLike = string | number | bigint;
 export type HashType = "type" | "data" | "data1" | "data2";
+
+/**
+ * Converts a HashTypeLike value to a HashType.
+ *
+ * @param val - The value to convert, which can be a string, number, or bigint.
+ * @returns The corresponding HashType.
+ *
+ * @throws Will throw an error if the input value is not a valid hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashType = hashTypeFrom(1); // Outputs "data"
+ * const hashType = hashTypeFrom("type"); // Outputs "type"
+ * ```
+ */
+
 export function hashTypeFrom(val: HashTypeLike): HashType {
   const hashType = (() => {
     if (typeof val === "number") {
@@ -29,9 +45,37 @@ export function hashTypeFrom(val: HashTypeLike): HashType {
   }
   return hashType;
 }
-export function hashTypeToBytes(hashType: HashType): Bytes {
-  return bytesFrom([HASH_TYPE_TO_NUM[hashType]]);
+
+/**
+ * Converts a HashTypeLike value to its corresponding byte representation.
+ *
+ * @param hashType - The hash type value to convert.
+ * @returns A Uint8Array containing the byte representation of the hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashTypeBytes = hashTypeToBytes("type"); // Outputs Uint8Array [0]
+ * ```
+ */
+
+export function hashTypeToBytes(hashType: HashTypeLike): Bytes {
+  return bytesFrom([HASH_TYPE_TO_NUM[hashTypeFrom(hashType)]]);
 }
+
+/**
+ * Converts a byte-like value to a HashType.
+ *
+ * @param bytes - The byte-like value to convert.
+ * @returns The corresponding HashType.
+ *
+ * @throws Will throw an error if the input bytes do not correspond to a valid hash type.
+ *
+ * @example
+ * ```typescript
+ * const hashType = hashTypeFromBytes(new Uint8Array([0])); // Outputs "type"
+ * ```
+ */
+
 export function hashTypeFromBytes(bytes: BytesLike): HashType {
   return NUM_TO_HASH_TYPE[bytesFrom(bytes)[0]];
 }
@@ -42,12 +86,36 @@ export type ScriptLike = {
   args: BytesLike;
 };
 export class Script {
+  /**
+   * Creates an instance of Script.
+   *
+   * @param codeHash - The code hash of the script.
+   * @param hashType - The hash type of the script.
+   * @param args - The arguments for the script.
+   */
+
   constructor(
     public codeHash: Hex,
     public hashType: HashType,
     public args: Hex,
   ) {}
 
+  /**
+   * Creates a Script instance from a ScriptLike object.
+   *
+   * @param script - A ScriptLike object or an instance of Script.
+   * @returns A Script instance.
+   *
+   * @example
+   * ```typescript
+   * const script = Script.from({
+   *   codeHash: "0x1234...",
+   *   hashType: "type",
+   *   args: "0xabcd..."
+   * });
+   * ```
+   */
+
   static from(script: ScriptLike): Script {
     if (script instanceof Script) {
       return script;
@@ -60,6 +128,12 @@ export class Script {
     );
   }
 
+  /**
+   * Converts the Script instance to molecule data format.
+   *
+   * @returns An object representing the script in molecule data format.
+   */
+
   _toMolData() {
     return {
       codeHash: bytesFrom(this.codeHash),
@@ -68,10 +142,33 @@ export class Script {
     };
   }
 
+  /**
+   * Converts the Script instance to bytes.
+   *
+   * @returns A Uint8Array containing the script bytes.
+   *
+   * @example
+   * ```typescript
+   * const scriptBytes = script.toBytes();
+   * ```
+   */
+
   toBytes(): Bytes {
     return bytesFrom(mol.SerializeScript(this._toMolData()));
   }
 
+  /**
+   * 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: BytesLike | mol.Script): Script {
     const view =
       bytes instanceof mol.Script ? bytes : new mol.Script(bytesFrom(bytes));
@@ -83,6 +180,18 @@ export class Script {
     );
   }
 
+  /**
+   * 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: ScriptLike): boolean {
     const script = Script.from(val);
     return (