ccxt 4.1.45 → 4.1.47

package/dist/cjs/src/okx.js

@@ -2551,6 +2551,13 @@ class okx extends okx$1 {
             request['tdMode'] = tradeMode;
         }
         else if (contract) {
+            if (market['swap'] || market['future']) {
+                let positionSide = undefined;
+                [positionSide, params] = this.handleOptionAndParams(params, 'createOrder', 'positionSide');
+                if (positionSide !== undefined) {
+                    request['posSide'] = positionSide;
+                }
+            }
             request['tdMode'] = marginMode;
         }
         const isMarketOrder = type === 'market';
@@ -2747,7 +2754,7 @@ class okx extends okx$1 {
          * @param {float} amount how much of currency you want to trade in units of base currency
          * @param {float} [price] the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
          * @param {object} [params] extra parameters specific to the okx api endpoint
-         * @param {bool} [params.reduceOnly] MARGIN orders only, or swap/future orders in net mode
+         * @param {bool} [params.reduceOnly] a mark to reduce the position size for margin, swap and future orders
          * @param {bool} [params.postOnly] true to place a post only order
          * @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered (perpetual swap markets only)
          * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
@@ -2757,6 +2764,7 @@ class okx extends okx$1 {
          * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
          * @param {float} [params.stopLoss.price] used for stop loss limit orders, not used for stop loss market price orders
          * @param {string} [params.stopLoss.type] 'market' or 'limit' used to specify the stop loss price type
+         * @param {string} [params.positionSide] if position mode is one-way: set to 'net', if position mode is hedge-mode: set to 'long' or 'short'
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
@@ -2776,7 +2784,16 @@ class okx extends okx$1 {
             // because it has a lower ratelimit
             request = [request];
         }
-        const response = await this[method](request);
+        let response = undefined;
+        if (method === 'privatePostTradeOrder') {
+            response = await this.privatePostTradeOrder(request);
+        }
+        else if (method === 'privatePostTradeOrderAlgo') {
+            response = await this.privatePostTradeOrderAlgo(request);
+        }
+        else {
+            response = await this.privatePostTradeBatchOrders(request);
+        }
         const data = this.safeValue(response, 'data', []);
         const first = this.safeValue(data, 0);
         const order = this.parseOrder(first, market);

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

@@ -23,6 +23,7 @@ class binance extends binance$1 {
                 'watchOrderBook': true,
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
+                'watchPositions': true,
                 'watchTicker': true,
                 'watchTickers': true,
                 'watchTrades': true,
@@ -97,6 +98,10 @@ class binance extends binance$1 {
                     'fetchBalanceSnapshot': false,
                     'awaitBalanceSnapshot': true, // whether to wait for the balance snapshot before providing updates
                 },
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
                 'wallet': 'wb',
                 'listenKeyRefreshRate': 1200000,
                 'ws': {
@@ -1479,6 +1484,7 @@ class binance extends binance$1 {
         const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
         this.setBalanceCache(client, type);
+        this.setPositionsCache(client, type);
         const options = this.safeValue(this.options, 'watchBalance');
         const fetchBalanceSnapshot = this.safeValue(options, 'fetchBalanceSnapshot', false);
         const awaitBalanceSnapshot = this.safeValue(options, 'awaitBalanceSnapshot', true);
@@ -1553,6 +1559,9 @@ class binance extends binance$1 {
         const subscriptions = Object.keys(client.subscriptions);
         const accountType = subscriptions[0];
         const messageHash = accountType + ':balance';
+        if (this.balance[accountType] === undefined) {
+            this.balance[accountType] = {};
+        }
         this.balance[accountType]['info'] = message;
         const event = this.safeString(message, 'e');
         if (event === 'balanceUpdate') {
@@ -2084,6 +2093,7 @@ class binance extends binance$1 {
         const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
         this.setBalanceCache(client, type);
+        this.setPositionsCache(client, type);
         const message = undefined;
         const orders = await this.watch(url, messageHash, message, type);
         if (this.newUpdates) {
@@ -2331,6 +2341,193 @@ class binance extends binance$1 {
         this.handleMyTrade(client, message);
         this.handleOrder(client, message);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#watchPositions
+         * @description watch all open positions
+         * @param {string[]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the binance 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(params);
+        let market = undefined;
+        let messageHash = '';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            market = this.getMarketFromSymbols(symbols);
+            messageHash = '::' + symbols.join(',');
+        }
+        const defaultType = this.safeString2(this.options, 'watchPositions', 'defaultType', 'future');
+        let type = this.safeString(params, 'type', defaultType);
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('watchPositions', market, params);
+        if (this.isLinear(type, subType)) {
+            type = 'future';
+        }
+        else if (this.isInverse(type, subType)) {
+            type = 'delivery';
+        }
+        messageHash = type + ':positions' + messageHash;
+        const url = this.urls['api']['ws'][type] + '/' + this.options[type]['listenKey'];
+        const client = this.client(url);
+        this.setBalanceCache(client, type);
+        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) {
+            const snapshot = await client.future(type + ':fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const newPositions = await this.watch(url, messageHash, undefined, type);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(cache, 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 Cache.ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash, type) {
+        const positions = await this.fetchPositions(undefined, { 'type': type });
+        this.positions[type] = new Cache.ArrayCacheBySymbolBySide();
+        const cache = this.positions[type];
+        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, type + ':position');
+    }
+    handlePositions(client, message) {
+        //
+        //     {
+        //         e: 'ACCOUNT_UPDATE',
+        //         T: 1667881353112,
+        //         E: 1667881353115,
+        //         a: {
+        //             B: [{
+        //                 a: 'USDT',
+        //                 wb: '1127.95750089',
+        //                 cw: '1040.82091149',
+        //                 bc: '0'
+        //             }],
+        //             P: [{
+        //                 s: 'BTCUSDT',
+        //                 pa: '-0.089',
+        //                 ep: '19700.03933',
+        //                 cr: '-1260.24809979',
+        //                 up: '1.53058860',
+        //                 mt: 'isolated',
+        //                 iw: '87.13658940',
+        //                 ps: 'BOTH',
+        //                 ma: 'USDT'
+        //             }],
+        //             m: 'ORDER'
+        //         }
+        //     }
+        //
+        // each account is connected to a different endpoint
+        // and has exactly one subscriptionhash which is the account type
+        const subscriptions = Object.keys(client.subscriptions);
+        const accountType = subscriptions[0];
+        if (this.positions === undefined) {
+            this.positions = {};
+        }
+        if (!(accountType in this.positions)) {
+            this.positions[accountType] = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions[accountType];
+        const data = this.safeValue(message, 'a', {});
+        const rawPositions = this.safeValue(data, 'P', []);
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parseWsPosition(rawPosition);
+            const timestamp = this.safeInteger(message, 'E');
+            position['timestamp'] = timestamp;
+            position['datetime'] = this.iso8601(timestamp);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, accountType + ':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, accountType + ':positions');
+    }
+    parseWsPosition(position, market = undefined) {
+        //
+        //     {
+        //         "s": "BTCUSDT", // Symbol
+        //         "pa": "0", // Position Amount
+        //         "ep": "0.00000", // Entry Price
+        //         "cr": "200", // (Pre-fee) Accumulated Realized
+        //         "up": "0", // Unrealized PnL
+        //         "mt": "isolated", // Margin Type
+        //         "iw": "0.00000000", // Isolated Wallet (if isolated position)
+        //         "ps": "BOTH" // Position Side
+        //     }
+        //
+        const marketId = this.safeString(position, 's');
+        const positionSide = this.safeStringLower(position, 'ps');
+        const hedged = positionSide !== 'both';
+        return this.safePosition({
+            'info': position,
+            'id': undefined,
+            'symbol': this.safeSymbol(marketId),
+            'notional': undefined,
+            'marginMode': this.safeString(position, 'mt'),
+            'liquidationPrice': undefined,
+            'entryPrice': this.safeNumber(position, 'ep'),
+            'unrealizedPnl': this.safeNumber(position, 'up'),
+            'percentage': undefined,
+            'contracts': this.safeNumber(position, 'pa'),
+            'contractSize': undefined,
+            'markPrice': undefined,
+            'side': positionSide,
+            'hedged': hedged,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'maintenanceMargin': undefined,
+            'maintenanceMarginPercentage': undefined,
+            'collateral': undefined,
+            'initialMargin': undefined,
+            'initialMarginPercentage': undefined,
+            'leverage': undefined,
+            'marginRatio': undefined,
+        });
+    }
     async fetchMyTradesWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -2450,6 +2647,7 @@ class binance extends binance$1 {
         const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
         const client = this.client(url);
         this.setBalanceCache(client, type);
+        this.setPositionsCache(client, type);
         const message = undefined;
         const trades = await this.watch(url, messageHash, message, type);
         if (this.newUpdates) {
@@ -2561,6 +2759,10 @@ class binance extends binance$1 {
             client.resolve(this.orders, messageHashSymbol);
         }
     }
+    handleAcountUpdate(client, message) {
+        this.handleBalance(client, message);
+        this.handlePositions(client, message);
+    }
     handleWsError(client, message) {
         //
         //    {
@@ -2629,7 +2831,7 @@ class binance extends binance$1 {
             'bookTicker': this.handleTicker,
             'outboundAccountPosition': this.handleBalance,
             'balanceUpdate': this.handleBalance,
-            'ACCOUNT_UPDATE': this.handleBalance,
+            'ACCOUNT_UPDATE': this.handleAcountUpdate,
             'executionReport': this.handleOrderUpdate,
             'ORDER_TRADE_UPDATE': this.handleOrderUpdate,
         };

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

@@ -29,6 +29,7 @@ class bitget extends bitget$1 {
                 'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
+                'watchPositions': true,
             },
             'urls': {
                 'api': {
@@ -750,6 +751,185 @@ class bitget extends bitget$1 {
             'fee': undefined,
         }, market);
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitget#watchPositions
+         * @description watch all open positions
+         * @see https://bitgetlimited.github.io/apidoc/en/mix/#positions-channel
+         * @param {string[]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the bitget api endpoint
+         * @param {string} params.instType Instrument Type umcbl:USDT Perpetual Contract Private Channel; dmcbl:Coin Margin Perpetual Contract Private Channel; cmcbl: USDC margin Perpetual Contract Private Channel
+         * @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 = '';
+        const subscriptionHash = 'positions';
+        let instType = 'umcbl';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            instType = 'dmcbl';
+            market = this.getMarketFromSymbols(symbols);
+            messageHash = '::' + symbols.join(',');
+            if (market['settle'] === 'USDT') {
+                instType = 'umcbl';
+            }
+            else if (market['settle'] === 'USDC') {
+                instType = 'cmcbl';
+            }
+        }
+        [instType, params] = this.handleOptionAndParams(params, 'watchPositions', 'instType', instType);
+        messageHash = instType + ':positions' + messageHash;
+        const args = {
+            'instType': instType,
+            'channel': 'positions',
+            'instId': 'default',
+        };
+        const newPositions = await this.watchPrivate(messageHash, subscriptionHash, args, params);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(newPositions, symbols, since, limit, true);
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        action: 'snapshot',
+        //        arg: {
+        //            instType: 'umcbl',
+        //            channel: 'positions',
+        //            instId: 'default'
+        //        },
+        //        data: [{
+        //                posId: '926036334386778112',
+        //                instId: 'LTCUSDT_UMCBL',
+        //                instName: 'LTCUSDT',
+        //                marginCoin: 'USDT',
+        //                margin: '9.667',
+        //                marginMode: 'crossed',
+        //                holdSide: 'long',
+        //                holdMode: 'double_hold',
+        //                total: '0.3',
+        //                available: '0.3',
+        //                locked: '0',
+        //                averageOpenPrice: '64.44',
+        //                leverage: 2,
+        //                achievedProfits: '0',
+        //                upl: '0.0759',
+        //                uplRate: '0.0078',
+        //                liqPx: '-153.32',
+        //                keepMarginRate: '0.010',
+        //                marginRate: '0.005910309637',
+        //                cTime: '1656510187717',
+        //                uTime: '1694880005480',
+        //                markPrice: '64.7',
+        //                autoMargin: 'off'
+        //            },
+        //            ...
+        //        ]
+        //    }
+        //
+        const arg = this.safeValue(message, 'arg', {});
+        const instType = this.safeString(arg, 'instType', '');
+        if (this.positions === undefined) {
+            this.positions = {};
+        }
+        if (!(instType in this.positions)) {
+            this.positions[instType] = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions[instType];
+        const rawPositions = this.safeValue(message, 'data', []);
+        const dataLength = rawPositions.length;
+        if (dataLength === 0) {
+            return;
+        }
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parseWsPosition(rawPosition);
+            newPositions.push(position);
+            cache.append(position);
+        }
+        const messageHashes = this.findMessageHashes(client, instType + ':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, instType + ':positions');
+    }
+    parseWsPosition(position, market = undefined) {
+        //
+        //    {
+        //        posId: '926036334386778112',
+        //        instId: 'LTCUSDT_UMCBL',
+        //        instName: 'LTCUSDT',
+        //        marginCoin: 'USDT',
+        //        margin: '9.667',
+        //        marginMode: 'crossed',
+        //        holdSide: 'long',
+        //        holdMode: 'double_hold',
+        //        total: '0.3',
+        //        available: '0.3',
+        //        locked: '0',
+        //        averageOpenPrice: '64.44',
+        //        leverage: 2,
+        //        achievedProfits: '0',
+        //        upl: '0.0759',
+        //        uplRate: '0.0078',
+        //        liqPx: '-153.32',
+        //        keepMarginRate: '0.010',
+        //        marginRate: '0.005910309637',
+        //        cTime: '1656510187717',
+        //        uTime: '1694880005480',
+        //        markPrice: '64.7',
+        //        autoMargin: 'off'
+        //    }
+        //
+        const marketId = this.safeString(position, 'instId');
+        const marginModeId = this.safeString(position, 'marginMode');
+        const marginMode = this.getSupportedMapping(marginModeId, {
+            'crossed': 'cross',
+            'fixed': 'isolated',
+        });
+        const hedgedId = this.safeString(position, 'holdMode');
+        const hedged = this.getSupportedMapping(hedgedId, {
+            'double_hold': true,
+            'single_hold': false,
+        });
+        const timestamp = this.safeInteger2(position, 'uTime', 'cTime');
+        return this.safePosition({
+            'info': position,
+            'id': this.safeString(position, 'posId'),
+            'symbol': this.safeSymbol(marketId, market),
+            'notional': undefined,
+            'marginMode': marginMode,
+            'liquidationPrice': undefined,
+            'entryPrice': this.safeNumber(position, 'averageOpenPrice'),
+            'unrealizedPnl': this.safeNumber(position, 'upl'),
+            'percentage': this.safeNumber(position, 'uplRate'),
+            'contracts': this.safeNumber(position, 'total'),
+            'contractSize': undefined,
+            'markPrice': this.safeNumber(position, 'markPrice'),
+            'side': this.safeString(position, 'holdSide'),
+            'hedged': hedged,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'maintenanceMargin': undefined,
+            'maintenanceMarginPercentage': this.safeNumber(position, 'keepMarginRate'),
+            'collateral': undefined,
+            'initialMargin': undefined,
+            'initialMarginPercentage': undefined,
+            'leverage': this.safeNumber(position, 'leverage'),
+            'marginRatio': this.safeNumber(position, 'marginRate'),
+        });
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1464,6 +1644,7 @@ class bitget extends bitget$1 {
             'orders': this.handleOrder,
             'ordersAlgo': this.handleOrder,
             'account': this.handleBalance,
+            'positions': this.handlePositions,
         };
         const arg = this.safeValue(message, 'arg', {});
         const topic = this.safeValue(arg, 'channel', '');