ccxt 4.2.53 → 4.2.55

package/js/src/pro/binance.js

@@ -66,6 +66,7 @@ export default class binance extends binanceRest {
                         'future': 'wss://fstream.binance.com/ws',
                         'delivery': 'wss://dstream.binance.com/ws',
                         'ws': 'wss://ws-api.binance.com:443/ws-api/v3',
+                        'papi': 'wss://fstream.binance.com/pm/ws',
                     },
                 },
             },
@@ -1241,11 +1242,12 @@ export default class binance extends binanceRest {
     }
     async authenticate(params = {}) {
         const time = this.milliseconds();
-        let query = undefined;
         let type = undefined;
-        [type, query] = this.handleMarketTypeAndParams('authenticate', undefined, params);
+        [type, params] = this.handleMarketTypeAndParams('authenticate', undefined, params);
         let subType = undefined;
-        [subType, query] = this.handleSubTypeAndParams('authenticate', undefined, query);
+        [subType, params] = this.handleSubTypeAndParams('authenticate', undefined, params);
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'authenticate', 'papi', 'portfolioMargin', false);
         if (this.isLinear(type, subType)) {
             type = 'future';
         }
@@ -1253,36 +1255,39 @@ export default class binance extends binanceRest {
             type = 'delivery';
         }
         let marginMode = undefined;
-        [marginMode, query] = this.handleMarginModeAndParams('authenticate', query);
+        [marginMode, params] = this.handleMarginModeAndParams('authenticate', params);
         const isIsolatedMargin = (marginMode === 'isolated');
         const isCrossMargin = (marginMode === 'cross') || (marginMode === undefined);
