ccxt 4.3.70 → 4.3.71

package/js/src/static_dependencies/starknet/utils/hash/classHash.js

@@ -0,0 +1,224 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ * Class Hash
+ */
+import { poseidonHashMany } from '../../../scure-starknet/index.js';
+import { ADDR_BOUND, API_VERSION } from '../../constants.js';
+import { CallData } from '../calldata/index.js';
+import { felt } from '../calldata/cairo.js';
+import { pedersen, poseidonHash, keccak } from '../../../scure-starknet/index.js';
+import { addHexPrefix, utf8ToArray } from '../encode.js';
+import { parse, stringify } from '../json.js';
+import { toHex } from '../num.js';
+import { encodeShortString, isString } from '../shortString.js';
+export function computePedersenHash(a, b) {
+    return pedersen(BigInt(a), BigInt(b));
+}
+export function computePoseidonHash(a, b) {
+    return toHex(poseidonHash(BigInt(a), BigInt(b)));
+}
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
+export function computeHashOnElements(data) {
+    return [...data, data.length]
+        .reduce((x, y) => pedersen(BigInt(x), BigInt(y)), 0)
+        .toString();
+}
+export const computePedersenHashOnElements = computeHashOnElements;
+export function computePoseidonHashOnElements(data) {
+    return toHex(poseidonHashMany(data.map((x) => BigInt(x))));
+}
+/**
+ * Calculate contract address from class hash
+ * @returns format: hex-string
+ */
+export function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const constructorCalldataHash = computeHashOnElements(compiledCalldata);
+    const CONTRACT_ADDRESS_PREFIX = felt('0x535441524b4e45545f434f4e54524143545f41444452455353'); // Equivalent to 'STARKNET_CONTRACT_ADDRESS'
+    const hash = computeHashOnElements([
+        CONTRACT_ADDRESS_PREFIX,
+        deployerAddress,
+        salt,
+        classHash,
+        constructorCalldataHash,
+    ]);
+    return toHex(BigInt(hash) % ADDR_BOUND);
+}
+function nullSkipReplacer(key, value) {
+    if (key === 'attributes' || key === 'accessible_scopes') {
+        return Array.isArray(value) && value.length === 0 ? undefined : value;
+    }
+    if (key === 'debug_info') {
+        return null;
+    }
+    return value === null ? undefined : value;
+}
+/**
+ * Format json-string to conform starknet json-string
+ * @param json json-string
+ * @returns format: json-string
+ */
+export function formatSpaces(json) {
+    let insideQuotes = false;
+    const newString = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const char of json) {
+        if (char === '"' && (newString.length > 0 && newString.slice(-1)[0] === '\\') === false) {
+            insideQuotes = !insideQuotes;
+        }
+        if (insideQuotes) {
+            newString.push(char);
+        }
+        else {
+            // eslint-disable-next-line no-nested-ternary
+            newString.push(char === ':' ? ': ' : char === ',' ? ', ' : char);
+        }
+    }
+    return newString.join('');
+}
+/**
+ * Compute hinted class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
+export default function computeHintedClassHash(compiledContract) {
+    const { abi, program } = compiledContract;
+    const contractClass = { abi, program };
+    const serializedJson = formatSpaces(stringify(contractClass, nullSkipReplacer));
+    return addHexPrefix(keccak(utf8ToArray(serializedJson)).toString(16));
+}
+/**
+ * Computes the class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
+export function computeLegacyContractClassHash(contract) {
+    const compiledContract = isString(contract)
+        ? parse(contract)
+        : contract;
+    const apiVersion = toHex(API_VERSION);
+    const externalEntryPointsHash = computeHashOnElements(compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset]));
+    const l1HandlerEntryPointsHash = computeHashOnElements(compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset]));
+    const constructorEntryPointHash = computeHashOnElements(compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset]));
+    const builtinsHash = computeHashOnElements(compiledContract.program.builtins.map((s) => encodeShortString(s)));
+    const hintedClassHash = computeHintedClassHash(compiledContract);
+    const dataHash = computeHashOnElements(compiledContract.program.data);
+    return computeHashOnElements([
+        apiVersion,
+        externalEntryPointsHash,
+        l1HandlerEntryPointsHash,
+        constructorEntryPointHash,
+        builtinsHash,
+        hintedClassHash,
+        dataHash,
+    ]);
+}
+// Cairo 1 Contract Hashes
+function hashBuiltins(builtins) {
+    return poseidonHashMany(builtins.flatMap((it) => {
+        return BigInt(encodeShortString(it));
+    }));
+}
+function hashEntryPoint(data) {
+    const base = data.flatMap((it) => {
+        return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+    });
+    return poseidonHashMany(base);
+}
+/**
+ * Compute hash of the bytecode for Sierra v1.5.0 onwards (Cairo 2.6.0)
+ * Each segment is Poseidon hashed.
+ * The global hash is : 1 + PoseidonHash(len0, h0, len1, h1, ...)
+ * @param casm compiled Sierra CASM file content.
+ * @returns the bytecode hash as bigint.
+ */
+export function hashByteCodeSegments(casm) {
+    const byteCode = casm.bytecode.map((n) => BigInt(n));
+    const bytecodeSegmentLengths = casm.bytecode_segment_lengths ?? [];
+    let segmentStart = 0;
+    const hashLeaves = bytecodeSegmentLengths.flatMap((len) => {
+        const segment = byteCode.slice(segmentStart, (segmentStart += len));
+        return [BigInt(len), poseidonHashMany(segment)];
+    });
+    return 1n + poseidonHashMany(hashLeaves);
+}
+/**
+ * Compute compiled class hash for contract (Cairo 1)
+ * @returns format: hex-string
+ */
+export function computeCompiledClassHash(casm) {
+    const COMPILED_CLASS_VERSION = 'COMPILED_CLASS_V1';
+    // Hash compiled class version
+    const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
+    // Hash external entry points.
+    const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
+    // Hash L1 handler entry points.
+    const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
+    // Hash constructor entry points.
+    const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
+    // Hash bytecode.
+    const bytecode = casm.bytecode_segment_lengths
+        ? hashByteCodeSegments(casm)
+        : poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
+    return toHex(poseidonHashMany([
+        compiledClassVersion,
+        externalEntryPointsHash,
+        l1Handlers,
+        constructor,
+        bytecode,
+    ]));
+}
+function hashEntryPointSierra(data) {
+    const base = data.flatMap((it) => {
+        return [BigInt(it.selector), BigInt(it.function_idx)];
+    });
+    return poseidonHashMany(base);
+}
+function hashAbi(sierra) {
+    const indentString = formatSpaces(stringify(sierra.abi, null));
+    return BigInt(addHexPrefix(keccak(utf8ToArray(indentString)).toString(16)));
+}
+/**
+ * Compute sierra contract class hash (Cairo 1)
+ * @returns format: hex-string
+ */
+export function computeSierraContractClassHash(sierra) {
+    const CONTRACT_CLASS_VERSION = 'CONTRACT_CLASS_V0.1.0';
+    // Hash class version
+    const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
+    // Hash external entry points.
+    const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
+    // Hash L1 handler entry points.
+    const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
+    // Hash constructor entry points.
+    const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
+    // Hash abi_hash.
+    const abiHash = hashAbi(sierra);
+    // Hash Sierra program.
+    const sierraProgram = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
+    return toHex(poseidonHashMany([
+        compiledClassVersion,
+        externalEntryPointsHash,
+        l1Handlers,
+        constructor,
+        abiHash,
+        sierraProgram,
+    ]));
+}
+/**
+ * Compute ClassHash (sierra or legacy) based on provided contract
+ * @returns format: hex-string
+ */
+export function computeContractClassHash(contract) {
+    const compiledContract = isString(contract) ? parse(contract) : contract;
+    if ('sierra_program' in compiledContract) {
+        return computeSierraContractClassHash(compiledContract);
+    }
+    return computeLegacyContractClassHash(compiledContract);
+}

