ccxt 4.2.11 → 4.2.12

package/dist/cjs/js/src/bitforex.js

@@ -0,0 +1,852 @@
+'use strict';
+
+var bitforex$1 = require('./abstract/bitforex.js');
+var errors = require('./base/errors.js');
+var number = require('./base/functions/number.js');
+var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
+
+//  ---------------------------------------------------------------------------
+//  ---------------------------------------------------------------------------
+/**
+ * @class bitforex
+ * @augments Exchange
+ */
+class bitforex extends bitforex$1 {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'id': 'bitforex',
+            'name': 'Bitforex',
+            'countries': ['CN'],
+            'rateLimit': 500,
+            'version': 'v1',
+            'has': {
+                'CORS': undefined,
+                'spot': true,
+                'margin': false,
+                'swap': false,
+                'future': false,
+                'option': false,
+                'addMargin': false,
+                'cancelOrder': true,
+                'createOrder': true,
+                'createReduceOnlyOrder': false,
+                'createStopLimitOrder': false,
+                'createStopMarketOrder': false,
+                'createStopOrder': false,
+                'fetchBalance': true,
+                'fetchBorrowInterest': false,
+                'fetchBorrowRateHistories': false,
+                'fetchBorrowRateHistory': false,
+                'fetchClosedOrders': true,
+                'fetchCrossBorrowRate': false,
+                'fetchCrossBorrowRates': false,
+                'fetchFundingHistory': false,
+                'fetchFundingRate': false,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
+                'fetchIndexOHLCV': false,
+                'fetchIsolatedBorrowRate': false,
+                'fetchIsolatedBorrowRates': false,
+                'fetchIsolatedPositions': false,
+                'fetchLeverage': false,
+                'fetchLeverageTiers': false,
+                'fetchMarginMode': false,
+                'fetchMarketLeverageTiers': false,
+                'fetchMarkets': true,
+                'fetchMarkOHLCV': false,
+                'fetchMyTrades': true,
+                'fetchOHLCV': true,
+                'fetchOpenInterestHistory': false,
+                'fetchOpenOrders': true,
+                'fetchOrder': true,
+                'fetchOrderBook': true,
+                'fetchPosition': false,
+                'fetchPositionMode': false,
+                'fetchPositions': false,
+                'fetchPositionsRisk': false,
+                'fetchPremiumIndexOHLCV': false,
+                'fetchTicker': true,
+                'fetchTickers': false,
+                'fetchTrades': true,
+                'fetchTransactionFees': false,
+                'fetchTransfer': false,
+                'fetchTransfers': false,
+                'fetchWithdrawal': false,
+                'fetchWithdrawals': false,
+                'reduceMargin': false,
+                'repayCrossMargin': false,
+                'repayIsolatedMargin': false,
+                'setLeverage': false,
+                'setMargin': false,
+                'setMarginMode': false,
+                'setPositionMode': false,
+                'transfer': false,
+                'withdraw': false,
+            },
+            'timeframes': {
+                '1m': '1min',
+                '5m': '5min',
+                '15m': '15min',
+                '30m': '30min',
+                '1h': '1hour',
+                '2h': '2hour',
+                '4h': '4hour',
+                '12h': '12hour',
+                '1d': '1day',
+                '1w': '1week',
+                '1M': '1month',
+            },
+            'urls': {
+                'logo': 'https://user-images.githubusercontent.com/51840849/87295553-1160ec00-c50e-11ea-8ea0-df79276a9646.jpg',
+                'api': {
+                    'rest': 'https://api.bitforex.com',
+                },
+                'www': 'https://www.bitforex.com',
+                'doc': 'https://github.com/githubdev2020/API_Doc_en/wiki',
+                'fees': 'https://help.bitforex.com/en_us/?cat=13',
+                'referral': 'https://www.bitforex.com/en/invitationRegister?inviterId=1867438',
+            },
+            'api': {
+                'public': {
+                    'get': {
+                        '/api/v1/ping': 0.2,
+                        '/api/v1/time': 0.2,
+                        'api/v1/market/symbols': 20,
+                        'api/v1/market/ticker': 4,
+                        'api/v1/market/ticker-all': 4,
+                        'api/v1/market/depth': 4,
+                        'api/v1/market/depth-all': 4,
+                        'api/v1/market/trades': 20,
+                        'api/v1/market/kline': 20,
+                    },
+                },
+                'private': {
+                    'post': {
+                        'api/v1/fund/mainAccount': 1,
+                        'api/v1/fund/allAccount': 30,
+                        'api/v1/trade/placeOrder': 1,
+                        'api/v1/trade/placeMultiOrder': 10,
+                        'api/v1/trade/cancelOrder': 1,
+                        'api/v1/trade/cancelMultiOrder': 6.67,
+                        'api/v1/trade/cancelAllOrder': 20,
+                        'api/v1/trade/orderInfo': 1,
+                        'api/v1/trade/multiOrderInfo': 10,
+                        'api/v1/trade/orderInfos': 20,
+                        'api/v1/trade/myTrades': 2,
+                    },
+                },
+            },
+            'fees': {
+                'trading': {
+                    'tierBased': false,
+                    'percentage': true,
+                    'maker': this.parseNumber('0.001'),
+                    'taker': this.parseNumber('0.001'),
+                },
+                'funding': {
+                    'tierBased': false,
+                    'percentage': true,
+                    'deposit': {},
+                    'withdraw': {},
+                },
+            },
+            'commonCurrencies': {
+                'BKC': 'Bank Coin',
+                'CAPP': 'Crypto Application Token',
+                'CREDIT': 'TerraCredit',
+                'CTC': 'Culture Ticket Chain',
+                'EWT': 'EcoWatt Token',
+                'IQ': 'IQ.Cash',
+                'MIR': 'MIR COIN',
+                'NOIA': 'METANOIA',
+                'TON': 'To The Moon',
+            },
+            'precisionMode': number.TICK_SIZE,
+            'exceptions': {
+                '1000': errors.OrderNotFound,
+                '1003': errors.BadSymbol,
+                '1013': errors.AuthenticationError,
+                '1016': errors.AuthenticationError,
+                '1017': errors.PermissionDenied,
+                '1019': errors.BadSymbol,
+                '3002': errors.InsufficientFunds,
+                '4002': errors.InvalidOrder,
+                '4003': errors.InvalidOrder,
+                '4004': errors.OrderNotFound,
+                '10204': errors.DDoSProtection,
+            },
+        });
+    }
+    async fetchMarkets(params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchMarkets
+         * @description retrieves data on all markets for bitforex
+         * @see https://apidoc.bitforex.com/#exchange-information
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} an array of objects representing market data
+         */
+        const response = await this.publicGetApiV1MarketSymbols(params);
+        //
+        //    {
+        //        "data": [
+        //            {
+        //                "amountPrecision":4,
+        //                "minOrderAmount":3.0E-4,
+        //                "pricePrecision":2,
+        //                "symbol":"coin-usdt-btc"
+        //            },
+        //            ...
+        //        ]
+        //    }
+        //
+        const data = response['data'];
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const market = data[i];
+            const id = this.safeString(market, 'symbol');
+            const symbolParts = id.split('-');
+            const baseId = symbolParts[2];
+            const quoteId = symbolParts[1];
+            const base = this.safeCurrencyCode(baseId);
+            const quote = this.safeCurrencyCode(quoteId);
+            result.push({
+                'id': id,
+                'symbol': base + '/' + quote,
+                'base': base,
+                'quote': quote,
+                'settle': undefined,
+                'baseId': baseId,
+                'quoteId': quoteId,
+                'settleId': undefined,
+                'type': 'spot',
+                'spot': true,
+                'margin': false,
+                'swap': false,
+                'future': false,
+                'option': false,
+                'active': true,
+                'contract': false,
+                'linear': undefined,
+                'inverse': undefined,
+                'contractSize': undefined,
+                'expiry': undefined,
+                'expiryDateTime': undefined,
+                'strike': undefined,
+                'optionType': undefined,
+                'precision': {
+                    'amount': this.parseNumber(this.parsePrecision(this.safeString(market, 'amountPrecision'))),
+                    'price': this.parseNumber(this.parsePrecision(this.safeString(market, 'pricePrecision'))),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'amount': {
+                        'min': this.safeNumber(market, 'minOrderAmount'),
+                        'max': undefined,
+                    },
+                    'price': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'cost': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                },
+                'created': undefined,
+                'info': market,
+            });
+        }
+        return result;
+    }
+    parseTrade(trade, market = undefined) {
+        //
+        // fetchTrades (public) v1
+        //
+        //      {
+        //          "price":57594.53,
+        //          "amount":0.3172,
+        //          "time":1637329685322,
+        //          "direction":1,
+        //          "tid":"1131019666"
+        //      }
+        //
+        // fetchMyTrades (private)
+        //
+        //     {
+        //         "symbol": "coin-usdt-babydoge",
+        //         "tid": 7289,
+        //         "orderId": "b6fe2b61-e5cb-4970-9bdc-8c7cd1fcb4d8",
+        //         "price": "0.000007",
+        //         "amount": "50000000",
+        //         "tradeFee": "50000",
+        //         "tradeFeeCurrency": "babydoge",
+        //         "time": "1684750536460",
+        //         "isBuyer": true,
+        //         "isMaker": true,
+        //         "isSelfTrade": true
+        //     }
+        //
+        const marketId = this.safeString(trade, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const timestamp = this.safeInteger(trade, 'time');
+        const id = this.safeString(trade, 'tid');
+        const orderId = this.safeString(trade, 'orderId');
+        const priceString = this.safeString(trade, 'price');
+        const amountString = this.safeString(trade, 'amount');
+        const sideId = this.safeInteger(trade, 'direction');
+        let side = this.parseSide(sideId);
+        if (side === undefined) {
+            const isBuyer = this.safeValue(trade, 'isBuyer');
+            side = isBuyer ? 'buy' : 'sell';
+        }
+        let takerOrMaker = undefined;
+        const isMaker = this.safeValue(trade, 'isMaker');
+        if (isMaker !== undefined) {
+            takerOrMaker = (isMaker) ? 'maker' : 'taker';
+        }
+        let fee = undefined;
+        const feeCostString = this.safeString(trade, 'tradeFee');
+        if (feeCostString !== undefined) {
+            const feeCurrencyId = this.safeString(trade, 'tradeFeeCurrency');
+            const feeCurrencyCode = this.safeCurrencyCode(feeCurrencyId);
+            fee = {
+                'cost': feeCostString,
+                'currency': feeCurrencyCode,
+            };
+        }
+        return this.safeTrade({
+            'info': trade,
+            'id': id,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': market['symbol'],
+            'type': undefined,
+            'side': side,
+            'price': priceString,
+            'amount': amountString,
+            'cost': undefined,
+            'order': orderId,
+            'fee': fee,
+            'takerOrMaker': takerOrMaker,
+        }, market);
+    }
+    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchTrades
+         * @description get the list of most recent trades for a particular symbol
+         * @see https://apidoc.bitforex.com/#recent-trades-list
+         * @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 request = {
+            'symbol': this.marketId(symbol),
+        };
+        if (limit !== undefined) {
+            request['size'] = limit;
+        }
+        const market = this.market(symbol);
+        const response = await this.publicGetApiV1MarketTrades(this.extend(request, params));
+        //
+        // {
+        //  "data":
+        //      [
+        //          {
+        //              "price":57594.53,
+        //              "amount":0.3172,
+        //              "time":1637329685322,
+        //              "direction":1,
+        //              "tid":"1131019666"
+        //          }
+        //      ],
+        //  "success": true,
+        //  "time": 1637329688475
+        // }
+        //
+        return this.parseTrades(response['data'], market, since, limit);
+    }
+    async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchMyTrades
+         * @description fetch all trades made by the user
+         * @see https://apidoc.bitforex.com/#spot-account-trade
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch trades for
+         * @param {int} [limit] the maximum number of trades structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
+         */
+        if (symbol === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' fetchMyTrades() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        const request = {
+        // 'symbol': market['id'],
+        // 'orderId': orderId,
+        // 'startTime': timestamp,
+        // 'endTime': timestamp,
+        // 'limit': limit, // default 500, max 1000
+        };
+        const market = this.market(symbol);
+        request['symbol'] = market['id'];
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        if (since !== undefined) {
+            request['startTime'] = Math.max(since - 1, 0);
+        }
+        const endTime = this.safeInteger2(params, 'until', 'endTime');
+        if (endTime !== undefined) {
+            request['endTime'] = endTime;
+        }
+        params = this.omit(params, ['until']);
+        const response = await this.privatePostApiV1TradeMyTrades(this.extend(request, params));
+        //
+        //     {
+        //         "data": [
+        //             {
+        //                 "symbol": "coin-usdt-babydoge",
+        //                 "tid": 7289,
+        //                 "orderId": "a262d030-11a5-40fd-a07c-7ba84aa68752",
+        //                 "price": "0.000007",
+        //                 "amount": "50000000",
+        //                 "tradeFee": "0.35",
+        //                 "tradeFeeCurrency": "usdt",
+        //                 "time": "1684750536460",
+        //                 "isBuyer": false,
+        //                 "isMaker": false,
+        //                 "isSelfTrade": true
+        //             }
+        //         ],
+        //         "success": true,
+        //         "time": 1685009320042
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseTrades(data, market, since, limit);
+    }
+    parseBalance(response) {
+        const data = response['data'];
+        const result = { 'info': response };
+        for (let i = 0; i < data.length; i++) {
+            const balance = data[i];
+            const currencyId = this.safeString(balance, 'currency');
+            const code = this.safeCurrencyCode(currencyId);
+            const account = this.account();
+            account['used'] = this.safeString(balance, 'frozen');
+            account['free'] = this.safeString(balance, 'active');
+            account['total'] = this.safeString(balance, 'fix');
+            result[code] = account;
+        }
+        return this.safeBalance(result);
+    }
+    async fetchBalance(params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchBalance
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @see https://apidoc.bitforex.com/#user-all-asset-information-user_data
+         * @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.privatePostApiV1FundAllAccount(params);
+        return this.parseBalance(response);
+    }
+    parseTicker(ticker, market = undefined) {
+        //
+        //     {
+        //         "buy":7.04E-7,
+        //         "date":1643371198598,
+        //         "high":7.48E-7,
+        //         "last":7.28E-7,
+        //         "low":7.10E-7,
+        //         "sell":7.54E-7,
+        //         "vol":9877287.2874
+        //     }
+        //
+        const symbol = this.safeSymbol(undefined, market);
+        const timestamp = this.safeInteger(ticker, 'date');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'high': this.safeString(ticker, 'high'),
+            'low': this.safeString(ticker, 'low'),
+            'bid': this.safeString(ticker, 'buy'),
+            'bidVolume': undefined,
+            'ask': this.safeString(ticker, 'sell'),
+            'askVolume': undefined,
+            'vwap': undefined,
+            'open': undefined,
+            'close': this.safeString(ticker, 'last'),
+            'last': this.safeString(ticker, 'last'),
+            'previousClose': undefined,
+            'change': undefined,
+            'percentage': undefined,
+            'average': undefined,
+            'baseVolume': this.safeString(ticker, 'vol'),
+            'quoteVolume': undefined,
+            'info': ticker,
+        }, market);
+    }
+    async fetchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchTicker
+         * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://apidoc.bitforex.com/#exchange-information
+         * @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.markets[symbol];
+        const request = {
+            'symbol': market['id'],
+        };
+        const response = await this.publicGetApiV1MarketTickerAll(this.extend(request, params));
+        const ticker = this.safeValue(response, 'data');
+        //
+        //     {
+        //         "data":{
+        //             "buy":37082.83,
+        //             "date":1643388686660,
+        //             "high":37487.83,
+        //             "last":37086.79,
+        //             "low":35544.44,
+        //             "sell":37090.52,
+        //             "vol":690.9776
+        //         },
+        //         "success":true,
+        //         "time":1643388686660
+        //     }
+        //
+        return this.parseTicker(ticker, market);
+    }
+    parseOHLCV(ohlcv, market = undefined) {
+        //
+        //     {
+        //         "close":0.02505143,
+        //         "currencyVol":0,
+        //         "high":0.02506422,
+        //         "low":0.02505143,
+        //         "open":0.02506095,
+        //         "time":1591508940000,
+        //         "vol":51.1869
+        //     }
+        //
+        return [
+            this.safeInteger(ohlcv, 'time'),
+            this.safeNumber(ohlcv, 'open'),
+            this.safeNumber(ohlcv, 'high'),
+            this.safeNumber(ohlcv, 'low'),
+            this.safeNumber(ohlcv, 'close'),
+            this.safeNumber(ohlcv, 'vol'),
+        ];
+    }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchOHLCV
+         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://apidoc.bitforex.com/#kline
+         * @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);
+        const request = {
+            'symbol': market['id'],
+            'ktype': this.safeString(this.timeframes, timeframe, timeframe),
+        };
+        if (limit !== undefined) {
+            request['size'] = limit; // default 1, max 600
+        }
+        const response = await this.publicGetApiV1MarketKline(this.extend(request, params));
+        //
+        //     {
+        //         "data":[
+        //             {"close":0.02505143,"currencyVol":0,"high":0.02506422,"low":0.02505143,"open":0.02506095,"time":1591508940000,"vol":51.1869},
+        //             {"close":0.02503914,"currencyVol":0,"high":0.02506687,"low":0.02503914,"open":0.02505358,"time":1591509000000,"vol":9.1082},
+        //             {"close":0.02505172,"currencyVol":0,"high":0.02507466,"low":0.02503895,"open":0.02506371,"time":1591509060000,"vol":63.7431},
+        //         ],
+        //         "success":true,
+        //         "time":1591509427131
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseOHLCVs(data, market, timeframe, since, limit);
+    }
+    async fetchOrderBook(symbol, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchOrderBook
+         * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://apidoc.bitforex.com/#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 {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 = {
+            'symbol': market['id'],
+        };
+        if (limit !== undefined) {
+            request['size'] = limit;
+        }
+        const response = await this.publicGetApiV1MarketDepthAll(this.extend(request, params));
+        const data = this.safeValue(response, 'data');
+        const timestamp = this.safeInteger(response, 'time');
+        return this.parseOrderBook(data, market['symbol'], timestamp, 'bids', 'asks', 'price', 'amount');
+    }
+    parseOrderStatus(status) {
+        const statuses = {
+            '0': 'open',
+            '1': 'open',
+            '2': 'closed',
+            '3': 'canceled',
+            '4': 'canceled',
+        };
+        return (status in statuses) ? statuses[status] : status;
+    }
+    parseSide(sideId) {
+        if (sideId === 1) {
+            return 'buy';
+        }
+        else if (sideId === 2) {
+            return 'sell';
+        }
+        else {
+            return undefined;
+        }
+    }
+    parseOrder(order, market = undefined) {
+        const id = this.safeString(order, 'orderId');
+        const timestamp = this.safeNumber(order, 'createTime');
+        const lastTradeTimestamp = this.safeNumber(order, 'lastTime');
+        const symbol = market['symbol'];
+        const sideId = this.safeInteger(order, 'tradeType');
+        const side = this.parseSide(sideId);
+        const type = undefined;
+        const price = this.safeString(order, 'orderPrice');
+        const average = this.safeString(order, 'avgPrice');
+        const amount = this.safeString(order, 'orderAmount');
+        const filled = this.safeString(order, 'dealAmount');
+        const status = this.parseOrderStatus(this.safeString(order, 'orderState'));
+        const feeSide = (side === 'buy') ? 'base' : 'quote';
+        const feeCurrency = market[feeSide];
+        const fee = {
+            'cost': this.safeNumber(order, 'tradeFee'),
+            'currency': feeCurrency,
+        };
+        return this.safeOrder({
+            'info': order,
+            'id': id,
+            'clientOrderId': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': lastTradeTimestamp,
+            'symbol': symbol,
+            'type': type,
+            'timeInForce': undefined,
+            'postOnly': undefined,
+            'side': side,
+            'price': price,
+            'stopPrice': undefined,
+            'triggerPrice': undefined,
+            'cost': undefined,
+            'average': average,
+            'amount': amount,
+            'filled': filled,
+            'remaining': undefined,
+            'status': status,
+            'fee': fee,
+            'trades': undefined,
+        }, market);
+    }
+    async fetchOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchOrder
+         * @description fetches information on an order made by the user
+         * @see https://apidoc.bitforex.com/#order-information-user_data
+         * @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 market = this.market(symbol);
+        const request = {
+            'symbol': this.marketId(symbol),
+            'orderId': id,
+        };
+        const response = await this.privatePostApiV1TradeOrderInfo(this.extend(request, params));
+        const order = this.parseOrder(response['data'], market);
+        return order;
+    }
+    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchOpenOrders
+         * @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 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 + ' fetchOpenOrders() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+            'state': 0,
+        };
+        const response = await this.privatePostApiV1TradeOrderInfos(this.extend(request, params));
+        return this.parseOrders(response['data'], market, since, limit);
+    }
+    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#fetchClosedOrders
+         * @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 = {
+            'symbol': market['id'],
+            'state': 1,
+        };
+        const response = await this.privatePostApiV1TradeOrderInfos(this.extend(request, params));
+        return this.parseOrders(response['data'], market, since, limit);
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#createOrder
+         * @description create a trade order
+         * @see https://apidoc.bitforex.com/#new-order-trade
+         * @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
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        let sideId = undefined;
+        if (side === 'buy') {
+            sideId = 1;
+        }
+        else if (side === 'sell') {
+            sideId = 2;
+        }
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+            'price': price,
+            'amount': amount,
+            'tradeType': sideId,
+        };
+        const response = await this.privatePostApiV1TradePlaceOrder(this.extend(request, params));
+        const data = response['data'];
+        return this.safeOrder({
+            'info': response,
+            'id': this.safeString(data, 'orderId'),
+        }, market);
+    }
+    async cancelOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitforex#cancelOrder
+         * @description cancels an open order
+         * @see https://apidoc.bitforex.com/#cancel-order-trade
+         * @param {string} id order id
+         * @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 = {
+            'orderId': id,
+        };
+        if (symbol !== undefined) {
+            request['symbol'] = this.marketId(symbol);
+        }
+        const results = await this.privatePostApiV1TradeCancelOrder(this.extend(request, params));
+        const success = results['success'];
+        const returnVal = { 'info': results, 'success': success };
+        return returnVal;
+    }
+    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();
+            let payload = this.urlencode({ 'accessKey': this.apiKey });
+            query['nonce'] = this.milliseconds();
+            if (Object.keys(query).length) {
+                payload += '&' + this.urlencode(this.keysort(query));
+            }
+            // let message = '/' + 'api/' + this.version + '/' + path + '?' + payload;
+            const message = '/' + path + '?' + payload;
+            const signature = this.hmac(this.encode(message), this.encode(this.secret), sha256.sha256);
+            body = payload + '&signData=' + signature;
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+        }
+        return { 'url': url, 'method': method, 'body': body, 'headers': headers };
+    }
+    handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
+        if (typeof body !== 'string') {
+            return undefined; // fallback to default error handler
+        }
+        if ((body[0] === '{') || (body[0] === '[')) {
+            const feedback = this.id + ' ' + body;
+            const success = this.safeValue(response, 'success');
+            if (success !== undefined) {
+                if (!success) {
+                    const codeInner = this.safeString(response, 'code');
+                    this.throwExactlyMatchedException(this.exceptions, codeInner, feedback);
+                    throw new errors.ExchangeError(feedback);
+                }
+            }
+        }
+        return undefined;
+    }
+}
+
+module.exports = bitforex;