ccxt-ir 4.10.0 → 4.12.0

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

@@ -0,0 +1,282 @@
+// ----------------------------------------------------------------------------
+
+// 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 { base64 } from '../../scure-base/index.js';
+/* eslint-disable no-param-reassign */
+export const IS_BROWSER = typeof window !== 'undefined';
+const STRING_ZERO = '0';
+/**
+ * Some functions recreated from https://github.com/pedrouid/enc-utils/blob/master/src/index.ts
+ * enc-utils is not a dependency to avoid using `Buffer` which only works in node and not browsers
+ */
+/**
+ * Convert array buffer to string
+ *
+ * *[internal usage]*
+ *
+ * @param {ArrayBuffer} array The ArrayBuffer to convert to string.
+ * @returns {string} The converted string.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new ArrayBuffer(5);
+ * const view = new Uint8Array(buffer);
+ * [72, 101, 108, 108, 111].forEach((x, idx) => view[idx] = x);
+ * const result = encode.arrayBufferToString(buffer);
+ * // result = "Hello"
+ * ```
+ */
+export function arrayBufferToString(array) {
+    return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), '');
+}
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * *[internal usage]*
+ *
+ * @param {string} str The UTF-8 string to convert.
+ * @returns {Uint8Array} The encoded Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'Hi';
+ * const result = encode.utf8ToArray(myString);
+ * // result = Uint8Array(2) [ 72, 105 ]
+ * ```
+ */
+export function utf8ToArray(str) {
+    return new TextEncoder().encode(str);
+}
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * @deprecated equivalent to 'utf8ToArray', alias will be removed
+ */
+export function stringToArrayBuffer(str) {
+    return utf8ToArray(str);
+}
+/**
+ * Convert string to array buffer (browser and node compatible)
+ *
+ * @param {string} a The Base64 encoded string to convert.
+ * @returns {Uint8Array} The decoded Uint8Array.
+ *
+ * @example
+ * ```typescript
+ * const base64String = 'SGVsbG8='; // 'Hello' in Base64
+ * const result = encode.atobUniversal(base64String);
+ * // result = Uint8Array(5) [ 72, 101, 108, 108, 111 ]
+ * ```
+ */
+export function atobUniversal(a) {
+    return base64.decode(a);
+}
+/**
+ * Convert array buffer to string (browser and node compatible)
+ *
+ * @param {ArrayBuffer} b The Array buffer.
+ * @returns {string} The Base64 encoded string.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new Uint8Array([72, 101, 108, 108, 111]); // Array with ASCII values for 'Hello'
+ * const result = encode.btoaUniversal(buffer);
+ * // result = "SGVsbG8="
+ * ```
+ */
+export function btoaUniversal(b) {
+    return base64.encode(new Uint8Array(b));
+}
+/**
+ * Convert array buffer to hex-string
+ *
+ * @param {Uint8Array} buffer The encoded Uint8Array.
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const buffer = new Uint8Array([72, 101, 108, 108, 111]); // Array with ASCII values for 'Hello'
+ * const result = encode.buf2hex(buffer);
+ * // result = "48656c6c6f"
+ * ```
+ */
+export function buf2hex(buffer) {
+    return buffer.reduce((r, x) => r + x.toString(16).padStart(2, '0'), '');
+}
+/**
+ * Remove hex prefix '0x' from hex-string
+ * @param hex hex-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const hexStringWithPrefix = '0x48656c6c6f';
+ * const result = encode.removeHexPrefix(hexStringWithPrefix);
+ * // result: "48656c6c6f"
+ * ```
+ */
+export function removeHexPrefix(hex) {
+    return hex.replace(/^0x/i, '');
+}
+/**
+ * Add hex prefix '0x' to base16-string
+ * @param hex base16-string
+ * @returns {string} The hex-string
+ *
+ * @example
+ * ```typescript
+ * const plainHexString = '48656c6c6f';
+ * const result = encode.addHexPrefix(plainHexString);
+ * // result: "0x48656c6c6f"
+ * ```
+ */
+export function addHexPrefix(hex) {
+    return `0x${removeHexPrefix(hex)}`;
+}
+/**
+ * Prepend or append to string
+ *
+ * *[internal usage]*
+ *
+ * Pads a string to a certain length with a specific string.
+ * The padding can be applied either to the left or the right of the input string.
+ *
+ * @param {string} str The string to pad.
+ * @param {number} length The target length for the padded string.
+ * @param {boolean} left Set to true to add padding to the left, false to add it to the right.
+ * @param {string} [padding='0'] The string to use for padding. Defaults to '0'.
+ * @returns {string} The padded string.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'hello';
+ * const result = padString(myString, 10, true);
+ * // result = '00000hello'
+ * ```
+ */
+function padString(str, length, left, padding = STRING_ZERO) {
+    const diff = length - str.length;
+    let result = str;
+    if (diff > 0) {
+        const pad = padding.repeat(diff);
+        result = left ? pad + str : str + pad;
+    }
+    return result;
+}
+/**
+ * Prepend string (default with '0')
+ *
+ * Pads a string to a certain length with a specific string.
+ * The padding can be applied only to the left of the input string.
+ *
+ * @param {string} str The string to pad.
+ * @param {number} length The target length for the padded string.
+ * @param {string} [padding='0'] The string to use for padding. Defaults to '0'.
+ * @returns {string} The padded string.
+ *
+ * @example
+ * ```typescript
+ * const myString = '1A3F';
+ * const result = encode.padLeft(myString, 10);
+ * // result: '0000001A3F'
+ * ```
+ */
+export function padLeft(str, length, padding = STRING_ZERO) {
+    return padString(str, length, true, padding);
+}
+/**
+ * Calculate byte length of string
+ *
+ * *[no internal usage]*
+ *
+ * Calculates the byte length of a string based on a specified byte size.
+ * The function rounds up the byte count to the nearest multiple of the specified byte size.
+ *
+ * @param {string} str The string whose byte length is to be calculated.
+ * @param {number} [byteSize='8'] The size of the byte block to round up to. Defaults to 8.
+ * @returns {number} The calculated byte length, rounded to the nearest multiple of byteSize.
+ *
+ * @example
+ * ```typescript
+ * const myString = 'Hello';
+ * const result = encode.calcByteLength(myString, 4);
+ * // result = 8 (rounded up to the nearest multiple of 4)
+ *
+ * ```
+ */
+export function calcByteLength(str, byteSize = 8) {
+    const { length } = str;
+    const remainder = length % byteSize;
+    return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;
+}
+/**
+ * Prepend '0' to string bytes
+ *
+ * *[no internal usage]*
+ *
+ *
+ * * Prepends padding to the left of a string to ensure it matches a specific byte length.
+ * The function uses a specified padding character and rounds up the string length to the nearest multiple of `byteSize`.
+ *
+ * @param {string} str The string to be padded.
+ * @param {number} [byteSize='8'] The byte block size to which the string length should be rounded up. Defaults to 8.
+ * @param {string} [padding='0'] The character to use for padding. Defaults to '0'.
+ * @returns {string} The padded string.
+ *
+ * @example
+ * ```typescript
+ * const myString = '123';
+ * const result = encode.sanitizeBytes(myString);
+ * // result: '00000123' (padded to 8 characters)
+ * ```
+ */
+export function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
+    return padLeft(str, calcByteLength(str, byteSize), padding);
+}
+/**
+ * Sanitizes a hex-string by removing any existing '0x' prefix, padding the string with '0' to ensure it has even length,
+ * and then re-adding the '0x' prefix.
+ *
+ * *[no internal usage]*
+ * @param hex hex-string
+ * @returns format: hex-string
+ *
+ * @example
+ * ```typescript
+ * const unevenHex = '0x23abc';
+ * const result = encode.sanitizeHex(unevenHex);
+ * // result = '0x023abc' (padded to ensure even length)
+ * ```
+ */
+export function sanitizeHex(hex) {
+    hex = removeHexPrefix(hex);
+    hex = sanitizeBytes(hex, 2);
+    if (hex) {
+        hex = addHexPrefix(hex);
+    }
+    return hex;
+}
+/**
+ * String transformation util
+ *
+ * Pascal case to screaming snake case
+ *
+ * @param {string} text The PascalCase string to convert.
+ * @returns {string} The converted snake_case string in uppercase.
+ *
+ * @example
+ * ```typescript
+ * const pascalString = 'PascalCaseExample';
+ * const result = encode.pascalToSnake(pascalString);
+ * // result: 'PASCAL_CASE_EXAMPLE'
+ * ```
+ */
+export const pascalToSnake = (text) => /[a-z]/.test(text)
+    ? text
+        .split(/(?=[A-Z])/)
+        .join('_')
+        .toUpperCase()
+    : text;

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

