@ckb-ccc/core 0.0.6-alpha.0 → 0.0.7-alpha.0

package/dist.commonjs/client/jsonRpc/transformers.js

@@ -6,155 +6,179 @@ const num_1 = require("../../num");
 const utils_1 = require("../../utils");
 const clientTypes_1 = require("../clientTypes");
 class JsonRpcTransformers {
-    static hashTypeFrom(hashType) {
-        return (0, ckb_1.hashTypeFrom)(hashType);
-    }
-    static hashTypeTo(hashType) {
-        return hashType;
-    }
-    static depTypeFrom(depType) {
-        switch ((0, ckb_1.depTypeFrom)(depType)) {
-            case "code":
-                return "code";
-            case "depGroup":
-                return "dep_group";
-        }
-    }
-    static depTypeTo(depType) {
-        switch (depType) {
-            case "code":
-                return "code";
-            case "dep_group":
-                return "depGroup";
-        }
-    }
-    static scriptFrom(scriptLike) {
-        const script = ckb_1.Script.from(scriptLike);
-        return {
-            code_hash: script.codeHash,
-            hash_type: JsonRpcTransformers.hashTypeFrom(script.hashType),
-            args: script.args,
-        };
-    }
-    static scriptTo(script) {
-        return ckb_1.Script.from({
-            codeHash: script.code_hash,
-            hashType: JsonRpcTransformers.hashTypeTo(script.hash_type),
-            args: script.args,
-        });
-    }
-    static outPointFrom(outPointLike) {
-        const outPoint = ckb_1.OutPoint.from(outPointLike);
-        return {
-            index: (0, num_1.numToHex)(outPoint.index),
-            tx_hash: outPoint.txHash,
-        };
-    }
-    static outPointTo(outPoint) {
-        return ckb_1.OutPoint.from({
-            index: outPoint.index,
-            txHash: outPoint.tx_hash,
-        });
-    }
-    static cellInputFrom(cellInput) {
-        return {
-            previous_output: JsonRpcTransformers.outPointFrom(cellInput.previousOutput),
-            since: (0, num_1.numToHex)(cellInput.since),
-        };
-    }
-    static cellInputTo(cellInput) {
-        return ckb_1.CellInput.from({
-            previousOutput: JsonRpcTransformers.outPointTo(cellInput.previous_output),
-            since: cellInput.since,
-        });
-    }
-    static cellOutputFrom(cellOutput) {
-        return {
-            capacity: (0, num_1.numToHex)(cellOutput.capacity),
-            lock: JsonRpcTransformers.scriptFrom(cellOutput.lock),
-            type: (0, utils_1.apply)(JsonRpcTransformers.scriptFrom, cellOutput.type),
-        };
-    }
-    static cellOutputTo(cellOutput) {
-        return ckb_1.CellOutput.from({
-            capacity: cellOutput.capacity,
-            lock: JsonRpcTransformers.scriptTo(cellOutput.lock),
-            type: (0, utils_1.apply)(JsonRpcTransformers.scriptTo, cellOutput.type),
-        });
-    }
-    static cellDepFrom(cellDep) {
-        return {
-            out_point: JsonRpcTransformers.outPointFrom(cellDep.outPoint),
-            dep_type: JsonRpcTransformers.depTypeFrom(cellDep.depType),
-        };
-    }
-    static cellDepTo(cellDep) {
-        return ckb_1.CellDep.from({
-            outPoint: JsonRpcTransformers.outPointTo(cellDep.out_point),
-            depType: JsonRpcTransformers.depTypeTo(cellDep.dep_type),
-        });
-    }
-    static transactionFrom(txLike) {
-        const tx = ckb_1.Transaction.from(txLike);
-        return {
-            version: (0, num_1.numToHex)(tx.version),
-            cell_deps: tx.cellDeps.map((c) => JsonRpcTransformers.cellDepFrom(c)),
-            header_deps: tx.headerDeps,
-            inputs: tx.inputs.map((i) => JsonRpcTransformers.cellInputFrom(i)),
-            outputs: tx.outputs.map((o) => JsonRpcTransformers.cellOutputFrom(o)),
-            outputs_data: tx.outputsData,
-            witnesses: tx.witnesses,
-        };
-    }
-    static transactionTo(tx) {
-        return ckb_1.Transaction.from({
-            version: tx.version,
-            cellDeps: tx.cell_deps.map((c) => JsonRpcTransformers.cellDepTo(c)),
-            headerDeps: tx.header_deps,
-            inputs: tx.inputs.map((i) => JsonRpcTransformers.cellInputTo(i)),
-            outputs: tx.outputs.map((o) => JsonRpcTransformers.cellOutputTo(o)),
-            outputsData: tx.outputs_data,
-            witnesses: tx.witnesses,
-        });
-    }
-    static transactionResponseTo({ tx_status: { status, block_number }, transaction, }) {
-        return {
-            transaction: JsonRpcTransformers.transactionTo(transaction),
-            status,
-            blockNumber: (0, num_1.numFrom)(block_number),
-        };
-    }
-    static rangeFrom([a, b]) {
-        return [(0, num_1.numToHex)(a), (0, num_1.numToHex)(b)];
-    }
-    static indexerSearchKeyFrom(keyLike) {
-        const key = clientTypes_1.ClientIndexerSearchKey.from(keyLike);
-        return {
-            script: JsonRpcTransformers.scriptFrom(key.script),
-            script_type: key.scriptType,
-            script_search_mode: key.scriptSearchMode,
-            filter: (0, utils_1.apply)((filter) => ({
-                script: (0, utils_1.apply)(JsonRpcTransformers.scriptFrom, filter.script),
-                script_len_range: (0, utils_1.apply)(JsonRpcTransformers.rangeFrom, filter.scriptLenRange),
-                output_data: filter.outputData,
-                output_data_filter_mode: filter.outputDataSearchMode,
-                output_data_len_range: (0, utils_1.apply)(JsonRpcTransformers.rangeFrom, filter.outputDataLenRange),
-                output_capacity_range: (0, utils_1.apply)(JsonRpcTransformers.rangeFrom, filter.outputCapacityRange),
-                block_range: (0, utils_1.apply)(JsonRpcTransformers.rangeFrom, filter.blockRange),
-            }), key.filter),
-            with_data: key.withData,
-        };
-    }
-    static findCellsResponseTo({ last_cursor, objects, }) {
-        return {
-            lastCursor: last_cursor,
-            cells: objects.map((cell) => ckb_1.Cell.from({
-                blockNumber: cell.block_number,
-                outPoint: JsonRpcTransformers.outPointTo(cell.out_point),
-                cellOutput: JsonRpcTransformers.cellOutputTo(cell.output),
-                outputData: cell.output_data,
-            })),
-        };
-    }
+  static hashTypeFrom(hashType) {
+    return (0, ckb_1.hashTypeFrom)(hashType);
+  }
+  static hashTypeTo(hashType) {
+    return hashType;
+  }
+  static depTypeFrom(depType) {
+    switch ((0, ckb_1.depTypeFrom)(depType)) {
+      case "code":
+        return "code";
+      case "depGroup":
+        return "dep_group";
+    }
+  }
+  static depTypeTo(depType) {
+    switch (depType) {
+      case "code":
+        return "code";
+      case "dep_group":
+        return "depGroup";
+    }
+  }
+  static scriptFrom(scriptLike) {
+    const script = ckb_1.Script.from(scriptLike);
+    return {
+      code_hash: script.codeHash,
+      hash_type: JsonRpcTransformers.hashTypeFrom(script.hashType),
+      args: script.args,
+    };
+  }
+  static scriptTo(script) {
+    return ckb_1.Script.from({
+      codeHash: script.code_hash,
+      hashType: JsonRpcTransformers.hashTypeTo(script.hash_type),
+      args: script.args,
+    });
+  }
+  static outPointFrom(outPointLike) {
+    const outPoint = ckb_1.OutPoint.from(outPointLike);
+    return {
+      index: (0, num_1.numToHex)(outPoint.index),
+      tx_hash: outPoint.txHash,
+    };
+  }
+  static outPointTo(outPoint) {
+    return ckb_1.OutPoint.from({
+      index: outPoint.index,
+      txHash: outPoint.tx_hash,
+    });
+  }
+  static cellInputFrom(cellInputLike) {
+    const cellInput = ckb_1.CellInput.from(cellInputLike);
+    return {
+      previous_output: JsonRpcTransformers.outPointFrom(
+        cellInput.previousOutput,
+      ),
+      since: (0, num_1.numToHex)(cellInput.since),
+    };
+  }
+  static cellInputTo(cellInput) {
+    return ckb_1.CellInput.from({
+      previousOutput: JsonRpcTransformers.outPointTo(cellInput.previous_output),
+      since: cellInput.since,
+    });
+  }
+  static cellOutputFrom(cellOutput) {
+    return {
+      capacity: (0, num_1.numToHex)(cellOutput.capacity),
+      lock: JsonRpcTransformers.scriptFrom(cellOutput.lock),
+      type: (0, utils_1.apply)(JsonRpcTransformers.scriptFrom, cellOutput.type),
+    };
+  }
+  static cellOutputTo(cellOutput) {
+    return ckb_1.CellOutput.from({
+      capacity: cellOutput.capacity,
+      lock: JsonRpcTransformers.scriptTo(cellOutput.lock),
+      type: (0, utils_1.apply)(JsonRpcTransformers.scriptTo, cellOutput.type),
+    });
+  }
+  static cellDepFrom(cellDep) {
+    return {
+      out_point: JsonRpcTransformers.outPointFrom(cellDep.outPoint),
+      dep_type: JsonRpcTransformers.depTypeFrom(cellDep.depType),
+    };
+  }
+  static cellDepTo(cellDep) {
+    return ckb_1.CellDep.from({
+      outPoint: JsonRpcTransformers.outPointTo(cellDep.out_point),
+      depType: JsonRpcTransformers.depTypeTo(cellDep.dep_type),
+    });
+  }
+  static transactionFrom(txLike) {
+    const tx = ckb_1.Transaction.from(txLike);
+    return {
+      version: (0, num_1.numToHex)(tx.version),
+      cell_deps: tx.cellDeps.map((c) => JsonRpcTransformers.cellDepFrom(c)),
+      header_deps: tx.headerDeps,
+      inputs: tx.inputs.map((i) => JsonRpcTransformers.cellInputFrom(i)),
+      outputs: tx.outputs.map((o) => JsonRpcTransformers.cellOutputFrom(o)),
+      outputs_data: tx.outputsData,
+      witnesses: tx.witnesses,
+    };
+  }
+  static transactionTo(tx) {
+    return ckb_1.Transaction.from({
+      version: tx.version,
+      cellDeps: tx.cell_deps.map((c) => JsonRpcTransformers.cellDepTo(c)),
+      headerDeps: tx.header_deps,
+      inputs: tx.inputs.map((i) => JsonRpcTransformers.cellInputTo(i)),
+      outputs: tx.outputs.map((o) => JsonRpcTransformers.cellOutputTo(o)),
+      outputsData: tx.outputs_data,
+      witnesses: tx.witnesses,
+    });
+  }
+  static transactionResponseTo({ tx_status: { status }, transaction }) {
+    if (transaction == null) {
+      return null;
+    }
+    return {
+      transaction: JsonRpcTransformers.transactionTo(transaction),
+      status,
+    };
+  }
+  static rangeFrom([a, b]) {
+    return [(0, num_1.numToHex)(a), (0, num_1.numToHex)(b)];
+  }
+  static indexerSearchKeyFrom(keyLike) {
+    const key = clientTypes_1.ClientIndexerSearchKey.from(keyLike);
+    return {
+      script: JsonRpcTransformers.scriptFrom(key.script),
+      script_type: key.scriptType,
+      script_search_mode: key.scriptSearchMode,
+      filter: (0, utils_1.apply)(
+        (filter) => ({
+          script: (0, utils_1.apply)(
+            JsonRpcTransformers.scriptFrom,
+            filter.script,
+          ),
+          script_len_range: (0, utils_1.apply)(
+            JsonRpcTransformers.rangeFrom,
+            filter.scriptLenRange,
+          ),
+          output_data: filter.outputData,
+          output_data_filter_mode: filter.outputDataSearchMode,
+          output_data_len_range: (0, utils_1.apply)(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputDataLenRange,
+          ),
+          output_capacity_range: (0, utils_1.apply)(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputCapacityRange,
+          ),
+          block_range: (0, utils_1.apply)(
+            JsonRpcTransformers.rangeFrom,
+            filter.blockRange,
+          ),
+        }),
+        key.filter,
+      ),
+      with_data: key.withData,
+    };
+  }
+  static findCellsResponseTo({ last_cursor, objects }) {
+    return {
+      lastCursor: last_cursor,
+      cells: objects.map((cell) =>
+        ckb_1.Cell.from({
+          outPoint: JsonRpcTransformers.outPointTo(cell.out_point),
+          cellOutput: JsonRpcTransformers.cellOutputTo(cell.output),
+          outputData: cell.output_data ?? "0x",
+        }),
+      ),
+    };
+  }
 }
 exports.JsonRpcTransformers = JsonRpcTransformers;

