ccxt 4.2.53 → 4.2.54

package/js/src/abstract/binanceusdm.d.ts

@@ -71,8 +71,6 @@ interface binance {
     sapiGetLoanFlexibleBorrowHistory(params?: {}): Promise<implicitReturnType>;
     sapiGetLoanFlexibleRepayHistory(params?: {}): Promise<implicitReturnType>;
     sapiGetLoanFlexibleLtvAdjustmentHistory(params?: {}): Promise<implicitReturnType>;
-    sapiGetLoanFlexibleLoanableData(params?: {}): Promise<implicitReturnType>;
-    sapiGetLoanFlexibleCollateralData(params?: {}): Promise<implicitReturnType>;
     sapiGetLoanVipOngoingOrders(params?: {}): Promise<implicitReturnType>;
     sapiGetLoanVipRepayHistory(params?: {}): Promise<implicitReturnType>;
     sapiGetLoanVipCollateralAccount(params?: {}): Promise<implicitReturnType>;
@@ -336,7 +334,6 @@ interface binance {
     sapiPostLoanRepay(params?: {}): Promise<implicitReturnType>;
     sapiPostLoanAdjustLtv(params?: {}): Promise<implicitReturnType>;
     sapiPostLoanCustomizeMarginCall(params?: {}): Promise<implicitReturnType>;
-    sapiPostLoanFlexibleBorrow(params?: {}): Promise<implicitReturnType>;
     sapiPostLoanFlexibleRepay(params?: {}): Promise<implicitReturnType>;
     sapiPostLoanFlexibleAdjustLtv(params?: {}): Promise<implicitReturnType>;
     sapiPostLoanVipRepay(params?: {}): Promise<implicitReturnType>;
@@ -379,8 +376,17 @@ interface binance {
     sapiV2GetSubAccountFuturesAccount(params?: {}): Promise<implicitReturnType>;
     sapiV2GetSubAccountFuturesAccountSummary(params?: {}): Promise<implicitReturnType>;
     sapiV2GetSubAccountFuturesPositionRisk(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleOngoingOrders(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleBorrowHistory(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleRepayHistory(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleLtvAdjustmentHistory(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleLoanableData(params?: {}): Promise<implicitReturnType>;
+    sapiV2GetLoanFlexibleCollateralData(params?: {}): Promise<implicitReturnType>;
     sapiV2PostEthStakingEthStake(params?: {}): Promise<implicitReturnType>;
     sapiV2PostSubAccountSubAccountApiIpRestriction(params?: {}): Promise<implicitReturnType>;
+    sapiV2PostLoanFlexibleBorrow(params?: {}): Promise<implicitReturnType>;
+    sapiV2PostLoanFlexibleRepay(params?: {}): Promise<implicitReturnType>;
+    sapiV2PostLoanFlexibleAdjustLtv(params?: {}): Promise<implicitReturnType>;
     sapiV3GetSubAccountAssets(params?: {}): Promise<implicitReturnType>;
     sapiV3PostAssetGetUserAsset(params?: {}): Promise<implicitReturnType>;
     sapiV4GetSubAccountAssets(params?: {}): Promise<implicitReturnType>;

package/js/src/binance.d.ts

@@ -264,6 +264,7 @@ export default class binance extends Exchange {
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
     setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
     setPositionMode(hedged: boolean, symbol?: Str, params?: {}): Promise<any>;
+    fetchLeverage(symbol: string, params?: {}): Promise<any>;
     fetchSettlementHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     fetchMySettlementHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseSettlement(settlement: any, market: any): {
@@ -274,6 +275,7 @@ export default class binance extends Exchange {
         datetime: string;
     };
     parseSettlements(settlements: any, market: any): any[];
+    fetchLedgerEntry(id: string, code?: Str, params?: {}): Promise<any>;
     fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseLedgerEntry(item: any, currency?: Currency): {
         id: string;

package/js/src/binance.js

@@ -96,7 +96,8 @@ export default class binance extends Exchange {
                 'fetchL3OrderBook': false,
                 'fetchLastPrices': true,
                 'fetchLedger': true,
-                'fetchLeverage': false,
+                'fetchLedgerEntry': true,
+                'fetchLeverage': true,
                 'fetchLeverageTiers': true,
                 'fetchLiquidations': false,
                 'fetchMarketLeverageTiers': 'emulated',
@@ -296,8 +297,6 @@ export default class binance extends Exchange {
                         'loan/flexible/borrow/history': 40,
                         'loan/flexible/repay/history': 40,
                         'loan/flexible/ltv/adjustment/history': 40,
-                        'loan/flexible/loanable/data': 40,
-                        'loan/flexible/collateral/data': 40,
                         'loan/vip/ongoing/orders': 40,
                         'loan/vip/repay/history': 40,
                         'loan/vip/collateral/account': 600,
@@ -589,7 +588,6 @@ export default class binance extends Exchange {
                         'loan/repay': 40.002,
                         'loan/adjust/ltv': 40.002,
                         'loan/customize/margin_call': 40.002,
-                        'loan/flexible/borrow': 40.002,
                         'loan/flexible/repay': 40.002,
                         'loan/flexible/adjust/ltv': 40.002,
                         'loan/vip/repay': 40.002,
@@ -644,10 +642,19 @@ export default class binance extends Exchange {
                         'sub-account/futures/account': 0.1,
                         'sub-account/futures/accountSummary': 1,
                         'sub-account/futures/positionRisk': 0.1,
+                        'loan/flexible/ongoing/orders': 30,
+                        'loan/flexible/borrow/history': 40,
+                        'loan/flexible/repay/history': 40,
+                        'loan/flexible/ltv/adjustment/history': 40,
+                        'loan/flexible/loanable/data': 40,
+                        'loan/flexible/collateral/data': 40, // Weight(IP): 400 => cost = 0.1 * 400 = 40
                     },
                     'post': {
                         'eth-staking/eth/stake': 15,
-                        'sub-account/subAccountApi/ipRestriction': 20.001, // Weight(UID): 3000 => cost = 0.006667 * 3000 = 20.001
+                        'sub-account/subAccountApi/ipRestriction': 20.001,
+                        'loan/flexible/borrow': 40.002,
+                        'loan/flexible/repay': 40.002,
+                        'loan/flexible/adjust/ltv': 40.002, // Weight(UID): 6000 => cost = 0.006667 * 6000 = 40.002
                     },
                 },
                 'sapiV3': {
@@ -10382,6 +10389,67 @@ export default class binance extends Exchange {
         //
         return response;
     }
+    async fetchLeverage(symbol, params = {}) {
+        /**
+         * @method
+         * @name binance#fetchLeverage
+         * @description fetch the set leverage for a market
+         * @see https://binance-docs.github.io/apidocs/futures/en/#account-information-v2-user_data
+         * @see https://binance-docs.github.io/apidocs/delivery/en/#account-information-user_data
+         * @see https://binance-docs.github.io/apidocs/pm/en/#get-um-account-detail-user_data
+         * @see https://binance-docs.github.io/apidocs/pm/en/#get-cm-account-detail-user_data
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
+         */
+        await this.loadMarkets();
+        await this.loadLeverageBrackets(false, params);
+        const market = this.market(symbol);
+        if (!market['contract']) {
+            throw new NotSupported(this.id + ' fetchLeverage() supports linear and inverse contracts only');
+        }
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchLeverage', market, params);
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchLeverage', market, params, 'linear');
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'fetchLeverage', 'papi', 'portfolioMargin', false);
+        let response = undefined;
+        if (this.isLinear(type, subType)) {
+            if (isPortfolioMargin) {
+                response = await this.papiGetUmAccount(params);
+            }
+            else {
+                response = await this.fapiPrivateV2GetAccount(params);
+            }
+        }
+        else if (this.isInverse(type, subType)) {
+            if (isPortfolioMargin) {
+                response = await this.papiGetCmAccount(params);
+            }
+            else {
+                response = await this.dapiPrivateGetAccount(params);
+            }
+        }
+        else {
+            throw new NotSupported(this.id + ' fetchPositions() supports linear and inverse contracts only');
+        }
+        const positions = this.safeList(response, 'positions', []);
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            const innerSymbol = this.safeString(position, 'symbol');
+            if (innerSymbol === market['id']) {
+                const isolated = this.safeBool(position, 'isolated');
+                const marginMode = isolated ? 'isolated' : 'cross';
+                return {
+                    'info': position,
+                    'marginMode': marginMode,
+                    'leverage': this.safeInteger(position, 'leverage'),
+                };
+            }
+        }
+        return response;
+    }
     async fetchSettlementHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -10564,6 +10632,19 @@ export default class binance extends Exchange {
         }
         return result;
     }
+    async fetchLedgerEntry(id, code = undefined, params = {}) {
+        await this.loadMarkets();
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchLedgerEntry', undefined, params);
+        const query = {
+            'recordId': id,
+            'type': type,
+        };
+        if (type !== 'option') {
+            throw new BadRequest(this.id + ' fetchLedgerEntry () can only be used for type option');
+        }
+        return await this.fetchLedger(code, undefined, undefined, this.extend(query, params));
+    }
     async fetchLedger(code = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method

package/js/src/bybit.d.ts

@@ -126,6 +126,11 @@ export default class bybit extends Exchange {
     fetchUsdcPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
     fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
     parsePosition(position: any, market?: Market): import("./base/types.js").Position;
+    fetchLeverage(symbol: string, params?: {}): Promise<{
+        info: import("./base/types.js").Position;
+        leverage: number;
+        marginMode: number;
+    }>;
     setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
     setPositionMode(hedged: boolean, symbol?: Str, params?: {}): Promise<any>;

package/js/src/bybit.js

@@ -111,6 +111,7 @@ export default class bybit extends Exchange {
                 'fetchUnderlyingAssets': false,
                 'fetchVolatilityHistory': true,
                 'fetchWithdrawals': true,
+                'fetchLeverage': true,
                 'repayCrossMargin': true,
                 'setLeverage': true,
                 'setMarginMode': true,
@@ -6347,6 +6348,24 @@ export default class bybit extends Exchange {
             'takeProfitPrice': this.safeNumber2(position, 'take_profit', 'takeProfit'),
         });
     }
+    async fetchLeverage(symbol, params = {}) {
+        /**
+         * @method
+         * @name bybit#fetchLeverage
+         * @description fetch the set leverage for a market
+         * @see https://bybit-exchange.github.io/docs/v5/position
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
+         */
+        await this.loadMarkets();
+        const position = await this.fetchPosition(symbol, params);
+        return {
+            'info': position,
+            'leverage': this.safeInteger(position, 'leverage'),
+            'marginMode': this.safeNumber(position, 'marginMode'),
+        };
+    }
     async setMarginMode(marginMode, symbol = undefined, params = {}) {
         /**
          * @method

package/js/src/pro/binance.d.ts

@@ -30,8 +30,8 @@ export default class binance extends binanceRest {
     signParams(params?: {}): any;
     authenticate(params?: {}): Promise<void>;
     keepAliveListenKey(params?: {}): Promise<void>;
-    setBalanceCache(client: Client, type: any): void;
-    loadBalanceSnapshot(client: any, messageHash: any, type: any): Promise<void>;
+    setBalanceCache(client: Client, type: any, isPortfolioMargin?: boolean): void;
+    loadBalanceSnapshot(client: any, messageHash: any, type: any, isPortfolioMargin: any): Promise<void>;
     fetchBalanceWs(params?: {}): Promise<Balances>;
     handleBalanceWs(client: Client, message: any): void;
     watchBalance(params?: {}): Promise<Balances>;
@@ -52,8 +52,8 @@ export default class binance extends binanceRest {
     parseWsOrder(order: any, market?: any): Order;
     handleOrderUpdate(client: Client, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    setPositionsCache(client: Client, type: any, symbols?: Strings): void;
-    loadPositionsSnapshot(client: any, messageHash: any, type: any): Promise<void>;
+    setPositionsCache(client: Client, type: any, symbols?: Strings, isPortfolioMargin?: boolean): void;
+    loadPositionsSnapshot(client: any, messageHash: any, type: any, isPortfolioMargin: any): Promise<void>;
     handlePositions(client: any, message: any): void;
     parseWsPosition(position: any, market?: any): Position;
     fetchMyTradesWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

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/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.54",
   "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

@@ -379,7 +379,7 @@
     },
     "onetrading": {
         "skip": true,
-        "until": "2024-02-28",
+        "until": "2024-03-28",
         "skipWs": true,
         "skipMethods": {
             "fetchOrderBook": "some bid might be lower than next bid",