package/js/src/static_dependencies/starknet/utils/hash/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashes Exports
+ */
+export * as poseidon from '../../../noble-curves/abstract/poseidon.js';
+export * from '../selector.js';
+export * from './classHash.js';

package/js/src/static_dependencies/starknet/utils/hash/index.js

@@ -0,0 +1,13 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ * Hashes Exports
+ */
+export * as poseidon from '../../../noble-curves/abstract/poseidon.js';
+export * from '../selector.js'; // Preserve legacy export structure
+// export * from './transactionHash/index.js';
+export * from './classHash.js';

package/js/src/static_dependencies/starknet/utils/json.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Convert JSON string to JSON object
+ *
+ * NOTE: the String() wrapping is used so the behavior conforms to JSON.parse()
+ * which can accept simple data types but is not represented in the default typing
+ * @param x JSON string
+ */
+export declare const parse: (x: string) => any;
+/**
+ * Convert JSON string to JSON object with all numbers as bigint
+ * @param x JSON string
+ */
+export declare const parseAlwaysAsBig: (x: string) => any;
+/**
+ * Convert JSON object to JSON string
+ *
+ * NOTE: the not-null assertion is used so the return type conforms to JSON.stringify()
+ * which can also return undefined but is not represented in the default typing
+ * json.NumberStringifier[]
+ * @returns JSON string
+ */
+export declare const stringify: (value: unknown, replacer?: any, space?: string | number | undefined, numberStringifiers?: any[] | undefined) => string;
+/** @deprecated equivalent to 'stringify', alias will be removed */
+export declare const stringifyAlwaysAsBig: (value: unknown, replacer?: any, space?: string | number | undefined, numberStringifiers?: any[] | undefined) => string;

