ccxt 4.1.62 → 4.1.63

package/js/src/pro/poloniex.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import poloniexRest from '../poloniex.js';
-import { BadRequest, AuthenticationError, ExchangeError } from '../base/errors.js';
+import { BadRequest, AuthenticationError, ExchangeError, ArgumentsRequired } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
 import { Precise } from '../base/Precise.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
@@ -25,6 +25,15 @@ export default class poloniex extends poloniexRest {
                 'watchStatus': false,
                 'watchOrders': true,
                 'watchMyTrades': true,
+                'createOrderWs': true,
+                'editOrderWs': false,
+                'fetchOpenOrdersWs': false,
+                'fetchOrderWs': false,
+                'cancelOrderWs': true,
+                'cancelOrdersWs': true,
+                'cancelAllOrdersWs': true,
+                'fetchTradesWs': false,
+                'fetchBalanceWs': false,
             },
             'urls': {
                 'api': {
@@ -35,6 +44,7 @@ export default class poloniex extends poloniexRest {
                 },
             },
             'options': {
+                'createMarketBuyOrderRequiresPrice': true,
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'OHLCVLimit': 1000,
@@ -154,6 +164,164 @@ export default class poloniex extends poloniexRest {
         const request = this.extend(subscribe, params);
         return await this.watch(url, messageHash, request, messageHash);
     }
+    async tradeRequest(name, params = {}) {
+        /**
+         * @ignore
+         * @method
+         * @description Connects to a websocket channel
+         * @param {string} name name of the channel
+         * @param {string[]|undefined} symbols CCXT market symbols
+         * @param {object} [params] extra parameters specific to the poloniex api
+         * @returns {object} data from the websocket stream
+         */
+        const url = this.urls['api']['ws']['private'];
+        const messageHash = this.nonce();
+        const subscribe = {
+            'id': messageHash,
+            'event': name,
+            'params': params,
+        };
+        return await this.watch(url, messageHash, subscribe, messageHash);
+    }
+    async createOrderWs(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name poloniex#createOrderWs
+         * @see https://docs.poloniex.com/#authenticated-channels-trade-requests-create-order
+         * @description create a trade order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} side 'buy' or 'sell'
+         * @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 poloniex api endpoint
+         * @param {string} [params.timeInForce] GTC (default), IOC, FOK
+         * @param {string} [params.clientOrderId] Maximum 64-character length.*
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+         * @param {string} [params.amount] quote units for the order
+         * @param {boolean} [params.allowBorrow] allow order to be placed by borrowing funds (Default: false)
+         * @param {string} [params.stpMode] self-trade prevention, defaults to expire_taker, none: enable self-trade; expire_taker: taker order will be canceled when self-trade happens
+         * @param {string} [params.slippageTolerance] used to control the maximum slippage ratio, the value range is greater than 0 and less than 1
+         * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+        */
+        await this.loadMarkets();
+        await this.authenticate();
+        const market = this.market(symbol);
+        let uppercaseType = type.toUpperCase();
+        const uppercaseSide = side.toUpperCase();
+        const isPostOnly = this.isPostOnly(uppercaseType === 'MARKET', uppercaseType === 'LIMIT_MAKER', params);
+        if (isPostOnly) {
+            uppercaseType = 'LIMIT_MAKER';
+        }
+        const request = {
+            'symbol': market['id'],
+            'side': side.toUpperCase(),
+            'type': type.toUpperCase(),
+        };
+        if ((uppercaseType === 'MARKET') && (uppercaseSide === 'BUY')) {
+            let quoteAmount = this.safeString(params, 'amount');
+            if ((quoteAmount === undefined) && (this.options['createMarketBuyOrderRequiresPrice'])) {
+                const cost = this.safeNumber(params, 'cost');
+                params = this.omit(params, 'cost');
+                if (price === undefined && cost === undefined) {
+                    throw new ArgumentsRequired(this.id + ' createOrder() requires the price argument with market buy orders to calculate total order cost (amount to spend), where cost = amount * price. Supply a price argument to createOrder() call if you want the cost to be calculated for you from price and amount, or, alternatively, add .options["createMarketBuyOrderRequiresPrice"] = false to supply the cost in the amount argument (the exchange-specific behaviour)');
+                }
+                else {
+                    const amountString = this.numberToString(amount);
+                    const priceString = this.numberToString(price);
+                    const quote = Precise.stringMul(amountString, priceString);
+                    amount = (cost !== undefined) ? cost : this.parseNumber(quote);
+                    quoteAmount = this.costToPrecision(symbol, amount);
+                }
+            }
+            else {
+                quoteAmount = this.costToPrecision(symbol, amount);
+            }
+            request['amount'] = this.amountToPrecision(market['symbol'], quoteAmount);
+        }
+        else {
+            request['quantity'] = this.amountToPrecision(market['symbol'], amount);
+            if (price !== undefined) {
+                request['price'] = this.priceToPrecision(symbol, price);
+            }
+        }
+        return await this.tradeRequest('createOrder', this.extend(request, params));
+    }
+    async cancelOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name poloniex#cancelOrderWs
+         * @see https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-multiple-orders
+         * @description cancel multiple orders
+         * @param {string} id order id
+         * @param {string} [symbol] unified market symbol
+         * @param {object} [params] extra parameters specific to the poloniex api endpoint
+         * @param {string} [params.clientOrderId] client order id
+         * @returns {object} an list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            const clientOrderIds = this.safeValue(params, 'clientOrderId', []);
+            params['clientOrderIds'] = this.arrayConcat(clientOrderIds, [clientOrderId]);
+        }
+        return await this.cancelOrdersWs([id], symbol, params);
+    }
+    async cancelOrdersWs(ids, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name poloniex#cancelOrdersWs
+         * @see https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-multiple-orders
+         * @description cancel multiple orders
+         * @param {string[]} ids order ids
+         * @param {string} symbol unified market symbol, default is undefined
+         * @param {object} [params] extra parameters specific to the poloniex api endpoint
+         * @param {string[]} [params.clientOrderIds] client order ids
+         * @returns {object} an list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        const request = {
+            'orderIds': ids,
+        };
+        return await this.tradeRequest('cancelOrders', this.extend(request, params));
+    }
+    async cancelAllOrdersWs(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name poloniex#cancelAllOrdersWs
+         * @see https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-all-orders
+         * @description cancel all open orders of a type. Only applicable to Option in Portfolio Margin mode, and MMP privilege is required.
+         * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
+         * @param {object} [params] extra parameters specific to the poloniex api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        return await this.tradeRequest('cancelAllOrders', params);
+    }
+    handleOrderRequest(client, message) {
+        //
+        //    {
+        //        "id": "1234567",
+        //        "data": [{
+        //           "orderId": 205343650954092544,
+        //           "clientOrderId": "",
+        //           "message": "",
+        //           "code": 200
+        //        }]
+        //    }
+        //
+        const messageHash = this.safeInteger(message, 'id');
+        const data = this.safeValue(message, 'data', []);
+        const orders = [];
+        for (let i = 0; i < data.length; i++) {
+            const order = data[i];
+            const parsedOrder = this.parseWsOrder(order);
+            orders.push(parsedOrder);
+        }
+        client.resolve(orders, messageHash);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -960,6 +1128,9 @@ export default class poloniex extends poloniexRest {
         const symbolMessageHash = messageHash + ':' + symbol;
         client.resolve(trades, symbolMessageHash);
     }
+    handlePong(client) {
+        client.lastPong = this.milliseconds();
+    }
     handleMessage(client, message) {
         if (this.handleErrorMessage(client, message)) {
             return;
@@ -990,11 +1161,26 @@ export default class poloniex extends poloniexRest {
             'trades': this.handleTrade,
             'orders': this.handleOrder,
             'balances': this.handleBalance,
+            'createOrder': this.handleOrderRequest,
+            'cancelOrder': this.handleOrderRequest,
+            'cancelAllOrders': this.handleOrderRequest,
+            'auth': this.handleAuthenticate,
         };
         const method = this.safeValue(methods, type);
         if (type === 'auth') {
             this.handleAuthenticate(client, message);
         }
+        else if (type === undefined) {
+            const data = this.safeValue(message, 'data');
+            const item = this.safeValue(data, 0);
+            const orderId = this.safeString(item, 'orderId');
+            if (orderId === '0') {
+                this.handleErrorMessage(client, item);
+            }
+            else {
+                return this.handleOrderRequest(client, message);
+            }
+        }
         else {
             const data = this.safeValue(message, 'data', []);
             const dataLength = data.length;
@@ -1005,9 +1191,26 @@ export default class poloniex extends poloniexRest {
     }
     handleErrorMessage(client, message) {
         //
-        // { message: 'Invalid channel value ["ordersss"]', event: 'error' }
+        //    {
+        //        message: 'Invalid channel value ["ordersss"]',
+        //        event: 'error'
+        //    }
+        //
+        //    {
+        //        "orderId": 0,
+        //        "clientOrderId": null,
+        //        "message": "Currency trade disabled",
+        //        "code": 21352
+        //    }
+        //
+        //    {
+        //       "event": "error",
+        //       "message": "Platform in maintenance mode"
+        //    }
+        //
         const event = this.safeString(message, 'event');
-        if (event === 'error') {
+        const orderId = this.safeString(message, 'orderId');
+        if ((event === 'error') || (orderId === '0')) {
             const error = this.safeString(message, 'message');
             throw new ExchangeError(this.id + ' error: ' + this.json(error));
         }

package/package.json

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