ccxt 4.3.70 → 4.3.72

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

@@ -0,0 +1,214 @@
+// ----------------------------------------------------------------------------
+
+// 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 { CairoUint256 } from '../cairoDataTypes/uint256.js';
+import { CairoUint512 } from '../cairoDataTypes/uint512.js';
+import { addHexPrefix, removeHexPrefix } from '../encode.js';
+import { toHex } from '../num.js';
+import { decodeShortString } from '../shortString.js';
+import { stringFromByteArray } from './byteArray.js';
+import { getArrayType, isCairo1Type, isLen, isTypeArray, isTypeBool, isTypeByteArray, isTypeEnum, isTypeSecp256k1Point, isTypeTuple, } from './cairo.js';
+import { CairoCustomEnum, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, } from './enum/index.js';
+import extractTupleMemberTypes from './tuple.js';
+/**
+ * Parse base types
+ * @param type type of element
+ * @param it iterator
+ * @returns bigint | boolean
+ */
+function parseBaseTypes(type, it) {
+    let temp;
+    switch (true) {
+        case isTypeBool(type):
+            temp = it.next().value;
+            return Boolean(BigInt(temp));
+        case CairoUint256.isAbiType(type):
+            const low = it.next().value;
+            const high = it.next().value;
+            return new CairoUint256(low, high).toBigInt();
+        case CairoUint512.isAbiType(type):
+            const limb0 = it.next().value;
+            const limb1 = it.next().value;
+            const limb2 = it.next().value;
+            const limb3 = it.next().value;
+            return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+        case type === 'core::starknet::eth_address::EthAddress':
+            temp = it.next().value;
+            return BigInt(temp);
+        case type === 'core::bytes_31::bytes31':
+            temp = it.next().value;
+            return decodeShortString(temp);
+        case isTypeSecp256k1Point(type):
+            const xLow = removeHexPrefix(it.next().value).padStart(32, '0');
+            const xHigh = removeHexPrefix(it.next().value).padStart(32, '0');
+            const yLow = removeHexPrefix(it.next().value).padStart(32, '0');
+            const yHigh = removeHexPrefix(it.next().value).padStart(32, '0');
+            const pubK = BigInt(addHexPrefix(xHigh + xLow + yHigh + yLow));
+            return pubK;
+        default:
+            temp = it.next().value;
+            return BigInt(temp);
+    }
+}
+/**
+ * Parse of the response elements that are converted to Object (Struct) by using the abi
+ *
+ * @param responseIterator - iterator of the response
+ * @param element - element of the field {name: string, type: string}
+ * @param structs - structs from abi
+ * @param enums
+ * @return {any} - parsed arguments in format that contract is expecting
+ */
+function parseResponseValue(responseIterator, element, structs, enums) {
+    if (element.type === '()') {
+        return {};
+    }
+    // type uint256 struct (c1v2)
+    if (CairoUint256.isAbiType(element.type)) {
+        const low = responseIterator.next().value;
+        const high = responseIterator.next().value;
+        return new CairoUint256(low, high).toBigInt();
+    }
+    // type uint512 struct
+    if (CairoUint512.isAbiType(element.type)) {
+        const limb0 = responseIterator.next().value;
+        const limb1 = responseIterator.next().value;
+        const limb2 = responseIterator.next().value;
+        const limb3 = responseIterator.next().value;
+        return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+    }
+    // type C1 ByteArray struct, representing a LongString
+    if (isTypeByteArray(element.type)) {
+        const parsedBytes31Arr = [];
+        const bytes31ArrLen = BigInt(responseIterator.next().value);
+        while (parsedBytes31Arr.length < bytes31ArrLen) {
+            parsedBytes31Arr.push(toHex(responseIterator.next().value));
+        }
+        const pending_word = toHex(responseIterator.next().value);
+        const pending_word_len = BigInt(responseIterator.next().value);
+        const myByteArray = {
+            data: parsedBytes31Arr,
+            pending_word,
+            pending_word_len,
+        };
+        return stringFromByteArray(myByteArray);
+    }
+    // type c1 array
+    if (isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: getArrayType(element.type) };
+        const len = BigInt(responseIterator.next().value); // get length
+        while (parsedDataArr.length < len) {
+            parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        }
+        return parsedDataArr;
+    }
+    // type struct
+    if (structs && element.type in structs && structs[element.type]) {
+        if (element.type === 'core::starknet::eth_address::EthAddress') {
+            return parseBaseTypes(element.type, responseIterator);
+        }
+        return structs[element.type].members.reduce((acc, el) => {
+            acc[el.name] = parseResponseValue(responseIterator, el, structs, enums);
+            return acc;
+        }, {});
+    }
+    // type Enum (only CustomEnum)
+    if (enums && element.type in enums && enums[element.type]) {
+        const variantNum = Number(responseIterator.next().value); // get variant number
+        const rawEnum = enums[element.type].variants.reduce((acc, variant, num) => {
+            if (num === variantNum) {
+                acc[variant.name] = parseResponseValue(responseIterator, { name: '', type: variant.type }, structs, enums);
+                return acc;
+            }
+            acc[variant.name] = undefined;
+            return acc;
+        }, {});
+        // Option
+        if (element.type.startsWith('core::option::Option')) {
+            const content = variantNum === CairoOptionVariant.Some ? rawEnum.Some : undefined;
+            return new CairoOption(variantNum, content);
+        }
+        // Result
+        if (element.type.startsWith('core::result::Result')) {
+            let content;
+            if (variantNum === CairoResultVariant.Ok) {
+                content = rawEnum.Ok;
+            }
+            else {
+                content = rawEnum.Err;
+            }
+            return new CairoResult(variantNum, content);
+        }
+        // Cairo custom Enum
+        const customEnum = new CairoCustomEnum(rawEnum);
+        return customEnum;
+    }
+    // type tuple
+    if (isTypeTuple(element.type)) {
+        const memberTypes = extractTupleMemberTypes(element.type);
+        return memberTypes.reduce((acc, it, idx) => {
+            const name = it?.name ? it.name : idx;
+            const type = it?.type ? it.type : it;
+            const el = { name, type };
+            acc[name] = parseResponseValue(responseIterator, el, structs, enums);
+            return acc;
+        }, {});
+    }
+    // type c1 array
+    if (isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: getArrayType(element.type) };
+        const len = BigInt(responseIterator.next().value); // get length
+        while (parsedDataArr.length < len) {
+            parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+        }
+        return parsedDataArr;
+    }
+    // base type
+    return parseBaseTypes(element.type, responseIterator);
+}
+/**
+ * Parse elements of the response and structuring them into one field by using output property from the abi for that method
+ *
+ * @param responseIterator - iterator of the response
+ * @param output - output(field) information from the abi that will be used to parse the data
+ * @param structs - structs from abi
+ * @param parsedResult
+ * @return - parsed response corresponding to the abi structure of the field
+ */
+export default function responseParser(responseIterator, output, structs, enums, parsedResult) {
+    const { name, type } = output;
+    let temp;
+    switch (true) {
+        case isLen(name):
+            temp = responseIterator.next().value;
+            return BigInt(temp);
+        case (structs && type in structs) || isTypeTuple(type):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case enums && isTypeEnum(type, enums):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case isTypeArray(type):
+            // C1 Array
+            if (isCairo1Type(type)) {
+                return parseResponseValue(responseIterator, output, structs, enums);
+            }
+            // C0 Array
+            // eslint-disable-next-line no-case-declarations
+            const parsedDataArr = [];
+            if (parsedResult && parsedResult[`${name}_len`]) {
+                const arrLen = parsedResult[`${name}_len`];
+                while (parsedDataArr.length < arrLen) {
+                    parsedDataArr.push(parseResponseValue(responseIterator, { name, type: output.type.replace('*', '') }, structs, enums));
+                }
+            }
+            return parsedDataArr;
+        default:
+            return parseBaseTypes(type, responseIterator);
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Convert tuple string definition into object like definition
+ * @param type tuple string definition
+ * @returns object like tuple
+ */
+export default function extractTupleMemberTypes(type: string): (string | object)[];

package/js/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/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/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);
+}