ccxt-ir 4.10.0 → 4.11.0

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

@@ -0,0 +1,113 @@
+// ----------------------------------------------------------------------------
+
+// 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-plusplus */
+import { isCairo1Type, isTypeNamedTuple } from './cairo.js';
+function parseNamedTuple(namedTuple) {
+    const name = namedTuple.substring(0, namedTuple.indexOf(':'));
+    const type = namedTuple.substring(name.length + ':'.length);
+    return { name, type };
+}
+function parseSubTuple(s) {
+    if (!s.includes('('))
+        return { subTuple: [], result: s };
+    const subTuple = [];
+    let result = '';
+    let i = 0;
+    while (i < s.length) {
+        if (s[i] === '(') {
+            let counter = 1;
+            const lBracket = i;
+            i++;
+            while (counter) {
+                if (s[i] === ')')
+                    counter--;
+                if (s[i] === '(')
+                    counter++;
+                i++;
+            }
+            subTuple.push(s.substring(lBracket, i));
+            result += ' ';
+            i--;
+        }
+        else {
+            result += s[i];
+        }
+        i++;
+    }
+    return {
+        subTuple,
+        result,
+    };
+}
+function extractCairo0Tuple(type) {
+    const cleanType = type.replace(/\s/g, '').slice(1, -1); // remove first lvl () and spaces
+    // Decompose subTuple
+    const { subTuple, result } = parseSubTuple(cleanType);
+    // Recompose subTuple
+    let recomposed = result.split(',').map((it) => {
+        return subTuple.length ? it.replace(' ', subTuple.shift()) : it;
+    });
+    // Parse named tuple
+    if (isTypeNamedTuple(type)) {
+        recomposed = recomposed.reduce((acc, it) => {
+            return acc.concat(parseNamedTuple(it));
+        }, []);
+    }
+    return recomposed;
+}
+function getClosureOffset(input, open, close) {
+    for (let i = 0, counter = 0; i < input.length; i++) {
+        if (input[i] === open) {
+            counter++;
+        }
+        else if (input[i] === close && --counter === 0) {
+            return i;
+        }
+    }
+    return Number.POSITIVE_INFINITY;
+}
+function extractCairo1Tuple(type) {
+    // un-named tuples support
+    const input = type.slice(1, -1); // remove first lvl ()
+    const result = [];
+    let currentIndex = 0;
+    let limitIndex;
+    while (currentIndex < input.length) {
+        switch (true) {
+            // Tuple
+            case input[currentIndex] === '(': {
+                limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), '(', ')') + 1;
+                break;
+            }
+            case input.startsWith('core::result::Result::<', currentIndex) ||
+                input.startsWith('core::array::Array::<', currentIndex) ||
+                input.startsWith('core::option::Option::<', currentIndex):
+                {
+                    limitIndex = currentIndex + getClosureOffset(input.slice(currentIndex), '<', '>') + 1;
+                    break;
+                }
+            default: {
+                const commaIndex = input.indexOf(',', currentIndex);
+                limitIndex = commaIndex !== -1 ? commaIndex : Number.POSITIVE_INFINITY;
+            }
+        }
+        result.push(input.slice(currentIndex, limitIndex));
+        currentIndex = limitIndex + 2; // +2 to skip ', '
+    }
+    return result;
+}
+/**
+ * Convert tuple string definition into object like definition
+ * @param type tuple string definition
+ * @returns object like tuple
+ */
+export default function extractTupleMemberTypes(type) {
+    if (isCairo1Type(type)) {
+        return extractCairo1Tuple(type);
+    }
+    return extractCairo0Tuple(type);
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Validate cairo contract method arguments
+ * Flow: Determine type from abi and than validate against parameter
+ */
+import { AbiEnums, AbiStructs, FunctionAbi } from '../../types/index.js';
+export default function validateFields(abiMethod: FunctionAbi, args: Array<any>, structs: AbiStructs, enums: AbiEnums): void;

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

@@ -0,0 +1,208 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/**
+ * Validate cairo contract method arguments
+ * Flow: Determine type from abi and than validate against parameter
+ */
+import { Literal, Uint, } from '../../types/index.js';
+import assert from '../assert.js';
+import { CairoUint256 } from '../cairoDataTypes/uint256.js';
+import { CairoUint512 } from '../cairoDataTypes/uint512.js';
+import { isBigInt, isBoolean, isHex, isNumber, toBigInt } from '../num.js';
+import { isLongText, isString } from '../shortString.js';
+import { getArrayType, isLen, isTypeArray, isTypeBool, isTypeByteArray, isTypeBytes31, isTypeEnum, isTypeFelt, isTypeLiteral, isTypeOption, isTypeResult, isTypeStruct, isTypeTuple, isTypeUint, } from './cairo.js';
+const validateFelt = (parameter, input) => {
+    assert(isString(parameter) || isNumber(parameter) || isBigInt(parameter), `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`);
+    if (isString(parameter) && !isHex(parameter))
+        return; // shortstring
+    const param = BigInt(parameter.toString(10));
+    assert(
+    // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1266
+    param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+};
+const validateBytes31 = (parameter, input) => {
+    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
+    assert(parameter.length < 32, `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`);
+};
+const validateByteArray = (parameter, input) => {
+    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
+};
+const validateUint = (parameter, input) => {
+    if (isNumber(parameter)) {
+        assert(parameter <= Number.MAX_SAFE_INTEGER, `Validation: Parameter is to large to be typed as Number use (BigInt or String)`);
+    }
+    assert(isString(parameter) ||
+        isNumber(parameter) ||
+        isBigInt(parameter) ||
+        (typeof parameter === 'object' && 'low' in parameter && 'high' in parameter) ||
+        (typeof parameter === 'object' &&
+            ['limb0', 'limb1', 'limb2', 'limb3'].every((key) => key in parameter)), `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt), but is ${typeof parameter} ${parameter}.`);
+    let param;
+    switch (input.type) {
+        case Uint.u256:
+            param = new CairoUint256(parameter).toBigInt();
+            break;
+        case Uint.u512:
+            param = new CairoUint512(parameter).toBigInt();
+            break;
+        default:
+            param = toBigInt(parameter);
+    }
+    switch (input.type) {
+        case Uint.u8:
+            assert(param >= 0n && param <= 255n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`);
+            break;
+        case Uint.u16:
+            assert(param >= 0n && param <= 65535n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`);
+            break;
+        case Uint.u32:
+            assert(param >= 0n && param <= 4294967295n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`);
+            break;
+        case Uint.u64:
+            assert(param >= 0n && param <= 2n ** 64n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`);
+            break;
+        case Uint.u128:
+            assert(param >= 0n && param <= 2n ** 128n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`);
+            break;
+        case Uint.u256:
+            assert(param >= 0n && param <= 2n ** 256n - 1n, `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`);
+            break;
+        case Uint.u512:
+            assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+            break;
+        case Literal.ClassHash:
+            assert(
+            // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
+            param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+            break;
+        case Literal.ContractAddress:
+            assert(
+            // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1245
+            param >= 0n && param <= 2n ** 252n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`);
+            break;
+        case Literal.Secp256k1Point: {
+            assert(param >= 0n && param <= 2n ** 512n - 1n, `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`);
+            break;
+        }
+        default:
+            break;
+    }
+};
+const validateBool = (parameter, input) => {
+    assert(isBoolean(parameter), `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`);
+};
+const validateStruct = (parameter, input, structs) => {
+    // c1v2 uint256 or u512 in struct
+    if (input.type === Uint.u256 || input.type === Uint.u512) {
+        validateUint(parameter, input);
+        return;
+    }
+    if (input.type === 'core::starknet::eth_address::EthAddress') {
+        assert(typeof parameter !== 'object', `EthAddress type is waiting a BigNumberish. Got ${parameter}`);
+        const param = BigInt(parameter.toString(10));
+        assert(
+        // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1259
+        param >= 0n && param <= 2n ** 160n - 1n, `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^160-1]`);
+        return;
+    }
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`);
+    // shallow struct validation, only first depth level
+    structs[input.type].members.forEach(({ name }) => {
+        assert(Object.keys(parameter).includes(name), `Validate: arg ${input.name} should have a property ${name}`);
+    });
+};
+const validateEnum = (parameter, input) => {
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} is cairo type Enum (${input.type}), and should be defined as js object (not array)`);
+    const methodsKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(parameter));
+    const keys = [...Object.getOwnPropertyNames(parameter), ...methodsKeys];
+    if (isTypeOption(input.type) && keys.includes('isSome') && keys.includes('isNone')) {
+        return; // Option Enum
+    }
+    if (isTypeResult(input.type) && keys.includes('isOk') && keys.includes('isErr')) {
+        return; // Result Enum
+    }
+    if (keys.includes('variant') && keys.includes('activeVariant')) {
+        return; // Custom Enum
+    }
+    throw new Error(`Validate Enum: argument ${input.name}, type ${input.type}, value received ${parameter}, is not an Enum.`);
+};
+const validateTuple = (parameter, input) => {
+    assert(typeof parameter === 'object' && !Array.isArray(parameter), `Validate: arg ${input.name} should be a tuple (defined as object)`);
+    // todo: skip tuple structural validation for now
+};
+const validateArray = (parameter, input, structs, enums) => {
+    const baseType = getArrayType(input.type);
+    // Long text (special case when parameter is not an array but long text)
+    if (isTypeFelt(baseType) && isLongText(parameter)) {
+        return;
+    }
+    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+    switch (true) {
+        case isTypeFelt(baseType):
+            parameter.forEach((param) => validateFelt(param, input));
+            break;
+        case isTypeTuple(baseType):
+            parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
+            break;
+        case isTypeArray(baseType):
+            parameter.forEach((param) => validateArray(param, { name: '', type: baseType }, structs, enums));
+            break;
+        case isTypeStruct(baseType, structs):
+            parameter.forEach((it) => validateStruct(it, { name: input.name, type: baseType }, structs));
+            break;
+        case isTypeEnum(baseType, enums):
+            parameter.forEach((it) => validateEnum(it, { name: input.name, type: baseType }));
+            break;
+        case isTypeUint(baseType) || isTypeLiteral(baseType):
+            parameter.forEach((param) => validateUint(param, { name: '', type: baseType }));
+            break;
+        case isTypeBool(baseType):
+            parameter.forEach((param) => validateBool(param, input));
+            break;
+        default:
+            throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+    }
+};
+export default function validateFields(abiMethod, args, structs, enums) {
+    abiMethod.inputs.reduce((acc, input) => {
+        const parameter = args[acc];
+        switch (true) {
+            case isLen(input.name):
+                return acc;
+            case isTypeFelt(input.type):
+                validateFelt(parameter, input);
+                break;
+            case isTypeBytes31(input.type):
+                validateBytes31(parameter, input);
+                break;
+            case isTypeUint(input.type) || isTypeLiteral(input.type):
+                validateUint(parameter, input);
+                break;
+            case isTypeBool(input.type):
+                validateBool(parameter, input);
+                break;
+            case isTypeByteArray(input.type):
+                validateByteArray(parameter, input);
+                break;
+            case isTypeArray(input.type):
+                validateArray(parameter, input, structs, enums);
+                break;
+            case isTypeStruct(input.type, structs):
+                validateStruct(parameter, input, structs);
+                break;
+            case isTypeEnum(input.type, enums):
+                validateEnum(parameter, input);
+                break;
+            case isTypeTuple(input.type):
+                validateTuple(parameter, input);
+                break;
+            default:
+                throw new Error(`Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`);
+        }
+        return acc + 1;
+    }, 0);
+}

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