package/js/src/static_dependencies/starknet/utils/json.js

@@ -0,0 +1,43 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// import * as json from 'lossless-json';
+const json = global.JSON;
+/**
+ * Convert string to number or bigint based on size
+ */
+const parseIntAsNumberOrBigInt = (x) => {
+    // if (!json.isInteger(x)) return parseFloat(x);
+    const v = parseInt(x, 10);
+    return Number.isSafeInteger(v) ? v : BigInt(x);
+};
+/**
+ * Convert JSON string to JSON object
+ *
+ * NOTE: the String() wrapping is used so the behavior conforms to JSON.parse()
+ * which can accept simple data types but is not represented in the default typing
+ * @param x JSON string
+ */
+// export const parse = (x: string): any => json.parse(String(x), undefined, parseIntAsNumberOrBigInt);
+export const parse = (x) => json.parse(String(x), undefined);
+/**
+ * Convert JSON string to JSON object with all numbers as bigint
+ * @param x JSON string
+ */
+// json.parse(String(x), undefined, json.parseNumberAndBigInt);
+export const parseAlwaysAsBig = (x) => json.parse(String(x), undefined);
+/**
+ * Convert JSON object to JSON string
+ *
+ * NOTE: the not-null assertion is used so the return type conforms to JSON.stringify()
+ * which can also return undefined but is not represented in the default typing
+ * json.NumberStringifier[]
+ * @returns JSON string
+ */
+// json.stringify(value, replacer, space, numberStringifiers)!;
+export const stringify = (value, replacer, space, numberStringifiers) => json.stringify(value, replacer, space);
+/** @deprecated equivalent to 'stringify', alias will be removed */
+export const stringifyAlwaysAsBig = stringify;

package/js/src/static_dependencies/starknet/utils/merkle.d.ts

@@ -0,0 +1,35 @@
+import { BigNumberish } from '../types/index.js';
+export declare class MerkleTree {
+    leaves: string[];
+    branches: string[][];
+    root: string;
+    hashMethod: (a: BigNumberish, b: BigNumberish) => string;
+    constructor(leafHashes: string[], hashMethod?: (a: BigNumberish, b: BigNumberish) => string);
+    /**
+     * Create Merkle tree
+     * @param leaves hex-string array
+     * @returns format: hex-string; Merkle tree root
+     */
+    private build;
+    /**
+     * Create hash from ordered a and b, Pedersen hash default
+     * @returns format: hex-string
+     */
+    static hash(a: BigNumberish, b: BigNumberish, hashMethod?: (a: BigNumberish, b: BigNumberish) => string): string;
+    /**
+     * Return path to leaf
+     * @param leaf hex-string
+     * @param branch hex-string array
+     * @param hashPath hex-string array
+     * @returns format: hex-string array
+     */
+    getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
+}
+/**
+ * Test Merkle tree path
+ * @param root hex-string
+ * @param leaf hex-string
+ * @param path hex-string array
+ * @param hashMethod hash method override, Pedersen default
+ */
+export declare function proofMerklePath(root: string, leaf: string, path: string[], hashMethod?: (a: BigNumberish, b: BigNumberish) => string): boolean;