@@ -0,0 +1,57 @@
+/**
+ * Class Hash
+ */
+import { BigNumberish, CompiledContract, CompiledSierra, CompiledSierraCasm, LegacyCompiledContract, RawArgs } from '../../types/index.js';
+export declare function computePedersenHash(a: BigNumberish, b: BigNumberish): string;
+export declare function computePoseidonHash(a: BigNumberish, b: BigNumberish): string;
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
+export declare function computeHashOnElements(data: BigNumberish[]): string;
+export declare const computePedersenHashOnElements: typeof computeHashOnElements;
+export declare function computePoseidonHashOnElements(data: BigNumberish[]): string;
+/**
+ * Calculate contract address from class hash
+ * @returns format: hex-string
+ */
+export declare function calculateContractAddressFromHash(salt: BigNumberish, classHash: BigNumberish, constructorCalldata: RawArgs, deployerAddress: BigNumberish): string;
+/**
+ * Format json-string to conform starknet json-string
+ * @param json json-string
+ * @returns format: json-string
+ */
+export declare function formatSpaces(json: string): string;
+/**
+ * Compute hinted class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
+export default function computeHintedClassHash(compiledContract: LegacyCompiledContract): string;
+/**
+ * Computes the class hash for legacy compiled contract (Cairo 0)
+ * @returns format: hex-string
+ */
+export declare function computeLegacyContractClassHash(contract: LegacyCompiledContract | string): string;
+/**
+ * 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 declare function hashByteCodeSegments(casm: CompiledSierraCasm): bigint;
+/**
+ * Compute compiled class hash for contract (Cairo 1)
+ * @returns format: hex-string
+ */
+export declare function computeCompiledClassHash(casm: CompiledSierraCasm): string;
+/**
+ * Compute sierra contract class hash (Cairo 1)
+ * @returns format: hex-string
+ */
+export declare function computeSierraContractClassHash(sierra: CompiledSierra): string;
+/**
+ * Compute ClassHash (sierra or legacy) based on provided contract
+ * @returns format: hex-string
+ */
+export declare function computeContractClassHash(contract: CompiledContract | string): string;

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

@@ -0,0 +1,223 @@
+// ----------------------------------------------------------------------------
+
+// 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 { 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(JSON.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)
+        ? JSON.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(JSON.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) ? JSON.parse(contract) : contract;
+    if ('sierra_program' in compiledContract) {
+        return computeSierraContractClassHash(compiledContract);
+    }
+    return computeLegacyContractClassHash(compiledContract);
+}

package/js/src/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/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/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;