ccxt 4.3.70 → 4.3.72

package/dist/cjs/src/static_dependencies/starknet/utils/typedData.js

@@ -0,0 +1,334 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+require('../types/calldata.js');
+require('../types/lib/index.js');
+var typedData = require('../types/typedData.js');
+var assert = require('./assert.js');
+var byteArray = require('./calldata/byteArray.js');
+require('../../noble-curves/abstract/modular.js');
+var selector = require('./selector.js');
+var classHash = require('./hash/classHash.js');
+var merkle = require('./merkle.js');
+var num = require('./num.js');
+var shortString = require('./shortString.js');
+
+/* eslint-disable no-param-reassign */
+const presetTypes = {
+    u256: JSON.parse('[{ "name": "low", "type": "u128" }, { "name": "high", "type": "u128" }]'),
+    TokenAmount: JSON.parse('[{ "name": "token_address", "type": "ContractAddress" }, { "name": "amount", "type": "u256" }]'),
+    NftId: JSON.parse('[{ "name": "collection_address", "type": "ContractAddress" }, { "name": "token_id", "type": "u256" }]'),
+};
+const revisionConfiguration = {
+    [typedData.TypedDataRevision.Active]: {
+        domain: 'StarknetDomain',
+        hashMethod: classHash.computePoseidonHashOnElements,
+        hashMerkleMethod: classHash.computePoseidonHash,
+        escapeTypeString: (s) => `"${s}"`,
+        presetTypes,
+    },
+    [typedData.TypedDataRevision.Legacy]: {
+        domain: 'StarkNetDomain',
+        hashMethod: classHash.computePedersenHashOnElements,
+        hashMerkleMethod: classHash.computePedersenHash,
+        escapeTypeString: (s) => s,
+        presetTypes: {},
+    },
+};
+function assertRange(data, type, { min, max }) {
+    const value = BigInt(data);
+    assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+}
+function identifyRevision({ types, domain }) {
+    if (revisionConfiguration[typedData.TypedDataRevision.Active].domain in types && domain.revision === typedData.TypedDataRevision.Active)
+        return typedData.TypedDataRevision.Active;
+    if (revisionConfiguration[typedData.TypedDataRevision.Legacy].domain in types &&
+        (domain.revision ?? typedData.TypedDataRevision.Legacy) === typedData.TypedDataRevision.Legacy)
+        return typedData.TypedDataRevision.Legacy;
+    return undefined;
+}
+function getHex(value) {
+    try {
+        return num.toHex(value);
+    }
+    catch (e) {
+        if (shortString.isString(value)) {
+            return num.toHex(shortString.encodeShortString(value));
+        }
+        throw new Error(`Invalid BigNumberish: ${value}`);
+    }
+}
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ */
+function validateTypedData(data) {
+    const typedData = data;
+    return Boolean(typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData));
+}
+/**
+ * Prepares the selector for use.
+ *
+ * @param {string} selector - The selector to be prepared.
+ * @returns {string} The prepared selector.
+ */
+function prepareSelector(selector$1) {
+    return num.isHex(selector$1) ? selector$1 : selector.getSelectorFromName(selector$1);
+}
+/**
+ * Checks if the given Starknet type is a Merkle tree type.
+ *
+ * @param {StarknetType} type - The StarkNet type to check.
+ *
+ * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ */
+function isMerkleTreeType(type) {
+    return type.type === 'merkletree';
+}
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ */
+function getDependencies(types, type, dependencies = [], contains = '', revision = typedData.TypedDataRevision.Legacy) {
+    // Include pointers (struct arrays)
+    if (type[type.length - 1] === '*') {
+        type = type.slice(0, -1);
+    }
+    else if (revision === typedData.TypedDataRevision.Active) {
+        // enum base
+        if (type === 'enum') {
+            type = contains;
+        }
+        // enum element types
+        else if (type.match(/^\(.*\)$/)) {
+            type = type.slice(1, -1);
+        }
+    }
+    if (dependencies.includes(type) || !types[type]) {
+        return dependencies;
+    }
+    return [
+        type,
+        ...types[type].reduce((previous, t) => [
+            ...previous,
+            ...getDependencies(types, t.type, previous, t.contains, revision).filter((dependency) => !previous.includes(dependency)),
+        ], []),
+    ];
+}
+function getMerkleTreeType(types, ctx) {
+    if (ctx.parent && ctx.key) {
+        const parentType = types[ctx.parent];
+        const merkleType = parentType.find((t) => t.name === ctx.key);
+        const isMerkleTree = isMerkleTreeType(merkleType);
+        if (!isMerkleTree) {
+            throw new Error(`${ctx.key} is not a merkle tree`);
+        }
+        if (merkleType.contains.endsWith('*')) {
+            throw new Error(`Merkle tree contain property must not be an array but was given ${ctx.key}`);
+        }
+        return merkleType.contains;
+    }
+    return 'raw';
+}
+/**
+ * Encode a type to a string. All dependent types are alphabetically sorted.
+ */
+function encodeType(types, type, revision = typedData.TypedDataRevision.Legacy) {
+    const allTypes = revision === typedData.TypedDataRevision.Active
+        ? { ...types, ...revisionConfiguration[revision].presetTypes }
+        : types;
+    const [primary, ...dependencies] = getDependencies(allTypes, type, undefined, undefined, revision);
+    const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
+    const esc = revisionConfiguration[revision].escapeTypeString;
+    return newTypes
+        .map((dependency) => {
+        const dependencyElements = allTypes[dependency].map((t) => {
+            const targetType = t.type === 'enum' && revision === typedData.TypedDataRevision.Active
+                ? t.contains
+                : t.type;
+            // parentheses handling for enum variant types
+            const typeString = targetType.match(/^\(.*\)$/)
+                ? `(${targetType
+                    .slice(1, -1)
+                    .split(',')
+                    .map((e) => (e ? esc(e) : e))
+                    .join(',')})`
+                : esc(targetType);
+            return `${esc(t.name)}:${typeString}`;
+        });
+        return `${esc(dependency)}(${dependencyElements})`;
+    })
+        .join('');
+}
+/**
+ * Get a type string as hash.
+ */
+function getTypeHash(types, type, revision = typedData.TypedDataRevision.Legacy) {
+    return selector.getSelectorFromName(encodeType(types, type, revision));
+}
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ */
+function encodeValue(types, type, data, ctx = {}, revision = typedData.TypedDataRevision.Legacy) {
+    if (types[type]) {
+        return [type, getStructHash(types, type, data, revision)];
+    }
+    if (revisionConfiguration[revision].presetTypes[type]) {
+        return [
+            type,
+            getStructHash(revisionConfiguration[revision].presetTypes, type, data, revision),
+        ];
+    }
+    if (type.endsWith('*')) {
+        const hashes = data.map((entry) => encodeValue(types, type.slice(0, -1), entry, undefined, revision)[1]);
+        return [type, revisionConfiguration[revision].hashMethod(hashes)];
+    }
+    switch (type) {
+        case 'enum': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                const [variantKey, variantData] = Object.entries(data)[0];
+                const parentType = types[ctx.parent][0];
+                const enumType = types[parentType.contains];
+                const variantType = enumType.find((t) => t.name === variantKey);
+                const variantIndex = enumType.indexOf(variantType);
+                const encodedSubtypes = variantType.type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((subtype, index) => {
+                    if (!subtype)
+                        return subtype;
+                    const subtypeData = variantData[index];
+                    return encodeValue(types, subtype, subtypeData, undefined, revision)[1];
+                });
+                return [
+                    type,
+                    revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes]),
+                ];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'merkletree': {
+            const merkleTreeType = getMerkleTreeType(types, ctx);
+            const structHashes = data.map((struct) => {
+                return encodeValue(types, merkleTreeType, struct, undefined, revision)[1];
+            });
+            const { root } = new merkle.MerkleTree(structHashes, revisionConfiguration[revision].hashMerkleMethod);
+            return ['felt', root];
+        }
+        case 'selector': {
+            return ['felt', prepareSelector(data)];
+        }
+        case 'string': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                const byteArray$1 = byteArray.byteArrayFromString(data);
+                const elements = [
+                    byteArray$1.data.length,
+                    ...byteArray$1.data,
+                    byteArray$1.pending_word,
+                    byteArray$1.pending_word_len,
+                ];
+                return [type, revisionConfiguration[revision].hashMethod(elements)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'i128': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                const value = BigInt(data);
+                assertRange(value, type, constants.RANGE_I128);
+                return [type, getHex(value < 0n ? constants.PRIME + value : value)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'timestamp':
+        case 'u128': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                assertRange(data, type, constants.RANGE_U128);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'felt':
+        case 'shortstring': {
+            // TODO: should 'shortstring' diverge into directly using encodeShortString()?
+            if (revision === typedData.TypedDataRevision.Active) {
+                assertRange(getHex(data), type, constants.RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'ClassHash':
+        case 'ContractAddress': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                assertRange(data, type, constants.RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'bool': {
+            if (revision === typedData.TypedDataRevision.Active) {
+                assert(typeof data === 'boolean', `Type mismatch for ${type} ${data}`);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        default: {
+            if (revision === typedData.TypedDataRevision.Active) {
+                throw new Error(`Unsupported type: ${type}`);
+            }
+            return [type, getHex(data)];
+        }
+    }
+}
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+function encodeData(types, type, data, revision = typedData.TypedDataRevision.Legacy) {
+    const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
+    const [returnTypes, values] = targetType.reduce(([ts, vs], field) => {
+        if (data[field.name] === undefined ||
+            (data[field.name] === null && field.type !== 'enum')) {
+            throw new Error(`Cannot encode data: missing data for '${field.name}'`);
+        }
+        const value = data[field.name];
+        const ctx = { parent: type, key: field.name };
+        const [t, encodedValue] = encodeValue(types, field.type, value, ctx, revision);
+        return [
+            [...ts, t],
+            [...vs, encodedValue],
+        ];
+    }, [['felt'], [getTypeHash(types, type, revision)]]);
+    return [returnTypes, values];
+}
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+function getStructHash(types, type, data, revision = typedData.TypedDataRevision.Legacy) {
+    return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+}
+/**
+ * Get the SNIP-12 encoded message to sign, from the typedData object.
+ */
+function getMessageHash(typedData, account) {
+    if (!validateTypedData(typedData)) {
+        throw new Error('Typed data does not match JSON schema');
+    }
+    const revision = identifyRevision(typedData);
+    const { domain, hashMethod } = revisionConfiguration[revision];
+    const message = [
+        shortString.encodeShortString('StarkNet Message'),
+        getStructHash(typedData.types, domain, typedData.domain, revision),
+        account,
+        getStructHash(typedData.types, typedData.primaryType, typedData.message, revision),
+    ];
+    return hashMethod(message);
+}
+
+exports.encodeData = encodeData;
+exports.encodeType = encodeType;
+exports.encodeValue = encodeValue;
+exports.getDependencies = getDependencies;
+exports.getMessageHash = getMessageHash;
+exports.getStructHash = getStructHash;
+exports.getTypeHash = getTypeHash;
+exports.isMerkleTreeType = isMerkleTreeType;
+exports.prepareSelector = prepareSelector;

package/dist/cjs/src/woo.js

@@ -2654,11 +2654,13 @@ class woo extends woo$1 {
         //
         const marketId = this.safeString(income, 'symbol');
         const symbol = this.safeSymbol(marketId, market);
-        const amount = this.safeNumber(income, 'funding_fee');
+        let amount = this.safeString(income, 'funding_fee');
         const code = this.safeCurrencyCode('USD');
         const id = this.safeString(income, 'id');
         const timestamp = this.safeTimestamp(income, 'updated_time');
         const rate = this.safeNumber(income, 'funding_rate');
+        const paymentType = this.safeString(income, 'payment_type');
+        amount = (paymentType === 'Pay') ? Precise["default"].stringNeg(amount) : amount;
         return {
             'info': income,
             'symbol': symbol,
@@ -2666,7 +2668,7 @@ class woo extends woo$1 {
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'id': id,
-            'amount': amount,
+            'amount': this.parseNumber(amount),
             'rate': rate,
         };
     }

package/examples/js/cli.js

@@ -374,10 +374,14 @@ async function run () {
                     }
 
                     if (debug) {
-                        const keys = Object.keys (httpsAgent.freeSockets)
-                        const firstKey = keys[0]
-                        let httpAgent = httpsAgent.freeSockets[firstKey];
-                        log (firstKey, httpAgent.length)
+                        if (httpsAgent.freeSockets) {
+                            const keys = Object.keys (httpsAgent.freeSockets)
+                            if (keys.length) {
+                                const firstKey = keys[0]
+                                let httpAgent = httpsAgent.freeSockets[firstKey];
+                                log (firstKey, httpAgent.length)
+                            }
+                        }
                     }
 
                     if (!poll && !isWsMethod){

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending } from './src/base/errors.js';
-declare const version = "4.3.69";
+declare const version = "4.3.71";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';
@@ -94,6 +94,7 @@ import okx from './src/okx.js';
 import onetrading from './src/onetrading.js';
 import oxfun from './src/oxfun.js';
 import p2b from './src/p2b.js';
+import paradex from './src/paradex.js';
 import paymium from './src/paymium.js';
 import phemex from './src/phemex.js';
 import poloniex from './src/poloniex.js';
@@ -171,6 +172,7 @@ import okxPro from './src/pro/okx.js';
 import onetradingPro from './src/pro/onetrading.js';
 import oxfunPro from './src/pro/oxfun.js';
 import p2bPro from './src/pro/p2b.js';
+import paradexPro from './src/pro/paradex.js';
 import phemexPro from './src/pro/phemex.js';
 import poloniexPro from './src/pro/poloniex.js';
 import poloniexfuturesPro from './src/pro/poloniexfutures.js';
@@ -272,6 +274,7 @@ declare const exchanges: {
     onetrading: typeof onetrading;
     oxfun: typeof oxfun;
     p2b: typeof p2b;
+    paradex: typeof paradex;
     paymium: typeof paymium;
     phemex: typeof phemex;
     poloniex: typeof poloniex;
@@ -351,6 +354,7 @@ declare const pro: {
     onetrading: typeof onetradingPro;
     oxfun: typeof oxfunPro;
     p2b: typeof p2bPro;
+    paradex: typeof paradexPro;
     phemex: typeof phemexPro;
     poloniex: typeof poloniexPro;
     poloniexfutures: typeof poloniexfuturesPro;
@@ -427,6 +431,7 @@ declare const ccxt: {
         onetrading: typeof onetradingPro;
         oxfun: typeof oxfunPro;
         p2b: typeof p2bPro;
+        paradex: typeof paradexPro;
         phemex: typeof phemexPro;
         poloniex: typeof poloniexPro;
         poloniexfutures: typeof poloniexfuturesPro;
@@ -529,6 +534,7 @@ declare const ccxt: {
     onetrading: typeof onetrading;
     oxfun: typeof oxfun;
     p2b: typeof p2b;
+    paradex: typeof paradex;
     paymium: typeof paymium;
     phemex: typeof phemex;
     poloniex: typeof poloniex;
@@ -549,5 +555,5 @@ declare const ccxt: {
     zaif: typeof zaif;
     zonda: typeof zonda;
 } & typeof functions & typeof errors;
-export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
+export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paradex, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
 export default ccxt;

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.70';
+const version = '4.3.72';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';
@@ -130,6 +130,7 @@ import okx from './src/okx.js';
 import onetrading from './src/onetrading.js';
 import oxfun from './src/oxfun.js';
 import p2b from './src/p2b.js';
+import paradex from './src/paradex.js';
 import paymium from './src/paymium.js';
 import phemex from './src/phemex.js';
 import poloniex from './src/poloniex.js';
@@ -208,6 +209,7 @@ import okxPro from './src/pro/okx.js';
 import onetradingPro from './src/pro/onetrading.js';
 import oxfunPro from './src/pro/oxfun.js';
 import p2bPro from './src/pro/p2b.js';
+import paradexPro from './src/pro/paradex.js';
 import phemexPro from './src/pro/phemex.js';
 import poloniexPro from './src/pro/poloniex.js';
 import poloniexfuturesPro from './src/pro/poloniexfutures.js';
@@ -309,6 +311,7 @@ const exchanges = {
     'onetrading': onetrading,
     'oxfun': oxfun,
     'p2b': p2b,
+    'paradex': paradex,
     'paymium': paymium,
     'phemex': phemex,
     'poloniex': poloniex,
@@ -388,6 +391,7 @@ const pro = {
     'onetrading': onetradingPro,
     'oxfun': oxfunPro,
     'p2b': p2bPro,
+    'paradex': paradexPro,
     'phemex': phemexPro,
     'poloniex': poloniexPro,
     'poloniexfutures': poloniexfuturesPro,
@@ -412,6 +416,6 @@ pro.exchanges = Object.keys(pro);
 pro['Exchange'] = Exchange; // now the same for rest and ts
 //-----------------------------------------------------------------------------
 const ccxt = Object.assign({ version, Exchange, Precise, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, functions, errors);
-export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
+export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paradex, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
 export default ccxt;
 //-----------------------------------------------------------------------------

package/js/src/abstract/paradex.d.ts

@@ -0,0 +1,43 @@
+import { implicitReturnType } from '../base/types.js';
+import { Exchange as _Exchange } from '../base/Exchange.js';
+interface Exchange {
+    publicGetBboMarket(params?: {}): Promise<implicitReturnType>;
+    publicGetFundingData(params?: {}): Promise<implicitReturnType>;
+    publicGetMarkets(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketsKlines(params?: {}): Promise<implicitReturnType>;
+    publicGetMarketsSummary(params?: {}): Promise<implicitReturnType>;
+    publicGetOrderbookMarket(params?: {}): Promise<implicitReturnType>;
+    publicGetInsurance(params?: {}): Promise<implicitReturnType>;
+    publicGetReferralsConfig(params?: {}): Promise<implicitReturnType>;
+    publicGetSystemConfig(params?: {}): Promise<implicitReturnType>;
+    publicGetSystemState(params?: {}): Promise<implicitReturnType>;
+    publicGetSystemTime(params?: {}): Promise<implicitReturnType>;
+    publicGetTrades(params?: {}): Promise<implicitReturnType>;
+    privateGetAccount(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountProfile(params?: {}): Promise<implicitReturnType>;
+    privateGetBalance(params?: {}): Promise<implicitReturnType>;
+    privateGetFills(params?: {}): Promise<implicitReturnType>;
+    privateGetFundingPayments(params?: {}): Promise<implicitReturnType>;
+    privateGetPositions(params?: {}): Promise<implicitReturnType>;
+    privateGetTradebusts(params?: {}): Promise<implicitReturnType>;
+    privateGetTransactions(params?: {}): Promise<implicitReturnType>;
+    privateGetLiquidations(params?: {}): Promise<implicitReturnType>;
+    privateGetOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetOrdersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetOrdersByClientIdClientId(params?: {}): Promise<implicitReturnType>;
+    privateGetOrdersOrderId(params?: {}): Promise<implicitReturnType>;
+    privateGetPointsDataMarketProgram(params?: {}): Promise<implicitReturnType>;
+    privateGetReferralsSummary(params?: {}): Promise<implicitReturnType>;
+    privateGetTransfers(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountProfileReferralCode(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountProfileUsername(params?: {}): Promise<implicitReturnType>;
+    privatePostAuth(params?: {}): Promise<implicitReturnType>;
+    privatePostOnboarding(params?: {}): Promise<implicitReturnType>;
+    privatePostOrders(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrders(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrdersByClientIdClientId(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrdersOrderId(params?: {}): Promise<implicitReturnType>;
+}
+declare abstract class Exchange extends _Exchange {
+}
+export default Exchange;

package/js/src/abstract/paradex.js

@@ -0,0 +1,11 @@
+// ----------------------------------------------------------------------------
+
+// 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 { Exchange as _Exchange } from '../base/Exchange.js';
+class Exchange extends _Exchange {
+}
+export default Exchange;

package/js/src/base/Exchange.d.ts

@@ -369,6 +369,13 @@ export default class Exchange {
     fixStringifiedJsonMembers(content: string): any;
     ethAbiEncode(types: any, args: any): Uint8Array;
     ethEncodeStructuredData(domain: any, messageTypes: any, messageData: any): Uint8Array;
+    retrieveStarkAccount(signature: any, accountClassHash: any, accountProxyClassHash: any): {
+        privateKey: string;
+        publicKey: string;
+        address: string;
+    };
+    starknetEncodeStructuredData(domain: any, messageTypes: any, messageData: any, address: any): string;
+    starknetSign(hash: any, pri: any): string;
     intToBase16(elem: any): string;
     extendExchangeOptions(newOptions: Dict): void;
     createSafeDictionary(): {};

package/js/src/base/Exchange.js

@@ -24,6 +24,8 @@ import totp from './functions/totp.js';
 import ethers from '../static_dependencies/ethers/index.js';
 import { TypedDataEncoder } from '../static_dependencies/ethers/hash/index.js';
 import { SecureRandom } from "../static_dependencies/jsencrypt/lib/jsbn/rng.js";
+import { getStarkKey, ethSigToPrivate, sign as starknetCurveSign } from '../static_dependencies/scure-starknet/index.js';
+import * as Starknet from '../static_dependencies/starknet/index.js';
 // ----------------------------------------------------------------------------
 /**
  * @class Exchange
@@ -1169,6 +1171,49 @@ export default class Exchange {
     ethEncodeStructuredData(domain, messageTypes, messageData) {
         return this.base16ToBinary(TypedDataEncoder.encode(domain, messageTypes, messageData).slice(-132));
     }
+    retrieveStarkAccount(signature, accountClassHash, accountProxyClassHash) {
+        const privateKey = ethSigToPrivate(signature);
+        const publicKey = getStarkKey(privateKey);
+        const callData = Starknet.CallData.compile({
+            implementation: accountClassHash,
+            selector: Starknet.hash.getSelectorFromName('initialize'),
+            calldata: Starknet.CallData.compile({
+                signer: publicKey,
+                guardian: '0',
+            }),
+        });
+        const address = Starknet.hash.calculateContractAddressFromHash(publicKey, accountProxyClassHash, callData, 0);
+        return {
+            privateKey,
+            publicKey,
+            address
+        };
+    }
+    starknetEncodeStructuredData(domain, messageTypes, messageData, address) {
+        const types = Object.keys(messageTypes);
+        if (types.length > 1) {
+            throw new NotSupported(this.id + 'starknetEncodeStructuredData only support single type');
+        }
+        const request = {
+            'domain': domain,
+            'primaryType': types[0],
+            'types': this.extend({
+                'StarkNetDomain': [
+                    { 'name': "name", 'type': "felt" },
+                    { 'name': "chainId", 'type': "felt" },
+                    { 'name': "version", 'type': "felt" },
+                ],
+            }, messageTypes),
+            'message': messageData,
+        };
+        const msgHash = Starknet.typedData.getMessageHash(request, address);
+        return msgHash;
+    }
+    starknetSign(hash, pri) {
+        // TODO: unify to ecdsa
+        const signature = starknetCurveSign(hash.replace('0x', ''), pri.slice(-64));
+        return this.json([signature.r.toString(), signature.s.toString()]);
+    }
     intToBase16(elem) {
         return elem.toString(16);
     }