-        const symbol = this.safeString(query, 'symbol');
-        query = this.omit(query, 'symbol');
+        const symbol = this.safeString(params, 'symbol');
+        params = this.omit(params, 'symbol');
         const options = this.safeValue(this.options, type, {});
         const lastAuthenticatedTime = this.safeInteger(options, 'lastAuthenticatedTime', 0);
         const listenKeyRefreshRate = this.safeInteger(this.options, 'listenKeyRefreshRate', 1200000);
         const delay = this.sum(listenKeyRefreshRate, 10000);
         if (time - lastAuthenticatedTime > delay) {
             let response = undefined;
-            if (type === 'future') {
-                response = await this.fapiPrivatePostListenKey(query);
+            if (isPortfolioMargin) {
+                response = await this.papiPostListenKey(params);
+            }
+            else if (type === 'future') {
+                response = await this.fapiPrivatePostListenKey(params);
             }
             else if (type === 'delivery') {
-                response = await this.dapiPrivatePostListenKey(query);
+                response = await this.dapiPrivatePostListenKey(params);
             }
             else if (type === 'margin' && isCrossMargin) {
-                response = await this.sapiPostUserDataStream(query);
+                response = await this.sapiPostUserDataStream(params);
             }
             else if (isIsolatedMargin) {
                 if (symbol === undefined) {
                     throw new ArgumentsRequired(this.id + ' authenticate() requires a symbol argument for isolated margin mode');
                 }
                 const marketId = this.marketId(symbol);
-                query = this.extend(query, { 'symbol': marketId });
-                response = await this.sapiPostUserDataStreamIsolated(query);
+                params = this.extend(params, { 'symbol': marketId });
+                response = await this.sapiPostUserDataStreamIsolated(params);
             }
             else {
-                response = await this.publicPostUserDataStream(query);
+                response = await this.publicPostUserDataStream(params);
             }
             this.options[type] = this.extend(options, {
                 'listenKey': this.safeString(response, 'listenKey'),
@@ -1295,6 +1300,8 @@ export default class binance extends binanceRest {
         // https://binance-docs.github.io/apidocs/spot/en/#listen-key-spot
         let type = this.safeString2(this.options, 'defaultType', 'authenticate', 'spot');
         type = this.safeString(params, 'type', type);
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'keepAliveListenKey', 'papi', 'portfolioMargin', false);
         const subTypeInfo = this.handleSubTypeAndParams('keepAliveListenKey', undefined, params);
         const subType = subTypeInfo[0];
         if (this.isLinear(type, subType)) {
@@ -1311,28 +1318,35 @@ export default class binance extends binanceRest {
         }
         const request = {};
         const symbol = this.safeString(params, 'symbol');
-        const sendParams = this.omit(params, ['type', 'symbol']);
+        params = this.omit(params, ['type', 'symbol']);
         const time = this.milliseconds();
         try {
-            if (type === 'future') {
-                await this.fapiPrivatePutListenKey(this.extend(request, sendParams));
+            if (isPortfolioMargin) {
+                await this.papiPutListenKey(this.extend(request, params));
+            }
+            else if (type === 'future') {
+                await this.fapiPrivatePutListenKey(this.extend(request, params));
             }
             else if (type === 'delivery') {
-                await this.dapiPrivatePutListenKey(this.extend(request, sendParams));
+                await this.dapiPrivatePutListenKey(this.extend(request, params));
             }
             else {
                 request['listenKey'] = listenKey;
                 if (type === 'margin') {
                     request['symbol'] = symbol;
-                    await this.sapiPutUserDataStream(this.extend(request, sendParams));
+                    await this.sapiPutUserDataStream(this.extend(request, params));
                 }
                 else {
-                    await this.publicPutUserDataStream(this.extend(request, sendParams));
+                    await this.publicPutUserDataStream(this.extend(request, params));
                 }
             }
         }
         catch (error) {
-            const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];
+            let urlType = type;
+            if (isPortfolioMargin) {
+                urlType = 'papi';
+            }
+            const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
             const client = this.client(url);
             const messageHashes = Object.keys(client.futures);
             for (let i = 0; i < messageHashes.length; i++) {
@@ -1364,7 +1378,7 @@ export default class binance extends binanceRest {
             }
         }
     }
-    setBalanceCache(client, type) {
+    setBalanceCache(client, type, isPortfolioMargin = false) {
         if (type in client.subscriptions) {
             return;
         }
@@ -1374,15 +1388,21 @@ export default class binance extends binanceRest {
             const messageHash = type + ':fetchBalanceSnapshot';
             if (!(messageHash in client.futures)) {
                 client.future(messageHash);
-                this.spawn(this.loadBalanceSnapshot, client, messageHash, type);
+                this.spawn(this.loadBalanceSnapshot, client, messageHash, type, isPortfolioMargin);
             }
         }
         else {
             this.balance[type] = {};
         }
     }
-    async loadBalanceSnapshot(client, messageHash, type) {
-        const response = await this.fetchBalance({ 'type': type });
+    async loadBalanceSnapshot(client, messageHash, type, isPortfolioMargin) {
+        const params = {
+            'type': type,
+        };
+        if (isPortfolioMargin) {
+            params['portfolioMargin'] = true;
+        }
+        const response = await this.fetchBalance(params);
         this.balance[type] = this.extend(response, this.safeValue(this.balance, type, {}));
         // don't remove the future from the .futures cache
         const future = client.futures[messageHash];
@@ -1476,6 +1496,7 @@ export default class binance extends binanceRest {
          * @name binance#watchBalance
          * @description watch 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
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to watch the balance of a portfolio margin account
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
         await this.loadMarkets();
@@ -1484,16 +1505,22 @@ export default class binance extends binanceRest {
         let type = this.safeString(params, 'type', defaultType);
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('watchBalance', undefined, params);
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'watchBalance', 'papi', 'portfolioMargin', false);
+        let urlType = type;
+        if (isPortfolioMargin) {
+            urlType = 'papi';
+        }
         if (this.isLinear(type, subType)) {
             type = 'future';
         }
         else if (this.isInverse(type, subType)) {
             type = 'delivery';
         }
-        const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];
+        const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
-        this.setBalanceCache(client, type);
-        this.setPositionsCache(client, type);
+        this.setBalanceCache(client, type, isPortfolioMargin);
+        this.setPositionsCache(client, type, undefined, isPortfolioMargin);
         const options = this.safeValue(this.options, 'watchBalance');
         const fetchBalanceSnapshot = this.safeBool(options, 'fetchBalanceSnapshot', false);
         const awaitBalanceSnapshot = this.safeBool(options, 'awaitBalanceSnapshot', true);
@@ -2100,11 +2127,14 @@ export default class binance extends binanceRest {
          * @name binance#watchOrders
          * @description watches information on multiple orders made by the user
          * @see https://binance-docs.github.io/apidocs/spot/en/#payload-order-update
+         * @see https://binance-docs.github.io/apidocs/pm/en/#event-futures-order-update
+         * @see https://binance-docs.github.io/apidocs/pm/en/#event-margin-order-update
          * @param {string} symbol unified market symbol of the market the orders were made in
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {string|undefined} [params.marginMode] 'cross' or 'isolated', for spot margin
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to watch portfolio margin account orders
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -2133,10 +2163,15 @@ export default class binance extends binanceRest {
         if ((type === 'margin') || ((type === 'spot') && (marginMode !== undefined))) {
             urlType = 'spot'; // spot-margin shares the same stream as regular spot
         }
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'watchOrders', 'papi', 'portfolioMargin', false);
+        if (isPortfolioMargin) {
+            urlType = 'papi';
+        }
         const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
-        this.setBalanceCache(client, type);
-        this.setPositionsCache(client, type);
+        this.setBalanceCache(client, type, isPortfolioMargin);
+        this.setPositionsCache(client, type, undefined, isPortfolioMargin);
         const message = undefined;
         const orders = await this.watch(url, messageHash, message, type);
         if (this.newUpdates) {
@@ -2391,6 +2426,7 @@ export default class binance extends binanceRest {
          * @description watch all open positions
          * @param {string[]|undefined} symbols list of unified market symbols
          * @param {object} params extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to watch positions in a portfolio margin account
          * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
          */
         await this.loadMarkets();
@@ -2421,10 +2457,16 @@ export default class binance extends binanceRest {
             type = 'delivery';
         }
         messageHash = type + ':positions' + messageHash;
-        const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'watchPositions', 'papi', 'portfolioMargin', false);
+        let urlType = type;
+        if (isPortfolioMargin) {
+            urlType = 'papi';
+        }
+        const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
-        this.setBalanceCache(client, type);
-        this.setPositionsCache(client, type, symbols);
+        this.setBalanceCache(client, type, isPortfolioMargin);
+        this.setPositionsCache(client, type, symbols, isPortfolioMargin);
         const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
         const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
         const cache = this.safeValue(this.positions, type);
@@ -2438,7 +2480,7 @@ export default class binance extends binanceRest {
         }
         return this.filterBySymbolsSinceLimit(cache, symbols, since, limit, true);
     }
-    setPositionsCache(client, type, symbols = undefined) {
+    setPositionsCache(client, type, symbols = undefined, isPortfolioMargin = false) {
         if (type === 'spot') {
             return;
         }
@@ -2453,15 +2495,21 @@ export default class binance extends binanceRest {
             const messageHash = type + ':fetchPositionsSnapshot';
             if (!(messageHash in client.futures)) {
                 client.future(messageHash);
-                this.spawn(this.loadPositionsSnapshot, client, messageHash, type);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash, type, isPortfolioMargin);
             }
         }
         else {
             this.positions[type] = new ArrayCacheBySymbolBySide();
         }
     }
-    async loadPositionsSnapshot(client, messageHash, type) {
-        const positions = await this.fetchPositions(undefined, { 'type': type });
+    async loadPositionsSnapshot(client, messageHash, type, isPortfolioMargin) {
+        const params = {
+            'type': type,
+        };
+        if (isPortfolioMargin) {
+            params['portfolioMargin'] = true;
+        }
+        const positions = await this.fetchPositions(undefined, params);
         this.positions[type] = new ArrayCacheBySymbolBySide();
         const cache = this.positions[type];
         for (let i = 0; i < positions.length; i++) {
@@ -2734,6 +2782,7 @@ export default class binance extends binanceRest {
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to watch trades in a portfolio margin account
          * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
          */
         await this.loadMarkets();
@@ -2763,10 +2812,15 @@ export default class binance extends binanceRest {
         if (type === 'margin') {
             urlType = 'spot'; // spot-margin shares the same stream as regular spot
         }
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'watchMyTrades', 'papi', 'portfolioMargin', false);
+        if (isPortfolioMargin) {
+            urlType = 'papi';
+        }
         const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
-        this.setBalanceCache(client, type);
-        this.setPositionsCache(client, type);
+        this.setBalanceCache(client, type, isPortfolioMargin);
+        this.setPositionsCache(client, type, undefined, isPortfolioMargin);
         const message = undefined;
         const trades = await this.watch(url, messageHash, message, type);
         if (this.newUpdates) {

package/js/src/static_dependencies/jsencrypt/lib/jsbn/jsbn.d.ts

@@ -15,7 +15,7 @@ export declare class BigInteger {
     protected intValue(): number;
     protected byteValue(): number;
     protected shortValue(): number;
-    protected signum(): 1 | 0 | -1;
+    protected signum(): 0 | 1 | -1;
     toByteArray(): number[];
     protected equals(a: BigInteger): boolean;
     protected min(a: BigInteger): BigInteger;

package/js/src/whitebit.js

@@ -230,6 +230,7 @@ export default class whitebit extends Exchange {
                     'account': 'spot',
                 },
                 'accountsByType': {
+                    'funding': 'main',
                     'main': 'main',
                     'spot': 'spot',
                     'margin': 'collateral',
@@ -1323,9 +1324,9 @@ export default class whitebit extends Exchange {
         else {
             const options = this.safeValue(this.options, 'fetchBalance', {});
             const defaultAccount = this.safeString(options, 'account');
-            const account = this.safeString(params, 'account', defaultAccount);
-            params = this.omit(params, 'account');
-            if (account === 'main') {
+            const account = this.safeString2(params, 'account', 'type', defaultAccount);
+            params = this.omit(params, ['account', 'type']);
+            if (account === 'main' || account === 'funding') {
                 response = await this.v4PrivatePostMainAccountBalance(params);
             }
             else {

package/jsdoc2md.js

@@ -108,10 +108,11 @@ const sidebar =
 - [Supported Exchanges](Exchange-Markets.md)
 - [Exchanges By Country](Exchange-Markets-By-Country.md)
 - [API Spec By Method](baseSpec.md)
-- API Spec by Exchange
-${exchangeLinks.join('\n')}
+- [FAQ](FAQ.md)
 - [Changelog](CHANGELOG.md)
 - [Awesome](Awesome.md)
+- API Spec by Exchange
+${exchangeLinks.join('\n')}
 `
 fs.writeFileSync('./wiki/_sidebar.md', sidebar);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.2.53",
+  "version": "4.2.55",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",

package/skip-tests.json

@@ -219,6 +219,12 @@
                 "withdraw": "not provided",
                 "deposit": "not provided"
             },
+            "fetchTickers": {
+                "open": "https://app.travis-ci.com/github/ccxt/ccxt/builds/269177570#L3624"
+            },
+            "watchTickers": {
+                "open": "same"
+            },
             "fetchOrderBook": {
                 "bid": "multiple bids might have same value"
             },
@@ -297,18 +303,30 @@
                 "networks": "missing"
             },
             "fetchTickers": {
-                "quoteVolume": "quoteVolume >= baseVolume * low is failing",
-                "baseVolume": "same"
+                "spread": "https://app.travis-ci.com/github/ccxt/ccxt/builds/269177564#L3615",
+                "quoteVolume": "quoteVolume >= baseVolume * low is failing"
             },
             "fetchTicker": {
-                "quoteVolume": "quoteVolume >= baseVolume * low is failing",
-                "baseVolume": "same"
+                "spread": "same",
+                "quoteVolume": "same"
+            },
+            "watchTickers": {
+                "spread": "same",
+                "quoteVolume": "same"
+            },
+            "fetchOrderBook": {
+                "spread": "https://app.travis-ci.com/github/ccxt/ccxt/builds/269177564#L3946"
+            },
+            "fetchL2OrderBook": {
+                "spread": "same"
             },
-            "fetchL2OrderBook": "bid==ask , https://app.travis-ci.com/github/ccxt/ccxt/builds/263304041#L2170",
-            "fetchLOrderBook": "same",
             "watchOrderBook": {
                 "nonce":"missing https://app.travis-ci.com/github/ccxt/ccxt/builds/267900037#L4256",
-                "bid": "wrong data https://app.travis-ci.com/github/ccxt/ccxt/builds/267900037#L4325"
+                "spread": "same"
+            },
+            "watchOrderBookForSymbols": {
+                "nonce":"same",
+                "spread": "same"
             },
             "watchTrades":{
                 "side": "not set https://app.travis-ci.com/github/ccxt/ccxt/builds/267900037#L4312"
@@ -379,7 +397,7 @@
     },
     "onetrading": {
         "skip": true,
-        "until": "2024-02-28",
+        "until": "2024-03-28",
         "skipWs": true,
         "skipMethods": {
             "fetchOrderBook": "some bid might be lower than next bid",
@@ -849,6 +867,7 @@
         }
     },
     "delta": {
+        "httpsProxy": "http://5.75.153.75:8002",
         "skipMethods": {
             "loadMarkets": "expiryDatetime must be equal to expiry in iso8601 format",
             "fetchOrderBook": "ask crossing bids test failing",
@@ -1223,6 +1242,7 @@
                 "currencyIdAndCode": "messed"
             },
             "fetchCurrencies": {
+                "currencyIdAndCode": "https://app.travis-ci.com/github/ccxt/ccxt/builds/269188556#L4337",
                 "withdraw":"not provided",
                 "deposit":"not provided"
             },