ccxt 4.3.69 → 4.3.71

package/dist/cjs/src/static_dependencies/starknet/utils/calldata/requestParser.js

@@ -0,0 +1,250 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var uint256 = require('../cairoDataTypes/uint256.js');
+var uint512 = require('../cairoDataTypes/uint512.js');
+var encode = require('../encode.js');
+var num = require('../num.js');
+var shortString = require('../shortString.js');
+var byteArray = require('./byteArray.js');
+var cairo = require('./cairo.js');
+var CairoOption = require('./enum/CairoOption.js');
+var CairoResult = require('./enum/CairoResult.js');
+var tuple = require('./tuple.js');
+
+/**
+ * parse base types
+ * @param type type from abi
+ * @param val value provided
+ * @returns string | string[]
+ */
+function parseBaseTypes(type, val) {
+    switch (true) {
+        case uint256.CairoUint256.isAbiType(type):
+            return new uint256.CairoUint256(val).toApiRequest();
+        case uint512.CairoUint512.isAbiType(type):
+            return new uint512.CairoUint512(val).toApiRequest();
+        case cairo.isTypeBytes31(type):
+            return shortString.encodeShortString(val.toString());
+        case cairo.isTypeSecp256k1Point(type): {
+            const pubKeyETH = encode.removeHexPrefix(num.toHex(val)).padStart(128, '0');
+            const pubKeyETHy = cairo.uint256(encode.addHexPrefix(pubKeyETH.slice(-64)));
+            const pubKeyETHx = cairo.uint256(encode.addHexPrefix(pubKeyETH.slice(0, -64)));
+            return [
+                cairo.felt(pubKeyETHx.low),
+                cairo.felt(pubKeyETHx.high),
+                cairo.felt(pubKeyETHy.low),
+                cairo.felt(pubKeyETHy.high),
+            ];
+        }
+        default:
+            return cairo.felt(val);
+    }
+}
+/**
+ * Parse tuple type string to array of known objects
+ * @param element request element
+ * @param typeStr tuple type string
+ * @returns Tupled[]
+ */
+function parseTuple(element, typeStr) {
+    const memberTypes = tuple(typeStr);
+    const elements = Object.values(element);
+    if (elements.length !== memberTypes.length) {
+        throw Error(`ParseTuple: provided and expected abi tuple size do not match.
+      provided: ${elements} 
+      expected: ${memberTypes}`);
+    }
+    return memberTypes.map((it, dx) => {
+        return {
+            element: elements[dx],
+            type: it.type ?? it,
+        };
+    });
+}
+function parseByteArray(element) {
+    const myByteArray = byteArray.byteArrayFromString(element);
+    return [
+        myByteArray.data.length.toString(),
+        ...myByteArray.data.map((bn) => bn.toString()),
+        myByteArray.pending_word.toString(),
+        myByteArray.pending_word_len.toString(),
+    ];
+}
+/**
+ * Deep parse of the object that has been passed to the method
+ *
+ * @param element - element that needs to be parsed
+ * @param type  - name of the method
+ * @param structs - structs from abi
+ * @param enums - enums from abi
+ * @return {string | string[]} - parsed arguments in format that contract is expecting
+ */
+function parseCalldataValue(element, type, structs, enums) {
+    if (element === undefined) {
+        throw Error(`Missing parameter for type ${type}`);
+    }
+    // value is Array
+    if (Array.isArray(element)) {
+        const result = [];
+        result.push(cairo.felt(element.length)); // Add length to array
+        const arrayType = cairo.getArrayType(type);
+        return element.reduce((acc, it) => {
+            return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+        }, result);
+    }
+    // checking if the passed element is struct
+    if (structs[type] && structs[type].members.length) {
+        if (uint256.CairoUint256.isAbiType(type)) {
+            return new uint256.CairoUint256(element).toApiRequest();
+        }
+        if (uint512.CairoUint512.isAbiType(type)) {
+            return new uint512.CairoUint512(element).toApiRequest();
+        }
+        if (type === 'core::starknet::eth_address::EthAddress')
+            return parseBaseTypes(type, element);
+        if (type === 'core::byte_array::ByteArray')
+            return parseByteArray(element);
+        const { members } = structs[type];
+        const subElement = element;
+        return members.reduce((acc, it) => {
+            return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs, enums));
+        }, []);
+    }
+    // check if abi element is tuple
+    if (cairo.isTypeTuple(type)) {
+        const tupled = parseTuple(element, type);
+        return tupled.reduce((acc, it) => {
+            const parsedData = parseCalldataValue(it.element, it.type, structs, enums);
+            return acc.concat(parsedData);
+        }, []);
+    }
+    // check if u256 C1v0
+    if (uint256.CairoUint256.isAbiType(type)) {
+        return new uint256.CairoUint256(element).toApiRequest();
+    }
+    // check if u512
+    if (uint512.CairoUint512.isAbiType(type)) {
+        return new uint512.CairoUint512(element).toApiRequest();
+    }
+    // check if Enum
+    if (cairo.isTypeEnum(type, enums)) {
+        const { variants } = enums[type];
+        // Option Enum
+        if (cairo.isTypeOption(type)) {
+            const myOption = element;
+            if (myOption.isSome()) {
+                const listTypeVariant = variants.find((variant) => variant.name === 'Some');
+                if (typeof listTypeVariant === 'undefined') {
+                    throw Error(`Error in abi : Option has no 'Some' variant.`);
+                }
+                const typeVariantSome = listTypeVariant.type;
+                if (typeVariantSome === '()') {
+                    return CairoOption.CairoOptionVariant.Some.toString();
+                }
+                const parsedParameter = parseCalldataValue(myOption.unwrap(), typeVariantSome, structs, enums);
+                if (Array.isArray(parsedParameter)) {
+                    return [CairoOption.CairoOptionVariant.Some.toString(), ...parsedParameter];
+                }
+                return [CairoOption.CairoOptionVariant.Some.toString(), parsedParameter];
+            }
+            return CairoOption.CairoOptionVariant.None.toString();
+        }
+        // Result Enum
+        if (cairo.isTypeResult(type)) {
+            const myResult = element;
+            if (myResult.isOk()) {
+                const listTypeVariant = variants.find((variant) => variant.name === 'Ok');
+                if (typeof listTypeVariant === 'undefined') {
+                    throw Error(`Error in abi : Result has no 'Ok' variant.`);
+                }
+                const typeVariantOk = listTypeVariant.type;
+                if (typeVariantOk === '()') {
+                    return CairoResult.CairoResultVariant.Ok.toString();
+                }
+                const parsedParameter = parseCalldataValue(myResult.unwrap(), typeVariantOk, structs, enums);
+                if (Array.isArray(parsedParameter)) {
+                    return [CairoResult.CairoResultVariant.Ok.toString(), ...parsedParameter];
+                }
+                return [CairoResult.CairoResultVariant.Ok.toString(), parsedParameter];
+            }
+            // is Result::Err
+            const listTypeVariant = variants.find((variant) => variant.name === 'Err');
+            if (typeof listTypeVariant === 'undefined') {
+                throw Error(`Error in abi : Result has no 'Err' variant.`);
+            }
+            const typeVariantErr = listTypeVariant.type;
+            if (typeVariantErr === '()') {
+                return CairoResult.CairoResultVariant.Err.toString();
+            }
+            const parsedParameter = parseCalldataValue(myResult.unwrap(), typeVariantErr, structs, enums);
+            if (Array.isArray(parsedParameter)) {
+                return [CairoResult.CairoResultVariant.Err.toString(), ...parsedParameter];
+            }
+            return [CairoResult.CairoResultVariant.Err.toString(), parsedParameter];
+        }
+        // Custom Enum
+        const myEnum = element;
+        const activeVariant = myEnum.activeVariant();
+        const listTypeVariant = variants.find((variant) => variant.name === activeVariant);
+        if (typeof listTypeVariant === 'undefined') {
+            throw Error(`Not find in abi : Enum has no '${activeVariant}' variant.`);
+        }
+        const typeActiveVariant = listTypeVariant.type;
+        const numActiveVariant = variants.findIndex((variant) => variant.name === activeVariant); // can not fail due to check of listTypeVariant
+        if (typeActiveVariant === '()') {
+            return numActiveVariant.toString();
+        }
+        const parsedParameter = parseCalldataValue(myEnum.unwrap(), typeActiveVariant, structs, enums);
+        if (Array.isArray(parsedParameter)) {
+            return [numActiveVariant.toString(), ...parsedParameter];
+        }
+        return [numActiveVariant.toString(), parsedParameter];
+    }
+    if (typeof element === 'object') {
+        throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+    }
+    return parseBaseTypes(type, element);
+}
+/**
+ * Parse one field of the calldata by using input field from the abi for that method
+ *
+ * @param argsIterator - Iterator for value of the field
+ * @param input  - input(field) information from the abi that will be used to parse the data
+ * @param structs - structs from abi
+ * @param enums - enums from abi
+ * @return {string | string[]} - parsed arguments in format that contract is expecting
+ */
+function parseCalldataField(argsIterator, input, structs, enums) {
+    const { name, type } = input;
+    let { value } = argsIterator.next();
+    switch (true) {
+        // Array
+        case cairo.isTypeArray(type):
+            if (!Array.isArray(value) && !shortString.isText(value)) {
+                throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+            }
+            if (shortString.isString(value)) {
+                // long string match cairo felt*
+                value = shortString.splitLongString(value);
+            }
+            return parseCalldataValue(value, input.type, structs, enums);
+        case type === 'core::starknet::eth_address::EthAddress':
+            return parseBaseTypes(type, value);
+        // Struct or Tuple
+        case cairo.isTypeStruct(type, structs) ||
+            cairo.isTypeTuple(type) ||
+            uint256.CairoUint256.isAbiType(type) ||
+            uint256.CairoUint256.isAbiType(type):
+            return parseCalldataValue(value, type, structs, enums);
+        // Enums
+        case cairo.isTypeEnum(type, enums):
+            return parseCalldataValue(value, type, structs, enums);
+        // Felt or unhandled
+        default:
+            return parseBaseTypes(type, value);
+    }
+}
+
+exports.parseCalldataField = parseCalldataField;

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

