@ckb-ccc/core 0.0.4-alpha.8 → 0.0.4

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

@@ -0,0 +1,41 @@
+import { Hex } from "../../hex";
+export type JsonRpcPayload = {
+    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;
+};
+export type JsonRpcOutPoint = {
+    index: Hex;
+    tx_hash: Hex;
+};
+export type JsonRpcCellInput = {
+    previous_output: JsonRpcOutPoint;
+    since: Hex;
+};
+export type JsonRpcCellOutput = {
+    capacity: Hex;
+    lock: JsonRpcScript;
+    type?: JsonRpcScript;
+};
+export type JsonRpcCellDep = {
+    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[];
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/client/jsonRpc/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAEhC,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,MAAM,CAAC;AAElD,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,GAAG,CAAC;IACf,SAAS,EAAE,eAAe,CAAC;IAC3B,IAAI,EAAE,GAAG,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,GAAG,CAAC;IACX,OAAO,EAAE,GAAG,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,KAAK,EAAE,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,eAAe,CAAC;IAC3B,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,GAAG,CAAC;IACb,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC;IACnB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB,SAAS,EAAE,GAAG,EAAE,CAAC;CAClB,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,49 @@
+/**
+ * Represents a fixed point value as a bigint.
+ */
+export type FixedPoint = bigint;
+/**
+ * Represents a value that can be converted to a fixed point value.
+ * It can be a bigint, string, or number.
+ */
+export type FixedPointLike = bigint | string | number;
+/**
+ * Converts a FixedPointLike value to its string representation with fixed-point decimals.
+ *
+ * @param val - The value to convert, which can be a bigint, string, or number.
+ * @param decimals - The number of decimal places for the fixed-point representation. Default is 8.
+ * @returns A string representing the fixed-point value.
+ *
+ * @example
+ * ```typescript
+ * const str = fixedPointToString(123456789n, 8); // Outputs "1.23456789"
+ * const strFromString = fixedPointToString("123456789", 8); // Outputs "1.23456789"
+ * const strFromNumber = fixedPointToString(123456789, 8); // Outputs "1.23456789"
+ * ```
+ */
+export declare function fixedPointToString(val: FixedPointLike, decimals?: number): string;
+/**
+ * Converts a FixedPointLike value to a FixedPoint (bigint) with fixed-point decimals.
+ *
+ * @param val - The value to convert, which can be a bigint, string, or number.
+ * @param decimals - The number of decimal places for the fixed-point representation. Default is 8.
+ * @returns A FixedPoint (bigint) representing the value with fixed-point decimals.
+ *
+ * @example
+ * ```typescript
+ * const fixedPoint = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
+ * const fixedPointFromString = fixedPointFrom("1.23456789", 8); // Outputs 123456789n
+ * const fixedPointFromNumber = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
+ * ```
+ */
+export declare function fixedPointFrom(val: FixedPointLike, decimals?: number): FixedPoint;
+/**
+ * Represents the fixed point value of zero as a bigint.
+ */
+export declare const Zero = 0n;
+/**
+ * Represents the fixed point value of one as a FixedPoint (bigint).
+ * Equivalent to 1 in fixed-point representation with default decimals (8).
+ */
+export declare const One: bigint;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixedPoint/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC;;;GAGG;AAEH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AAEH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,EAAE,QAAQ,SAAI,GAAG,MAAM,CAS5E;AAED;;;;;;;;;;;;;GAaG;AAEH,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,EAAE,QAAQ,SAAI,GAAG,UAAU,CAY5E;AAED;;GAEG;AAEH,eAAO,MAAM,IAAI,KAAK,CAAC;AAEvB;;;GAGG;AAEH,eAAO,MAAM,GAAG,QAAsB,CAAC"}

package/dist.commonjs/fixedPoint/index.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Represents a fixed point value as a bigint.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.One = exports.Zero = exports.fixedPointFrom = exports.fixedPointToString = void 0;
+/**
+ * Converts a FixedPointLike value to its string representation with fixed-point decimals.
+ *
+ * @param val - The value to convert, which can be a bigint, string, or number.
+ * @param decimals - The number of decimal places for the fixed-point representation. Default is 8.
+ * @returns A string representing the fixed-point value.
+ *
+ * @example
+ * ```typescript
+ * const str = fixedPointToString(123456789n, 8); // Outputs "1.23456789"
+ * const strFromString = fixedPointToString("123456789", 8); // Outputs "1.23456789"
+ * const strFromNumber = fixedPointToString(123456789, 8); // Outputs "1.23456789"
+ * ```
+ */
+function fixedPointToString(val, decimals = 8) {
+    const str = fixedPointFrom(val).toString();
+    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;
+/**
+ * Converts a FixedPointLike value to a FixedPoint (bigint) with fixed-point decimals.
+ *
+ * @param val - The value to convert, which can be a bigint, string, or number.
+ * @param decimals - The number of decimal places for the fixed-point representation. Default is 8.
+ * @returns A FixedPoint (bigint) representing the value with fixed-point decimals.
+ *
+ * @example
+ * ```typescript
+ * const fixedPoint = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
+ * const fixedPointFromString = fixedPointFrom("1.23456789", 8); // Outputs 123456789n
+ * const fixedPointFromNumber = fixedPointFrom(1.23456789, 8); // Outputs 123456789n
+ * ```
+ */
+function fixedPointFrom(val, decimals = 8) {
+    if (typeof val === "bigint") {
+        return val;
+    }
+    const [l, r] = 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;
+/**
+ * Represents the fixed point value of zero as a bigint.
+ */
+exports.Zero = 0n;
+/**
+ * Represents the fixed point value of one as a FixedPoint (bigint).
+ * Equivalent to 1 in fixed-point representation with default decimals (8).
+ */
+exports.One = fixedPointFrom("1");

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../src/hasher/advanced.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,qBAAqB,CAAC"}

package/dist.commonjs/hasher/advanced.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CKB_BLAKE2B_PERSONAL = void 0;
+exports.CKB_BLAKE2B_PERSONAL = "ckb-default-hash";

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

@@ -0,0 +1,52 @@
+import { BytesLike } from "../bytes";
+import { Hex } from "../hex";
+export declare class Hasher {
+    private readonly hasher;
+    /**
+     * Creates an instance of Hasher.
+     *
+     * @param outLength - The output length of the hash in bytes. Default is 32.
+     * @param personal - The personal string for the Blake2b algorithm. Default is CKB_BLAKE2B_PERSONAL.
+     */
+    constructor(outLength?: number, personal?: string);
+    /**
+     * Updates the hash with the given data.
+     *
+     * @param data - The data to update the hash with.
+     * @returns The current Hasher instance for chaining.
+     *
+     * @example
+     * ```typescript
+     * const hasher = new Hasher();
+     * hasher.update("some data").update("more data");
+     * const hash = hasher.digest();
+     * ```
+     */
+    update(data: BytesLike): Hasher;
+    /**
+     * Finalizes the hash and returns the digest as a hexadecimal string.
+     *
+     * @returns The hexadecimal string representation of the hash.
+     *
+     * @example
+     * ```typescript
+     * const hasher = new Hasher();
+     * hasher.update("some data");
+     * const hash = hasher.digest(); // Outputs something like "0x..."
+     * ```
+     */
+    digest(): Hex;
+}
+/**
+ * Computes the CKB hash of the given data using the Blake2b algorithm.
+ *
+ * @param data - The data to hash.
+ * @returns The hexadecimal string representation of the hash.
+ *
+ * @example
+ * ```typescript
+ * const hash = ckbHash("some data"); // Outputs something like "0x..."
+ * ```
+ */
+export declare function ckbHash(data: BytesLike): Hex;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hasher/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAa,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAG7B,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IAEjC;;;;;OAKG;gBAES,SAAS,SAAK,EAAE,QAAQ,SAAuB;IAS3D;;;;;;;;;;;;OAYG;IAEH,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAK/B;;;;;;;;;;;OAWG;IAEH,MAAM,IAAI,GAAG;CAGd;AAED;;;;;;;;;;GAUG;AAEH,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,GAAG,CAE5C"}

package/dist.commonjs/hasher/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ckbHash = exports.Hasher = void 0;
+const blake2b_1 = __importDefault(require("blake2b"));
+const bytes_1 = require("../bytes");
+const advanced_1 = require("./advanced");
+class Hasher {
+    /**
+     * Creates an instance of Hasher.
+     *
+     * @param outLength - The output length of the hash in bytes. Default is 32.
+     * @param personal - The personal string for the Blake2b algorithm. Default is CKB_BLAKE2B_PERSONAL.
+     */
+    constructor(outLength = 32, personal = advanced_1.CKB_BLAKE2B_PERSONAL) {
+        this.hasher = (0, blake2b_1.default)(outLength, undefined, undefined, (0, bytes_1.bytesFrom)(personal, "utf8"));
+    }
+    /**
+     * Updates the hash with the given data.
+     *
+     * @param data - The data to update the hash with.
+     * @returns The current Hasher instance for chaining.
+     *
+     * @example
+     * ```typescript
+     * const hasher = new Hasher();
+     * hasher.update("some data").update("more data");
+     * const hash = hasher.digest();
+     * ```
+     */
+    update(data) {
+        this.hasher.update((0, bytes_1.bytesFrom)(data));
+        return this;
+    }
+    /**
+     * Finalizes the hash and returns the digest as a hexadecimal string.
+     *
+     * @returns The hexadecimal string representation of the hash.
+     *
+     * @example
+     * ```typescript
+     * const hasher = new Hasher();
+     * hasher.update("some data");
+     * const hash = hasher.digest(); // Outputs something like "0x..."
+     * ```
+     */
+    digest() {
+        return `0x${this.hasher.digest("hex")}`;
+    }
+}
+exports.Hasher = Hasher;
+/**
+ * Computes the CKB hash of the given data using the Blake2b algorithm.
+ *
+ * @param data - The data to hash.
+ * @returns The hexadecimal string representation of the hash.
+ *
+ * @example
+ * ```typescript
+ * const hash = ckbHash("some data"); // Outputs something like "0x..."
+ * ```
+ */
+function ckbHash(data) {
+    return new Hasher().update(data).digest();
+}
+exports.ckbHash = ckbHash;

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

@@ -0,0 +1,24 @@
+import { BytesLike } from "../bytes";
+/**
+ * Represents a hexadecimal string prefixed with "0x".
+ */
+export type Hex = `0x${string}`;
+/**
+ * Represents a value that can be converted to a hexadecimal string.
+ * It extends the BytesLike type.
+ */
+export type HexLike = BytesLike;
+/**
+ * Converts a HexLike value to a Hex string.
+ *
+ * @param hex - The value to convert, which can be a string, Uint8Array, ArrayBuffer, or number array.
+ * @returns A Hex string representing the value.
+ *
+ * @example
+ * ```typescript
+ * const hexString = hexFrom("68656c6c6f"); // Outputs "0x68656c6c6f"
+ * const hexStringFromBytes = hexFrom(new Uint8Array([104, 101, 108, 108, 111])); // Outputs "0x68656c6c6f"
+ * ```
+ */
+export declare function hexFrom(hex: HexLike): Hex;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAW,MAAM,UAAU,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAChC;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC;AAEhC;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAEzC"}

package/dist.commonjs/hex/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexFrom = void 0;
+const bytes_1 = require("../bytes");
+/**
+ * Converts a HexLike value to a Hex string.
+ *
+ * @param hex - The value to convert, which can be a string, Uint8Array, ArrayBuffer, or number array.
+ * @returns A Hex string representing the value.
+ *
+ * @example
+ * ```typescript
+ * const hexString = hexFrom("68656c6c6f"); // Outputs "0x68656c6c6f"
+ * const hexStringFromBytes = hexFrom(new Uint8Array([104, 101, 108, 108, 111])); // Outputs "0x68656c6c6f"
+ * ```
+ */
+function hexFrom(hex) {
+    return `0x${(0, bytes_1.bytesTo)((0, bytes_1.bytesFrom)(hex), "hex")}`;
+}
+exports.hexFrom = hexFrom;

package/dist.commonjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./barrel";
+export * as ccc from "./barrel";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC"}

package/dist.commonjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    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.ccc = void 0;
+__exportStar(require("./barrel"), exports);
+exports.ccc = __importStar(require("./barrel"));

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

@@ -0,0 +1,112 @@
+import { Bytes, BytesLike } from "../bytes";
+import { Hex, HexLike } from "../hex";
+/**
+ * Represents a numeric value as a bigint.
+ */
+export type Num = bigint;
+/**
+ * Represents a value that can be converted to a numeric value.
+ * It can be a string, number, bigint, or HexLike.
+ */
+export type NumLike = string | number | bigint | HexLike;
+/**
+ * Converts a NumLike value to a Num (bigint).
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @returns A Num (bigint) representing the value.
+ *
+ * @example
+ * ```typescript
+ * const num = numFrom("12345"); // Outputs 12345n
+ * const numFromHex = numFrom("0x3039"); // Outputs 12345n
+ * ```
+ */
+export declare function numFrom(val: NumLike): Num;
+/**
+ * Converts a NumLike value to a hexadecimal string.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @returns A Hex string representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const hex = numToHex(12345); // Outputs "0x3039"
+ * ```
+ */
+export declare function numToHex(val: NumLike): Hex;
+/**
+ * Converts a NumLike value to a byte array in little-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numToBytes(12345, 4); // Outputs Uint8Array [57, 48, 0, 0]
+ * ```
+ */
+export declare function numToBytes(val: NumLike, bytes?: number): Bytes;
+/**
+ * Converts a NumLike value to a byte array in little-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numLeToBytes(12345, 4); // Outputs Uint8Array [57, 48, 0, 0]
+ * ```
+ */
+export declare function numLeToBytes(val: NumLike, bytes?: number): Bytes;
+/**
+ * Converts a NumLike value to a byte array in big-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numBeToBytes(12345, 4); // Outputs Uint8Array [0, 0, 48, 57]
+ * ```
+ */
+export declare function numBeToBytes(val: NumLike, bytes?: number): Bytes;
+/**
+ * Converts a byte array to a Num (bigint) assuming little-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numFromBytes(new Uint8Array([57, 48, 0, 0])); // Outputs 12345n
+ * ```
+ */
+export declare function numFromBytes(val: BytesLike): Num;
+/**
+ * Converts a byte array to a Num (bigint) assuming little-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numLeFromBytes(new Uint8Array([57, 48, 0, 0])); // Outputs 12345n
+ * ```
+ */
+export declare function numLeFromBytes(val: BytesLike): Num;
+/**
+ * Converts a byte array to a Num (bigint) assuming big-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numBeFromBytes(new Uint8Array([0, 0, 48, 57])); // Outputs 12345n
+ * ```
+ */
+export declare function numBeFromBytes(val: BytesLike): Num;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/num/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAA0B,MAAM,UAAU,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAW,MAAM,QAAQ,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AAEzB;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAUzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,CAE1C;AAED;;;;;;;;;;;GAWG;AAEH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAE9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAEhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAUhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAEhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAElD"}

package/dist.commonjs/num/index.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numBeFromBytes = exports.numLeFromBytes = exports.numFromBytes = exports.numBeToBytes = exports.numLeToBytes = exports.numToBytes = exports.numToHex = exports.numFrom = void 0;
+const bytes_1 = require("../bytes");
+const hex_1 = require("../hex");
+/**
+ * Converts a NumLike value to a Num (bigint).
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @returns A Num (bigint) representing the value.
+ *
+ * @example
+ * ```typescript
+ * const num = numFrom("12345"); // Outputs 12345n
+ * const numFromHex = numFrom("0x3039"); // Outputs 12345n
+ * ```
+ */
+function numFrom(val) {
+    if (typeof val === "bigint") {
+        return val;
+    }
+    if (typeof val === "string" || typeof val === "number") {
+        return BigInt(val);
+    }
+    return BigInt((0, hex_1.hexFrom)(val));
+}
+exports.numFrom = numFrom;
+/**
+ * Converts a NumLike value to a hexadecimal string.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @returns A Hex string representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const hex = numToHex(12345); // Outputs "0x3039"
+ * ```
+ */
+function numToHex(val) {
+    return `0x${numFrom(val).toString(16)}`;
+}
+exports.numToHex = numToHex;
+/**
+ * Converts a NumLike value to a byte array in little-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numToBytes(12345, 4); // Outputs Uint8Array [57, 48, 0, 0]
+ * ```
+ */
+function numToBytes(val, bytes) {
+    return numLeToBytes(val, bytes);
+}
+exports.numToBytes = numToBytes;
+/**
+ * Converts a NumLike value to a byte array in little-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numLeToBytes(12345, 4); // Outputs Uint8Array [57, 48, 0, 0]
+ * ```
+ */
+function numLeToBytes(val, bytes) {
+    return numBeToBytes(val, bytes).reverse();
+}
+exports.numLeToBytes = numLeToBytes;
+/**
+ * Converts a NumLike value to a byte array in big-endian order.
+ *
+ * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
+ * @param bytes - The number of bytes to use for the representation. If not provided, the exact number of bytes needed is used.
+ * @returns A Uint8Array containing the byte representation of the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const bytes = numBeToBytes(12345, 4); // Outputs Uint8Array [0, 0, 48, 57]
+ * ```
+ */
+function numBeToBytes(val, bytes) {
+    const rawBytes = (0, bytes_1.bytesFrom)(numFrom(val).toString(16));
+    if (bytes == null) {
+        return rawBytes;
+    }
+    return (0, bytes_1.bytesConcat)(Array.from(Array(bytes - rawBytes.length), () => 0), rawBytes);
+}
+exports.numBeToBytes = numBeToBytes;
+/**
+ * Converts a byte array to a Num (bigint) assuming little-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numFromBytes(new Uint8Array([57, 48, 0, 0])); // Outputs 12345n
+ * ```
+ */
+function numFromBytes(val) {
+    return numLeFromBytes(val);
+}
+exports.numFromBytes = numFromBytes;
+/**
+ * Converts a byte array to a Num (bigint) assuming little-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numLeFromBytes(new Uint8Array([57, 48, 0, 0])); // Outputs 12345n
+ * ```
+ */
+function numLeFromBytes(val) {
+    return numBeFromBytes((0, bytes_1.bytesFrom)(val).reverse());
+}
+exports.numLeFromBytes = numLeFromBytes;
+/**
+ * Converts a byte array to a Num (bigint) assuming big-endian order.
+ *
+ * @param val - The byte array to convert.
+ * @returns A Num (bigint) representing the numeric value.
+ *
+ * @example
+ * ```typescript
+ * const num = numBeFromBytes(new Uint8Array([0, 0, 48, 57])); // Outputs 12345n
+ * ```
+ */
+function numBeFromBytes(val) {
+    return numFrom((0, bytes_1.bytesFrom)(val));
+}
+exports.numBeFromBytes = numBeFromBytes;

package/dist.commonjs/signer/btc/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./signerBtc";
+export * from "./signerBtcPublicKeyReadonly";
+//# sourceMappingURL=index.d.ts.map

package/dist.commonjs/signer/btc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/signer/btc/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,8BAA8B,CAAC"}