package/dist.commonjs/client/jsonRpc/types.d.ts

@@ -1,56 +1,56 @@
 import { Hex } from "../../hex";
 export type JsonRpcPayload = {
-    id: number;
-    jsonrpc: "2.0";
-    method: string;
-    params: unknown[] | Record<string, unknown>;
+  id: number;
+  jsonrpc: "2.0";
+  method: string;
+  params: unknown[] | Record<string, unknown>;
 };
 export type JsonRpcHashType = "type" | "data" | "data1" | "data2";
 export type JsonRpcDepType = "dep_group" | "code";
 export type JsonRpcScript = {
-    code_hash: Hex;
-    hash_type: JsonRpcHashType;
-    args: Hex;
+  code_hash: Hex;
+  hash_type: JsonRpcHashType;
+  args: Hex;
 };
 export type JsonRpcOutPoint = {
-    index: Hex;
-    tx_hash: Hex;
+  index: Hex;
+  tx_hash: Hex;
 };
 export type JsonRpcCellInput = {
-    previous_output: JsonRpcOutPoint;
-    since: Hex;
+  previous_output: JsonRpcOutPoint;
+  since: Hex;
 };
 export type JsonRpcCellOutput = {
-    capacity: Hex;
-    lock: JsonRpcScript;
-    type?: JsonRpcScript;
+  capacity: Hex;
+  lock: JsonRpcScript;
+  type?: JsonRpcScript;
 };
 export type JsonRpcCellDep = {
-    out_point: JsonRpcOutPoint;
-    dep_type: JsonRpcDepType;
+  out_point: JsonRpcOutPoint;
+  dep_type: JsonRpcDepType;
 };
 export type JsonRpcTransaction = {
-    version: Hex;
-    cell_deps: JsonRpcCellDep[];
-    header_deps: Hex[];
-    inputs: JsonRpcCellInput[];
-    outputs: JsonRpcCellOutput[];
-    outputs_data: Hex[];
-    witnesses: Hex[];
+  version: Hex;
+  cell_deps: JsonRpcCellDep[];
+  header_deps: Hex[];
+  inputs: JsonRpcCellInput[];
+  outputs: JsonRpcCellOutput[];
+  outputs_data: Hex[];
+  witnesses: Hex[];
 };
 export type JsonRpcIndexerSearchKey = {
-    script: JsonRpcScript;
-    script_type: "lock" | "type";
-    script_search_mode?: "prefix" | "exact" | "partial";
-    filter?: {
-        script?: JsonRpcScript;
-        script_len_range?: [Hex, Hex];
-        output_data?: Hex;
-        output_data_filter_mode?: "prefix" | "exact" | "partial";
-        output_data_len_range?: [Hex, Hex];
-        output_capacity_range?: [Hex, Hex];
-        block_range?: [Hex, Hex];
-    };
-    with_data?: boolean;
-};
-//# sourceMappingURL=types.d.ts.map
+  script: JsonRpcScript;
+  script_type: "lock" | "type";
+  script_search_mode?: "prefix" | "exact" | "partial";
+  filter?: {
+    script?: JsonRpcScript;
+    script_len_range?: [Hex, Hex];
+    output_data?: Hex;
+    output_data_filter_mode?: "prefix" | "exact" | "partial";
+    output_data_len_range?: [Hex, Hex];
+    output_capacity_range?: [Hex, Hex];
+    block_range?: [Hex, Hex];
+  };
+  with_data?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist.commonjs/fixedPoint/index.d.ts

