ccxt 4.3.70 → 4.3.72

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

@@ -0,0 +1,17 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/**
+ * Asserts that the given condition is true, otherwise throws an error with an optional message.
+ * @param {any} condition - The condition to check.
+ * @param {string} [message] - The optional message to include in the error.
+ * @throws {Error} Throws an error if the condition is false.
+ */
+export default function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failure');
+    }
+}

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/felt.d.ts

@@ -0,0 +1,6 @@
+import { BigNumberish } from '../num.js';
+/**
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
+ */
+export declare function CairoFelt(it: BigNumberish): string;

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/felt.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
+
+// TODO Convert to CairoFelt base on CairoUint256 and implement it in the codebase in the backward compatible manner
+import { isBigInt, isBoolean, isHex, isStringWholeNumber } from '../num.js';
+import { encodeShortString, isShortString, isString, isText } from '../shortString.js';
+/**
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
+ */
+export function CairoFelt(it) {
+    // BN or number
+    if (isBigInt(it) || Number.isInteger(it)) {
+        return it.toString();
+    }
+    // Handling strings
+    if (isString(it)) {
+        // Hex strings
+        if (isHex(it)) {
+            return BigInt(it).toString();
+        }
+        // Text strings that must be short
+        if (isText(it)) {
+            if (!isShortString(it)) {
+                throw new Error(`${it} is a long string > 31 chars. Please split it into an array of short strings.`);
+            }
+            // Assuming encodeShortString returns a hex representation of the string
+            return BigInt(encodeShortString(it)).toString();
+        }
+        // Whole numeric strings
+        if (isStringWholeNumber(it)) {
+            return it;
+        }
+    }
+    // bool to felt
+    if (isBoolean(it)) {
+        return `${+it}`;
+    }
+    throw new Error(`${it} can't be computed by felt()`);
+}

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/uint256.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Singular class handling cairo u256 data type
+ */
+import { BigNumberish, Uint256 } from '../../types/index.js';
+export declare const UINT_128_MAX: bigint;
+export declare const UINT_256_MAX: bigint;
+export declare const UINT_256_MIN = 0n;
+export declare const UINT_256_LOW_MAX = 340282366920938463463374607431768211455n;
+export declare const UINT_256_HIGH_MAX = 340282366920938463463374607431768211455n;
+export declare const UINT_256_LOW_MIN = 0n;
+export declare const UINT_256_HIGH_MIN = 0n;
+export declare class CairoUint256 {
+    low: bigint;
+    high: bigint;
+    static abiSelector: string;
+    /**
+     * Default constructor (Lib usage)
+     * @param bigNumberish BigNumberish value representing uin256
+     */
+    constructor(bigNumberish: BigNumberish);
+    /**
+     * Direct props initialization (Api response)
+     */
+    constructor(low: BigNumberish, high: BigNumberish);
+    /**
+     * Initialization from Uint256 object
+     */
+    constructor(uint256: Uint256);
+    /**
+     * Validate if BigNumberish can be represented as Unit256
+     */
+    static validate(bigNumberish: BigNumberish): bigint;
+    /**
+     * Validate if low and high can be represented as Unit256
+     */
+    static validateProps(low: BigNumberish, high: BigNumberish): {
+        low: bigint;
+        high: bigint;
+    };
+    /**
+     * Check if BigNumberish can be represented as Unit256
+     */
+    static is(bigNumberish: BigNumberish): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    /**
+     * Return bigint representation
+     */
+    toBigInt(): bigint;
+    /**
+     * Return Uint256 structure with HexString props
+     * {low: HexString, high: HexString}
+     */
+    toUint256HexString(): {
+        low: string;
+        high: string;
+    };
+    /**
+     * Return Uint256 structure with DecimalString props
+     * {low: DecString, high: DecString}
+     */
+    toUint256DecimalString(): {
+        low: string;
+        high: string;
+    };
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest(): string[];
+}

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/uint256.js