package/js/src/static_dependencies/starknet/utils/merkle.js

@@ -0,0 +1,84 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { computePedersenHash } from './hash/index.js';
+export class MerkleTree {
+    constructor(leafHashes, hashMethod = computePedersenHash) {
+        this.branches = [];
+        this.hashMethod = hashMethod;
+        this.leaves = leafHashes;
+        this.root = this.build(leafHashes);
+    }
+    /**
+     * Create Merkle tree
+     * @param leaves hex-string array
+     * @returns format: hex-string; Merkle tree root
+     */
+    build(leaves) {
+        if (leaves.length === 1) {
+            return leaves[0];
+        }
+        if (leaves.length !== this.leaves.length) {
+            this.branches.push(leaves);
+        }
+        const newLeaves = [];
+        for (let i = 0; i < leaves.length; i += 2) {
+            if (i + 1 === leaves.length) {
+                newLeaves.push(MerkleTree.hash(leaves[i], '0x0', this.hashMethod));
+            }
+            else {
+                newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1], this.hashMethod));
+            }
+        }
+        return this.build(newLeaves);
+    }
+    /**
+     * Create hash from ordered a and b, Pedersen hash default
+     * @returns format: hex-string
+     */
+    static hash(a, b, hashMethod = computePedersenHash) {
+        const [aSorted, bSorted] = [BigInt(a), BigInt(b)].sort((x, y) => (x >= y ? 1 : -1));
+        return hashMethod(aSorted, bSorted);
+    }
+    /**
+     * Return path to leaf
+     * @param leaf hex-string
+     * @param branch hex-string array
+     * @param hashPath hex-string array
+     * @returns format: hex-string array
+     */
+    getProof(leaf, branch = this.leaves, hashPath = []) {
+        const index = branch.indexOf(leaf);
+        if (index === -1) {
+            throw new Error('leaf not found');
+        }
+        if (branch.length === 1) {
+            return hashPath;
+        }
+        const isLeft = index % 2 === 0;
+        const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? '0x0';
+        const newHashPath = [...hashPath, neededBranch];
+        const currentBranchLevelIndex = this.leaves.length === branch.length
+            ? -1
+            : this.branches.findIndex((b) => b.length === branch.length);
+        const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
+        return this.getProof(MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf, this.hashMethod), nextBranch, newHashPath);
+    }
+}
+/**
+ * Test Merkle tree path
+ * @param root hex-string
+ * @param leaf hex-string
+ * @param path hex-string array
+ * @param hashMethod hash method override, Pedersen default
+ */
+export function proofMerklePath(root, leaf, path, hashMethod = computePedersenHash) {
+    if (path.length === 0) {
+        return root === leaf;
+    }
+    const [next, ...rest] = path;
+    return proofMerklePath(root, MerkleTree.hash(leaf, next, hashMethod), rest, hashMethod);
+}

package/js/src/static_dependencies/starknet/utils/num.d.ts