@@ -21,7 +21,10 @@ export type FixedPointLike = bigint | string | number;
  * const strFromNumber = fixedPointToString(123456789, 8); // Outputs "1.23456789"
  * ```
  */
-export declare function fixedPointToString(val: FixedPointLike, decimals?: number): string;
+export declare function fixedPointToString(
+  val: FixedPointLike,
+  decimals?: number,
+): string;
 /**
  * Converts a FixedPointLike value to a FixedPoint (bigint) with fixed-point decimals.
  *
@@ -36,7 +39,10 @@ export declare function fixedPointToString(val: FixedPointLike, decimals?: numbe
  * const fixedPointFromNumber = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
  * ```
  */
-export declare function fixedPointFrom(val: FixedPointLike, decimals?: number): FixedPoint;
+export declare function fixedPointFrom(
+  val: FixedPointLike,
+  decimals?: number,
+): FixedPoint;
 /**
  * Represents the fixed point value of zero as a bigint.
  */
@@ -46,4 +52,4 @@ export declare const Zero = 0n;
  * Equivalent to 1 in fixed-point representation with default decimals (8).
  */
 export declare const One: bigint;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist.commonjs/fixedPoint/index.js

@@ -3,7 +3,11 @@
  * Represents a fixed point value as a bigint.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.One = exports.Zero = exports.fixedPointFrom = exports.fixedPointToString = void 0;