@@ -0,0 +1,117 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/* eslint-disable no-bitwise */
+/**
+ * Singular class handling cairo u256 data type
+ */
+import { addHexPrefix } from '../encode.js';
+import { CairoFelt } from './felt.js';
+export const UINT_128_MAX = (1n << 128n) - 1n;
+export const UINT_256_MAX = (1n << 256n) - 1n;
+export const UINT_256_MIN = 0n;
+export const UINT_256_LOW_MAX = 340282366920938463463374607431768211455n;
+export const UINT_256_HIGH_MAX = 340282366920938463463374607431768211455n;
+export const UINT_256_LOW_MIN = 0n;
+export const UINT_256_HIGH_MIN = 0n;
+export class CairoUint256 {
+    constructor(...arr) {
+        if (typeof arr[0] === 'object' && arr.length === 1 && 'low' in arr[0] && 'high' in arr[0]) {
+            const props = CairoUint256.validateProps(arr[0].low, arr[0].high);
+            this.low = props.low;
+            this.high = props.high;
+        }
+        else if (arr.length === 1) {
+            const bigInt = CairoUint256.validate(arr[0]);
+            this.low = bigInt & UINT_128_MAX;
+            this.high = bigInt >> 128n;
+        }
+        else if (arr.length === 2) {
+            const props = CairoUint256.validateProps(arr[0], arr[1]);
+            this.low = props.low;
+            this.high = props.high;
+        }
+        else {
+            throw Error('Incorrect constructor parameters');
+        }
+    }
+    /**
+     * Validate if BigNumberish can be represented as Unit256
+     */
+    static validate(bigNumberish) {
+        const bigInt = BigInt(bigNumberish);
+        if (bigInt < UINT_256_MIN)
+            throw Error('bigNumberish is smaller than UINT_256_MIN');
+        if (bigInt > UINT_256_MAX)
+            throw new Error('bigNumberish is bigger than UINT_256_MAX');
+        return bigInt;
+    }
+    /**
+     * Validate if low and high can be represented as Unit256
+     */
+    static validateProps(low, high) {
+        const bigIntLow = BigInt(low);
+        const bigIntHigh = BigInt(high);
+        if (bigIntLow < UINT_256_LOW_MIN || bigIntLow > UINT_256_LOW_MAX) {
+            throw new Error('low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX');
+        }
+        if (bigIntHigh < UINT_256_HIGH_MIN || bigIntHigh > UINT_256_HIGH_MAX) {
+            throw new Error('high is out of range UINT_256_HIGH_MIN - UINT_256_HIGH_MAX');
+        }
+        return { low: bigIntLow, high: bigIntHigh };
+    }
+    /**
+     * Check if BigNumberish can be represented as Unit256
+     */
+    static is(bigNumberish) {
+        try {
+            CairoUint256.validate(bigNumberish);
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+        return abiType === CairoUint256.abiSelector;
+    }
+    /**
+     * Return bigint representation
+     */
+    toBigInt() {
+        return (this.high << 128n) + this.low;
+    }
+    /**
+     * Return Uint256 structure with HexString props
+     * {low: HexString, high: HexString}
+     */
+    toUint256HexString() {
+        return {
+            low: addHexPrefix(this.low.toString(16)),
+            high: addHexPrefix(this.high.toString(16)),
+        };
+    }
+    /**
+     * Return Uint256 structure with DecimalString props
+     * {low: DecString, high: DecString}
+     */
+    toUint256DecimalString() {
+        return {
+            low: this.low.toString(10),
+            high: this.high.toString(10),
+        };
+    }
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest() {
+        return [CairoFelt(this.low), CairoFelt(this.high)];
+    }
+}
+CairoUint256.abiSelector = 'core::integer::u256';

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/uint512.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Singular class handling cairo u512 data type
+ */
+import { BigNumberish, type Uint512 } from '../../types/index.js';
+export declare const UINT_512_MAX: bigint;
+export declare const UINT_512_MIN = 0n;
+export declare const UINT_128_MIN = 0n;
+export declare class CairoUint512 {
+    limb0: bigint;
+    limb1: bigint;
+    limb2: bigint;
+    limb3: bigint;
+    static abiSelector: string;
+    /**
+     * Default constructor (Lib usage)
+     * @param bigNumberish BigNumberish value representing u512
+     */
+    constructor(bigNumberish: BigNumberish);
+    /**
+     * Direct props initialization (Api response)
+     */
+    constructor(limb0: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish);
+    /**
+     * Initialization from Uint512 object
+     */
+    constructor(uint512: Uint512);
+    /**
+     * Validate if BigNumberish can be represented as Uint512
+     */
+    static validate(bigNumberish: BigNumberish): bigint;
+    /**
+     * Validate if limbs can be represented as Uint512
+     */
+    static validateProps(limb0: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish): {
+        limb0: bigint;
+        limb1: bigint;
+        limb2: bigint;
+        limb3: bigint;
+    };
+    /**
+     * Check if BigNumberish can be represented as Uint512
+     */
+    static is(bigNumberish: BigNumberish): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    /**
+     * Return bigint representation
+     */
+    toBigInt(): bigint;
+    /**
+     * Return Uint512 structure with HexString props
+     * limbx: HexString
+     */
+    toUint512HexString(): {
+        limb0: string;
+        limb1: string;
+        limb2: string;
+        limb3: string;
+    };
+    /**
+     * Return Uint512 structure with DecimalString props
+     * limbx DecString
+     */
+    toUint512DecimalString(): {
+        limb0: string;
+        limb1: string;
+        limb2: string;
+        limb3: string;
+    };
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest(): string[];
+}

package/js/src/static_dependencies/starknet/utils/cairoDataTypes/uint512.js

@@ -0,0 +1,136 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/* eslint-disable no-bitwise */
+/**
+ * Singular class handling cairo u512 data type
+ */
+import { addHexPrefix } from '../encode.js';
+import { CairoFelt } from './felt.js';
+import { UINT_128_MAX } from './uint256.js';
+export const UINT_512_MAX = (1n << 512n) - 1n;
+export const UINT_512_MIN = 0n;
+export const UINT_128_MIN = 0n;
+export class CairoUint512 {
+    constructor(...arr) {
+        if (typeof arr[0] === 'object' &&
+            arr.length === 1 &&
+            'limb0' in arr[0] &&
+            'limb1' in arr[0] &&
+            'limb2' in arr[0] &&
+            'limb3' in arr[0]) {
+            const props = CairoUint512.validateProps(arr[0].limb0, arr[0].limb1, arr[0].limb2, arr[0].limb3);
+            this.limb0 = props.limb0;
+            this.limb1 = props.limb1;
+            this.limb2 = props.limb2;
+            this.limb3 = props.limb3;
+        }
+        else if (arr.length === 1) {
+            const bigInt = CairoUint512.validate(arr[0]);
+            this.limb0 = bigInt & UINT_128_MAX;
+            this.limb1 = (bigInt & (UINT_128_MAX << 128n)) >> 128n;
+            this.limb2 = (bigInt & (UINT_128_MAX << 256n)) >> 256n;
+            this.limb3 = bigInt >> 384n;
+        }
+        else if (arr.length === 4) {
+            const props = CairoUint512.validateProps(arr[0], arr[1], arr[2], arr[3]);
+            this.limb0 = props.limb0;
+            this.limb1 = props.limb1;
+            this.limb2 = props.limb2;
+            this.limb3 = props.limb3;
+        }
+        else {
+            throw Error('Incorrect Uint512 constructor parameters');
+        }
+    }
+    /**
+     * Validate if BigNumberish can be represented as Uint512
+     */
+    static validate(bigNumberish) {
+        const bigInt = BigInt(bigNumberish);
+        if (bigInt < UINT_512_MIN)
+            throw Error('bigNumberish is smaller than UINT_512_MIN.');
+        if (bigInt > UINT_512_MAX)
+            throw Error('bigNumberish is bigger than UINT_512_MAX.');
+        return bigInt;
+    }
+    /**
+     * Validate if limbs can be represented as Uint512
+     */
+    static validateProps(limb0, limb1, limb2, limb3) {
+        const l0 = BigInt(limb0);
+        const l1 = BigInt(limb1);
+        const l2 = BigInt(limb2);
+        const l3 = BigInt(limb3);
+        [l0, l1, l2, l3].forEach((value, index) => {
+            if (value < UINT_128_MIN || value > UINT_128_MAX) {
+                throw Error(`limb${index} is not in the range of a u128 number`);
+            }
+        });
+        return { limb0: l0, limb1: l1, limb2: l2, limb3: l3 };
+    }
+    /**
+     * Check if BigNumberish can be represented as Uint512
+     */
+    static is(bigNumberish) {
+        try {
+            CairoUint512.validate(bigNumberish);
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+        return abiType === CairoUint512.abiSelector;
+    }
+    /**
+     * Return bigint representation
+     */
+    toBigInt() {
+        return (this.limb3 << 384n) + (this.limb2 << 256n) + (this.limb1 << 128n) + this.limb0;
+    }
+    /**
+     * Return Uint512 structure with HexString props
+     * limbx: HexString
+     */
+    toUint512HexString() {
+        return {
+            limb0: addHexPrefix(this.limb0.toString(16)),
+            limb1: addHexPrefix(this.limb1.toString(16)),
+            limb2: addHexPrefix(this.limb2.toString(16)),
+            limb3: addHexPrefix(this.limb3.toString(16)),
+        };
+    }
+    /**
+     * Return Uint512 structure with DecimalString props
+     * limbx DecString
+     */
+    toUint512DecimalString() {
+        return {
+            limb0: this.limb0.toString(10),
+            limb1: this.limb1.toString(10),
+            limb2: this.limb2.toString(10),
+            limb3: this.limb3.toString(10),
+        };
+    }
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest() {
+        // lower limb first : https://github.com/starkware-libs/cairo/blob/07484c52791b76abcc18fd86265756904557d0d2/corelib/src/test/integer_test.cairo#L767
+        return [
+            CairoFelt(this.limb0),
+            CairoFelt(this.limb1),
+            CairoFelt(this.limb2),
+            CairoFelt(this.limb3),
+        ];
+    }
+}
+CairoUint512.abiSelector = 'core::integer::u512';

package/js/src/static_dependencies/starknet/utils/calldata/byteArray.d.ts

@@ -0,0 +1,32 @@
+import { ByteArray } from '../../types/lib/index.js';
+/**
+ * convert a Cairo ByteArray to a JS string
+ * @param myByteArray Cairo representation of a LongString
+ * @returns a JS string
+ * @example
+ * ```typescript
+ * const myByteArray = {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ * const result: String = stringFromByteArray(myByteArray); // ABCDEFGHI
+ * ```
+ */
+export declare function stringFromByteArray(myByteArray: ByteArray): string;
+/**
+ * convert a JS string to a Cairo ByteArray
+ * @param targetString a JS string
+ * @returns Cairo representation of a LongString
+ * @example
+ * ```typescript
+ * const myByteArray: ByteArray = byteArrayFromString("ABCDEFGHI");
+ * ```
+ * Result is :
+ * {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ */
+export declare function byteArrayFromString(targetString: string): ByteArray;

package/js/src/static_dependencies/starknet/utils/calldata/byteArray.js

@@ -0,0 +1,59 @@
+// ----------------------------------------------------------------------------
+
+// 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 { toHex } from '../num.js';
+import { decodeShortString, encodeShortString, splitLongString } from '../shortString.js';
+/**
+ * convert a Cairo ByteArray to a JS string
+ * @param myByteArray Cairo representation of a LongString
+ * @returns a JS string
+ * @example
+ * ```typescript
+ * const myByteArray = {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ * const result: String = stringFromByteArray(myByteArray); // ABCDEFGHI
+ * ```
+ */
+export function stringFromByteArray(myByteArray) {
+    const pending_word = BigInt(myByteArray.pending_word) === 0n
+        ? ''
+        : decodeShortString(toHex(myByteArray.pending_word));
+    return (myByteArray.data.reduce((cumuledString, encodedString) => {
+        const add = BigInt(encodedString) === 0n ? '' : decodeShortString(toHex(encodedString));
+        return cumuledString + add;
+    }, '') + pending_word);
+}
+/**
+ * convert a JS string to a Cairo ByteArray
+ * @param targetString a JS string
+ * @returns Cairo representation of a LongString
+ * @example
+ * ```typescript
+ * const myByteArray: ByteArray = byteArrayFromString("ABCDEFGHI");
+ * ```
+ * Result is :
+ * {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ */
+export function byteArrayFromString(targetString) {
+    const shortStrings = splitLongString(targetString);
+    const remainder = shortStrings[shortStrings.length - 1];
+    const shortStringsEncoded = shortStrings.map(encodeShortString);
+    const [pendingWord, pendingWordLength] = remainder === undefined || remainder.length === 31
+        ? ['0x00', 0]
+        : [shortStringsEncoded.pop(), remainder.length];
+    return {
+        data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
+        pending_word: pendingWord,
+        pending_word_len: pendingWordLength,
+    };
+}