@@ -0,0 +1,182 @@
+import { BigNumberish } from '../types/index.js';
+/** @deprecated prefer importing from 'types' over 'num' */
+export type { BigNumberish };
+/**
+ * Test if string is hex-string
+ * @param hex hex-string
+ * @returns {boolean} True if the input string is a hexadecimal string, false otherwise
+ * @example
+ * ```typescript
+ * const hexString1 = "0x2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result1 = isHex(hexString1);
+ * // result1 = true
+ *
+ * const hexString2 = "2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914";
+ * const result2 = isHex(hexString2);
+ * // result2 = false
+ * ```
+ */
+export declare function isHex(hex: string): boolean;
+/**
+ * Convert BigNumberish to bigint
+ */
+export declare function toBigInt(value: BigNumberish): bigint;
+/**
+ * Test if value is bigint
+ */
+export declare function isBigInt(value: any): value is bigint;
+/**
+ * Convert BigNumberish to hex-string
+ * @returns format: hex-string
+ */
+export declare function toHex(number: BigNumberish): string;
+/**
+ * Alias of ToHex
+ */
+export declare const toHexString: typeof toHex;
+/**
+ * Convert BigNumberish to storage-key-string
+ *
+ * Same as toHex but conforming to the STORAGE_KEY pattern `^0x0[0-7]{1}[a-fA-F0-9]{0,62}$`.
+ *
+ * A storage key is represented as up to 62 hex digits, 3 bits, and 5 leading zeroes:
+ * `0x0 + [0-7] + 62 hex = 0x + 64 hex`
+ * @returns format: storage-key-string
+ */
+export declare function toStorageKey(number: BigNumberish): string;
+/**
+ * Convert hexadecimal string to decimal string
+ * @param hex hex-string
+ * @returns format: decimal string
+ */
+export declare function hexToDecimalString(hex: string): string;
+/**
+ * Remove hex string leading zero and lowercase it
+ * @example '0x01A...' -> '0x1a..'
+ * @param hex hex-string
+ * @returns format: hex-string
+ */
+export declare const cleanHex: (hex: string) => string;
+/**
+ * Asserts input is equal to or greater then lowerBound and lower then upperBound.
+ *
+ * The `inputName` parameter is used in the assertion message.
+ * @param input Value to check
+ * @param lowerBound Lower bound value
+ * @param upperBound Upper bound value
+ * @param inputName Name of the input for error message
+ * @Throws Error if input is out of range
+ * @example
+ * ```typescript
+ * const input1:BigNumberish = 10;
+ * assertInRange(input1, 5, 20, 'value')
+ *
+ * const input2: BigNumberish = 25;
+ * assertInRange(input2, 5, 20, 'value');
+ * // Throws Error: Message not signable, invalid value length.
+ * ```
+ */
+export declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+/**
+ * Convert BigNumberish array to decimal string array
+ * @returns format: decimal string array
+ */
+export declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Convert BigNumberish array to hexadecimal string array
+ * @returns format: hex-string array
+ */
+export declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
+/**
+ * Test if string is whole number (0, 1, 2, 3...)
+ */
+export declare const isStringWholeNumber: (value: string) => boolean;
+/**
+ * Convert string to decimal string
+ * @returns format: decimal string
+ * @example
+ * ```typescript
+ * const result = getDecimalString("0x1a");
+ * // result = "26"
+ *
+ * const result2 = getDecimalString("Hello");
+ * // Throws Error: "Hello need to be hex-string or whole-number-string"
+ * ```
+ */
+export declare function getDecimalString(value: string): string;
+/**
+ * Convert string to hexadecimal string
+ * @returns format: hex-string
+ * @example
+ * ```typescript
+ * const result = getHexString("123");
+ * // result = "0x7b"
+ *
+ * const result2 = getHexString("Hello");
+ * // Throws Error: Hello need to be hex-string or whole-number-string
+ * ```
+ */
+export declare function getHexString(value: string): string;
+/**
+ * Convert string array to hex-string array
+ * @returns format: hex-string array
+ */
+export declare function getHexStringArray(value: Array<string>): string[];
+/**
+ * Convert boolean to "0" or "1"
+ * @param value The boolean value to be converted.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = toCairoBool(true);
+ * // result ="1"
+ *
+ * const result2 = toCairoBool(false);
+ * // result2 = "0"
+ * ```
+ */
+export declare const toCairoBool: (value: boolean) => string;
+/**
+ * Convert hex-string to an array of Bytes (Uint8Array)
+ * @param value hex-string
+ */
+export declare function hexToBytes(value: string): Uint8Array;
+/**
+ *
+ * @param number value to be increased
+ * @param percent integer as percent ex. 50 for 50%
+ * @returns increased value
+ */
+export declare function addPercent(number: BigNumberish, percent: number): bigint;
+/**
+ * Check if a value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if the value is a number, otherwise returns false.
+ * @example
+ * ```typescript
+ * const result = isNumber(123);
+ * // result = true
+ *
+ * const result2 = isNumber("123");
+ * // result2 = false
+ * ```
+ * @return {boolean} Returns true if the value is a number, otherwise returns false.
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a given value is of boolean type.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} - True if the value is of boolean type, false otherwise.
+ * @example
+ * ```typescript
+ * const result = isBoolean(true);
+ * // result = true
+ *
+ * const result2 = isBoolean(false);
+ * // result2 = false
+ * ```
+ * @return {boolean} - True if the value is of boolean type, false otherwise.
+ */
+export declare function isBoolean(value: unknown): value is boolean;