@@ -0,0 +1,215 @@
+'use strict';
+
+var uint256 = require('../cairoDataTypes/uint256.js');
+var uint512 = require('../cairoDataTypes/uint512.js');
+var encode = require('../encode.js');
+var num = require('../num.js');
+var shortString = require('../shortString.js');
+var byteArray = require('./byteArray.js');
+var cairo = require('./cairo.js');
+var CairoCustomEnum = require('./enum/CairoCustomEnum.js');
+var CairoOption = require('./enum/CairoOption.js');
+var CairoResult = require('./enum/CairoResult.js');
+var tuple = require('./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 cairo.isTypeBool(type):
+            temp = it.next().value;
+            return Boolean(BigInt(temp));
+        case uint256.CairoUint256.isAbiType(type):
+            const low = it.next().value;
+            const high = it.next().value;
+            return new uint256.CairoUint256(low, high).toBigInt();
+        case uint512.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 uint512.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 shortString.decodeShortString(temp);
+        case cairo.isTypeSecp256k1Point(type):
+            const xLow = encode.removeHexPrefix(it.next().value).padStart(32, '0');
+            const xHigh = encode.removeHexPrefix(it.next().value).padStart(32, '0');
+            const yLow = encode.removeHexPrefix(it.next().value).padStart(32, '0');
+            const yHigh = encode.removeHexPrefix(it.next().value).padStart(32, '0');
+            const pubK = BigInt(encode.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 (uint256.CairoUint256.isAbiType(element.type)) {
+        const low = responseIterator.next().value;
+        const high = responseIterator.next().value;
+        return new uint256.CairoUint256(low, high).toBigInt();
+    }
+    // type uint512 struct
+    if (uint512.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 uint512.CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+    }
+    // type C1 ByteArray struct, representing a LongString
+    if (cairo.isTypeByteArray(element.type)) {
+        const parsedBytes31Arr = [];
+        const bytes31ArrLen = BigInt(responseIterator.next().value);
+        while (parsedBytes31Arr.length < bytes31ArrLen) {
+            parsedBytes31Arr.push(num.toHex(responseIterator.next().value));
+        }
+        const pending_word = num.toHex(responseIterator.next().value);
+        const pending_word_len = BigInt(responseIterator.next().value);
+        const myByteArray = {
+            data: parsedBytes31Arr,
+            pending_word,
+            pending_word_len,
+        };
+        return byteArray.stringFromByteArray(myByteArray);
+    }
+    // type c1 array
+    if (cairo.isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: cairo.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 === CairoOption.CairoOptionVariant.Some ? rawEnum.Some : undefined;
+            return new CairoOption.CairoOption(variantNum, content);
+        }
+        // Result
+        if (element.type.startsWith('core::result::Result')) {
+            let content;
+            if (variantNum === CairoResult.CairoResultVariant.Ok) {
+                content = rawEnum.Ok;
+            }
+            else {
+                content = rawEnum.Err;
+            }
+            return new CairoResult.CairoResult(variantNum, content);
+        }
+        // Cairo custom Enum
+        const customEnum = new CairoCustomEnum.CairoCustomEnum(rawEnum);
+        return customEnum;
+    }
+    // type tuple
+    if (cairo.isTypeTuple(element.type)) {
+        const memberTypes = tuple(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 (cairo.isTypeArray(element.type)) {
+        // eslint-disable-next-line no-case-declarations
+        const parsedDataArr = [];
+        const el = { name: '', type: cairo.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
+ */
+function responseParser(responseIterator, output, structs, enums, parsedResult) {
+    const { name, type } = output;
+    let temp;
+    switch (true) {
+        case cairo.isLen(name):
+            temp = responseIterator.next().value;
+            return BigInt(temp);
+        case (structs && type in structs) || cairo.isTypeTuple(type):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case enums && cairo.isTypeEnum(type, enums):
+            return parseResponseValue(responseIterator, output, structs, enums);
+        case cairo.isTypeArray(type):
+            // C1 Array
+            if (cairo.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);
+    }
+}
+
+module.exports = responseParser;

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

@@ -0,0 +1,112 @@
+'use strict';
+
+var cairo = require('./cairo.js');
+
+/* eslint-disable no-plusplus */
+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 (cairo.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
+ */
+function extractTupleMemberTypes(type) {
+    if (cairo.isCairo1Type(type)) {
+        return extractCairo1Tuple(type);
+    }
+    return extractCairo0Tuple(type);
+}
+
+module.exports = extractTupleMemberTypes;