ccxt 4.4.21 → 4.4.23

package/js/src/cex.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/cex.js';
-import { ExchangeError, ArgumentsRequired, AuthenticationError, NullResponse, InvalidOrder, InsufficientFunds, InvalidNonce, OrderNotFound, RateLimitExceeded, DDoSProtection, BadSymbol } from './base/errors.js';
+import { ExchangeError, ArgumentsRequired, NullResponse, PermissionDenied, InsufficientFunds, BadRequest } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { TICK_SIZE } from './base/functions/number.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
@@ -21,7 +21,7 @@ export default class cex extends Exchange {
             'id': 'cex',
             'name': 'CEX.IO',
             'countries': ['GB', 'EU', 'CY', 'RU'],
-            'rateLimit': 1500,
+            'rateLimit': 1667,
             'pro': true,
             'has': {
                 'CORS': undefined,
@@ -30,152 +30,82 @@ export default class cex extends Exchange {
                 'swap': false,
                 'future': false,
                 'option': false,
-                'addMargin': false,
                 'cancelAllOrders': true,
                 'cancelOrder': true,
-                'cancelOrders': false,
-                'createDepositAddress': false,
-                'createMarketBuyOrderWithCost': true,
-                'createMarketOrderWithCost': false,
-                'createMarketSellOrderWithCost': false,
                 'createOrder': true,
-                'createStopLimitOrder': false,
-                'createStopMarketOrder': false,
-                'createStopOrder': false,
-                'editOrder': true,
+                'fetchAccounts': true,
                 'fetchBalance': true,
                 'fetchClosedOrders': true,
                 'fetchCurrencies': true,
-                'fetchDeposit': false,
                 'fetchDepositAddress': true,
-                'fetchDepositAddresses': false,
-                'fetchDepositAddressesByNetwork': false,
-                'fetchDeposits': false,
-                'fetchDepositsWithdrawals': false,
+                'fetchDepositsWithdrawals': true,
                 'fetchFundingHistory': false,
                 'fetchFundingRate': false,
                 'fetchFundingRateHistory': false,
                 'fetchFundingRates': false,
-                'fetchIndexOHLCV': false,
-                'fetchMarginMode': false,
+                'fetchLedger': true,
                 'fetchMarkets': true,
-                'fetchMarkOHLCV': false,
                 'fetchOHLCV': true,
-                'fetchOpenInterestHistory': false,
                 'fetchOpenOrders': true,
-                'fetchOrder': true,
                 'fetchOrderBook': true,
-                'fetchOrders': true,
-                'fetchPosition': false,
-                'fetchPositionHistory': false,
-                'fetchPositionMode': false,
-                'fetchPositions': false,
-                'fetchPositionsForSymbol': false,
-                'fetchPositionsHistory': false,
-                'fetchPositionsRisk': false,
-                'fetchPremiumIndexOHLCV': false,
                 'fetchTicker': true,
                 'fetchTickers': true,
+                'fetchTime': true,
                 'fetchTrades': true,
-                'fetchTradingFee': false,
                 'fetchTradingFees': true,
-                'fetchTransactions': false,
-                'fetchTransfer': false,
-                'fetchTransfers': false,
-                'fetchWithdrawal': false,
-                'fetchWithdrawals': false,
-                'fetchWithdrawalWhitelist': false,
-                'reduceMargin': false,
-                'setLeverage': false,
-                'setMargin': false,
-                'setMarginMode': false,
-                'transfer': false,
-                'withdraw': false,
-            },
-            'timeframes': {
-                '1m': '1m',
-                '1h': '1h',
-                '1d': '1d',
+                'transfer': true,
             },
             'urls': {
                 'logo': 'https://user-images.githubusercontent.com/1294454/27766442-8ddc33b0-5ed8-11e7-8b98-f786aef0f3c9.jpg',
                 'api': {
-                    'rest': 'https://cex.io/api',
+                    'public': 'https://trade.cex.io/api/spot/rest-public',
+                    'private': 'https://trade.cex.io/api/spot/rest',
                 },
                 'www': 'https://cex.io',
-                'doc': 'https://cex.io/cex-api',
+                'doc': 'https://trade.cex.io/docs/',
                 'fees': [
                     'https://cex.io/fee-schedule',
                     'https://cex.io/limits-commissions',
                 ],
                 'referral': 'https://cex.io/r/0/up105393824/0/',
             },
-            'requiredCredentials': {
-                'apiKey': true,
-                'secret': true,
-                'uid': true,
-            },
             'api': {
                 'public': {
-                    'get': [
-                        'currency_profile',
-                        'currency_limits/',
-                        'last_price/{pair}/',
-                        'last_prices/{currencies}/',
-                        'ohlcv/hd/{yyyymmdd}/{pair}',
-                        'order_book/{pair}/',
-                        'ticker/{pair}/',
-                        'tickers/{currencies}/',
-                        'trade_history/{pair}/',
-                    ],
-                    'post': [
-                        'convert/{pair}',
-                        'price_stats/{pair}',
-                    ],
+                    'get': {},
+                    'post': {
+                        'get_server_time': 1,
+                        'get_pairs_info': 1,
+                        'get_currencies_info': 1,
+                        'get_processing_info': 10,
+                        'get_ticker': 1,
+                        'get_trade_history': 1,
+                        'get_order_book': 1,
+                        'get_candles': 1,
+                    },
                 },
                 'private': {
-                    'post': [
-                        'active_orders_status/',
-                        'archived_orders/{pair}/',
-                        'balance/',
-                        'cancel_order/',
-                        'cancel_orders/{pair}/',
-                        'cancel_replace_order/{pair}/',
-                        'close_position/{pair}/',
-                        'get_address/',
-                        'get_crypto_address',
-                        'get_myfee/',
-                        'get_order/',
-                        'get_order_tx/',
-                        'open_orders/{pair}/',
-                        'open_orders/',
-                        'open_position/{pair}/',
-                        'open_positions/{pair}/',
-                        'place_order/{pair}/',
-                        'raw_tx_history',
-                    ],
-                },
-            },
-            'fees': {
-                'trading': {
-                    'maker': this.parseNumber('0.0016'),
-                    'taker': this.parseNumber('0.0025'),
-                },
-                'funding': {
-                    'withdraw': {},
-                    'deposit': {
-                        // 'USD': amount => amount * 0.035 + 0.25,
-                        // 'EUR': amount => amount * 0.035 + 0.24,
-                        // 'RUB': amount => amount * 0.05 + 15.57,
-                        // 'GBP': amount => amount * 0.035 + 0.2,
-                        'BTC': 0.0,
-                        'ETH': 0.0,
-                        'BCH': 0.0,
-                        'DASH': 0.0,
-                        'BTG': 0.0,
-                        'ZEC': 0.0,
-                        'XRP': 0.0,
-                        'XLM': 0.0,
+                    'get': {},
+                    'post': {
+                        'get_my_current_fee': 5,
+                        'get_fee_strategy': 1,
+                        'get_my_volume': 5,
+                        'do_create_account': 1,
+                        'get_my_account_status_v3': 5,
+                        'get_my_wallet_balance': 5,
+                        'get_my_orders': 5,
+                        'do_my_new_order': 1,
+                        'do_cancel_my_order': 1,
+                        'do_cancel_all_orders': 5,
+                        'get_order_book': 1,
+                        'get_candles': 1,
+                        'get_trade_history': 1,
+                        'get_my_transaction_history': 1,
+                        'get_my_funding_history': 5,
+                        'do_my_internal_transfer': 1,
+                        'get_processing_info': 10,
+                        'get_deposit_address': 5,
+                        'do_deposit_funds_from_wallet': 1,
+                        'do_withdrawal_funds_to_wallet': 1,
                     },
                 },
             },
@@ -183,1520 +113,1516 @@ export default class cex extends Exchange {
             'exceptions': {
                 'exact': {},
                 'broad': {
+                    'You have negative balance on following accounts': InsufficientFunds,
+                    'Mandatory parameter side should be one of BUY,SELL': BadRequest,
+                    'API orders from Main account are not allowed': BadRequest,
+                    'check failed': BadRequest,
                     'Insufficient funds': InsufficientFunds,
-                    'Nonce must be incremented': InvalidNonce,
-                    'Invalid Order': InvalidOrder,
-                    'Order not found': OrderNotFound,
-                    'limit exceeded': RateLimitExceeded,
-                    'Invalid API key': AuthenticationError,
-                    'There was an error while placing your order': InvalidOrder,
-                    'Sorry, too many clients already': DDoSProtection,
-                    'Invalid Symbols Pair': BadSymbol,
-                    'Wrong currency pair': BadSymbol, // {"error":"There was an error while placing your order: Wrong currency pair.","safe":true}
+                    'Get deposit address for main account is not allowed': PermissionDenied,
+                    'Market Trigger orders are not allowed': BadRequest, // for some reason, triggerPrice does not work for market orders
                 },
             },
+            'timeframes': {
+                '1m': '1m',
+                '5m': '5m',
+                '15m': '15m',
+                '30m': '30m',
+                '1h': '1h',
+                '2h': '2h',
+                '4h': '4h',
+                '1d': '1d',
+            },
             'options': {
-                'fetchOHLCVWarning': true,
-                'createMarketBuyOrderRequiresPrice': true,
-                'order': {
-                    'status': {
-                        'c': 'canceled',
-                        'd': 'closed',
-                        'cd': 'canceled',
-                        'a': 'open',
-                    },
-                },
-                'defaultNetwork': 'ERC20',
-                'defaultNetworks': {
-                    'USDT': 'TRC20',
-                },
                 'networks': {
-                    'ERC20': 'Ethereum',
-                    'BTC': 'BTC',
-                    'BEP20': 'Binance Smart Chain',
-                    'TRC20': 'Tron',
+                    'BTC': 'bitcoin',
+                    'ERC20': 'ERC20',
+                    'BSC20': 'binancesmartchain',
+                    'DOGE': 'dogecoin',
+                    'ALGO': 'algorand',
+                    'XLM': 'stellar',
+                    'ATOM': 'cosmos',
+                    'LTC': 'litecoin',
+                    'XRP': 'ripple',
+                    'FTM': 'fantom',
+                    'MINA': 'mina',
+                    'THETA': 'theta',
+                    'XTZ': 'tezos',
+                    'TIA': 'celestia',
+                    'CRONOS': 'cronos',
+                    'MATIC': 'polygon',
+                    'TON': 'ton',
+                    'TRC20': 'tron',
+                    'SOLANA': 'solana',
+                    'SGB': 'songbird',
+                    'DYDX': 'dydx',
+                    'DASH': 'dash',
+                    'ZIL': 'zilliqa',
+                    'EOS': 'eos',
+                    'AVALANCHEC': 'avalanche',
+                    'ETHPOW': 'ethereumpow',
+                    'NEAR': 'near',
+                    'ARB': 'arbitrum',
+                    'DOT': 'polkadot',
+                    'OPT': 'optimism',
+                    'INJ': 'injective',
+                    'ADA': 'cardano',
+                    'ONT': 'ontology',
+                    'ICP': 'icp',
+                    'KAVA': 'kava',
+                    'KSM': 'kusama',
+                    'SEI': 'sei',
+                    // 'OSM': 'osmosis',
+                    'NEO': 'neo',
+                    'NEO3': 'neo3',
+                    // 'TERRAOLD': 'terra', // tbd
+                    // 'TERRA': 'terra2', // tbd
+                    // 'EVER': 'everscale', // tbd
+                    'XDC': 'xdc',
                 },
             },
         });
     }
-    async fetchCurrenciesFromCache(params = {}) {
-        // this method is now redundant
-        // currencies are now fetched before markets
-        const options = this.safeValue(this.options, 'fetchCurrencies', {});
-        const timestamp = this.safeInteger(options, 'timestamp');
-        const expires = this.safeInteger(options, 'expires', 1000);
-        const now = this.milliseconds();
-        if ((timestamp === undefined) || ((now - timestamp) > expires)) {
-            const response = await this.publicGetCurrencyProfile(params);
-            this.options['fetchCurrencies'] = this.extend(options, {
-                'response': response,
-                'timestamp': now,
-            });
-        }
-        return this.safeValue(this.options['fetchCurrencies'], 'response');
-    }
     async fetchCurrencies(params = {}) {
         /**
          * @method
          * @name cex#fetchCurrencies
          * @description fetches all available currencies on an exchange
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} an associative dictionary of currencies
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-currencies-info
+         * @param {dict} [params] extra parameters specific to the exchange API endpoint
+         * @returns {dict} an associative dictionary of currencies
          */
-        const response = await this.fetchCurrenciesFromCache(params);
-        this.options['currencies'] = {
-            'timestamp': this.milliseconds(),
-            'response': response,
-        };
+        const promises = [];
+        promises.push(this.publicPostGetCurrenciesInfo(params));
         //
-        //     {
-        //         "e":"currency_profile",
-        //         "ok":"ok",
-        //         "data":{
-        //             "symbols":[
-        //                 {
-        //                     "code":"GHS",
-        //                     "contract":true,
-        //                     "commodity":true,
-        //                     "fiat":false,
-        //                     "description":"CEX.IO doesn't provide cloud mining services anymore.",
-        //                     "precision":8,
-        //                     "scale":0,
-        //                     "minimumCurrencyAmount":"0.00000001",
-        //                     "minimalWithdrawalAmount":-1
-        //                 },
-        //                 {
-        //                     "code":"BTC",
-        //                     "contract":false,
-        //                     "commodity":false,
-        //                     "fiat":false,
-        //                     "description":"",
-        //                     "precision":8,
-        //                     "scale":0,
-        //                     "minimumCurrencyAmount":"0.00000001",
-        //                     "minimalWithdrawalAmount":0.002
-        //                 },
-        //                 {
-        //                     "code":"ETH",
-        //                     "contract":false,
-        //                     "commodity":false,
-        //                     "fiat":false,
-        //                     "description":"",
-        //                     "precision":8,
-        //                     "scale":2,
-        //                     "minimumCurrencyAmount":"0.00000100",
-        //                     "minimalWithdrawalAmount":0.01
-        //                 }
-        //             ],
-        //             "pairs":[
-        //                 {
-        //                     "symbol1":"BTC",
-        //                     "symbol2":"USD",
-        //                     "pricePrecision":1,
-        //                     "priceScale":"/1000000",
-        //                     "minLotSize":0.002,
-        //                     "minLotSizeS2":20
-        //                 },
-        //                 {
-        //                     "symbol1":"ETH",
-        //                     "symbol2":"USD",
-        //                     "pricePrecision":2,
-        //                     "priceScale":"/10000",
-        //                     "minLotSize":0.1,
-        //                     "minLotSizeS2":20
-        //                 }
-        //             ]
-        //         }
-        //     }
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "currency": "ZAP",
+        //                "fiat": false,
+        //                "precision": "8",
+        //                "walletPrecision": "6",
+        //                "walletDeposit": true,
+        //                "walletWithdrawal": true
+        //            },
+        //            ...
         //
-        const data = this.safeValue(response, 'data', []);
-        const currencies = this.safeValue(data, 'symbols', []);
-        const result = {};
-        for (let i = 0; i < currencies.length; i++) {
-            const currency = currencies[i];
-            const id = this.safeString(currency, 'code');
-            const code = this.safeCurrencyCode(id);
-            const active = true;
-            result[code] = {
-                'id': id,
-                'code': code,
-                'name': id,
-                'active': active,
-                'deposit': undefined,
-                'withdraw': undefined,
-                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'precision'))),
-                'fee': undefined,
+        promises.push(this.publicPostGetProcessingInfo(params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "ADA": {
+        //                "name": "Cardano",
+        //                "blockchains": {
+        //                    "cardano": {
+        //                        "type": "coin",
+        //                        "deposit": "enabled",
+        //                        "minDeposit": "1",
+        //                        "withdrawal": "enabled",
+        //                        "minWithdrawal": "5",
+        //                        "withdrawalFee": "1",
+        //                        "withdrawalFeePercent": "0",
+        //                        "depositConfirmations": "15"
+        //                    }
+        //                }
+        //            },
+        //            ...
+        //
+        const responses = await Promise.all(promises);
+        const dataCurrencies = this.safeList(responses[0], 'data', []);
+        const dataNetworks = this.safeDict(responses[1], 'data', {});
+        const currenciesIndexed = this.indexBy(dataCurrencies, 'currency');
+        const data = this.deepExtend(currenciesIndexed, dataNetworks);
+        return this.parseCurrencies(this.toArray(data));
+    }
+    parseCurrency(rawCurrency) {
+        const id = this.safeString(rawCurrency, 'currency');
+        const code = this.safeCurrencyCode(id);
+        const type = this.safeBool(rawCurrency, 'fiat') ? 'fiat' : 'crypto';
+        const currencyDepositEnabled = this.safeBool(rawCurrency, 'walletDeposit');
+        const currencyWithdrawEnabled = this.safeBool(rawCurrency, 'walletWithdrawal');
+        const currencyPrecision = this.parseNumber(this.parsePrecision(this.safeString(rawCurrency, 'precision')));
+        const networks = {};
+        const rawNetworks = this.safeDict(rawCurrency, 'blockchains', {});
+        const keys = Object.keys(rawNetworks);
+        for (let j = 0; j < keys.length; j++) {
+            const networkId = keys[j];
+            const rawNetwork = rawNetworks[networkId];
+            const networkCode = this.networkIdToCode(networkId);
+            const deposit = this.safeString(rawNetwork, 'deposit') === 'enabled';
+            const withdraw = this.safeString(rawNetwork, 'withdrawal') === 'enabled';
+            networks[networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'margin': undefined,
+                'deposit': deposit,
+                'withdraw': withdraw,
+                'fee': this.safeNumber(rawNetwork, 'withdrawalFee'),
+                'precision': currencyPrecision,
                 'limits': {
-                    'amount': {
-                        'min': this.safeNumber(currency, 'minimumCurrencyAmount'),
+                    'deposit': {
+                        'min': this.safeNumber(rawNetwork, 'minDeposit'),
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': this.safeNumber(currency, 'minimalWithdrawalAmount'),
+                        'min': this.safeNumber(rawNetwork, 'minWithdrawal'),
                         'max': undefined,
                     },
                 },
-                'info': currency,
+                'info': rawNetwork,
             };
         }
-        return result;
+        return this.safeCurrencyStructure({
+            'id': id,
+            'code': code,
+            'name': undefined,
+            'type': type,
+            'active': undefined,
+            'deposit': currencyDepositEnabled,
+            'withdraw': currencyWithdrawEnabled,
+            'fee': undefined,
+            'precision': currencyPrecision,
+            'limits': {
+                'amount': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+                'withdraw': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+            },
+            'networks': networks,
+            'info': rawCurrency,
+        });
     }
     async fetchMarkets(params = {}) {
         /**
          * @method
          * @name cex#fetchMarkets
-         * @description retrieves data on all markets for cex
+         * @description retrieves data on all markets for ace
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-pairs-info
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} an array of objects representing market data
          */
-        const currenciesResponse = await this.fetchCurrenciesFromCache(params);
-        const currenciesData = this.safeValue(currenciesResponse, 'data', {});
-        const currencies = this.safeValue(currenciesData, 'symbols', []);
-        const currenciesById = this.indexBy(currencies, 'code');
-        const pairs = this.safeValue(currenciesData, 'pairs', []);
-        const response = await this.publicGetCurrencyLimits(params);
+        const response = await this.publicPostGetPairsInfo(params);
         //
-        //     {
-        //         "e":"currency_limits",
-        //         "ok":"ok",
-        //         "data": {
-        //             "pairs":[
-        //                 {
-        //                     "symbol1":"BTC",
-        //                     "symbol2":"USD",
-        //                     "minLotSize":0.002,
-        //                     "minLotSizeS2":20,
-        //                     "maxLotSize":30,
-        //                     "minPrice":"1500",
-        //                     "maxPrice":"35000"
-        //                 },
-        //                 {
-        //                     "symbol1":"BCH",
-        //                     "symbol2":"EUR",
-        //                     "minLotSize":0.1,
-        //                     "minLotSizeS2":20,
-        //                     "maxLotSize":null,
-        //                     "minPrice":"25",
-        //                     "maxPrice":"8192"
-        //                 }
-        //             ]
-        //         }
-        //     }
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "base": "AI",
+        //                "quote": "USD",
+        //                "baseMin": "30",
+        //                "baseMax": "2516000",
+        //                "baseLotSize": "0.000001",
+        //                "quoteMin": "10",
+        //                "quoteMax": "1000000",
+        //                "quoteLotSize": "0.01000000",
+        //                "basePrecision": "6",
+        //                "quotePrecision": "8",
+        //                "pricePrecision": "4",
+        //                "minPrice": "0.0377",
+        //                "maxPrice": "19.5000"
+        //            },
+        //            ...
         //
-        const result = [];
-        const markets = this.safeValue(response['data'], 'pairs');
-        for (let i = 0; i < markets.length; i++) {
-            const market = markets[i];
-            const baseId = this.safeString(market, 'symbol1');
-            const quoteId = this.safeString(market, 'symbol2');
-            const base = this.safeCurrencyCode(baseId);
-            const quote = this.safeCurrencyCode(quoteId);
-            const baseCurrency = this.safeValue(currenciesById, baseId, {});
-            const quoteCurrency = this.safeValue(currenciesById, quoteId, {});
-            let pricePrecisionString = this.safeString(quoteCurrency, 'precision', '8');
-            for (let j = 0; j < pairs.length; j++) {
-                const pair = pairs[j];
-                if ((pair['symbol1'] === baseId) && (pair['symbol2'] === quoteId)) {
-                    // we might need to account for `priceScale` here
-                    pricePrecisionString = this.safeString(pair, 'pricePrecision', pricePrecisionString);
-                }
-            }
-            const baseCurrencyPrecision = this.safeString(baseCurrency, 'precision', '8');
-            const baseCurrencyScale = this.safeString(baseCurrency, 'scale', '0');
-            const amountPrecisionString = Precise.stringSub(baseCurrencyPrecision, baseCurrencyScale);
-            result.push({
-                'id': baseId + '/' + quoteId,
-                'symbol': base + '/' + quote,
-                'base': base,
-                'quote': quote,
-                'settle': undefined,
-                'baseId': baseId,
-                'quoteId': quoteId,
-                'settleId': undefined,
-                'type': 'spot',
-                'spot': true,
-                'margin': undefined,
-                'swap': false,
-                'future': false,
-                'option': false,
-                'active': undefined,
-                'contract': false,
-                'linear': undefined,
-                'inverse': undefined,
-                'contractSize': undefined,
-                'expiry': undefined,
-                'expiryDatetime': undefined,
-                'strike': undefined,
-                'optionType': undefined,
-                'precision': {
-                    'amount': this.parseNumber(this.parsePrecision(amountPrecisionString)),
-                    'price': this.parseNumber(this.parsePrecision(pricePrecisionString)),
+        const data = this.safeList(response, 'data', []);
+        return this.parseMarkets(data);
+    }
+    parseMarket(market) {
+        const baseId = this.safeString(market, 'base');
+        const base = this.safeCurrencyCode(baseId);
+        const quoteId = this.safeString(market, 'quote');
+        const quote = this.safeCurrencyCode(quoteId);
+        const id = base + '-' + quote; // not actual id, but for this exchange we can use this abbreviation, because e.g. tickers have hyphen in between
+        const symbol = base + '/' + quote;
+        return this.safeMarketStructure({
+            'id': id,
+            'symbol': symbol,
+            'base': base,
+            'baseId': baseId,
+            'quote': quote,
+            'quoteId': quoteId,
+            'settle': undefined,
+            'settleId': undefined,
+            'type': 'spot',
+            'spot': true,
+            'margin': false,
+            'swap': false,
+            'future': false,
+            'option': false,
+            'contract': false,
+            'linear': undefined,
+            'inverse': undefined,
+            'contractSize': undefined,
+            'expiry': undefined,
+            'expiryDatetime': undefined,
+            'strike': undefined,
+            'optionType': undefined,
+            'limits': {
+                'amount': {
+                    'min': this.safeNumber(market, 'baseMin'),
+                    'max': this.safeNumber(market, 'baseMax'),
                 },
-                'limits': {
-                    'leverage': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'amount': {
-                        'min': this.safeNumber(market, 'minLotSize'),
-                        'max': this.safeNumber(market, 'maxLotSize'),
-                    },
-                    'price': {
-                        'min': this.safeNumber(market, 'minPrice'),
-                        'max': this.safeNumber(market, 'maxPrice'),
-                    },
-                    'cost': {
-                        'min': this.safeNumber(market, 'minLotSizeS2'),
-                        'max': undefined,
-                    },
+                'price': {
+                    'min': this.safeNumber(market, 'minPrice'),
+                    'max': this.safeNumber(market, 'maxPrice'),
                 },
-                'created': undefined,
-                'info': market,
-            });
-        }
-        return result;
-    }
-    parseBalance(response) {
-        const result = { 'info': response };
-        const ommited = ['username', 'timestamp'];
-        const balances = this.omit(response, ommited);
-        const currencyIds = Object.keys(balances);
-        for (let i = 0; i < currencyIds.length; i++) {
-            const currencyId = currencyIds[i];
-            const balance = this.safeValue(balances, currencyId, {});
-            const account = this.account();
-            account['free'] = this.safeString(balance, 'available');
-            // https://github.com/ccxt/ccxt/issues/5484
-            account['used'] = this.safeString(balance, 'orders', '0');
-            const code = this.safeCurrencyCode(currencyId);
-            result[code] = account;
-        }
-        return this.safeBalance(result);
+                'cost': {
+                    'min': this.safeNumber(market, 'quoteMin'),
+                    'max': this.safeNumber(market, 'quoteMax'),
+                },
+                'leverage': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+            },
+            'precision': {
+                'amount': this.safeString(market, 'baseLotSize'),
+                'price': this.parseNumber(this.parsePrecision(this.safeString(market, 'pricePrecision'))),
+                // 'cost': this.parseNumber (this.parsePrecision (this.safeString (market, 'quoteLotSize'))), // buggy, doesn't reflect their documentation
+                'base': this.parseNumber(this.parsePrecision(this.safeString(market, 'basePrecision'))),
+                'quote': this.parseNumber(this.parsePrecision(this.safeString(market, 'quotePrecision'))),
+            },
+            'active': undefined,
+            'created': undefined,
+            'info': market,
+        });
     }
-    async fetchBalance(params = {}) {
+    async fetchTime(params = {}) {
         /**
          * @method
-         * @name cex#fetchBalance
-         * @see https://docs.cex.io/#account-balance
-         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @name cex#fetchTime
+         * @description fetches the current integer timestamp in milliseconds from the exchange server
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+         * @returns {int} the current integer timestamp in milliseconds from the exchange server
          */
-        await this.loadMarkets();
-        const response = await this.privatePostBalance(params);
-        return this.parseBalance(response);
+        const response = await this.publicPostGetServerTime(params);
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "timestamp": "1728472063472",
+        //            "ISODate": "2024-10-09T11:07:43.472Z"
+        //        }
+        //    }
+        //
+        const data = this.safeDict(response, 'data');
+        const timestamp = this.safeInteger(data, 'timestamp');
+        return timestamp;
     }
-    async fetchOrderBook(symbol, limit = undefined, params = {}) {
+    async fetchTicker(symbol, params = {}) {
         /**
          * @method
-         * @name cex#fetchOrderBook
-         * @see https://docs.cex.io/#orderbook
-         * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
-         * @param {string} symbol unified symbol of the market to fetch the order book for
-         * @param {int} [limit] the maximum amount of order book entries to return
+         * @name cex#fetchTicker
+         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-ticker
+         * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = {
-            'pair': market['id'],
-        };
-        if (limit !== undefined) {
-            request['depth'] = limit;
-        }
-        const response = await this.publicGetOrderBookPair(this.extend(request, params));
-        const timestamp = this.safeTimestamp(response, 'timestamp');
-        return this.parseOrderBook(response, market['symbol'], timestamp);
-    }
-    parseOHLCV(ohlcv, market = undefined) {
-        //
-        //     [
-        //         1591403940,
-        //         0.024972,
-        //         0.024972,
-        //         0.024969,
-        //         0.024969,
-        //         0.49999900
-        //     ]
-        //
-        return [
-            this.safeTimestamp(ohlcv, 0),
-            this.safeNumber(ohlcv, 1),
-            this.safeNumber(ohlcv, 2),
-            this.safeNumber(ohlcv, 3),
-            this.safeNumber(ohlcv, 4),
-            this.safeNumber(ohlcv, 5),
-        ];
+        const response = await this.fetchTickers([symbol], params);
+        return this.safeDict(response, symbol, {});
     }
-    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+    async fetchTickers(symbols = undefined, params = {}) {
         /**
          * @method
-         * @name cex#fetchOHLCV
-         * @see https://docs.cex.io/#historical-ohlcv-chart
-         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
-         * @param {string} timeframe the length of time each candle represents
-         * @param {int} [since] timestamp in ms of the earliest candle to fetch
-         * @param {int} [limit] the maximum amount of candles to fetch
+         * @name cex#fetchTickers
+         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-ticker
+         * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
-        const market = this.market(symbol);
-        if (since === undefined) {
-            since = this.milliseconds() - 86400000; // yesterday
-        }
-        else {
-            if (this.options['fetchOHLCVWarning']) {
-                throw new ExchangeError(this.id + " fetchOHLCV warning: CEX can return historical candles for a certain date only, this might produce an empty or null reply. Set exchange.options['fetchOHLCVWarning'] = false or add ({ 'options': { 'fetchOHLCVWarning': false }}) to constructor params to suppress this warning message.");
-            }
-        }
-        const request = {
-            'pair': market['id'],
-            'yyyymmdd': this.yyyymmdd(since, ''),
-        };
-        try {
-            const response = await this.publicGetOhlcvHdYyyymmddPair(this.extend(request, params));
-            //
-            //     {
-            //         "time":20200606,
-            //         "data1m":"[[1591403940,0.024972,0.024972,0.024969,0.024969,0.49999900]]",
-            //     }
-            //
-            const key = 'data' + this.safeString(this.timeframes, timeframe, timeframe);
-            const data = this.safeString(response, key);
-            const ohlcvs = JSON.parse(data);
-            return this.parseOHLCVs(ohlcvs, market, timeframe, since, limit);
-        }
-        catch (e) {
-            if (e instanceof NullResponse) {
-                return [];
-            }
+        const request = {};
+        if (symbols !== undefined) {
+            request['pairs'] = this.marketIds(symbols);
         }
-        return undefined;
+        const response = await this.publicPostGetTicker(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "AI-USD": {
+        //                "bestBid": "0.3917",
+        //                "bestAsk": "0.3949",
+        //                "bestBidChange": "0.0035",
+        //                "bestBidChangePercentage": "0.90",
+        //                "bestAskChange": "0.0038",
+        //                "bestAskChangePercentage": "0.97",
+        //                "low": "0.3787",
+        //                "high": "0.3925",
+        //                "volume30d": "2945.722277",
+        //                "lastTradeDateISO": "2024-10-11T06:18:42.077Z",
+        //                "volume": "120.736000",
+        //                "quoteVolume": "46.65654070",
+        //                "lastTradeVolume": "67.914000",
+        //                "volumeUSD": "46.65",
+        //                "last": "0.3949",
+        //                "lastTradePrice": "0.3925",
+        //                "priceChange": "0.0038",
+        //                "priceChangePercentage": "0.97"
+        //            },
+        //            ...
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseTickers(data, symbols);
     }
     parseTicker(ticker, market = undefined) {
-        const timestamp = this.safeTimestamp(ticker, 'timestamp');
-        const volume = this.safeString(ticker, 'volume');
-        const high = this.safeString(ticker, 'high');
-        const low = this.safeString(ticker, 'low');
-        const bid = this.safeString(ticker, 'bid');
-        const ask = this.safeString(ticker, 'ask');
-        const last = this.safeString(ticker, 'last');
-        const symbol = this.safeSymbol(undefined, market);
+        const marketId = this.safeString(ticker, 'id');
+        const symbol = this.safeSymbol(marketId, market);
         return this.safeTicker({
             'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'high': high,
-            'low': low,
-            'bid': bid,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'high': this.safeNumber(ticker, 'high'),
+            'low': this.safeNumber(ticker, 'low'),
+            'bid': this.safeNumber(ticker, 'bestBid'),
             'bidVolume': undefined,
-            'ask': ask,
+            'ask': this.safeNumber(ticker, 'bestAsk'),
             'askVolume': undefined,
             'vwap': undefined,
             'open': undefined,
-            'close': last,
-            'last': last,
+            'close': this.safeString(ticker, 'lastTradePrice'),
             'previousClose': undefined,
-            'change': undefined,
-            'percentage': undefined,
+            'change': this.safeNumber(ticker, 'priceChange'),
+            'percentage': this.safeNumber(ticker, 'priceChangePercentage'),
             'average': undefined,
-            'baseVolume': volume,
-            'quoteVolume': undefined,
+            'baseVolume': this.safeString(ticker, 'volume'),
+            'quoteVolume': this.safeString(ticker, 'quoteVolume'),
             'info': ticker,
         }, market);
     }
-    async fetchTickers(symbols = undefined, params = {}) {
-        /**
-         * @method
-         * @name cex#fetchTickers
-         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-         * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
-         */
-        await this.loadMarkets();
-        symbols = this.marketSymbols(symbols);
-        const currencies = Object.keys(this.currencies);
-        const request = {
-            'currencies': currencies.join('/'),
-        };
-        const response = await this.publicGetTickersCurrencies(this.extend(request, params));
-        const tickers = this.safeValue(response, 'data', []);
-        const result = {};
-        for (let t = 0; t < tickers.length; t++) {
-            const ticker = tickers[t];
-            const marketId = this.safeString(ticker, 'pair');
-            const market = this.safeMarket(marketId, undefined, ':');
-            const symbol = market['symbol'];
-            result[symbol] = this.parseTicker(ticker, market);
-        }
-        return this.filterByArrayTickers(result, 'symbol', symbols);
-    }
-    async fetchTicker(symbol, params = {}) {
+    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name cex#fetchTicker
-         * @see https://docs.cex.io/#ticker
-         * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @name cex#fetchTrades
+         * @description get the list of most recent trades for a particular symbol
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-trade-history
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {int} [since] timestamp in ms of the earliest trade to fetch
+         * @param {int} [limit] the maximum amount of trades to fetch
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         * @param {int} [params.until] timestamp in ms of the latest entry
+         * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
             'pair': market['id'],
         };
-        const ticker = await this.publicGetTickerPair(this.extend(request, params));
-        return this.parseTicker(ticker, market);
+        if (since !== undefined) {
+            request['fromDateISO'] = this.iso8601(since);
+        }
+        let until = undefined;
+        [until, params] = this.handleParamInteger2(params, 'until', 'till');
+        if (until !== undefined) {
+            request['toDateISO'] = this.iso8601(until);
+        }
+        if (limit !== undefined) {
+            request['pageSize'] = Math.min(limit, 10000); // has a bug, still returns more trades
+        }
+        const response = await this.publicPostGetTradeHistory(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "pageSize": "10",
+        //            "trades": [
+        //                {
+        //                    "tradeId": "1728630559823-0",
+        //                    "dateISO": "2024-10-11T07:09:19.823Z",
+        //                    "side": "SELL",
+        //                    "price": "60879.5",
+        //                    "amount": "0.00165962"
+        //                },
+        //                ... followed by older trades
+        //
+        const data = this.safeDict(response, 'data', {});
+        const trades = this.safeList(data, 'trades', []);
+        return this.parseTrades(trades, market, since, limit);
     }
     parseTrade(trade, market = undefined) {
         //
-        // fetchTrades (public)
+        // public fetchTrades
         //
-        //      {
-        //          "type": "sell",
-        //          "date": "1638401878",
-        //          "amount": "0.401000",
-        //          "price": "249",
-        //          "tid": "11922"
-        //      }
+        //                {
+        //                    "tradeId": "1728630559823-0",
+        //                    "dateISO": "2024-10-11T07:09:19.823Z",
+        //                    "side": "SELL",
+        //                    "price": "60879.5",
+        //                    "amount": "0.00165962"
+        //                },
         //
-        const timestamp = this.safeTimestamp(trade, 'date');
-        const id = this.safeString(trade, 'tid');
-        const type = undefined;
-        const side = this.safeString(trade, 'type');
-        const priceString = this.safeString(trade, 'price');
-        const amountString = this.safeString(trade, 'amount');
+        const dateStr = this.safeString(trade, 'dateISO');
+        const timestamp = this.parse8601(dateStr);
         market = this.safeMarket(undefined, market);
         return this.safeTrade({
             'info': trade,
-            'id': id,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'symbol': market['symbol'],
-            'type': type,
-            'side': side,
+            'id': this.safeString(trade, 'tradeId'),
             'order': undefined,
+            'type': undefined,
             'takerOrMaker': undefined,
-            'price': priceString,
-            'amount': amountString,
+            'side': this.safeStringLower(trade, 'side'),
+            'price': this.safeString(trade, 'price'),
+            'amount': this.safeString(trade, 'amount'),
             'cost': undefined,
             'fee': undefined,
         }, market);
     }
-    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+    async fetchOrderBook(symbol, limit = undefined, params = {}) {
         /**
          * @method
-         * @name cex#fetchTrades
-         * @see https://docs.cex.io/#trade-history
-         * @description get the list of most recent trades for a particular symbol
-         * @param {string} symbol unified symbol of the market to fetch trades for
-         * @param {int} [since] timestamp in ms of the earliest trade to fetch
-         * @param {int} [limit] the maximum amount of trades to fetch
+         * @name cex#fetchOrderBook
+         * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-order-book
+         * @param {string} symbol unified symbol of the market to fetch the order book for
+         * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'pair': market['id'],
+        };
+        const response = await this.publicPostGetOrderBook(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "timestamp": "1728636922648",
+        //            "currency1": "BTC",
+        //            "currency2": "USDT",
+        //            "bids": [
+        //                [
+        //                    "60694.1",
+        //                    "13.12849761"
+        //                ],
+        //                [
+        //                    "60694.0",
+        //                    "0.71829244"
+        //                ],
+        //                ...
+        //
+        const orderBook = this.safeDict(response, 'data', {});
+        const timestamp = this.safeInteger(orderBook, 'timestamp');
+        return this.parseOrderBook(orderBook, market['symbol'], timestamp);
+    }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchOHLCV
+         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-candles
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {int} [since] timestamp in ms of the earliest candle to fetch
+         * @param {int} [limit] the maximum amount of candles to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest entry
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
+        let dataType = undefined;
+        [dataType, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'dataType');
+        if (dataType === undefined) {
+            throw new ArgumentsRequired(this.id + ' fetchOHLCV requires a parameter "dataType" to be either "bestBid" or "bestAsk"');
+        }
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
             'pair': market['id'],
+            'resolution': this.timeframes[timeframe],
+            'dataType': dataType,
         };
-        const response = await this.publicGetTradeHistoryPair(this.extend(request, params));
-        return this.parseTrades(response, market, since, limit);
+        if (since !== undefined) {
+            request['fromISO'] = this.iso8601(since);
+        }
+        let until = undefined;
+        [until, params] = this.handleParamInteger2(params, 'until', 'till');
+        if (until !== undefined) {
+            request['toISO'] = this.iso8601(until);
+        }
+        else if (since === undefined) {
+            // exchange still requires that we provide one of them
+            request['toISO'] = this.iso8601(this.milliseconds());
+        }
+        if (since !== undefined && until !== undefined && limit !== undefined) {
+            throw new ArgumentsRequired(this.id + ' fetchOHLCV does not support fetching candles with both a limit and since/until');
+        }
+        else if ((since !== undefined || until !== undefined) && limit === undefined) {
+            throw new ArgumentsRequired(this.id + ' fetchOHLCV requires a limit parameter when fetching candles with since or until');
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        const response = await this.publicPostGetCandles(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "timestamp": "1728643320000",
+        //                "open": "61061",
+        //                "high": "61095.1",
+        //                "low": "61048.5",
+        //                "close": "61087.8",
+        //                "volume": "0",
+        //                "resolution": "1m",
+        //                "isClosed": true,
+        //                "timestampISO": "2024-10-11T10:42:00.000Z"
+        //            },
+        //            ...
+        //
+        const data = this.safeList(response, 'data', []);
+        return this.parseOHLCVs(data, market, timeframe, since, limit);
+    }
+    parseOHLCV(ohlcv, market = undefined) {
+        return [
+            this.safeInteger(ohlcv, 'timestamp'),
+            this.safeNumber(ohlcv, 'open'),
+            this.safeNumber(ohlcv, 'high'),
+            this.safeNumber(ohlcv, 'low'),
+            this.safeNumber(ohlcv, 'close'),
+            this.safeNumber(ohlcv, 'volume'),
+        ];
     }
     async fetchTradingFees(params = {}) {
         /**
          * @method
          * @name cex#fetchTradingFees
-         * @see https://docs.cex.io/#get-my-fee
          * @description fetch the trading fees for multiple markets
+         * @see https://trade.cex.io/docs/#rest-public-api-calls-candles
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a dictionary of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} indexed by market symbols
          */
         await this.loadMarkets();
-        const response = await this.privatePostGetMyfee(params);
+        const response = await this.privatePostGetMyCurrentFee(params);
         //
-        //      {
-        //          "e": "get_myfee",
-        //          "ok": "ok",
-        //          "data": {
-        //            'BTC:USD': { buy: '0.25', sell: '0.25', buyMaker: '0.15', sellMaker: "0.15" },
-        //            'ETH:USD': { buy: '0.25', sell: '0.25', buyMaker: '0.15', sellMaker: "0.15" },
-        //            ..
-        //          }
-        //      }
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "tradingFee": {
+        //                "AI-USD": {
+        //                    "percent": "0.25"
+        //                },
+        //                ...
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
+        const fees = this.safeDict(data, 'tradingFee', {});
+        return this.parseTradingFees(fees, true);
+    }
+    parseTradingFees(response, useKeyAsId = false) {
         const result = {};
+        const keys = Object.keys(response);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            let market = undefined;
+            if (useKeyAsId) {
+                market = this.safeMarket(key);
+            }
+            const parsed = this.parseTradingFee(response[key], market);
+            result[parsed['symbol']] = parsed;
+        }
         for (let i = 0; i < this.symbols.length; i++) {
             const symbol = this.symbols[i];
-            const market = this.market(symbol);
-            const fee = this.safeValue(data, market['id'], {});
-            const makerString = this.safeString(fee, 'buyMaker');
-            const takerString = this.safeString(fee, 'buy');
-            const maker = this.parseNumber(Precise.stringDiv(makerString, '100'));
-            const taker = this.parseNumber(Precise.stringDiv(takerString, '100'));
-            result[symbol] = {
-                'info': fee,
-                'symbol': symbol,
-                'maker': maker,
-                'taker': taker,
-                'percentage': true,
-            };
+            if (!(symbol in result)) {
+                const market = this.market(symbol);
+                result[symbol] = this.parseTradingFee(response, market);
+            }
         }
         return result;
     }
-    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+    parseTradingFee(fee, market = undefined) {
+        return {
+            'info': fee,
+            'symbol': this.safeString(market, 'symbol'),
+            'maker': this.safeNumber(fee, 'percent'),
+            'taker': this.safeNumber(fee, 'percent'),
+            'percentage': undefined,
+            'tierBased': undefined,
+        };
+    }
+    async fetchAccounts(params = {}) {
+        await this.loadMarkets();
+        const response = await this.privatePostGetMyAccountStatusV3(params);
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "convertedCurrency": "USD",
+        //            "balancesPerAccounts": {
+        //                "": {
+        //                    "AI": {
+        //                        "balance": "0.000000",
+        //                        "balanceOnHold": "0.000000"
+        //                    },
+        //                    "USDT": {
+        //                        "balance": "0.00000000",
+        //                        "balanceOnHold": "0.00000000"
+        //                    }
+        //                }
+        //            }
+        //        }
+        //    }
+        //
+        const data = this.safeDict(response, 'data', {});
+        const balances = this.safeDict(data, 'balancesPerAccounts', {});
+        const arrays = this.toArray(balances);
+        return this.parseAccounts(arrays, params);
+    }
+    parseAccount(account) {
+        return {
+            'id': undefined,
+            'type': undefined,
+            'code': undefined,
+            'info': account,
+        };
+    }
+    async fetchBalance(params = {}) {
         /**
          * @method
-         * @name cex#createOrder
-         * @see https://docs.cex.io/#place-order
-         * @description create a trade order
-         * @see https://cex.io/rest-api#place-order
-         * @param {string} symbol unified symbol of the market to create an order in
-         * @param {string} type 'market' or 'limit'
-         * @param {string} side 'buy' or 'sell'
-         * @param {float} amount how much of currency you want to trade in units of base currency
-         * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
+         * @name cex#fetchBalance
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-account-status-v3
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {float} [params.cost] the quote quantity that can be used as an alternative for the amount for market buy orders
-         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         * @param {object} [params.method] 'privatePostGetMyWalletBalance' or 'privatePostGetMyAccountStatusV3'
+         * @param {object} [params.account]  in case 'privatePostGetMyAccountStatusV3' is chosen, this can specify the account name (default is empty string)
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = {
-            'pair': market['id'],
-            'type': side,
-        };
-        // for market buy it requires the amount of quote currency to spend
-        if ((type === 'market') && (side === 'buy')) {
-            let quoteAmount = undefined;
-            let createMarketBuyOrderRequiresPrice = true;
-            [createMarketBuyOrderRequiresPrice, params] = this.handleOptionAndParams(params, 'createOrder', 'createMarketBuyOrderRequiresPrice', true);
-            const cost = this.safeString(params, 'cost');
-            params = this.omit(params, 'cost');
-            if (cost !== undefined) {
-                quoteAmount = this.costToPrecision(symbol, cost);
-            }
-            else if (createMarketBuyOrderRequiresPrice) {
-                if (price === undefined) {
-                    throw new InvalidOrder(this.id + ' createOrder() requires the price argument for market buy orders to calculate the total cost to spend (amount * price), alternatively set the createMarketBuyOrderRequiresPrice option or param to false and pass the cost to spend in the amount argument');
-                }
-                else {
-                    const amountString = this.numberToString(amount);
-                    const priceString = this.numberToString(price);
-                    const costRequest = Precise.stringMul(amountString, priceString);
-                    quoteAmount = this.costToPrecision(symbol, costRequest);
-                }
-            }
-            else {
-                quoteAmount = this.costToPrecision(symbol, amount);
-            }
-            request['amount'] = quoteAmount;
+        let accountName = undefined;
+        [accountName, params] = this.handleParamString(params, 'account', ''); // default is empty string
+        let method = undefined;
+        [method, params] = this.handleParamString(params, 'method', 'privatePostGetMyWalletBalance');
+        let accountBalance = undefined;
+        if (method === 'privatePostGetMyAccountStatusV3') {
+            const response = await this.privatePostGetMyAccountStatusV3(params);
+            //
+            //    {
+            //        "ok": "ok",
+            //        "data": {
+            //            "convertedCurrency": "USD",
+            //            "balancesPerAccounts": {
+            //                "": {
+            //                    "AI": {
+            //                        "balance": "0.000000",
+            //                        "balanceOnHold": "0.000000"
+            //                    },
+            //                    ....
+            //
+            const data = this.safeDict(response, 'data', {});
+            const balances = this.safeDict(data, 'balancesPerAccounts', {});
+            accountBalance = this.safeDict(balances, accountName, {});
         }
         else {
-            request['amount'] = this.amountToPrecision(symbol, amount);
+            const response = await this.privatePostGetMyWalletBalance(params);
+            //
+            //    {
+            //        "ok": "ok",
+            //        "data": {
+            //            "AI": {
+            //                "balance": "25.606429"
+            //            },
+            //            "USDT": {
+            //                "balance": "7.935449"
+            //            },
+            //            ...
+            //
+            accountBalance = this.safeDict(response, 'data', {});
         }
-        if (type === 'limit') {
-            request['price'] = this.numberToString(price);
+        return this.parseBalance(accountBalance);
+    }
+    parseBalance(response) {
+        const result = {
+            'info': response,
+        };
+        const keys = Object.keys(response);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const balance = this.safeDict(response, key, {});
+            const code = this.safeCurrencyCode(key);
+            const account = {
+                'used': this.safeString(balance, 'balanceOnHold'),
+                'free': this.safeString(balance, 'balance'),
+            };
+            result[code] = account;
         }
-        else {
-            request['order_type'] = type;
+        return this.safeBalance(result);
+    }
+    async fetchOrdersByStatus(status, symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchOrders
+         * @description fetches information on multiple orders made by the user
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-orders
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest entry
+         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const request = {};
+        const isClosedOrders = (status === 'closed');
+        if (isClosedOrders) {
+            request['archived'] = true;
         }
-        const response = await this.privatePostPlaceOrderPair(this.extend(request, params));
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['pair'] = market['id'];
+        }
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
+        }
+        if (since !== undefined) {
+            request['serverCreateTimestampFrom'] = since;
+        }
+        else if (isClosedOrders) {
+            // exchange requires a `since` parameter for closed orders, so set default to allowed 365
+            request['serverCreateTimestampFrom'] = this.milliseconds() - 364 * 24 * 60 * 60 * 1000;
+        }
+        let until = undefined;
+        [until, params] = this.handleParamInteger2(params, 'until', 'till');
+        if (until !== undefined) {
+            request['serverCreateTimestampTo'] = until;
+        }
+        const response = await this.privatePostGetMyOrders(this.extend(request, params));
         //
-        //     {
-        //         "id": "12978363524",
-        //         "time": 1586610022259,
-        //         "type": "buy",
-        //         "price": "0.033934",
-        //         "amount": "0.10722802",
-        //         "pending": "0.10722802",
-        //         "complete": false
-        //     }
+        // if called without `pair`
         //
-        const placedAmount = this.safeString(response, 'amount');
-        const remaining = this.safeString(response, 'pending');
-        const timestamp = this.safeValue(response, 'time');
-        const complete = this.safeValue(response, 'complete');
-        const status = complete ? 'closed' : 'open';
-        let filled = undefined;
-        if ((placedAmount !== undefined) && (remaining !== undefined)) {
-            filled = Precise.stringMax(Precise.stringSub(placedAmount, remaining), '0');
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "orderId": "1313003",
+        //                "clientOrderId": "037F0AFEB93A",
+        //                "clientId": "up421412345",
+        //                "accountId": null,
+        //                "status": "FILLED",
+        //                "statusIsFinal": true,
+        //                "currency1": "AI",
+        //                "currency2": "USDT",
+        //                "side": "BUY",
+        //                "orderType": "Market",
+        //                "timeInForce": "IOC",
+        //                "comment": null,
+        //                "rejectCode": null,
+        //                "rejectReason": null,
+        //                "initialOnHoldAmountCcy1": null,
+        //                "initialOnHoldAmountCcy2": "10.23456700",
+        //                "executedAmountCcy1": "25.606429",
+        //                "executedAmountCcy2": "10.20904439",
+        //                "requestedAmountCcy1": null,
+        //                "requestedAmountCcy2": "10.20904439",
+        //                "originalAmountCcy2": "10.23456700",
+        //                "feeAmount": "0.02552261",
+        //                "feeCurrency": "USDT",
+        //                "price": null,
+        //                "averagePrice": "0.3986",
+        //                "clientCreateTimestamp": "1728474625320",
+        //                "serverCreateTimestamp": "1728474624956",
+        //                "lastUpdateTimestamp": "1728474628015",
+        //                "expireTime": null,
+        //                "effectiveTime": null
+        //            },
+        //            ...
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseOrders(data, market, since, limit);
+    }
+    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchClosedOrders
+         * @description fetches information on multiple canceled orders made by the user
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] timestamp in ms of the earliest order, default is undefined
+         * @param {int} [limit] max number of orders to return, default is undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        return await this.fetchOrdersByStatus('closed', symbol, since, limit, params);
+    }
+    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchOpenOrders
+         * @description fetches information on multiple canceled orders made by the user
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] timestamp in ms of the earliest order, default is undefined
+         * @param {int} [limit] max number of orders to return, default is undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        return await this.fetchOrdersByStatus('open', symbol, since, limit, params);
+    }
+    parseOrderStatus(status) {
+        const statuses = {
+            'FILLED': 'closed',
+            'CANCELLED': 'canceled',
+        };
+        return this.safeString(statuses, status, undefined);
+    }
+    parseOrder(order, market = undefined) {
+        //
+        //                "orderId": "1313003",
+        //                "clientOrderId": "037F0AFEB93A",
+        //                "clientId": "up421412345",
+        //                "accountId": null,
+        //                "status": "FILLED",
+        //                "statusIsFinal": true,
+        //                "currency1": "AI",
+        //                "currency2": "USDT",
+        //                "side": "BUY",
+        //                "orderType": "Market",
+        //                "timeInForce": "IOC",
+        //                "comment": null,
+        //                "rejectCode": null,
+        //                "rejectReason": null,
+        //                "initialOnHoldAmountCcy1": null,
+        //                "initialOnHoldAmountCcy2": "10.23456700",
+        //                "executedAmountCcy1": "25.606429",
+        //                "executedAmountCcy2": "10.20904439",
+        //                "requestedAmountCcy1": null,
+        //                "requestedAmountCcy2": "10.20904439",
+        //                "originalAmountCcy2": "10.23456700",
+        //                "feeAmount": "0.02552261",
+        //                "feeCurrency": "USDT",
+        //                "price": null,
+        //                "averagePrice": "0.3986",
+        //                "clientCreateTimestamp": "1728474625320",
+        //                "serverCreateTimestamp": "1728474624956",
+        //                "lastUpdateTimestamp": "1728474628015",
+        //                "expireTime": null,
+        //                "effectiveTime": null
+        //
+        const currency1 = this.safeString(order, 'currency1');
+        const currency2 = this.safeString(order, 'currency2');
+        let marketId = undefined;
+        if (currency1 !== undefined && currency2 !== undefined) {
+            marketId = currency1 + '-' + currency2;
         }
+        market = this.safeMarket(marketId, market);
+        const symbol = market['symbol'];
+        const status = this.parseOrderStatus(this.safeString(order, 'status'));
+        const fee = {};
+        const feeAmount = this.safeNumber(order, 'feeAmount');
+        if (feeAmount !== undefined) {
+            const currencyId = this.safeString(order, 'feeCurrency');
+            const feeCode = this.safeCurrencyCode(currencyId);
+            fee['currency'] = feeCode;
+            fee['fee'] = feeAmount;
+        }
+        const timestamp = this.safeInteger(order, 'serverCreateTimestamp');
+        const requestedBase = this.safeNumber(order, 'requestedAmountCcy1');
+        const executedBase = this.safeNumber(order, 'executedAmountCcy1');
+        // const requestedQuote = this.safeNumber (order, 'requestedAmountCcy2');
+        const executedQuote = this.safeNumber(order, 'executedAmountCcy2');
         return this.safeOrder({
-            'id': this.safeString(response, 'id'),
-            'info': response,
-            'clientOrderId': undefined,
+            'id': this.safeString(order, 'orderId'),
+            'clientOrderId': this.safeString(order, 'clientOrderId'),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
+            'lastUpdateTimestamp': this.safeInteger(order, 'lastUpdateTimestamp'),
             'lastTradeTimestamp': undefined,
-            'type': type,
-            'side': this.safeString(response, 'type'),
-            'symbol': market['symbol'],
+            'symbol': symbol,
+            'type': this.safeStringLower(order, 'orderType'),
+            'timeInForce': this.safeString(order, 'timeInForce'),
+            'postOnly': undefined,
+            'side': this.safeStringLower(order, 'side'),
+            'price': this.safeNumber(order, 'price'),
+            'stopPrice': this.safeNumber(order, 'stopPrice'),
+            'amount': requestedBase,
+            'cost': executedQuote,
+            'average': this.safeNumber(order, 'averagePrice'),
+            'filled': executedBase,
+            'remaining': undefined,
             'status': status,
-            'price': this.safeString(response, 'price'),
-            'amount': placedAmount,
-            'cost': undefined,
-            'average': undefined,
-            'remaining': remaining,
-            'filled': filled,
-            'fee': undefined,
+            'fee': fee,
             'trades': undefined,
-        });
+            'info': order,
+        }, market);
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#createOrder
+         * @description create a trade order
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-new-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much of currency you want to trade in units of base currency
+         * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.accountId] account-id to use (default is empty string)
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        let accountId = undefined;
+        [accountId, params] = this.handleOptionAndParams(params, 'createOrder', 'accountId');
+        if (accountId === undefined) {
+            throw new ArgumentsRequired(this.id + ' createOrder() : API trading is now allowed from main account, set params["accountId"] or .options["createOrder"]["accountId"] to the name of your sub-account');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'clientOrderId': this.uuid(),
+            'currency1': market['baseId'],
+            'currency2': market['quoteId'],
+            'accountId': accountId,
+            'orderType': this.capitalize(type.toLowerCase()),
+            'side': side.toUpperCase(),
+            'timestamp': this.milliseconds(),
+            'amountCcy1': this.amountToPrecision(symbol, amount),
+        };
+        let timeInForce = undefined;
+        [timeInForce, params] = this.handleOptionAndParams(params, 'createOrder', 'timeInForce', 'GTC');
+        if (type === 'limit') {
+            request['price'] = this.priceToPrecision(symbol, price);
+            request['timeInForce'] = timeInForce;
+        }
+        let triggerPrice = undefined;
+        [triggerPrice, params] = this.handleParamString(params, 'triggerPrice');
+        if (triggerPrice !== undefined) {
+            request['type'] = 'Stop Limit';
+            request['stopPrice'] = triggerPrice;
+        }
+        const response = await this.privatePostDoMyNewOrder(this.extend(request, params));
+        //
+        // on success
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "messageType": "executionReport",
+        //            "clientId": "up132245425",
+        //            "orderId": "1318485",
+        //            "clientOrderId": "b5b6cd40-154c-4c1c-bd51-4a442f3d50b9",
+        //            "accountId": "sub1",
+        //            "status": "FILLED",
+        //            "currency1": "LTC",
+        //            "currency2": "USDT",
+        //            "side": "BUY",
+        //            "executedAmountCcy1": "0.23000000",
+        //            "executedAmountCcy2": "15.09030000",
+        //            "requestedAmountCcy1": "0.23000000",
+        //            "requestedAmountCcy2": null,
+        //            "orderType": "Market",
+        //            "timeInForce": null,
+        //            "comment": null,
+        //            "executionType": "Trade",
+        //            "executionId": "1726747124624_101_41116",
+        //            "transactTime": "2024-10-15T15:08:12.794Z",
+        //            "expireTime": null,
+        //            "effectiveTime": null,
+        //            "averagePrice": "65.61",
+        //            "lastQuantity": "0.23000000",
+        //            "lastAmountCcy1": "0.23000000",
+        //            "lastAmountCcy2": "15.09030000",
+        //            "lastPrice": "65.61",
+        //            "feeAmount": "0.03772575",
+        //            "feeCurrency": "USDT",
+        //            "clientCreateTimestamp": "1729004892014",
+        //            "serverCreateTimestamp": "1729004891628",
+        //            "lastUpdateTimestamp": "1729004892786"
+        //        }
+        //    }
+        //
+        // on failure, there are extra fields
+        //
+        //             "status": "REJECTED",
+        //             "requestedAmountCcy1": null,
+        //             "orderRejectReason": "{\\" code \\ ":405,\\" reason \\ ":\\" Either AmountCcy1(OrderQty)or AmountCcy2(CashOrderQty)should be specified for market order not both \\ "}",
+        //             "rejectCode": 405,
+        //             "rejectReason": "Either AmountCcy1 (OrderQty) or AmountCcy2 (CashOrderQty) should be specified for market order not both",
+        //
+        const data = this.safeDict(response, 'data');
+        return this.parseOrder(data, market);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**
          * @method
          * @name cex#cancelOrder
-         * @see https://docs.cex.io/#cancel-order
          * @description cancels an open order
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-cancel-order
          * @param {string} id order id
-         * @param {string} symbol not used by cex cancelOrder ()
+         * @param {string} symbol unified symbol of the market the order was made in
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
         const request = {
-            'id': id,
+            'orderId': parseInt(id),
+            'cancelRequestId': 'c_' + (this.milliseconds()).toString(),
+            'timestamp': this.milliseconds(),
         };
-        const response = await this.privatePostCancelOrder(this.extend(request, params));
-        // 'true'
-        return this.extend(this.parseOrder({}), { 'info': response, 'type': undefined, 'id': id, 'status': 'canceled' });
+        const response = await this.privatePostDoCancelMyOrder(this.extend(request, params));
+        //
+        //      {"ok":"ok","data":{}}
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseOrder(data);
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
         /**
          * @method
          * @name cex#cancelAllOrders
-         * @see https://docs.cex.io/#cancel-all-orders-for-given-pair
          * @description cancel all open orders in a market
-         * @param {string} symbol unified market symbol of the market to cancel orders in
-         * @param {object} [params] extra parameters specific to the cex api endpoint
-         * @param {string} [params.marginMode] 'cross' or 'isolated', for spot margin trading
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-cancel-all-orders
+         * @param {string} symbol alpaca cancelAllOrders cannot setting symbol, it will cancel all open orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
-        if (symbol === undefined) {
-            throw new ArgumentsRequired(this.id + ' cancelAllOrders requires a symbol.');
-        }
         await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = {
-            'pair': market['id'],
-        };
-        const orders = await this.privatePostCancelOrdersPair(this.extend(request, params));
+        const response = await this.privatePostDoCancelAllOrders(params);
         //
-        //  {
-        //      "e":"cancel_orders",
-        //      "ok":"ok",
-        //      "data":[
-        //      ]
-        //   }
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "clientOrderIds": [
+        //                "3AF77B67109F"
+        //            ]
+        //        }
+        //    }
         //
-        return orders;
-    }
-    parseOrder(order, market = undefined) {
-        // Depending on the call, 'time' can be a unix int, unix string or ISO string
-        // Yes, really
-        let timestamp = this.safeValue(order, 'time');
-        if (typeof timestamp === 'string' && timestamp.indexOf('T') >= 0) {
-            // ISO8601 string
-            timestamp = this.parse8601(timestamp);
+        const data = this.safeDict(response, 'data', {});
+        const ids = this.safeList(data, 'clientOrderIds', []);
+        const orders = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            orders.push({ 'clientOrderId': id });
         }
-        else if (timestamp !== undefined) {
-            // either integer or string integer
-            timestamp = parseInt(timestamp);
-        }
-        let symbol = undefined;
-        const baseId = this.safeString(order, 'symbol1');
-        const quoteId = this.safeString(order, 'symbol2');
-        if (market === undefined && baseId !== undefined && quoteId !== undefined) {
-            const base = this.safeCurrencyCode(baseId);
-            const quote = this.safeCurrencyCode(quoteId);
-            if ((base !== undefined) && (quote !== undefined)) {
-                symbol = base + '/' + quote;
-            }
-            if (symbol in this.markets) {
-                market = this.market(symbol);
-            }
+        return this.parseOrders(orders);
+    }
+    async fetchLedger(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchLedger
+         * @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-transaction-history
+         * @param {string} [code] unified currency code
+         * @param {int} [since] timestamp in ms of the earliest ledger entry
+         * @param {int} [limit] max number of ledger entries to return
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest ledger entry
+         * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger-structure}
+         */
+        await this.loadMarkets();
+        let currency = undefined;
+        const request = {};
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['currency'] = currency['id'];
         }
-        const status = this.parseOrderStatus(this.safeString(order, 'status'));
-        const price = this.safeString(order, 'price');
-        let amount = this.omitZero(this.safeString(order, 'amount'));
-        // sell orders can have a negative amount
-        // https://github.com/ccxt/ccxt/issues/5338
-        if (amount !== undefined) {
-            amount = Precise.stringAbs(amount);
+        if (since !== undefined) {
+            request['dateFrom'] = since;
         }
-        else if (market !== undefined) {
-            const amountKey = 'a:' + market['base'] + 'cds:';
-            amount = Precise.stringAbs(this.safeString(order, amountKey));
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
         }
-        const remaining = this.safeString2(order, 'pending', 'remains');
-        const filled = Precise.stringSub(amount, remaining);
-        let fee = undefined;
-        let cost = undefined;
-        if (market !== undefined) {
-            symbol = market['symbol'];
-            const taCost = this.safeString(order, 'ta:' + market['quote']);
-            const ttaCost = this.safeString(order, 'tta:' + market['quote']);
-            cost = Precise.stringAdd(taCost, ttaCost);
-            const baseFee = 'fa:' + market['base'];
-            const baseTakerFee = 'tfa:' + market['base'];
-            const quoteFee = 'fa:' + market['quote'];
-            const quoteTakerFee = 'tfa:' + market['quote'];
-            let feeRate = this.safeString(order, 'tradingFeeMaker');
-            if (!feeRate) {
-                feeRate = this.safeString(order, 'tradingFeeTaker', feeRate);
-            }
-            if (feeRate) {
-                feeRate = Precise.stringDiv(feeRate, '100'); // convert to mathematically-correct percentage coefficients: 1.0 = 100%
-            }
-            if ((baseFee in order) || (baseTakerFee in order)) {
-                const baseFeeCost = this.safeNumber2(order, baseFee, baseTakerFee);
-                fee = {
-                    'currency': market['base'],
-                    'rate': this.parseNumber(feeRate),
-                    'cost': baseFeeCost,
-                };
-            }
-            else if ((quoteFee in order) || (quoteTakerFee in order)) {
-                const quoteFeeCost = this.safeNumber2(order, quoteFee, quoteTakerFee);
-                fee = {
-                    'currency': market['quote'],
-                    'rate': this.parseNumber(feeRate),
-                    'cost': quoteFeeCost,
-                };
-            }
+        let until = undefined;
+        [until, params] = this.handleParamInteger2(params, 'until', 'till');
+        if (until !== undefined) {
+            request['dateTo'] = until;
         }
-        if (!cost) {
-            cost = Precise.stringMul(price, filled);
+        const response = await this.privatePostGetMyTransactionHistory(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "transactionId": "30367722",
+        //                "timestamp": "2024-10-14T14:08:49.987Z",
+        //                "accountId": "",
+        //                "type": "withdraw",
+        //                "amount": "-12.39060600",
+        //                "details": "Withdraw fundingId=1235039 clientId=up421412345 walletTxId=76337154166",
+        //                "currency": "USDT"
+        //            },
+        //            ...
+        //
+        const data = this.safeList(response, 'data', []);
+        return this.parseLedger(data, currency, since, limit);
+    }
+    parseLedgerEntry(item, currency = undefined) {
+        let amount = this.safeString(item, 'amount');
+        let direction = undefined;
+        if (Precise.stringLe(amount, '0')) {
+            direction = 'out';
+            amount = Precise.stringMul('-1', amount);
         }
-        const side = this.safeString(order, 'type');
-        let trades = undefined;
-        const orderId = this.safeString(order, 'id');
-        if ('vtx' in order) {
-            trades = [];
-            for (let i = 0; i < order['vtx'].length; i++) {
-                const item = order['vtx'][i];
-                const tradeSide = this.safeString(item, 'type');
-                if (tradeSide === 'cancel') {
-                    // looks like this might represent the cancelled part of an order
-                    //   { "id": "4426729543",
-                    //     "type": "cancel",
-                    //     "time": "2017-09-22T00:24:30.476Z",
-                    //     "user": "up106404164",
-                    //     "c": "user:up106404164:a:BCH",
-                    //     "d": "order:4426728375:a:BCH",
-                    //     "a": "0.09935956",
-                    //     "amount": "0.09935956",
-                    //     "balance": "0.42580261",
-                    //     "symbol": "BCH",
-                    //     "order": "4426728375",
-                    //     "buy": null,
-                    //     "sell": null,
-                    //     "pair": null,
-                    //     "pos": null,
-                    //     "cs": "0.42580261",
-                    //     "ds": 0 }
-                    continue;
-                }
-                const tradePrice = this.safeString(item, 'price');
-                if (tradePrice === undefined) {
-                    // this represents the order
-                    //   {
-                    //     "a": "0.47000000",
-                    //     "c": "user:up106404164:a:EUR",
-                    //     "d": "order:6065499239:a:EUR",
-                    //     "cs": "1432.93",
-                    //     "ds": "476.72",
-                    //     "id": "6065499249",
-                    //     "buy": null,
-                    //     "pos": null,
-                    //     "pair": null,
-                    //     "sell": null,
-                    //     "time": "2018-04-22T13:07:22.152Z",
-                    //     "type": "buy",
-                    //     "user": "up106404164",
-                    //     "order": "6065499239",
-                    //     "amount": "-715.97000000",
-                    //     "symbol": "EUR",
-                    //     "balance": "1432.93000000" }
-                    continue;
-                }
-                // todo: deal with these
-                if (tradeSide === 'costsNothing') {
-                    continue;
-                }
-                // --
-                // if (side !== tradeSide)
-                //     throw new Error (JSON.stringify (order, null, 2));
-                // if (orderId !== item['order'])
-                //     throw new Error (JSON.stringify (order, null, 2));
-                // --
-                // partial buy trade
-                //   {
-                //     "a": "0.01589885",
-                //     "c": "user:up106404164:a:BTC",
-                //     "d": "order:6065499239:a:BTC",
-                //     "cs": "0.36300000",
-                //     "ds": 0,
-                //     "id": "6067991213",
-                //     "buy": "6065499239",
-                //     "pos": null,
-                //     "pair": null,
-                //     "sell": "6067991206",
-                //     "time": "2018-04-22T23:09:11.773Z",
-                //     "type": "buy",
-                //     "user": "up106404164",
-                //     "order": "6065499239",
-                //     "price": 7146.5,
-                //     "amount": "0.01589885",
-                //     "symbol": "BTC",
-                //     "balance": "0.36300000",
-                //     "symbol2": "EUR",
-                //     "fee_amount": "0.19" }
-                // --
-                // trade with zero amount, but non-zero fee
-                //   {
-                //     "a": "0.00000000",
-                //     "c": "user:up106404164:a:EUR",
-                //     "d": "order:5840654423:a:EUR",
-                //     "cs": 559744,
-                //     "ds": 0,
-                //     "id": "5840654429",
-                //     "buy": "5807238573",
-                //     "pos": null,
-                //     "pair": null,
-                //     "sell": "5840654423",
-                //     "time": "2018-03-15T03:20:14.010Z",
-                //     "type": "sell",
-                //     "user": "up106404164",
-                //     "order": "5840654423",
-                //     "price": 730,
-                //     "amount": "0.00000000",
-                //     "symbol": "EUR",
-                //     "balance": "5597.44000000",
-                //     "symbol2": "BCH",
-                //     "fee_amount": "0.01" }
-                // --
-                // trade which should have an amount of exactly 0.002BTC
-                //   {
-                //     "a": "16.70000000",
-                //     "c": "user:up106404164:a:GBP",
-                //     "d": "order:9927386681:a:GBP",
-                //     "cs": "86.90",
-                //     "ds": 0,
-                //     "id": "9927401610",
-                //     "buy": "9927401601",
-                //     "pos": null,
-                //     "pair": null,
-                //     "sell": "9927386681",
-                //     "time": "2019-08-21T15:25:37.777Z",
-                //     "type": "sell",
-                //     "user": "up106404164",
-                //     "order": "9927386681",
-                //     "price": 8365,
-                //     "amount": "16.70000000",
-                //     "office": "UK",
-                //     "symbol": "GBP",
-                //     "balance": "86.90000000",
-                //     "symbol2": "BTC",
-                //     "fee_amount": "0.03"
-                //   }
-                const tradeTimestamp = this.parse8601(this.safeString(item, 'time'));
-                const tradeAmount = this.safeString(item, 'amount');
-                const feeCost = this.safeString(item, 'fee_amount');
-                let absTradeAmount = Precise.stringAbs(tradeAmount);
-                let tradeCost = undefined;
-                if (tradeSide === 'sell') {
-                    tradeCost = absTradeAmount;
-                    absTradeAmount = Precise.stringDiv(Precise.stringAdd(feeCost, tradeCost), tradePrice);
-                }
-                else {
-                    tradeCost = Precise.stringMul(absTradeAmount, tradePrice);
-                }
-                trades.push({
-                    'id': this.safeString(item, 'id'),
-                    'timestamp': tradeTimestamp,
-                    'datetime': this.iso8601(tradeTimestamp),
-                    'order': orderId,
-                    'symbol': symbol,
-                    'price': this.parseNumber(tradePrice),
-                    'amount': this.parseNumber(absTradeAmount),
-                    'cost': this.parseNumber(tradeCost),
-                    'side': tradeSide,
-                    'fee': {
-                        'cost': this.parseNumber(feeCost),
-                        'currency': market['quote'],
-                    },
-                    'info': item,
-                    'type': undefined,
-                    'takerOrMaker': undefined,
-                });
-            }
+        else {
+            direction = 'in';
         }
-        return this.safeOrder({
-            'info': order,
-            'id': orderId,
-            'clientOrderId': undefined,
-            'datetime': this.iso8601(timestamp),
+        const currencyId = this.safeString(item, 'currency');
+        currency = this.safeCurrency(currencyId, currency);
+        const code = this.safeCurrencyCode(currencyId, currency);
+        const timestampString = this.safeString(item, 'timestamp');
+        const timestamp = this.parse8601(timestampString);
+        const type = this.safeString(item, 'type');
+        return this.safeLedgerEntry({
+            'info': item,
+            'id': this.safeString(item, 'transactionId'),
+            'direction': direction,
+            'account': this.safeString(item, 'accountId', ''),
+            'referenceAccount': undefined,
+            'referenceId': undefined,
+            'type': this.parseLedgerEntryType(type),
+            'currency': code,
+            'amount': this.parseNumber(amount),
             'timestamp': timestamp,
-            'lastTradeTimestamp': undefined,
-            'status': status,
-            'symbol': symbol,
-            'type': (price === undefined) ? 'market' : 'limit',
-            'timeInForce': undefined,
-            'postOnly': undefined,
-            'side': side,
-            'price': price,
-            'stopPrice': undefined,
-            'triggerPrice': undefined,
-            'cost': cost,
-            'amount': amount,
-            'filled': filled,
-            'remaining': remaining,
-            'trades': trades,
-            'fee': fee,
-            'average': undefined,
-        });
+            'datetime': this.iso8601(timestamp),
+            'before': undefined,
+            'after': undefined,
+            'status': undefined,
+            'fee': undefined,
+        }, currency);
     }
-    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+    parseLedgerEntryType(type) {
+        const ledgerType = {
+            'deposit': 'deposit',
+            'withdraw': 'withdrawal',
+            'commission': 'fee',
+        };
+        return this.safeString(ledgerType, type, type);
+    }
+    async fetchDepositsWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name cex#fetchOpenOrders
-         * @see https://docs.cex.io/#open-orders
-         * @description fetch all unfilled currently open orders
-         * @param {string} symbol unified market symbol
-         * @param {int} [since] the earliest time in ms to fetch open orders for
-         * @param {int} [limit] the maximum number of  open orders structures to retrieve
+         * @name cex#fetchDepositsWithdrawals
+         * @description fetch history of deposits and withdrawals
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-funding-history
+         * @param {string} [code] unified currency code for the currency of the deposit/withdrawals, default is undefined
+         * @param {int} [since] timestamp in ms of the earliest deposit/withdrawal, default is undefined
+         * @param {int} [limit] max number of deposit/withdrawals to return, default is undefined
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         * @returns {object} a list of [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
          */
         await this.loadMarkets();
         const request = {};
-        let market = undefined;
-        let orders = undefined;
-        if (symbol !== undefined) {
-            market = this.market(symbol);
-            request['pair'] = market['id'];
-            orders = await this.privatePostOpenOrdersPair(this.extend(request, params));
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
         }
-        else {
-            orders = await this.privatePostOpenOrders(this.extend(request, params));
+        if (since !== undefined) {
+            request['dateFrom'] = since;
+        }
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
         }
-        for (let i = 0; i < orders.length; i++) {
-            orders[i] = this.extend(orders[i], { 'status': 'open' });
+        let until = undefined;
+        [until, params] = this.handleParamInteger2(params, 'until', 'till');
+        if (until !== undefined) {
+            request['dateTo'] = until;
         }
-        return this.parseOrders(orders, market, since, limit);
+        const response = await this.privatePostGetMyFundingHistory(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": [
+        //            {
+        //                "clientId": "up421412345",
+        //                "accountId": "",
+        //                "currency": "USDT",
+        //                "direction": "withdraw",
+        //                "amount": "12.39060600",
+        //                "commissionAmount": "0.00000000",
+        //                "status": "approved",
+        //                "updatedAt": "2024-10-14T14:08:50.013Z",
+        //                "txId": "30367718",
+        //                "details": {}
+        //            },
+        //            ...
+        //
+        const data = this.safeList(response, 'data', []);
+        return this.parseTransactions(data, currency, since, limit);
     }
-    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+    parseTransaction(transaction, currency = undefined) {
+        const currencyId = this.safeString(transaction, 'currency');
+        const direction = this.safeString(transaction, 'direction');
+        const type = (direction === 'withdraw') ? 'withdrawal' : 'deposit';
+        const code = this.safeCurrencyCode(currencyId, currency);
+        const updatedAt = this.safeString(transaction, 'updatedAt');
+        const timestamp = this.parse8601(updatedAt);
+        return {
+            'info': transaction,
+            'id': this.safeString(transaction, 'txId'),
+            'txid': undefined,
+            'type': type,
+            'currency': code,
+            'network': undefined,
+            'amount': this.safeNumber(transaction, 'amount'),
+            'status': this.parseTransactionStatus(this.safeString(transaction, 'status')),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'address': undefined,
+            'addressFrom': undefined,
+            'addressTo': undefined,
+            'tag': undefined,
+            'tagFrom': undefined,
+            'tagTo': undefined,
+            'updated': undefined,
+            'comment': undefined,
+            'fee': {
+                'currency': code,
+                'cost': this.safeNumber(transaction, 'commissionAmount'),
+            },
+            'internal': undefined,
+        };
+    }
+    parseTransactionStatus(status) {
+        const statuses = {
+            'rejected': 'rejected',
+            'pending': 'pending',
+            'approved': 'ok',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    async transfer(code, amount, fromAccount, toAccount, params = {}) {
         /**
          * @method
-         * @name cex#fetchClosedOrders
-         * @see https://docs.cex.io/#archived-orders
-         * @description fetches information on multiple closed orders made by the user
-         * @param {string} symbol unified market symbol of the market orders were made in
-         * @param {int} [since] the earliest time in ms to fetch orders for
-         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @name cex#transfer
+         * @description transfer currency internally between wallets on the same account
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-internal-transfer
+         * @param {string} code unified currency code
+         * @param {float} amount amount to transfer
+         * @param {string} fromAccount 'SPOT', 'FUND', or 'CONTRACT'
+         * @param {string} toAccount 'SPOT', 'FUND', or 'CONTRACT'
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
          */
-        if (symbol === undefined) {
-            throw new ArgumentsRequired(this.id + ' fetchClosedOrders() requires a symbol argument');
+        let transfer = undefined;
+        if (toAccount !== '' && fromAccount !== '') {
+            transfer = await this.transferBetweenSubAccounts(code, amount, fromAccount, toAccount, params);
         }
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = { 'pair': market['id'] };
-        const response = await this.privatePostArchivedOrdersPair(this.extend(request, params));
-        return this.parseOrders(response, market, since, limit);
+        else {
+            transfer = await this.transferBetweenMainAndSubAccount(code, amount, fromAccount, toAccount, params);
+        }
+        const fillResponseFromRequest = this.handleOption('transfer', 'fillResponseFromRequest', true);
+        if (fillResponseFromRequest) {
+            transfer['fromAccount'] = fromAccount;
+            transfer['toAccount'] = toAccount;
+        }
+        return transfer;
     }
-    async fetchOrder(id, symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name cex#fetchOrder
-         * @see https://docs.cex.io/?python#get-order-details
-         * @description fetches information on an order made by the user
-         * @param {string} id the order id
-         * @param {string} symbol not used by cex fetchOrder
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
+    async transferBetweenMainAndSubAccount(code, amount, fromAccount, toAccount, params = {}) {
         await this.loadMarkets();
+        const currency = this.currency(code);
+        const fromMain = (fromAccount === '');
+        const targetAccount = fromMain ? toAccount : fromAccount;
+        const guid = this.safeString(params, 'guid', this.uuid());
         const request = {
-            'id': id.toString(),
+            'currency': currency['id'],
+            'amount': this.currencyToPrecision(code, amount),
+            'accountId': targetAccount,
+            'clientTxId': guid,
         };
-        const response = await this.privatePostGetOrderTx(this.extend(request, params));
-        const data = this.safeValue(response, 'data', {});
+        let response = undefined;
+        if (fromMain) {
+            response = await this.privatePostDoDepositFundsFromWallet(this.extend(request, params));
+        }
+        else {
+            response = await this.privatePostDoWithdrawalFundsToWallet(this.extend(request, params));
+        }
+        // both endpoints return the same structure, the only difference is that
+        // the "accountId" is filled with the "subAccount"
         //
         //     {
-        //         "id": "5442731603",
-        //         "type": "sell",
-        //         "time": 1516132358071,
-        //         "lastTxTime": 1516132378452,
-        //         "lastTx": "5442734452",
-        //         "pos": null,
-        //         "user": "up106404164",
-        //         "status": "d",
-        //         "symbol1": "ETH",
-        //         "symbol2": "EUR",
-        //         "amount": "0.50000000",
-        //         "kind": "api",
-        //         "price": "923.3386",
-        //         "tfacf": "1",
-        //         "fa:EUR": "0.55",
-        //         "ta:EUR": "369.77",
-        //         "remains": "0.00000000",
-        //         "tfa:EUR": "0.22",
-        //         "tta:EUR": "91.95",
-        //         "a:ETH:cds": "0.50000000",
-        //         "a:EUR:cds": "461.72",
-        //         "f:EUR:cds": "0.77",
-        //         "tradingFeeMaker": "0.15",
-        //         "tradingFeeTaker": "0.23",
-        //         "tradingFeeStrategy": "userVolumeAmount",
-        //         "tradingFeeUserVolumeAmount": "2896912572",
-        //         "orderId": "5442731603",
-        //         "next": false,
-        //         "vtx": [
-        //             {
-        //                 "id": "5442734452",
-        //                 "type": "sell",
-        //                 "time": "2018-01-16T19:52:58.452Z",
-        //                 "user": "up106404164",
-        //                 "c": "user:up106404164:a:EUR",
-        //                 "d": "order:5442731603:a:EUR",
-        //                 "a": "104.53000000",
-        //                 "amount": "104.53000000",
-        //                 "balance": "932.71000000",
-        //                 "symbol": "EUR",
-        //                 "order": "5442731603",
-        //                 "buy": "5442734443",
-        //                 "sell": "5442731603",
-        //                 "pair": null,
-        //                 "pos": null,
-        //                 "office": null,
-        //                 "cs": "932.71",
-        //                 "ds": 0,
-        //                 "price": 923.3386,
-        //                 "symbol2": "ETH",
-        //                 "fee_amount": "0.16"
-        //             },
-        //             {
-        //                 "id": "5442731609",
-        //                 "type": "sell",
-        //                 "time": "2018-01-16T19:52:38.071Z",
-        //                 "user": "up106404164",
-        //                 "c": "user:up106404164:a:EUR",
-        //                 "d": "order:5442731603:a:EUR",
-        //                 "a": "91.73000000",
-        //                 "amount": "91.73000000",
-        //                 "balance": "563.49000000",
-        //                 "symbol": "EUR",
-        //                 "order": "5442731603",
-        //                 "buy": "5442618127",
-        //                 "sell": "5442731603",
-        //                 "pair": null,
-        //                 "pos": null,
-        //                 "office": null,
-        //                 "cs": "563.49",
-        //                 "ds": 0,
-        //                 "price": 924.0092,
-        //                 "symbol2": "ETH",
-        //                 "fee_amount": "0.22"
-        //             },
-        //             {
-        //                 "id": "5442731604",
-        //                 "type": "sell",
-        //                 "time": "2018-01-16T19:52:38.071Z",
-        //                 "user": "up106404164",
-        //                 "c": "order:5442731603:a:ETH",
-        //                 "d": "user:up106404164:a:ETH",
-        //                 "a": "0.50000000",
-        //                 "amount": "-0.50000000",
-        //                 "balance": "15.80995000",
-        //                 "symbol": "ETH",
-        //                 "order": "5442731603",
-        //                 "buy": null,
-        //                 "sell": null,
-        //                 "pair": null,
-        //                 "pos": null,
-        //                 "office": null,
-        //                 "cs": "0.50000000",
-        //                 "ds": "15.80995000"
-        //             }
-        //         ]
+        //         "ok": "ok",
+        //         "data": {
+        //             "accountId": "sub1",
+        //             "clientTxId": "27ba8284-67cf-4386-9ec7-80b3871abd45",
+        //             "currency": "USDT",
+        //             "status": "approved"
+        //         }
         //     }
         //
-        return this.parseOrder(data);
+        const data = this.safeDict(response, 'data', {});
+        return this.parseTransfer(data, currency);
     }
-    async fetchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name cex#fetchOrders
-         * @see https://docs.cex.io/#archived-orders
-         * @description fetches information on multiple orders made by the user
-         * @param {string} symbol unified market symbol of the market orders were made in
-         * @param {int} [since] the earliest time in ms to fetch orders for
-         * @param {int} [limit] the maximum number of order structures to retrieve
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
+    async transferBetweenSubAccounts(code, amount, fromAccount, toAccount, params = {}) {
         await this.loadMarkets();
-        const market = this.market(symbol);
+        const currency = this.currency(code);
         const request = {
-            'limit': limit,
-            'pair': market['id'],
-            'dateFrom': since,
+            'currency': currency['id'],
+            'amount': this.currencyToPrecision(code, amount),
+            'fromAccountId': fromAccount,
+            'toAccountId': toAccount,
         };
-        const response = await this.privatePostArchivedOrdersPair(this.extend(request, params));
-        const results = [];
-        for (let i = 0; i < response.length; i++) {
-            // cancelled (unfilled):
-            //    { "id": "4005785516",
-            //     "type": "sell",
-            //     "time": "2017-07-18T19:08:34.223Z",
-            //     "lastTxTime": "2017-07-18T19:08:34.396Z",
-            //     "lastTx": "4005785522",
-            //     "pos": null,
-            //     "status": "c",
-            //     "symbol1": "ETH",
-            //     "symbol2": "GBP",
-            //     "amount": "0.20000000",
-            //     "price": "200.5625",
-            //     "remains": "0.20000000",
-            //     'a:ETH:cds': "0.20000000",
-            //     "tradingFeeMaker": "0",
-            //     "tradingFeeTaker": "0.16",
-            //     "tradingFeeUserVolumeAmount": "10155061217",
-            //     "orderId": "4005785516" }
-            // --
-            // cancelled (partially filled buy):
-            //    { "id": "4084911657",
-            //     "type": "buy",
-            //     "time": "2017-08-05T03:18:39.596Z",
-            //     "lastTxTime": "2019-03-19T17:37:46.404Z",
-            //     "lastTx": "8459265833",
-            //     "pos": null,
-            //     "status": "cd",
-            //     "symbol1": "BTC",
-            //     "symbol2": "GBP",
-            //     "amount": "0.05000000",
-            //     "price": "2241.4692",
-            //     "tfacf": "1",
-            //     "remains": "0.03910535",
-            //     'tfa:GBP': "0.04",
-            //     'tta:GBP': "24.39",
-            //     'a:BTC:cds': "0.01089465",
-            //     'a:GBP:cds': "112.26",
-            //     'f:GBP:cds': "0.04",
-            //     "tradingFeeMaker": "0",
-            //     "tradingFeeTaker": "0.16",
-            //     "tradingFeeUserVolumeAmount": "13336396963",
-            //     "orderId": "4084911657" }
-            // --
-            // cancelled (partially filled sell):
-            //    { "id": "4426728375",
-            //     "type": "sell",
-            //     "time": "2017-09-22T00:24:20.126Z",
-            //     "lastTxTime": "2017-09-22T00:24:30.476Z",
-            //     "lastTx": "4426729543",
-            //     "pos": null,
-            //     "status": "cd",
-            //     "symbol1": "BCH",
-            //     "symbol2": "BTC",
-            //     "amount": "0.10000000",
-            //     "price": "0.11757182",
-            //     "tfacf": "1",
-            //     "remains": "0.09935956",
-            //     'tfa:BTC': "0.00000014",
-            //     'tta:BTC': "0.00007537",
-            //     'a:BCH:cds': "0.10000000",
-            //     'a:BTC:cds': "0.00007537",
-            //     'f:BTC:cds': "0.00000014",
-            //     "tradingFeeMaker": "0",
-            //     "tradingFeeTaker": "0.18",
-            //     "tradingFeeUserVolumeAmount": "3466715450",
-            //     "orderId": "4426728375" }
-            // --
-            // filled:
-            //    { "id": "5342275378",
-            //     "type": "sell",
-            //     "time": "2018-01-04T00:28:12.992Z",
-            //     "lastTxTime": "2018-01-04T00:28:12.992Z",
-            //     "lastTx": "5342275393",
-            //     "pos": null,
-            //     "status": "d",
-            //     "symbol1": "BCH",
-            //     "symbol2": "BTC",
-            //     "amount": "0.10000000",
-            //     "kind": "api",
-            //     "price": "0.17",
-            //     "remains": "0.00000000",
-            //     'tfa:BTC': "0.00003902",
-            //     'tta:BTC': "0.01699999",
-            //     'a:BCH:cds': "0.10000000",
-            //     'a:BTC:cds': "0.01699999",
-            //     'f:BTC:cds': "0.00003902",
-            //     "tradingFeeMaker": "0.15",
-            //     "tradingFeeTaker": "0.23",
-            //     "tradingFeeUserVolumeAmount": "1525951128",
-            //     "orderId": "5342275378" }
-            // --
-            // market order (buy):
-            //    { "id": "6281946200",
-            //     "pos": null,
-            //     "time": "2018-05-23T11:55:43.467Z",
-            //     "type": "buy",
-            //     "amount": "0.00000000",
-            //     "lastTx": "6281946210",
-            //     "status": "d",
-            //     "amount2": "20.00",
-            //     "orderId": "6281946200",
-            //     "remains": "0.00000000",
-            //     "symbol1": "ETH",
-            //     "symbol2": "EUR",
-            //     "tfa:EUR": "0.05",
-            //     "tta:EUR": "19.94",
-            //     "a:ETH:cds": "0.03764100",
-            //     "a:EUR:cds": "20.00",
-            //     "f:EUR:cds": "0.05",
-            //     "lastTxTime": "2018-05-23T11:55:43.467Z",
-            //     "tradingFeeTaker": "0.25",
-            //     "tradingFeeUserVolumeAmount": "55998097" }
-            // --
-            // market order (sell):
-            //   { "id": "6282200948",
-            //     "pos": null,
-            //     "time": "2018-05-23T12:42:58.315Z",
-            //     "type": "sell",
-            //     "amount": "-0.05000000",
-            //     "lastTx": "6282200958",
-            //     "status": "d",
-            //     "orderId": "6282200948",
-            //     "remains": "0.00000000",
-            //     "symbol1": "ETH",
-            //     "symbol2": "EUR",
-            //     "tfa:EUR": "0.07",
-            //     "tta:EUR": "26.49",
-            //     "a:ETH:cds": "0.05000000",
-            //     "a:EUR:cds": "26.49",
-            //     "f:EUR:cds": "0.07",
-            //     "lastTxTime": "2018-05-23T12:42:58.315Z",
-            //     "tradingFeeTaker": "0.25",
-            //     "tradingFeeUserVolumeAmount": "56294576" }
-            const order = response[i];
-            const status = this.parseOrderStatus(this.safeString(order, 'status'));
-            const baseId = this.safeString(order, 'symbol1');
-            const quoteId = this.safeString(order, 'symbol2');
-            const base = this.safeCurrencyCode(baseId);
-            const quote = this.safeCurrencyCode(quoteId);
-            const symbolInner = base + '/' + quote;
-            const side = this.safeString(order, 'type');
-            const baseAmount = this.safeNumber(order, 'a:' + baseId + ':cds');
-            const quoteAmount = this.safeNumber(order, 'a:' + quoteId + ':cds');
-            const fee = this.safeNumber(order, 'f:' + quoteId + ':cds');
-            const amount = this.safeString(order, 'amount');
-            const price = this.safeString(order, 'price');
-            const remaining = this.safeString(order, 'remains');
-            const filled = Precise.stringSub(amount, remaining);
-            let orderAmount = undefined;
-            let cost = undefined;
-            let average = undefined;
-            let type = undefined;
-            if (!price) {
-                type = 'market';
-                orderAmount = baseAmount;
-                cost = quoteAmount;
-                average = Precise.stringDiv(orderAmount, cost);
-            }
-            else {
-                const ta = this.safeString(order, 'ta:' + quoteId, '0');
-                const tta = this.safeString(order, 'tta:' + quoteId, '0');
-                const fa = this.safeString(order, 'fa:' + quoteId, '0');
-                const tfa = this.safeString(order, 'tfa:' + quoteId, '0');
-                if (side === 'sell') {
-                    cost = Precise.stringAdd(Precise.stringAdd(ta, tta), Precise.stringAdd(fa, tfa));
-                }
-                else {
-                    cost = Precise.stringSub(Precise.stringAdd(ta, tta), Precise.stringAdd(fa, tfa));
-                }
-                type = 'limit';
-                orderAmount = amount;
-                average = Precise.stringDiv(cost, filled);
-            }
-            const time = this.safeString(order, 'time');
-            const lastTxTime = this.safeString(order, 'lastTxTime');
-            const timestamp = this.parse8601(time);
-            const safeOrder = this.safeOrder({
-                'info': order,
-                'id': this.safeString(order, 'id'),
-                'timestamp': timestamp,
-                'datetime': this.iso8601(timestamp),
-                'lastUpdated': this.parse8601(lastTxTime),
-                'status': status,
-                'symbol': symbolInner,
-                'side': side,
-                'price': price,
-                'amount': orderAmount,
-                'average': average,
-                'type': type,
-                'filled': filled,
-                'cost': cost,
-                'remaining': remaining,
-                'fee': {
-                    'cost': fee,
-                    'currency': quote,
-                },
-            });
-            results.push(safeOrder);
-        }
-        return results;
-    }
-    parseOrderStatus(status) {
-        return this.safeString(this.options['order']['status'], status, status);
+        const response = await this.privatePostDoMyInternalTransfer(this.extend(request, params));
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "transactionId": "30225415"
+        //        }
+        //    }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseTransfer(data, currency);
     }
-    async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
-        /**
-         * @method
-         * @name cex#editOrderWs
-         * @description edit a trade order
-         * @see https://docs.cex.io/#cancel-replace-order
-         * @param {string} id order id
-         * @param {string} symbol unified symbol of the market to create an order in
-         * @param {string} type 'market' or 'limit'
-         * @param {string} side 'buy' or 'sell'
-         * @param {float} amount how much of the currency you want to trade in units of the base currency
-         * @param {float|undefined} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
-         * @param {object} [params] extra parameters specific to the cex api endpoint
-         * @returns {object} an [order structure]{@link https://docs.ccxt.com/en/latest/manual.html#order-structure}
-         */
-        if (amount === undefined) {
-            throw new ArgumentsRequired(this.id + ' editOrder() requires a amount argument');
-        }
-        if (price === undefined) {
-            throw new ArgumentsRequired(this.id + ' editOrder() requires a price argument');
-        }
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        // see: https://cex.io/rest-api#/definitions/CancelReplaceOrderRequest
-        const request = {
-            'pair': market['id'],
-            'type': side,
-            'amount': amount,
-            'price': price,
-            'order_id': id,
+    parseTransfer(transfer, currency = undefined) {
+        //
+        // transferBetweenSubAccounts
+        //
+        //    {
+        //        "ok": "ok",
+        //        "data": {
+        //            "transactionId": "30225415"
+        //        }
+        //    }
+        //
+        // transfer between main/sub
+        //
+        //     {
+        //         "ok": "ok",
+        //         "data": {
+        //             "accountId": "sub1",
+        //             "clientTxId": "27ba8284-67cf-4386-9ec7-80b3871abd45",
+        //             "currency": "USDT",
+        //             "status": "approved"
+        //         }
+        //     }
+        //
+        const currencyId = this.safeString(transfer, 'currency');
+        const currencyCode = this.safeCurrencyCode(currencyId, currency);
+        return {
+            'info': transfer,
+            'id': this.safeString2(transfer, 'transactionId', 'clientTxId'),
+            'timestamp': undefined,
+            'datetime': undefined,
+            'currency': currencyCode,
+            'amount': undefined,
+            'fromAccount': undefined,
+            'toAccount': undefined,
+            'status': this.parseTransactionStatus(this.safeString(transfer, 'status')),
         };
-        const response = await this.privatePostCancelReplaceOrderPair(this.extend(request, params));
-        return this.parseOrder(response, market);
     }
     async fetchDepositAddress(code, params = {}) {
         /**
          * @method
          * @name cex#fetchDepositAddress
-         * @see https://docs.cex.io/#get-crypto-address
          * @description fetch the deposit address for a currency associated with this account
+         * @see https://trade.cex.io/docs/#rest-private-api-calls-deposit-address
          * @param {string} code unified currency code
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.accountId] account-id (default to empty string) to refer to (at this moment, only sub-accounts allowed by exchange)
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
+        let accountId = undefined;
+        [accountId, params] = this.handleOptionAndParams(params, 'createOrder', 'accountId');
+        if (accountId === undefined) {
+            throw new ArgumentsRequired(this.id + ' fetchDepositAddress() : main account is not allowed to fetch deposit address from api, set params["accountId"] or .options["createOrder"]["accountId"] to the name of your sub-account');
+        }
         await this.loadMarkets();
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
         const currency = this.currency(code);
         const request = {
+            'accountId': accountId,
             'currency': currency['id'],
+            'blockchain': this.networkCodeToId(networkCode),
         };
-        const [networkCode, query] = this.handleNetworkCodeAndParams(params);
-        // atm, cex doesn't support network in the request
-        const response = await this.privatePostGetCryptoAddress(this.extend(request, query));
+        const response = await this.privatePostGetDepositAddress(this.extend(request, params));
         //
         //    {
-        //         "e": "get_crypto_address",
-        //         "ok": "ok",
-        //         "data": {
-        //             "name": "BTC",
-        //             "addresses": [
-        //                 {
-        //                     "blockchain": "Bitcoin",
-        //                     "address": "2BvKwe1UwrdTjq2nzhscFYXwqCjCaaHCeq"
+        //        "ok": "ok",
+        //        "data": {
+        //            "address": "TCr..................1AE",
+        //            "accountId": "sub1",
+        //            "currency": "USDT",
+        //            "blockchain": "tron"
+        //        }
+        //    }
         //
-        //                     // for others coins (i.e. XRP, XLM) other keys are present:
-        //                     //     "destination": "rF1sdh25BJX3qFwneeTBwaq3zPEWYcwjp2",
-        //                     //     "destinationTag": "7519113655",
-        //                     //     "memo": "XLM-memo12345",
-        //                 }
-        //             ]
-        //         }
-        //     }
-        //
-        const data = this.safeValue(response, 'data', {});
-        const addresses = this.safeValue(data, 'addresses', []);
-        const chainsIndexedById = this.indexBy(addresses, 'blockchain');
-        const selectedNetworkId = this.selectNetworkIdFromRawNetworks(code, networkCode, chainsIndexedById);
-        const addressObject = this.safeValue(chainsIndexedById, selectedNetworkId, {});
-        const address = this.safeString2(addressObject, 'address', 'destination');
+        const data = this.safeDict(response, 'data', {});
+        return this.parseDepositAddress(data, currency);
+    }
+    parseDepositAddress(depositAddress, currency = undefined) {
+        const address = this.safeString(depositAddress, 'address');
+        const currencyId = this.safeString(depositAddress, 'currency');
+        currency = this.safeCurrency(currencyId, currency);
         this.checkAddress(address);
         return {
-            'info': data,
-            'currency': code,
-            'network': this.networkIdToCode(selectedNetworkId),
+            'info': depositAddress,
+            'currency': currency['code'],
+            'network': this.networkIdToCode(this.safeString(depositAddress, 'blockchain')),
             'address': address,
-            'tag': this.safeString2(addressObject, 'destinationTag', 'memo'),
+            'tag': undefined,
         };
     }
-    nonce() {
-        return this.milliseconds();
-    }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
-        let url = this.urls['api']['rest'] + '/' + this.implodeParams(path, params);
+        let url = this.urls['api'][api] + '/' + this.implodeParams(path, params);
         const query = this.omit(params, this.extractParams(path));
         if (api === 'public') {
-            if (Object.keys(query).length) {
-                url += '?' + this.urlencode(query);
+            if (method === 'GET') {
+                if (Object.keys(query).length) {
+                    url += '?' + this.urlencode(query);
+                }
+            }
+            else {
+                body = this.json(query);
+                headers = {
+                    'Content-Type': 'application/json',
+                };
             }
         }
         else {
             this.checkRequiredCredentials();
-            const nonce = this.nonce().toString();
-            const auth = nonce + this.uid + this.apiKey;
-            const signature = this.hmac(this.encode(auth), this.encode(this.secret), sha256);
-            body = this.json(this.extend({
-                'key': this.apiKey,
-                'signature': signature.toUpperCase(),
-                'nonce': nonce,
-            }, query));
+            const seconds = this.seconds().toString();
+            body = this.json(query);
+            const auth = path + seconds + body;
+            const signature = this.hmac(this.encode(auth), this.encode(this.secret), sha256, 'base64');
             headers = {
                 'Content-Type': 'application/json',
+                'X-AGGR-KEY': this.apiKey,
+                'X-AGGR-TIMESTAMP': seconds,
+                'X-AGGR-SIGNATURE': signature,
             };
         }
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };
     }
     handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
-        if (Array.isArray(response)) {
-            return response; // public endpoints may return []-arrays
-        }
-        if (body === 'true') {
-            return undefined;
-        }
+        // in some cases, like from createOrder, exchange returns nested escaped JSON string:
+        //      {"ok":"ok","data":{"messageType":"executionReport", "orderRejectReason":"{\"code\":405}"} }
+        // and because of `.parseJson` bug, we need extra fix
         if (response === undefined) {
-            throw new NullResponse(this.id + ' returned ' + this.json(response));
-        }
-        if ('e' in response) {
-            if ('ok' in response) {
-                if (response['ok'] === 'ok') {
-                    return undefined;
-                }
+            if (body === undefined) {
+                throw new NullResponse(this.id + ' returned empty response');
+            }
+            else if (body[0] === '{') {
+                const fixed = this.fixStringifiedJsonMembers(body);
+                response = this.parseJson(fixed);
+            }
+            else {
+                throw new NullResponse(this.id + ' returned unparsed response: ' + body);
             }
         }
-        if ('error' in response) {
-            const message = this.safeString(response, 'error');
+        const error = this.safeString(response, 'error');
+        if (error !== undefined) {
             const feedback = this.id + ' ' + body;
-            this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
-            this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
+            this.throwExactlyMatchedException(this.exceptions['exact'], error, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], error, feedback);
             throw new ExchangeError(feedback);
         }
+        // check errors in order-engine (the responses are not standard, so we parse here)
+        if (url.indexOf('do_my_new_order') >= 0) {
+            const data = this.safeDict(response, 'data', {});
+            const rejectReason = this.safeString(data, 'rejectReason');
+            if (rejectReason !== undefined) {
+                this.throwBroadlyMatchedException(this.exceptions['broad'], rejectReason, rejectReason);
+                throw new ExchangeError(this.id + ' createOrder() ' + rejectReason);
+            }
+        }
         return undefined;
     }
 }