+exports.One =
+  exports.Zero =
+  exports.fixedPointFrom =
+  exports.fixedPointToString =
+    void 0;
 /**
  * Converts a FixedPointLike value to its string representation with fixed-point decimals.
  *
@@ -19,16 +23,16 @@ exports.One = exports.Zero = exports.fixedPointFrom = exports.fixedPointToString
  * ```
  */
 function fixedPointToString(val, decimals = 8) {
-    const str = fixedPointFrom(val).toString();
-    if (decimals === 0) {
-        return str;
-    }
-    const l = str.length <= decimals ? "0" : str.slice(0, -decimals);
-    const r = str.slice(-decimals).padStart(decimals, "0").replace(/0*$/, "");
-    if (r === "") {
-        return l;
-    }
-    return `${l}.${r}`;
+  const str = fixedPointFrom(val).toString();
+  if (decimals === 0) {
+    return str;
+  }
+  const l = str.length <= decimals ? "0" : str.slice(0, -decimals);
+  const r = str.slice(-decimals).padStart(decimals, "0").replace(/0*$/, "");
+  if (r === "") {
+    return l;
+  }
+  return `${l}.${r}`;
 }
 exports.fixedPointToString = fixedPointToString;
 /**
@@ -46,15 +50,17 @@ exports.fixedPointToString = fixedPointToString;
  * ```
  */
 function fixedPointFrom(val, decimals = 8) {
-    if (typeof val === "bigint") {
-        return val;
-    }
-    const [l, r] = (typeof val === "number" ? val.toFixed(decimals) : val.toString()).split(".");
-    const lVal = BigInt(l.padEnd(l.length + decimals, "0"));
-    if (r === undefined) {
-        return lVal;
-    }
-    return lVal + BigInt(r.slice(0, decimals).padEnd(decimals, "0"));
+  if (typeof val === "bigint") {
+    return val;
+  }
+  const [l, r] = (
+    typeof val === "number" ? val.toFixed(decimals) : val.toString()
+  ).split(".");
+  const lVal = BigInt(l.padEnd(l.length + decimals, "0"));
+  if (r === undefined) {
+    return lVal;
+  }
+  return lVal + BigInt(r.slice(0, decimals).padEnd(decimals, "0"));
 }
 exports.fixedPointFrom = fixedPointFrom;
 /**

package/dist.commonjs/fixedPoint/index.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=index.test.d.ts.map
+//# sourceMappingURL=index.test.d.ts.map

package/dist.commonjs/fixedPoint/index.test.js

@@ -2,44 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = require(".");
 describe("fixedPointToString", () => {
-    const cases = [
-        [0n, "0"],
-        [1n, "0.00000001"],
-        [100000000n, "1"],
-        [1000000000n, "10"],
-        [1010100000n, "10.101"],
-        [11n, "1.1", 1],
-        [0n, "0", 1],
-        [1n, "1", 0],
-        [0n, "0", 0],
-    ];
-    cases.forEach(([i, o, decimals]) => test(`${i} with ${decimals ?? "default"} decimals = "${o}"`, () => {
-        expect((0, _1.fixedPointToString)(i, decimals)).toBe(o);
-    }));
+  const cases = [
+    [0n, "0"],
+    [1n, "0.00000001"],
+    [100000000n, "1"],
+    [1000000000n, "10"],
+    [1010100000n, "10.101"],
+    [11n, "1.1", 1],
+    [0n, "0", 1],
+    [1n, "1", 0],
+    [0n, "0", 0],
+  ];
+  cases.forEach(([i, o, decimals]) =>
+    test(`${i} with ${decimals ?? "default"} decimals = "${o}"`, () => {
+      expect((0, _1.fixedPointToString)(i, decimals)).toBe(o);
+    }),
+  );
 });
 describe("fixedPointFrom string", () => {
-    const cases = [
-        ["0", 0n],
-        ["0.00000001", 1n],
-        ["1", 100000000n],
-        ["10", 1000000000n],
-        ["10.101", 1010100000n],
-        ["1.1", 11n, 1],
-        ["0", 0n, 1],
-        ["1", 1n, 0],
-        ["0", 0n, 0],
-    ];
-    cases.forEach(([i, o, decimals]) => test(`"${i}" = ${o} with ${decimals ?? "default"} decimals `, () => {
-        expect((0, _1.fixedPointFrom)(i, decimals)).toBe(o);
-    }));
+  const cases = [
+    ["0", 0n],
+    ["0.00000001", 1n],
+    ["1", 100000000n],
+    ["10", 1000000000n],
+    ["10.101", 1010100000n],
+    ["1.1", 11n, 1],
+    ["0", 0n, 1],
+    ["1", 1n, 0],
+    ["0", 0n, 0],
+  ];
+  cases.forEach(([i, o, decimals]) =>
+    test(`"${i}" = ${o} with ${decimals ?? "default"} decimals `, () => {
+      expect((0, _1.fixedPointFrom)(i, decimals)).toBe(o);
+    }),
+  );
 });
 describe("fixedPointFrom number", () => {
-    const cases = [
-        [0.00000001, 1n],
-        [10.101, 1010100000n],
-        [1.1, 11n, 1],
-    ];
-    cases.forEach(([i, o, decimals]) => test(`${i} = ${o} with ${decimals ?? "default"} decimals `, () => {
-        expect((0, _1.fixedPointFrom)(i, decimals)).toBe(o);
-    }));
+  const cases = [
+    [0.00000001, 1n],
+    [10.101, 1010100000n],
+    [1.1, 11n, 1],
+  ];
+  cases.forEach(([i, o, decimals]) =>
+    test(`${i} = ${o} with ${decimals ?? "default"} decimals `, () => {
+      expect((0, _1.fixedPointFrom)(i, decimals)).toBe(o);
+    }),
+  );
 });

package/dist.commonjs/hasher/advanced.d.ts

@@ -1,2 +1,2 @@
 export declare const CKB_BLAKE2B_PERSONAL = "ckb-default-hash";
-//# sourceMappingURL=advanced.d.ts.map
+//# sourceMappingURL=advanced.d.ts.map