ccxt 4.1.45 → 4.1.46

package/dist/cjs/src/pro/huobi.js

@@ -67,14 +67,14 @@ class huobi extends huobi$1 {
                                 },
                             },
                             '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',
+                                },
                             },
                         },
                     },
@@ -1187,6 +1187,127 @@ class huobi extends huobi$1 {
             '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 Cache.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
@@ -1690,6 +1811,9 @@ class huobi extends huobi$1 {
             if (topic.indexOf('account') >= 0) {
                 this.handleBalance(client, message);
             }
+            if (topic.indexOf('positions') >= 0) {
+                this.handlePositions(client, message);
+            }
         }
     }
     async pong(client, message) {

package/dist/cjs/src/pro/krakenfutures.js

@@ -23,6 +23,7 @@ class krakenfutures extends krakenfutures$1 {
                 // 'watchStatus': true, // https://docs.futures.kraken.com/#websocket-api-public-feeds-heartbeat
                 'watchOrders': true,
                 'watchMyTrades': true,
+                'watchPositions': true,
             },
             'urls': {
                 'api': {
@@ -204,6 +205,133 @@ class krakenfutures extends krakenfutures$1 {
         const orderbook = await this.subscribePublic('book', [symbol], params);
         return orderbook.limit();
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name krakenfutures#watchPositions
+         * @see https://docs.futures.kraken.com/#websocket-api-private-feeds-open-positions
+         * @description watch all open positions
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the krakenfutures api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        let messageHash = '';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            messageHash = '::' + symbols.join(',');
+        }
+        messageHash = 'positions' + messageHash;
+        const newPositions = await this.subscribePrivate('open_positions', messageHash, params);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        feed: 'open_positions',
+        //        account: '3b111acc-4fcc-45be-a622-57e611fe9f7f',
+        //        positions: [
+        //            {
+        //                instrument: 'PF_LTCUSD',
+        //                balance: 0.5,
+        //                pnl: -0.8628305877699987,
+        //                entry_price: 70.53,
+        //                mark_price: 68.80433882446,
+        //                index_price: 68.8091,
+        //                liquidation_threshold: 0,
+        //                effective_leverage: 0.007028866753648637,
+        //                return_on_equity: -1.2233525985679834,
+        //                unrealized_funding: 0.0000690610530935388,
+        //                initial_margin: 0.7053,
+        //                initial_margin_with_orders: 0.7053,
+        //                maintenance_margin: 0.35265,
+        //                pnl_currency: 'USD'
+        //            }
+        //        ],
+        //        seq: 0,
+        //        timestamp: 1698608414910
+        //    }
+        //
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolById();
+        }
+        const cache = this.positions;
+        const rawPositions = this.safeValue(message, 'positions', []);
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parseWsPosition(rawPosition);
+            const timestamp = this.safeInteger(message, 'timestamp');
+            position['timestamp'] = timestamp;
+            position['datetime'] = this.iso8601(timestamp);
+            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');
+    }
+    parseWsPosition(position, market = undefined) {
+        //
+        //        {
+        //            instrument: 'PF_LTCUSD',
+        //            balance: 0.5,
+        //            pnl: -0.8628305877699987,
+        //            entry_price: 70.53,
+        //            mark_price: 68.80433882446,
+        //            index_price: 68.8091,
+        //            liquidation_threshold: 0,
+        //            effective_leverage: 0.007028866753648637,
+        //            return_on_equity: -1.2233525985679834,
+        //            unrealized_funding: 0.0000690610530935388,
+        //            initial_margin: 0.7053,
+        //            initial_margin_with_orders: 0.7053,
+        //            maintenance_margin: 0.35265,
+        //            pnl_currency: 'USD'
+        //        }
+        //
+        const marketId = this.safeString(position, 'instrument');
+        const hedged = 'both';
+        const balance = this.safeNumber(position, 'balance');
+        const side = (balance > 0) ? 'long' : 'short';
+        return this.safePosition({
+            'info': position,
+            'id': undefined,
+            'symbol': this.safeSymbol(marketId),
+            'notional': undefined,
+            'marginMode': undefined,
+            'liquidationPrice': this.safeNumber(position, 'liquidation_threshold'),
+            'entryPrice': this.safeNumber(position, 'entry_price'),
+            'unrealizedPnl': this.safeNumber(position, 'pnl'),
+            'percentage': this.safeNumber(position, 'return_on_equity'),
+            'contracts': this.parseNumber(Precise["default"].stringAbs(this.numberToString(balance))),
+            'contractSize': undefined,
+            'markPrice': this.safeNumber(position, 'mark_price'),
+            'side': side,
+            'hedged': hedged,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'maintenanceMargin': this.safeNumber(position, 'maintenance_margin'),
+            'maintenanceMarginPercentage': undefined,
+            'collateral': undefined,
+            'initialMargin': this.safeNumber(position, 'initial_margin'),
+            'initialMarginPercentage': undefined,
+            'leverage': undefined,
+            'marginRatio': undefined,
+        });
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1279,6 +1407,7 @@ class krakenfutures extends krakenfutures$1 {
                 'open_orders_snapshot': this.handleOrderSnapshot,
                 'balances': this.handleBalance,
                 'balances_snapshot': this.handleBalance,
+                'open_positions': this.handlePositions,
             };
             const method = this.safeValue(methods, feed);
             if (method !== undefined) {

package/dist/cjs/src/pro/kucoinfutures.js

@@ -16,6 +16,9 @@ class kucoinfutures extends kucoinfutures$1 {
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchBalance': true,
+                'watchPosition': true,
+                'watchPositions': false,
+                'watchPositionForSymbols': false,
                 'watchTradesForSymbols': true,
                 'watchOrderBookForSymbols': true,
             },
@@ -41,6 +44,10 @@ class kucoinfutures extends kucoinfutures$1 {
                 'watchTicker': {
                     'name': 'contractMarket/tickerV2', // market/ticker
                 },
+                'watchPosition': {
+                    'fetchPositionSnapshot': true,
+                    'awaitPositionSnapshot': true, // whether to wait for the position snapshot before providing updates
+                },
             },
             'streaming': {
                 // kucoin does not support built-in ws protocol-level ping-pong
@@ -177,6 +184,178 @@ class kucoinfutures extends kucoinfutures$1 {
         client.resolve(ticker, messageHash);
         return message;
     }
+    async watchPosition(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#watchPosition
+         * @description watch open positions for a specific symbol
+         * @see https://docs.kucoin.com/futures/#position-change-events
+         * @param {string|undefined} symbol unified market symbol
+         * @param {object} params extra parameters specific to the kucoinfutures api endpoint
+         * @returns {object} a [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        this.checkRequiredSymbol('watchPosition', symbol);
+        await this.loadMarkets();
+        const url = await this.negotiate(true);
+        const market = this.market(symbol);
+        const topic = '/contract/position:' + market['id'];
+        const request = {
+            'privateChannel': true,
+        };
+        const messageHash = 'position:' + market['symbol'];
+        const client = this.client(url);
+        this.setPositionCache(client, symbol);
+        const fetchPositionSnapshot = this.handleOption('watchPosition', 'fetchPositionSnapshot', true);
+        const awaitPositionSnapshot = this.safeValue('watchPosition', 'awaitPositionSnapshot', true);
+        const currentPosition = this.getCurrentPosition(symbol);
+        if (fetchPositionSnapshot && awaitPositionSnapshot && currentPosition === undefined) {
+            const snapshot = await client.future('fetchPositionSnapshot:' + symbol);
+            return snapshot;
+        }
+        return await this.subscribe(url, messageHash, topic, undefined, this.extend(request, params));
+    }
+    getCurrentPosition(symbol) {
+        if (this.positions === undefined) {
+            return undefined;
+        }
+        const cache = this.positions.hashmap;
+        const symbolCache = this.safeValue(cache, symbol, {});
+        const values = Object.values(symbolCache);
+        return this.safeValue(values, 0);
+    }
+    setPositionCache(client, symbol) {
+        const fetchPositionSnapshot = this.handleOption('watchPosition', 'fetchPositionSnapshot', false);
+        if (fetchPositionSnapshot) {
+            const messageHash = 'fetchPositionSnapshot:' + symbol;
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionSnapshot, client, messageHash, symbol);
+            }
+        }
+    }
+    async loadPositionSnapshot(client, messageHash, symbol) {
+        const position = await this.fetchPosition(symbol);
+        this.positions = new Cache.ArrayCacheBySymbolById();
+        const cache = this.positions;
+        cache.append(position);
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(position, 'position:' + symbol);
+    }
+    handlePosition(client, message) {
+        //
+        // Position Changes Caused Operations
+        //    {
+        //        "type": "message",
+        //        "userId": "5c32d69203aa676ce4b543c7", // Deprecated, will detele later
+        //        "channelType": "private",
+        //        "topic": "/contract/position:XBTUSDM",
+        //        "subject": "position.change",
+        //        "data": {
+        //            "realisedGrossPnl": 0E-8, //Accumulated realised profit and loss
+        //            "symbol": "XBTUSDM", //Symbol
+        //            "crossMode": false, //Cross mode or not
+        //            "liquidationPrice": 1000000.0, //Liquidation price
+        //            "posLoss": 0E-8, //Manually added margin amount
+        //            "avgEntryPrice": 7508.22, //Average entry price
+        //            "unrealisedPnl": -0.00014735, //Unrealised profit and loss
+        //            "markPrice": 7947.83, //Mark price
+        //            "posMargin": 0.00266779, //Position margin
+        //            "autoDeposit": false, //Auto deposit margin or not
+        //            "riskLimit": 100000, //Risk limit
+        //            "unrealisedCost": 0.00266375, //Unrealised value
+        //            "posComm": 0.00000392, //Bankruptcy cost
+        //            "posMaint": 0.00001724, //Maintenance margin
+        //            "posCost": 0.00266375, //Position value
+        //            "maintMarginReq": 0.005, //Maintenance margin rate
+        //            "bankruptPrice": 1000000.0, //Bankruptcy price
+        //            "realisedCost": 0.00000271, //Currently accumulated realised position value
+        //            "markValue": 0.00251640, //Mark value
+        //            "posInit": 0.00266375, //Position margin
+        //            "realisedPnl": -0.00000253, //Realised profit and losts
+        //            "maintMargin": 0.00252044, //Position margin
+        //            "realLeverage": 1.06, //Leverage of the order
+        //            "changeReason": "positionChange", //changeReason:marginChange、positionChange、liquidation、autoAppendMarginStatusChange、adl
+        //            "currentCost": 0.00266375, //Current position value
+        //            "openingTimestamp": 1558433191000, //Open time
+        //            "currentQty": -20, //Current position
+        //            "delevPercentage": 0.52, //ADL ranking percentile
+        //            "currentComm": 0.00000271, //Current commission
+        //            "realisedGrossCost": 0E-8, //Accumulated reliased gross profit value
+        //            "isOpen": true, //Opened position or not
+        //            "posCross": 1.2E-7, //Manually added margin
+        //            "currentTimestamp": 1558506060394, //Current timestamp
+        //            "unrealisedRoePcnt": -0.0553, //Rate of return on investment
+        //            "unrealisedPnlPcnt": -0.0553, //Position profit and loss ratio
+        //            "settleCurrency": "XBT" //Currency used to clear and settle the trades
+        //        }
+        //    }
+        // Position Changes Caused by Mark Price
+        //    {
+        //        "userId": "5cd3f1a7b7ebc19ae9558591", // Deprecated, will detele later
+        //        "topic": "/contract/position:XBTUSDM",
+        //        "subject": "position.change",
+        //          "data": {
+        //              "markPrice": 7947.83,                   //Mark price
+        //              "markValue": 0.00251640,                 //Mark value
+        //              "maintMargin": 0.00252044,              //Position margin
+        //              "realLeverage": 10.06,                   //Leverage of the order
+        //              "unrealisedPnl": -0.00014735,           //Unrealised profit and lost
+        //              "unrealisedRoePcnt": -0.0553,           //Rate of return on investment
+        //              "unrealisedPnlPcnt": -0.0553,            //Position profit and loss ratio
+        //              "delevPercentage": 0.52,             //ADL ranking percentile
+        //              "currentTimestamp": 1558087175068,      //Current timestamp
+        //              "settleCurrency": "XBT"                 //Currency used to clear and settle the trades
+        //          }
+        //    }
+        //  Funding Settlement
+        //    {
+        //        "userId": "xbc453tg732eba53a88ggyt8c", // Deprecated, will detele later
+        //        "topic": "/contract/position:XBTUSDM",
+        //        "subject": "position.settlement",
+        //        "data": {
+        //            "fundingTime": 1551770400000,          //Funding time
+        //            "qty": 100,                            //Position siz
+        //            "markPrice": 3610.85,                 //Settlement price
+        //            "fundingRate": -0.002966,             //Funding rate
+        //            "fundingFee": -296,                   //Funding fees
+        //            "ts": 1547697294838004923,             //Current time (nanosecond)
+        //            "settleCurrency": "XBT"                //Currency used to clear and settle the trades
+        //        }
+        //    }
+        // Adjustmet result of risk limit level
+        //     {
+        //         "userId": "xbc453tg732eba53a88ggyt8c",
+        //         "topic": "/contract/position:ADAUSDTM",
+        //         "subject": "position.adjustRiskLimit",
+        //         "data": {
+        //           "success": true, // Successful or not
+        //           "riskLimitLevel": 1, // Current risk limit level
+        //           "msg": "" // Failure reason
+        //         }
+        //     }
+        //
+        const topic = this.safeString(message, 'topic', '');
+        const parts = topic.split(':');
+        const marketId = this.safeString(parts, 1);
+        const symbol = this.safeSymbol(marketId, undefined, '');
+        const cache = this.positions;
+        const currentPosition = this.getCurrentPosition(symbol);
+        const messageHash = 'position:' + symbol;
+        const data = this.safeValue(message, 'data', {});
+        const newPosition = this.parsePosition(data);
+        const keys = Object.keys(newPosition);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (newPosition[key] === undefined) {
+                delete newPosition[key];
+            }
+        }
+        const position = this.extend(currentPosition, newPosition);
+        cache.append(position);
+        client.resolve(position, messageHash);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -729,6 +908,9 @@ class kucoinfutures extends kucoinfutures$1 {
             'match': this.handleTrade,
             'orderChange': this.handleOrder,
             'orderUpdated': this.handleOrder,
+            'position.change': this.handlePosition,
+            'position.settlement': this.handlePosition,
+            'position.adjustRiskLimit': this.handlePosition,
         };
         const method = this.safeValue(methods, subject);
         if (method === undefined) {

package/dist/cjs/src/pro/okx.js

@@ -22,6 +22,7 @@ class okx extends okx$1 {
                 'watchOHLCV': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
+                'watchPositions': true,
                 'createOrderWs': true,
                 'editOrderWs': true,
                 'cancelOrderWs': true,
@@ -850,6 +851,125 @@ class okx extends okx$1 {
         }
         return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#watchPositions
+         * @see https://www.okx.com/docs-v5/en/#trading-account-websocket-positions-channel
+         * @description watch all open positions
+         * @param {[string]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the okx api endpoint
+         * @returns {[object]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        if (this.isEmpty(symbols)) {
+            throw new errors.ArgumentsRequired(this.id + ' watchPositions requires a list of symbols');
+        }
+        await this.loadMarkets();
+        await this.authenticate(params);
+        symbols = this.marketSymbols(symbols);
+        const request = {
+            'instType': 'ANY',
+        };
+        const channel = 'positions';
+        const newPositions = await this.subscribeMultiple('private', channel, symbols, this.extend(request, params));
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        arg: {
+        //            channel: 'positions',
+        //            instType: 'ANY',
+        //            instId: 'XRP-USDT-SWAP',
+        //            uid: '464737184507959869'
+        //        },
+        //        data: [{
+        //            adl: '1',
+        //            availPos: '',
+        //            avgPx: '0.52668',
+        //            baseBal: '',
+        //            baseBorrowed: '',
+        //            baseInterest: '',
+        //            bizRefId: '',
+        //            bizRefType: '',
+        //            cTime: '1693151444408',
+        //            ccy: 'USDT',
+        //            closeOrderAlgo: [],
+        //            deltaBS: '',
+        //            deltaPA: '',
+        //            gammaBS: '',
+        //            gammaPA: '',
+        //            idxPx: '0.52683',
+        //            imr: '17.564000000000004',
+        //            instId: 'XRP-USDT-SWAP',
+        //            instType: 'SWAP',
+        //            interest: '',
+        //            last: '0.52691',
+        //            lever: '3',
+        //            liab: '',
+        //            liabCcy: '',
+        //            liqPx: '0.3287514731020614',
+        //            margin: '',
+        //            markPx: '0.52692',
+        //            mgnMode: 'cross',
+        //            mgnRatio: '69.00363001456147',
+        //            mmr: '0.26346',
+        //            notionalUsd: '52.68620388000001',
+        //            optVal: '',
+        //            pTime: '1693151906023',
+        //            pendingCloseOrdLiabVal: '',
+        //            pos: '1',
+        //            posCcy: '',
+        //            posId: '616057041198907393',
+        //            posSide: 'net',
+        //            quoteBal: '',
+        //            quoteBorrowed: '',
+        //            quoteInterest: '',
+        //            spotInUseAmt: '',
+        //            spotInUseCcy: '',
+        //            thetaBS: '',
+        //            thetaPA: '',
+        //            tradeId: '138745402',
+        //            uTime: '1693151444408',
+        //            upl: '0.0240000000000018',
+        //            uplLastPx: '0.0229999999999952',
+        //            uplRatio: '0.0013670539986328',
+        //            uplRatioLastPx: '0.001310093415356',
+        //            usdPx: '',
+        //            vegaBS: '',
+        //            vegaPA: ''
+        //        }]
+        //    }
+        //
+        const arg = this.safeValue(message, 'arg', {});
+        const channel = this.safeString(arg, 'channel', '');
+        const data = this.safeValue(message, 'data', []);
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        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, channel + '::');
+        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);
+            }
+        }
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1422,6 +1542,7 @@ class okx extends okx$1 {
                 'books50-l2-tbt': this.handleOrderBook,
                 'books-l2-tbt': this.handleOrderBook,
                 'tickers': this.handleTicker,
+                'positions': this.handlePositions,
                 'index-tickers': this.handleTicker,
                 'sprd-tickers': this.handleTicker,
                 'block-tickers': this.handleTicker,

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.1.44";
+declare const version = "4.1.45";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';