ccxt 4.2.11 → 4.2.13

package/dist/cjs/js/src/cex.js

@@ -0,0 +1,1693 @@
+'use strict';
+
+var cex$1 = require('./abstract/cex.js');
+var errors = require('./base/errors.js');
+var Precise = require('./base/Precise.js');
+var number = require('./base/functions/number.js');
+var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
+
+//  ---------------------------------------------------------------------------
+//  ---------------------------------------------------------------------------
+/**
+ * @class cex
+ * @augments Exchange
+ */
+class cex extends cex$1 {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'id': 'cex',
+            'name': 'CEX.IO',
+            'countries': ['GB', 'EU', 'CY', 'RU'],
+            'rateLimit': 1500,
+            'pro': true,
+            'has': {
+                'CORS': undefined,
+                'spot': true,
+                'margin': false,
+                '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,
+                'fetchBalance': true,
+                'fetchClosedOrders': true,
+                'fetchCurrencies': true,
+                'fetchDeposit': false,
+                'fetchDepositAddress': true,
+                'fetchDepositAddresses': false,
+                'fetchDeposits': false,
+                'fetchDepositsWithdrawals': false,
+                'fetchFundingHistory': false,
+                'fetchFundingRate': false,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
+                'fetchIndexOHLCV': false,
+                'fetchMarginMode': false,
+                'fetchMarkets': true,
+                'fetchMarkOHLCV': false,
+                'fetchOHLCV': true,
+                'fetchOpenInterestHistory': false,
+                'fetchOpenOrders': true,
+                'fetchOrder': true,
+                'fetchOrderBook': true,
+                'fetchOrders': true,
+                'fetchPositionMode': false,
+                'fetchPremiumIndexOHLCV': false,
+                'fetchTicker': true,
+                'fetchTickers': 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',
+            },
+            'urls': {
+                'logo': 'https://user-images.githubusercontent.com/1294454/27766442-8ddc33b0-5ed8-11e7-8b98-f786aef0f3c9.jpg',
+                'api': {
+                    'rest': 'https://cex.io/api',
+                },
+                'www': 'https://cex.io',
+                'doc': 'https://cex.io/cex-api',
+                '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}',
+                    ],
+                },
+                '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,
+                    },
+                },
+            },
+            'precisionMode': number.TICK_SIZE,
+            'exceptions': {
+                'exact': {},
+                'broad': {
+                    'Insufficient funds': errors.InsufficientFunds,
+                    'Nonce must be incremented': errors.InvalidNonce,
+                    'Invalid Order': errors.InvalidOrder,
+                    'Order not found': errors.OrderNotFound,
+                    'limit exceeded': errors.RateLimitExceeded,
+                    'Invalid API key': errors.AuthenticationError,
+                    'There was an error while placing your order': errors.InvalidOrder,
+                    'Sorry, too many clients already': errors.DDoSProtection,
+                    'Invalid Symbols Pair': errors.BadSymbol,
+                    'Wrong currency pair': errors.BadSymbol, // {"error":"There was an error while placing your order: Wrong currency pair.","safe":true}
+                },
+            },
+            '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',
+                },
+            },
+        });
+    }
+    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
+         */
+        const response = await this.fetchCurrenciesFromCache(params);
+        this.options['currencies'] = {
+            'timestamp': this.milliseconds(),
+            'response': response,
+        };
+        //
+        //     {
+        //         "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
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        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,
+                'limits': {
+                    'amount': {
+                        'min': this.safeNumber(currency, 'minimumCurrencyAmount'),
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': this.safeNumber(currency, 'minimalWithdrawalAmount'),
+                        'max': undefined,
+                    },
+                },
+                'info': currency,
+            };
+        }
+        return result;
+    }
+    async fetchMarkets(params = {}) {
+        /**
+         * @method
+         * @name cex#fetchMarkets
+         * @description retrieves data on all markets for cex
+         * @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);
+        //
+        //     {
+        //         "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"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        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["default"].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)),
+                },
+                '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,
+                    },
+                },
+                '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);
+    }
+    async fetchBalance(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
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+         */
+        await this.loadMarkets();
+        const response = await this.privatePostBalance(params);
+        return this.parseBalance(response);
+    }
+    async fetchOrderBook(symbol, limit = undefined, 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
+         * @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
+         */
+        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),
+        ];
+    }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = 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
+         * @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
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        if (since === undefined) {
+            since = this.milliseconds() - 86400000; // yesterday
+        }
+        else {
+            if (this.options['fetchOHLCVWarning']) {
+                throw new errors.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 errors.NullResponse) {
+                return [];
+            }
+        }
+        return undefined;
+    }
+    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);
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'high': high,
+            'low': low,
+            'bid': bid,
+            'bidVolume': undefined,
+            'ask': ask,
+            'askVolume': undefined,
+            'vwap': undefined,
+            'open': undefined,
+            'close': last,
+            'last': last,
+            'previousClose': undefined,
+            'change': undefined,
+            'percentage': undefined,
+            'average': undefined,
+            'baseVolume': volume,
+            'quoteVolume': undefined,
+            '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 = {}) {
+        /**
+         * @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
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        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);
+    }
+    parseTrade(trade, market = undefined) {
+        //
+        // fetchTrades (public)
+        //
+        //      {
+        //          "type": "sell",
+        //          "date": "1638401878",
+        //          "amount": "0.401000",
+        //          "price": "249",
+        //          "tid": "11922"
+        //      }
+        //
+        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');
+        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,
+            'order': undefined,
+            'takerOrMaker': undefined,
+            'price': priceString,
+            'amount': amountString,
+            'cost': undefined,
+            'fee': undefined,
+        }, market);
+    }
+    async fetchTrades(symbol, since = undefined, 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
+         * @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}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'pair': market['id'],
+        };
+        const response = await this.publicGetTradeHistoryPair(this.extend(request, params));
+        return this.parseTrades(response, market, since, limit);
+    }
+    async fetchTradingFees(params = {}) {
+        /**
+         * @method
+         * @name cex#fetchTradingFees
+         * @see https://docs.cex.io/#get-my-fee
+         * @description fetch the trading fees for multiple markets
+         * @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);
+        //
+        //      {
+        //          "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" },
+        //            ..
+        //          }
+        //      }
+        //
+        const data = this.safeValue(response, 'data', {});
+        const result = {};
+        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["default"].stringDiv(makerString, '100'));
+            const taker = this.parseNumber(Precise["default"].stringDiv(takerString, '100'));
+            result[symbol] = {
+                'info': fee,
+                'symbol': symbol,
+                'maker': maker,
+                'taker': taker,
+                'percentage': true,
+            };
+        }
+        return result;
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, 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 fullfilled, in units of the quote currency, ignored in market orders
+         * @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}
+         */
+        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 errors.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["default"].stringMul(amountString, priceString);
+                    quoteAmount = this.costToPrecision(symbol, costRequest);
+                }
+            }
+            else {
+                quoteAmount = this.costToPrecision(symbol, amount);
+            }
+            request['amount'] = quoteAmount;
+        }
+        else {
+            request['amount'] = this.amountToPrecision(symbol, amount);
+        }
+        if (type === 'limit') {
+            request['price'] = this.numberToString(price);
+        }
+        else {
+            request['order_type'] = type;
+        }
+        const response = await this.privatePostPlaceOrderPair(this.extend(request, params));
+        //
+        //     {
+        //         "id": "12978363524",
+        //         "time": 1586610022259,
+        //         "type": "buy",
+        //         "price": "0.033934",
+        //         "amount": "0.10722802",
+        //         "pending": "0.10722802",
+        //         "complete": false
+        //     }
+        //
+        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["default"].stringMax(Precise["default"].stringSub(placedAmount, remaining), '0');
+        }
+        return this.safeOrder({
+            'id': this.safeString(response, 'id'),
+            'info': response,
+            'clientOrderId': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': undefined,
+            'type': type,
+            'side': this.safeString(response, 'type'),
+            'symbol': market['symbol'],
+            'status': status,
+            'price': this.safeString(response, 'price'),
+            'amount': placedAmount,
+            'cost': undefined,
+            'average': undefined,
+            'remaining': remaining,
+            'filled': filled,
+            'fee': undefined,
+            'trades': undefined,
+        });
+    }
+    async cancelOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#cancelOrder
+         * @see https://docs.cex.io/#cancel-order
+         * @description cancels an open order
+         * @param {string} id order id
+         * @param {string} symbol not used by cex cancelOrder ()
+         * @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,
+        };
+        const response = await this.privatePostCancelOrder(this.extend(request, params));
+        // 'true'
+        return this.extend(this.parseOrder({}), { 'info': response, 'type': undefined, 'id': id, 'status': 'canceled' });
+    }
+    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
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (symbol === undefined) {
+            throw new errors.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));
+        //
+        //  {
+        //      "e":"cancel_orders",
+        //      "ok":"ok",
+        //      "data":[
+        //      ]
+        //   }
+        //
+        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);
+        }
+        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);
+            }
+        }
+        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["default"].stringAbs(amount);
+        }
+        else if (market !== undefined) {
+            const amountKey = 'a:' + market['base'] + 'cds:';
+            amount = Precise["default"].stringAbs(this.safeString(order, amountKey));
+        }
+        const remaining = this.safeString2(order, 'pending', 'remains');
+        const filled = Precise["default"].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["default"].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["default"].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,
+                };
+            }
+        }
+        if (!cost) {
+            cost = Precise["default"].stringMul(price, filled);
+        }
+        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["default"].stringAbs(tradeAmount);
+                let tradeCost = undefined;
+                if (tradeSide === 'sell') {
+                    tradeCost = absTradeAmount;
+                    absTradeAmount = Precise["default"].stringDiv(Precise["default"].stringAdd(feeCost, tradeCost), tradePrice);
+                }
+                else {
+                    tradeCost = Precise["default"].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,
+                });
+            }
+        }
+        return this.safeOrder({
+            'info': order,
+            'id': orderId,
+            'clientOrderId': undefined,
+            'datetime': this.iso8601(timestamp),
+            '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,
+        });
+    }
+    async fetchOpenOrders(symbol = 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
+         * @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}
+         */
+        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));
+        }
+        else {
+            orders = await this.privatePostOpenOrders(this.extend(request, params));
+        }
+        for (let i = 0; i < orders.length; i++) {
+            orders[i] = this.extend(orders[i], { 'status': 'open' });
+        }
+        return this.parseOrders(orders, market, since, limit);
+    }
+    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, 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
+         * @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}
+         */
+        if (symbol === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' fetchClosedOrders() requires a symbol argument');
+        }
+        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);
+    }
+    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} 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}
+         */
+        await this.loadMarkets();
+        const request = {
+            'id': id.toString(),
+        };
+        const response = await this.privatePostGetOrderTx(this.extend(request, params));
+        const data = this.safeValue(response, 'data', {});
+        //
+        //     {
+        //         "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"
+        //             }
+        //         ]
+        //     }
+        //
+        return this.parseOrder(data);
+    }
+    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}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'limit': limit,
+            'pair': market['id'],
+            'dateFrom': since,
+        };
+        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["default"].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["default"].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["default"].stringAdd(Precise["default"].stringAdd(ta, tta), Precise["default"].stringAdd(fa, tfa));
+                }
+                else {
+                    cost = Precise["default"].stringSub(Precise["default"].stringAdd(ta, tta), Precise["default"].stringAdd(fa, tfa));
+                }
+                type = 'limit';
+                orderAmount = amount;
+                average = Precise["default"].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);
+    }
+    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 fullfilled, 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 errors.ArgumentsRequired(this.id + ' editOrder() requires a amount argument');
+        }
+        if (price === undefined) {
+            throw new errors.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,
+        };
+        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
+         * @param {string} code unified currency code
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'currency': currency['id'],
+        };
+        const [networkCode, query] = this.handleNetworkCodeAndParams(params);
+        // atm, cex doesn't support network in the request
+        const response = await this.privatePostGetCryptoAddress(this.extend(request, query));
+        //
+        //    {
+        //         "e": "get_crypto_address",
+        //         "ok": "ok",
+        //         "data": {
+        //             "name": "BTC",
+        //             "addresses": [
+        //                 {
+        //                     "blockchain": "Bitcoin",
+        //                     "address": "2BvKwe1UwrdTjq2nzhscFYXwqCjCaaHCeq"
+        //
+        //                     // 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');
+        this.checkAddress(address);
+        return {
+            'currency': code,
+            'address': address,
+            'tag': this.safeString2(addressObject, 'destinationTag', 'memo'),
+            'network': this.networkIdToCode(selectedNetworkId),
+            'info': data,
+        };
+    }
+    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);
+        const query = this.omit(params, this.extractParams(path));
+        if (api === 'public') {
+            if (Object.keys(query).length) {
+                url += '?' + this.urlencode(query);
+            }
+        }
+        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.sha256);
+            body = this.json(this.extend({
+                'key': this.apiKey,
+                'signature': signature.toUpperCase(),
+                'nonce': nonce,
+            }, query));
+            headers = {
+                'Content-Type': 'application/json',
+            };
+        }
+        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;
+        }
+        if (response === undefined) {
+            throw new errors.NullResponse(this.id + ' returned ' + this.json(response));
+        }
+        if ('e' in response) {
+            if ('ok' in response) {
+                if (response['ok'] === 'ok') {
+                    return undefined;
+                }
+            }
+        }
+        if ('error' in response) {
+            const message = this.safeString(response, 'error');
+            const feedback = this.id + ' ' + body;
+            this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
+            throw new errors.ExchangeError(feedback);
+        }
+        return undefined;
+    }
+}
+
+module.exports = cex;