@@ -0,0 +1,207 @@
+export declare const IS_BROWSER: boolean;
+/**
+ * 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 declare function arrayBufferToString(array: ArrayBuffer): string;
+/**
+ * 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 declare function utf8ToArray(str: string): Uint8Array;
+/**
+ * Convert utf8-string to Uint8Array
+ *
+ * @deprecated equivalent to 'utf8ToArray', alias will be removed
+ */
+export declare function stringToArrayBuffer(str: string): Uint8Array;
+/**
+ * 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 declare function atobUniversal(a: string): Uint8Array;
+/**
+ * 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 declare function btoaUniversal(b: ArrayBuffer): string;
+/**
+ * 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 declare function buf2hex(buffer: Uint8Array): string;
+/**
+ * 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 declare function removeHexPrefix(hex: string): string;
+/**
+ * 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 declare function addHexPrefix(hex: string): string;
+/**
+ * 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 declare function padLeft(str: string, length: number, padding?: string): string;
+/**
+ * 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 declare function calcByteLength(str: string, byteSize?: number): number;
+/**
+ * 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 declare function sanitizeBytes(str: string, byteSize?: number, padding?: string): string;
+/**
+ * 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 declare function sanitizeHex(hex: string): string;
+/**
+ * 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 declare const pascalToSnake: (text: string) => string;