ccxt 4.1.11 → 4.1.13

package/dist/cjs/ccxt.js

@@ -180,7 +180,7 @@ var woo$1 = require('./src/pro/woo.js');
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.11';
+const version = '4.1.13';
 Exchange["default"].ccxtVersion = version;
 const exchanges = {
     'ace': ace,

package/dist/cjs/src/ace.js

@@ -242,6 +242,7 @@ class ace extends ace$1 {
                     'amount': this.parseNumber(this.parsePrecision(this.safeString(market, 'basePrecision'))),
                 },
                 'active': undefined,
+                'created': undefined,
                 'info': market,
             });
         }

package/dist/cjs/src/alpaca.js

@@ -306,6 +306,7 @@ class alpaca extends alpaca$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': asset,
             });
         }

package/dist/cjs/src/base/Exchange.js

@@ -3276,6 +3276,12 @@ class Exchange {
     async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         throw new errors.NotSupported(this.id + ' fetchMyTrades() is not supported yet');
     }
+    async fetchMyLiquidations(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        throw new errors.NotSupported(this.id + ' fetchMyLiquidations() is not supported yet');
+    }
+    async fetchLiquidations(symbol, since = undefined, limit = undefined, params = {}) {
+        throw new errors.NotSupported(this.id + ' fetchLiquidations() is not supported yet');
+    }
     async fetchMyTradesWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         throw new errors.NotSupported(this.id + ' fetchMyTradesWs() is not supported yet');
     }
@@ -4400,6 +4406,30 @@ class Exchange {
             'info': this.safeValue(interest, 'info'),
         });
     }
+    parseLiquidation(liquidation, market = undefined) {
+        throw new errors.NotSupported(this.id + ' parseLiquidation () is not supported yet');
+    }
+    parseLiquidations(liquidations, market = undefined, since = undefined, limit = undefined) {
+        /**
+         * @ignore
+         * @method
+         * @description parses liquidation info from the exchange response
+         * @param {object[]} liquidations each item describes an instance of a liquidation event
+         * @param {object} market ccxt market
+         * @param {int} [since] when defined, the response items are filtered to only include items after this timestamp
+         * @param {int} [limit] limits the number of items in the response
+         * @returns {object[]} an array of [liquidation structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure}
+         */
+        const result = [];
+        for (let i = 0; i < liquidations.length; i++) {
+            const entry = liquidations[i];
+            const parsed = this.parseLiquidation(entry, market);
+            result.push(parsed);
+        }
+        const sorted = this.sortBy(result, 'timestamp');
+        const symbol = this.safeString(market, 'symbol');
+        return this.filterBySymbolSinceLimit(sorted, symbol, since, limit);
+    }
 }
 
 exports.Exchange = Exchange;

package/dist/cjs/src/bigone.js

@@ -567,6 +567,7 @@ class bigone extends bigone$1 {
                         'max': this.safeNumber(market, 'max_quote_value'),
                     },
                 },
+                'created': undefined,
                 'info': market,
             };
             result.push(entry);

package/dist/cjs/src/binance.js

