ccxt 4.1.44 → 4.1.46

package/js/src/pro/cryptocom.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import cryptocomRest from '../cryptocom.js';
 import { AuthenticationError, NetworkError } from '../base/errors.js';
-import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
 export default class cryptocom extends cryptocomRest {
@@ -25,6 +25,7 @@ export default class cryptocom extends cryptocomRest {
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
                 'watchOHLCV': true,
+                'watchPositions': true,
                 'createOrderWs': true,
                 'cancelOrderWs': true,
                 'cancelAllOrders': true,
@@ -41,7 +42,12 @@ export default class cryptocom extends cryptocomRest {
                     'private': 'wss://uat-stream.3ona.co/exchange/v1/user',
                 },
             },
-            'options': {},
+            'options': {
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
+            },
             'streaming': {},
         });
     }
@@ -450,6 +456,129 @@ export default class cryptocom extends cryptocomRest {
             client.resolve(stored, 'user.order');
         }
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cryptocom#watchPositions
+         * @description watch all open positions
+         * @see https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#user-position_balance
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the cryptocom api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        const url = this.urls['api']['ws']['private'];
+        const id = this.nonce();
+        const request = {
+            'method': 'subscribe',
+            'params': {
+                'channels': ['user.position_balance'],
+            },
+            'nonce': id,
+        };
+        let messageHash = 'positions';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            messageHash = '::' + symbols.join(',');
+        }
+        const client = this.client(url);
+        this.setPositionsCache(client, symbols);
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && this.positions === undefined) {
+            const snapshot = await client.future('fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const newPositions = await this.watch(url, messageHash, this.extend(request, params));
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', false);
+        if (fetchPositionsSnapshot) {
+            const messageHash = 'fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash);
+            }
+        }
+        else {
+            this.positions = new ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash) {
+        const positions = await this.fetchPositions();
+        this.positions = new ArrayCacheBySymbolBySide();
+        const cache = this.positions;
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            const contracts = this.safeNumber(position, 'contracts', 0);
+            if (contracts > 0) {
+                cache.append(position);
+            }
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, 'positions');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        subscription: "user.position_balance",
+        //        channel: "user.position_balance",
+        //        data: [{
+        //            balances: [{
+        //                instrument_name: "USD",
+        //                quantity: "8.9979961950886",
+        //                update_timestamp_ms: 1695598760597,
+        //            }],
+        //            positions: [{
+        //                account_id: "96a0edb1-afb5-4c7c-af89-5cb610319e2c",
+        //                instrument_name: "LTCUSD-PERP",
+        //                type: "PERPETUAL_SWAP",
+        //                quantity: "1.8",
+        //                cost: "114.766",
+        //                open_position_pnl: "-0.0216206",
+        //                session_pnl: "0.00962994",
+        //                update_timestamp_ms: 1695598760597,
+        //                open_pos_cost: "114.766",
+        //            }],
+        //        }],
+        //    }
+        //
+        // each account is connected to a different endpoint
+        // and has exactly one subscriptionhash which is the account type
+        const data = this.safeValue(message, 'data', []);
+        const firstData = this.safeValue(data, 0, {});
+        const rawPositions = this.safeValue(firstData, 'positions', []);
+        if (this.positions === undefined) {
+            this.positions = new ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parsePosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, 'positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, 'positions');
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -716,6 +845,7 @@ export default class cryptocom extends cryptocomRest {
             'user.order': this.handleOrders,
             'user.trade': this.handleTrades,
             'user.balance': this.handleBalance,
+            'user.position_balance': this.handlePositions,
         };
         const result = this.safeValue2(message, 'result', 'info');
         const channel = this.safeString(result, 'channel');

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

@@ -21,6 +21,10 @@ export default class gate extends gateRest {
     handleMyTrades(client: Client, message: any): void;
     watchBalance(params?: {}): Promise<any>;
     handleBalance(client: Client, message: any): void;
+    watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    setPositionsCache(client: Client, type: any, symbols?: string[]): void;
+    loadPositionsSnapshot(client: any, messageHash: any, type: any): Promise<void>;
+    handlePositions(client: any, message: any): void;
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleOrder(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
@@ -30,6 +34,7 @@ export default class gate extends gateRest {
     getUrlByMarket(market: any): any;
     getTypeByMarket(market: any): "spot" | "futures" | "options";
     getUrlByMarketType(type: any, isInverse?: boolean): any;
+    getMarketTypeByUrl(url: string): any;
     requestId(): any;
     subscribePublic(url: any, messageHash: any, payload: any, channel: any, params?: {}, subscription?: any): Promise<any>;
     subscribePrivate(url: any, messageHash: any, payload: any, channel: any, params: any, requiresUid?: boolean): Promise<any>;

package/js/src/pro/gate.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import gateRest from '../gate.js';
 import { AuthenticationError, BadRequest, ArgumentsRequired, InvalidNonce } from '../base/errors.js';
-import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha512 } from '../static_dependencies/noble-hashes/sha512.js';
 //  ---------------------------------------------------------------------------
 export default class gate extends gateRest {
@@ -24,6 +24,7 @@ export default class gate extends gateRest {
                 'watchOHLCV': true,
                 'watchBalance': true,
                 'watchOrders': true,
+                'watchPositions': true,
             },
             'urls': {
                 'api': {
@@ -75,6 +76,10 @@ export default class gate extends gateRest {
                     'settle': 'usdt',
                     'spot': 'spot.balances', // spot.margin_balances, spot.funding_balances or spot.cross_balances
                 },
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
             },
             'exceptions': {
                 'ws': {
@@ -753,6 +758,145 @@ export default class gate extends gateRest {
         this.balance = this.safeBalance(this.balance);
         client.resolve(this.balance, messageHash);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#watchPositions
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#positions-subscription
+         * @see https://www.gate.io/docs/developers/delivery/ws/en/#positions-subscription
+         * @see https://www.gate.io/docs/developers/options/ws/en/#positions-channel
+         * @description watch all open positions
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the gate api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        symbols = this.marketSymbols(symbols);
+        const payload = ['!' + 'all'];
+        if (!this.isEmpty(symbols)) {
+            market = this.getMarketFromSymbols(symbols);
+        }
+        let type = undefined;
+        let query = undefined;
+        [type, query] = this.handleMarketTypeAndParams('watchPositions', market, params);
+        if (type === 'spot') {
+            type = 'swap';
+        }
+        const typeId = this.getSupportedMapping(type, {
+            'future': 'futures',
+            'swap': 'futures',
+            'option': 'options',
+        });
+        let messageHash = type + ':positions';
+        if (!this.isEmpty(symbols)) {
+            messageHash += '::' + symbols.join(',');
+        }
+        const channel = typeId + '.positions';
+        let subType = undefined;
+        [subType, query] = this.handleSubTypeAndParams('watchPositions', market, query);
+        const isInverse = (subType === 'inverse');
+        const url = this.getUrlByMarketType(type, isInverse);
+        const client = this.client(url);
+        this.setPositionsCache(client, type, symbols);
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        const cache = this.safeValue(this.positions, type);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && cache === undefined) {
+            return await client.future(type + ':fetchPositionsSnapshot');
+        }
+        const positions = await this.subscribePrivate(url, messageHash, payload, channel, query, true);
+        if (this.newUpdates) {
+            return positions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        if (this.positions === undefined) {
+            this.positions = {};
+        }
+        if (type in this.positions) {
+            return;
+        }
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', false);
+        if (fetchPositionsSnapshot) {
+            const messageHash = type + ':fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash, type);
+            }
+        }
+        else {
+            this.positions[type] = new ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash, type) {
+        const positions = await this.fetchPositions(undefined, { 'type': type });
+        this.positions[type] = new ArrayCacheBySymbolBySide();
+        const cache = this.positions[type];
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            cache.append(position);
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, type + ':position');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        time: 1693158497,
+        //        time_ms: 1693158497204,
+        //        channel: 'futures.positions',
+        //        event: 'update',
+        //        result: [{
+        //            contract: 'XRP_USDT',
+        //            cross_leverage_limit: 0,
+        //            entry_price: 0.5253,
+        //            history_pnl: 0,
+        //            history_point: 0,
+        //            last_close_pnl: 0,
+        //            leverage: 0,
+        //            leverage_max: 50,
+        //            liq_price: 0.0361,
+        //            maintenance_rate: 0.01,
+        //            margin: 4.89609962852,
+        //            mode: 'single',
+        //            realised_pnl: -0.0026265,
+        //            realised_point: 0,
+        //            risk_limit: 500000,
+        //            size: 1,
+        //            time: 1693158497,
+        //            time_ms: 1693158497195,
+        //            update_id: 1,
+        //            user: '10444586'
+        //        }]
+        //    }
+        //
+        const type = this.getMarketTypeByUrl(client.url);
+        const data = this.safeValue(message, 'result', []);
+        const cache = this.positions[type];
+        const newPositions = [];
+        for (let i = 0; i < data.length; i++) {
+            const rawPosition = data[i];
+            const position = this.parsePosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, type + ':positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, type + ':positions');
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1039,6 +1183,7 @@ export default class gate extends gateRest {
             'usertrades': this.handleMyTrades,
             'candlesticks': this.handleOHLCV,
             'orders': this.handleOrder,
+            'positions': this.handlePositions,
             'tickers': this.handleTicker,
             'book_ticker': this.handleTicker,
             'trades': this.handleTrades,
@@ -1080,6 +1225,22 @@ export default class gate extends gateRest {
             return url;
         }
     }
+    getMarketTypeByUrl(url) {
+        const findBy = {
+            'op-': 'option',
+            'delivery': 'future',
+            'fx': 'swap',
+        };
+        const keys = Object.keys(findBy);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = findBy[key];
+            if (url.indexOf(key) >= 0) {
+                return value;
+            }
+        }
+        return 'spot';
+    }
     requestId() {
         // their support said that reqid must be an int32, not documented
         const reqid = this.sum(this.safeInteger(this.options, 'reqid', 0), 1);

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

@@ -24,6 +24,8 @@ export default class huobi extends huobiRest {
     handleOrder(client: Client, message: any): void;
     parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
     parseOrderTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    handlePositions(client: any, message: any): void;
     watchBalance(params?: {}): Promise<any>;
     handleBalance(client: Client, message: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;

package/js/src/pro/huobi.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import huobiRest from '../huobi.js';
 import { ExchangeError, InvalidNonce, ArgumentsRequired, BadRequest, BadSymbol, AuthenticationError, NetworkError } from '../base/errors.js';
-import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
 export default class huobi extends huobiRest {
@@ -70,14 +70,14 @@ export default class huobi extends huobiRest {
                                 },
                             },
                             'swap': {
-                                'inverse': {
-                                    'public': 'wss://api.hbdm.vn/swap-ws',
-                                    'private': 'wss://api.hbdm.vn/swap-notification',
-                                },
                                 'linear': {
                                     'public': 'wss://api.hbdm.vn/linear-swap-ws',
                                     'private': 'wss://api.hbdm.vn/linear-swap-notification',
                                 },
+                                'inverse': {
+                                    'public': 'wss://api.hbdm.vn/swap-ws',
+                                    'private': 'wss://api.hbdm.vn/swap-notification',
+                                },
                             },
                         },
                     },
@@ -1190,6 +1190,127 @@ export default class huobi extends huobiRest {
             'fee': undefined,
         }, market);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name huobi#watchPositions
+         * @see https://www.huobi.com/en-in/opend/newApiPages/?id=8cb7de1c-77b5-11ed-9966-0242ac110003
+         * @see https://www.huobi.com/en-in/opend/newApiPages/?id=8cb7df0f-77b5-11ed-9966-0242ac110003
+         * @see https://www.huobi.com/en-in/opend/newApiPages/?id=28c34a7d-77ae-11ed-9966-0242ac110003
+         * @see https://www.huobi.com/en-in/opend/newApiPages/?id=5d5156b5-77b6-11ed-9966-0242ac110003
+         * @description watch all open positions. Note: huobi has one channel for each marginMode and type
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the huobi api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        let messageHash = '';
+        if (!this.isEmpty(symbols)) {
+            market = this.getMarketFromSymbols(symbols);
+            messageHash = '::' + symbols.join(',');
+        }
+        let type = undefined;
+        let subType = undefined;
+        if (market !== undefined) {
+            type = market['type'];
+            subType = market['linear'] ? 'linear' : 'inverse';
+        }
+        else {
+            [type, params] = this.handleMarketTypeAndParams('watchPositions', market, params);
+            if (type === 'spot') {
+                type = 'future';
+            }
+            [subType, params] = this.handleOptionAndParams(params, 'watchPositions', 'subType', subType);
+        }
+        symbols = this.marketSymbols(symbols);
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('watchPositions', params, 'cross');
+        const isLinear = (subType === 'linear');
+        const url = this.getUrlByMarketType(type, isLinear, true);
+        messageHash = marginMode + ':positions' + messageHash;
+        const channel = (marginMode === 'cross') ? 'positions_cross.*' : 'positions.*';
+        const newPositions = await this.subscribePrivate(channel, messageHash, type, subType, params);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions[url][marginMode], symbols, since, limit, false);
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        op: 'notify',
+        //        topic: 'positions_cross',
+        //        ts: 1696767149650,
+        //        event: 'snapshot',
+        //        data: [
+        //          {
+        //            contract_type: 'swap',
+        //            pair: 'BTC-USDT',
+        //            business_type: 'swap',
+        //            liquidation_price: null,
+        //            symbol: 'BTC',
+        //            contract_code: 'BTC-USDT',
+        //            volume: 1,
+        //            available: 1,
+        //            frozen: 0,
+        //            cost_open: 27802.2,
+        //            cost_hold: 27802.2,
+        //            profit_unreal: 0.0175,
+        //            profit_rate: 0.000629446590557581,
+        //            profit: 0.0175,
+        //            margin_asset: 'USDT',
+        //            position_margin: 27.8197,
+        //            lever_rate: 1,
+        //            direction: 'buy',
+        //            last_price: 27819.7,
+        //            margin_mode: 'cross',
+        //            margin_account: 'USDT',
+        //            trade_partition: 'USDT',
+        //            position_mode: 'dual_side'
+        //          },
+        //        ]
+        //    }
+        //
+        const url = client.url;
+        const topic = this.safeString(message, 'topic', '');
+        const marginMode = (topic === 'positions_cross') ? 'cross' : 'isolated';
+        if (this.positions === undefined) {
+            this.positions = {};
+        }
+        const clientPositions = this.safeValue(this.positions, url);
+        if (clientPositions === undefined) {
+            this.positions[url] = {};
+        }
+        const clientMarginModePositions = this.safeValue(clientPositions, marginMode);
+        if (clientMarginModePositions === undefined) {
+            this.positions[url][marginMode] = new ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions[url][marginMode];
+        const rawPositions = this.safeValue(message, 'data', []);
+        const newPositions = [];
+        const timestamp = this.safeInteger(message, 'ts');
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parsePosition(rawPosition);
+            position['timestamp'] = timestamp;
+            position['datetime'] = this.iso8601(timestamp);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, marginMode + ':positions::');
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split('::');
+            const symbolsString = parts[1];
+            const symbols = symbolsString.split(',');
+            const positions = this.filterByArray(newPositions, 'symbol', symbols, false);
+            if (!this.isEmpty(positions)) {
+                client.resolve(positions, messageHash);
+            }
+        }
+        client.resolve(newPositions, marginMode + ':positions');
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -1693,6 +1814,9 @@ export default class huobi extends huobiRest {
             if (topic.indexOf('account') >= 0) {
                 this.handleBalance(client, message);
             }
+            if (topic.indexOf('positions') >= 0) {
+                this.handlePositions(client, message);
+            }
         }
     }
     async pong(client, message) {

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

@@ -10,6 +10,9 @@ export default class krakenfutures extends krakenfuturesRest {
     watchTickers(symbols?: string[], params?: {}): Promise<any>;
     watchTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    handlePositions(client: any, message: any): void;
+    parseWsPosition(position: any, market?: any): import("../base/types.js").Position;
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchBalance(params?: {}): Promise<any>;