@@ -74,9 +74,11 @@ class binance extends binance$1 {
                 'fetchLedger': true,
                 'fetchLeverage': false,
                 'fetchLeverageTiers': true,
+                'fetchLiquidations': false,
                 'fetchMarketLeverageTiers': 'emulated',
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': true,
+                'fetchMyLiquidations': true,
                 'fetchMySettlementHistory': true,
                 'fetchMyTrades': true,
                 'fetchOHLCV': true,
@@ -1807,14 +1809,16 @@ class binance extends binance$1 {
         const query = this.omit(params, 'type');
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchTime', undefined, params);
-        let method = 'publicGetTime';
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTime';
+            response = await this.fapiPublicGetTime(query);
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTime';
+            response = await this.dapiPublicGetTime(query);
+        }
+        else {
+            response = await this.publicGetTime(query);
         }
-        const response = await this[method](query);
         return this.safeInteger(response, 'serverTime');
     }
     async fetchCurrencies(params = {}) {
@@ -2800,17 +2804,19 @@ class binance extends binance$1 {
         if (limit !== undefined) {
             request['limit'] = limit; // default 100, max 5000, see https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#order-book
         }
-        let method = 'publicGetDepth';
+        let response = undefined;
         if (market['option']) {
-            method = 'eapiPublicGetDepth';
+            response = await this.eapiPublicGetDepth(this.extend(request, params));
         }
         else if (market['linear']) {
-            method = 'fapiPublicGetDepth';
+            response = await this.fapiPublicGetDepth(this.extend(request, params));
         }
         else if (market['inverse']) {
-            method = 'dapiPublicGetDepth';
+            response = await this.dapiPublicGetDepth(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetDepth(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         // future
         //
@@ -3044,17 +3050,19 @@ class binance extends binance$1 {
         const request = {
             'symbol': market['id'],
         };
-        let method = 'publicGetTicker24hr';
+        let response = undefined;
         if (market['option']) {
-            method = 'eapiPublicGetTicker';
+            response = await this.eapiPublicGetTicker(this.extend(request, params));
         }
         else if (market['linear']) {
-            method = 'fapiPublicGetTicker24hr';
+            response = await this.fapiPublicGetTicker24hr(this.extend(request, params));
         }
         else if (market['inverse']) {
-            method = 'dapiPublicGetTicker24hr';
+            response = await this.dapiPublicGetTicker24hr(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetTicker24hr(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         if (Array.isArray(response)) {
             const firstTicker = this.safeValue(response, 0, {});
             return this.parseTicker(firstTicker, market);
@@ -3084,17 +3092,16 @@ class binance extends binance$1 {
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchBidsAsks', market, params);
         [type, params] = this.handleMarketTypeAndParams('fetchBidsAsks', market, params);
-        let method = undefined;
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTickerBookTicker';
+            response = await this.fapiPublicGetTickerBookTicker(params);
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTickerBookTicker';
+            response = await this.dapiPublicGetTickerBookTicker(params);
         }
         else {
-            method = 'publicGetTickerBookTicker';
+            response = await this.publicGetTickerBookTicker(params);
         }
-        const response = await this[method](params);
         return this.parseTickers(response, symbols);
     }
     async fetchLastPrices(symbols = undefined, params = {}) {
@@ -3116,9 +3123,9 @@ class binance extends binance$1 {
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchLastPrices', market, params);
         [type, params] = this.handleMarketTypeAndParams('fetchLastPrices', market, params);
-        let method = undefined;
+        let response = undefined;
         if (this.isLinear(type, subType)) {
-            method = 'fapiPublicGetTickerPrice';
+            response = await this.fapiPublicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3131,7 +3138,7 @@ class binance extends binance$1 {
             //
         }
         else if (this.isInverse(type, subType)) {
-            method = 'dapiPublicGetTickerPrice';
+            response = await this.dapiPublicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3144,7 +3151,7 @@ class binance extends binance$1 {
             //
         }
         else if (type === 'spot') {
-            method = 'publicGetTickerPrice';
+            response = await this.publicGetTickerPrice(params);
             //
             //     [
             //         {
@@ -3158,7 +3165,6 @@ class binance extends binance$1 {
         else {
             throw new errors.NotSupported(this.id + ' fetchLastPrices() does not support ' + type + ' markets yet');
         }
-        const response = await this[method](params);
         return this.parseLastPrices(response, symbols);
     }
     parseLastPrice(info, market = undefined) {
@@ -6478,10 +6484,20 @@ class binance extends binance$1 {
     }
     parseTradingFee(fee, market = undefined) {
         //
+        // spot
+        //     [
+        //       {
+        //         "symbol": "BTCUSDT",
+        //         "makerCommission": "0.001",
+        //         "takerCommission": "0.001"
+        //       }
+        //     ]
+        //
+        // swap
         //     {
-        //         "symbol": "ADABNB",
-        //         "makerCommission": 0.001,
-        //         "takerCommission": 0.001
+        //         "symbol": "BTCUSD_PERP",
+        //         "makerCommissionRate": "0.00015",  // 0.015%
+        //         "takerCommissionRate": "0.00040"   // 0.040%
         //     }
         //
         const marketId = this.safeString(fee, 'symbol');
@@ -6489,8 +6505,8 @@ class binance extends binance$1 {
         return {
             'info': fee,
             'symbol': symbol,
-            'maker': this.safeNumber(fee, 'makerCommission'),
-            'taker': this.safeNumber(fee, 'takerCommission'),
+            'maker': this.safeNumber2(fee, 'makerCommission', 'makerCommissionRate'),
+            'taker': this.safeNumber2(fee, 'takerCommission', 'takerCommissionRate'),
         };
     }
     async fetchTradingFee(symbol, params = {}) {
@@ -6499,17 +6515,37 @@ class binance extends binance$1 {
          * @name binance#fetchTradingFee
          * @description fetch the trading fees for a market
          * @see https://binance-docs.github.io/apidocs/spot/en/#trade-fee-user_data
+         * @see https://binance-docs.github.io/apidocs/futures/en/#user-commission-rate-user_data
+         * @see https://binance-docs.github.io/apidocs/delivery/en/#user-commission-rate-user_data
          * @param {string} symbol unified market symbol
          * @param {object} [params] extra parameters specific to the binance api endpoint
          * @returns {object} a [fee structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
+        const defaultType = this.safeString2(this.options, 'fetchTradingFee', 'defaultType', 'linear');
+        const type = this.safeString(params, 'type', defaultType);
+        params = this.omit(params, 'type');
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchTradingFee', market, params);
+        const isSpotOrMargin = (type === 'spot') || (type === 'margin');
+        const isLinear = this.isLinear(type, subType);
+        const isInverse = this.isInverse(type, subType);
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.sapiGetAssetTradeFee(this.extend(request, params));
+        let response = undefined;
+        if (isSpotOrMargin) {
+            response = await this.sapiGetAssetTradeFee(this.extend(request, params));
+        }
+        else if (isLinear) {
+            response = await this.fapiPrivateGetCommissionRate(this.extend(request, params));
+        }
+        else if (isInverse) {
+            response = await this.dapiPrivateGetCommissionRate(this.extend(request, params));
+        }
         //
+        // spot
         //     [
         //       {
         //         "symbol": "BTCUSDT",
@@ -6518,8 +6554,18 @@ class binance extends binance$1 {
         //       }
         //     ]
         //
-        const first = this.safeValue(response, 0, {});
-        return this.parseTradingFee(first);
+        // swap
+        //     {
+        //         "symbol": "BTCUSD_PERP",
+        //         "makerCommissionRate": "0.00015",  // 0.015%
+        //         "takerCommissionRate": "0.00040"   // 0.040%
+        //     }
+        //
+        let data = response;
+        if (Array.isArray(data)) {
+            data = this.safeValue(data, 0, {});
+        }
+        return this.parseTradingFee(data);
     }
     async fetchTradingFees(params = {}) {
         /**
@@ -6534,11 +6580,10 @@ class binance extends binance$1 {
          */
         await this.loadMarkets();
         let method = undefined;
-        const defaultType = this.safeString2(this.options, 'fetchTradingFees', 'defaultType', 'linear');
-        const type = this.safeString(params, 'type', defaultType);
-        params = this.omit(params, 'type');
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchTradingFees', undefined, params);
         let subType = undefined;
-        [subType, params] = this.handleSubTypeAndParams('fetchTradingFees', undefined, params);
+        [subType, params] = this.handleSubTypeAndParams('fetchTradingFees', undefined, params, 'linear');
         const isSpotOrMargin = (type === 'spot') || (type === 'margin');
         const isLinear = this.isLinear(type, subType);
         const isInverse = this.isInverse(type, subType);
@@ -8215,13 +8260,15 @@ class binance extends binance$1 {
         let type = undefined;
         let subType = undefined;
         let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+        }
         let method = undefined;
         const request = {};
         [type, params] = this.handleMarketTypeAndParams('fetchLedger', undefined, params);
         [subType, params] = this.handleSubTypeAndParams('fetchLedger', undefined, params);
         if (type === 'option') {
             this.checkRequiredArgument('fetchLedger', code, 'code');
-            currency = this.currency(code);
             request['currency'] = currency['id'];
             method = 'eapiPrivateGetBill';
         }
@@ -9176,6 +9223,232 @@ class binance extends binance$1 {
             'info': interest,
         }, market);
     }
+    async fetchMyLiquidations(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#fetchMyLiquidations
+         * @description retrieves the users liquidated positions
+         * @see https://binance-docs.github.io/apidocs/spot/en/#get-force-liquidation-record-user_data
+         * @see https://binance-docs.github.io/apidocs/futures/en/#user-39-s-force-orders-user_data
+         * @see https://binance-docs.github.io/apidocs/delivery/en/#user-39-s-force-orders-user_data
+         * @param {string} [symbol] unified CCXT market symbol
+         * @param {int} [since] the earliest time in ms to fetch liquidations for
+         * @param {int} [limit] the maximum number of liquidation structures to retrieve
+         * @param {object} [params] exchange specific parameters for the binance api endpoint
+         * @param {int} [params.until] timestamp in ms of the latest liquidation
+         * @param {boolean} [params.paginate] *spot only* default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         * @returns {object} an array of [liquidation structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchMyLiquidations', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallIncremental('fetchMyLiquidations', symbol, since, limit, params, 'current', 100);
+        }
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+        }
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchMyLiquidations', market, params);
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchMyLiquidations', market, params, 'linear');
+        let request = {};
+        if (type !== 'spot') {
+            request['autoCloseType'] = 'LIQUIDATION';
+        }
+        if (market !== undefined) {
+            const symbolKey = market['spot'] ? 'isolatedSymbol' : 'symbol';
+            request[symbolKey] = market['id'];
+        }
+        if (since !== undefined) {
+            request['startTime'] = since;
+        }
+        if (limit !== undefined) {
+            if (type === 'spot') {
+                request['size'] = limit;
+            }
+            else {
+                request['limit'] = limit;
+            }
+        }
+        [request, params] = this.handleUntilOption('endTime', request, params);
+        let response = undefined;
+        if (type === 'spot') {
+            response = await this.sapiGetMarginForceLiquidationRec(this.extend(request, params));
+        }
+        else if (subType === 'linear') {
+            response = await this.fapiPrivateGetForceOrders(this.extend(request, params));
+        }
+        else if (subType === 'inverse') {
+            response = await this.dapiPrivateGetForceOrders(this.extend(request, params));
+        }
+        else {
+            throw new errors.NotSupported(this.id + ' fetchMyLiquidations() does not support ' + market['type'] + ' markets');
+        }
+        //
+        // margin
+        //
+        //     {
+        //         "rows": [
+        //             {
+        //                 "avgPrice": "0.00388359",
+        //                 "executedQty": "31.39000000",
+        //                 "orderId": 180015097,
+        //                 "price": "0.00388110",
+        //                 "qty": "31.39000000",
+        //                 "side": "SELL",
+        //                 "symbol": "BNBBTC",
+        //                 "timeInForce": "GTC",
+        //                 "isIsolated": true,
+        //                 "updatedTime": 1558941374745
+        //             }
+        //         ],
+        //         "total": 1
+        //     }
+        //
+        // linear
+        //
+        //     [
+        //         {
+        //             "orderId": 6071832819,
+        //             "symbol": "BTCUSDT",
+        //             "status": "FILLED",
+        //             "clientOrderId": "autoclose-1596107620040000020",
+        //             "price": "10871.09",
+        //             "avgPrice": "10913.21000",
+        //             "origQty": "0.001",
+        //             "executedQty": "0.001",
+        //             "cumQuote": "10.91321",
+        //             "timeInForce": "IOC",
+        //             "type": "LIMIT",
+        //             "reduceOnly": false,
+        //             "closePosition": false,
+        //             "side": "SELL",
+        //             "positionSide": "BOTH",
+        //             "stopPrice": "0",
+        //             "workingType": "CONTRACT_PRICE",
+        //             "origType": "LIMIT",
+        //             "time": 1596107620044,
+        //             "updateTime": 1596107620087
+        //         },
+        //     ]
+        //
+        // inverse
+        //
+        //     [
+        //         {
+        //             "orderId": 165123080,
+        //             "symbol": "BTCUSD_200925",
+        //             "pair": "BTCUSD",
+        //             "status": "FILLED",
+        //             "clientOrderId": "autoclose-1596542005017000006",
+        //             "price": "11326.9",
+        //             "avgPrice": "11326.9",
+        //             "origQty": "1",
+        //             "executedQty": "1",
+        //             "cumBase": "0.00882854",
+        //             "timeInForce": "IOC",
+        //             "type": "LIMIT",
+        //             "reduceOnly": false,
+        //             "closePosition": false,
+        //             "side": "SELL",
+        //             "positionSide": "BOTH",
+        //             "stopPrice": "0",
+        //             "workingType": "CONTRACT_PRICE",
+        //             "priceProtect": false,
+        //             "origType": "LIMIT",
+        //             "time": 1596542005019,
+        //             "updateTime": 1596542005050
+        //         },
+        //     ]
+        //
+        const liquidations = this.safeValue(response, 'rows', response);
+        return this.parseLiquidations(liquidations, market, since, limit);
+    }
+    parseLiquidation(liquidation, market = undefined) {
+        //
+        // margin
+        //
+        //     {
+        //         "avgPrice": "0.00388359",
+        //         "executedQty": "31.39000000",
+        //         "orderId": 180015097,
+        //         "price": "0.00388110",
+        //         "qty": "31.39000000",
+        //         "side": "SELL",
+        //         "symbol": "BNBBTC",
+        //         "timeInForce": "GTC",
+        //         "isIsolated": true,
+        //         "updatedTime": 1558941374745
+        //     }
+        //
+        // linear
+        //
+        //     {
+        //         "orderId": 6071832819,
+        //         "symbol": "BTCUSDT",
+        //         "status": "FILLED",
+        //         "clientOrderId": "autoclose-1596107620040000020",
+        //         "price": "10871.09",
+        //         "avgPrice": "10913.21000",
+        //         "origQty": "0.001",
+        //         "executedQty": "0.001",
+        //         "cumQuote": "10.91321",
+        //         "timeInForce": "IOC",
+        //         "type": "LIMIT",
+        //         "reduceOnly": false,
+        //         "closePosition": false,
+        //         "side": "SELL",
+        //         "positionSide": "BOTH",
+        //         "stopPrice": "0",
+        //         "workingType": "CONTRACT_PRICE",
+        //         "origType": "LIMIT",
+        //         "time": 1596107620044,
+        //         "updateTime": 1596107620087
+        //     }
+        //
+        // inverse
+        //
+        //     {
+        //         "orderId": 165123080,
+        //         "symbol": "BTCUSD_200925",
+        //         "pair": "BTCUSD",
+        //         "status": "FILLED",
+        //         "clientOrderId": "autoclose-1596542005017000006",
+        //         "price": "11326.9",
+        //         "avgPrice": "11326.9",
+        //         "origQty": "1",
+        //         "executedQty": "1",
+        //         "cumBase": "0.00882854",
+        //         "timeInForce": "IOC",
+        //         "type": "LIMIT",
+        //         "reduceOnly": false,
+        //         "closePosition": false,
+        //         "side": "SELL",
+        //         "positionSide": "BOTH",
+        //         "stopPrice": "0",
+        //         "workingType": "CONTRACT_PRICE",
+        //         "priceProtect": false,
+        //         "origType": "LIMIT",
+        //         "time": 1596542005019,
+        //         "updateTime": 1596542005050
+        //     }
+        //
+        const marketId = this.safeString(liquidation, 'symbol');
+        const timestamp = this.safeInteger2(liquidation, 'updatedTime', 'updateTime');
+        return {
+            'info': liquidation,
+            'symbol': this.safeSymbol(marketId, market),
+            'contracts': this.safeNumber(liquidation, 'executedQty'),
+            'contractSize': this.safeNumber(market, 'contractSize'),
+            'price': this.safeNumber(liquidation, 'avgPrice'),
+            'baseValue': this.safeNumber(liquidation, 'cumBase'),
+            'quoteValue': this.safeNumber(liquidation, 'cumQuote'),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+        };
+    }
 }
 
 module.exports = binance;

package/dist/cjs/src/bingx.js

@@ -610,6 +610,7 @@ class bingx extends bingx$1 {
                     'max': this.safeNumber(market, 'maxNotional'),
                 },
             },
+            'created': undefined,
             'info': market,
         };
         return entry;

package/dist/cjs/src/bitbank.js

@@ -246,6 +246,7 @@ class bitbank extends bitbank$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': entry,
             });
         }

package/dist/cjs/src/bitbns.js

@@ -275,6 +275,7 @@ class bitbns extends bitbns$1 {
                         'max': this.safeNumber(costLimits, 'max'),
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }

package/dist/cjs/src/bitfinex.js

@@ -654,6 +654,7 @@ class bitfinex extends bitfinex$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }

package/dist/cjs/src/bitfinex2.js

@@ -574,6 +574,7 @@ class bitfinex2 extends bitfinex2$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }

package/dist/cjs/src/bitflyer.js

@@ -292,6 +292,7 @@ class bitflyer extends bitflyer$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }

package/dist/cjs/src/bitforex.js

@@ -230,6 +230,7 @@ class bitforex extends bitforex$1 {
                         'max': undefined,
                     },
                 },
+                'created': undefined,
                 'info': market,
             });
         }