ccxt 4.1.72 → 4.1.74

package/js/src/pro/cex.js

@@ -6,10 +6,10 @@
 
 //  ---------------------------------------------------------------------------
 import cexRest from '../cex.js';
-import { ArgumentsRequired, ExchangeError } from '../base/errors.js';
+import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
+import { ArgumentsRequired, ExchangeError, BadRequest } from '../base/errors.js';
 import { Precise } from '../base/Precise.js';
 import { ArrayCacheBySymbolById, ArrayCacheByTimestamp, ArrayCache } from '../base/ws/Cache.js';
-import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
 export default class cex extends cexRest {
     describe() {
@@ -25,6 +25,14 @@ export default class cex extends cexRest {
                 'watchOrderBook': true,
                 'watchOHLCV': true,
                 'watchPosition': undefined,
+                'createOrderWs': true,
+                'editOrderWs': true,
+                'cancelOrderWs': true,
+                'cancelOrdersWs': true,
+                'fetchOrderWs': true,
+                'fetchOpenOrdersWs': true,
+                'fetchTickerWs': true,
+                'fetchBalanceWs': true,
             },
             'urls': {
                 'api': {
@@ -41,7 +49,7 @@ export default class cex extends cexRest {
     requestId() {
         const requestId = this.sum(this.safeInteger(this.options, 'requestId', 0), 1);
         this.options['requestId'] = requestId;
-        return requestId;
+        return requestId.toString();
     }
     async watchBalance(params = {}) {
         /**
@@ -53,7 +61,7 @@ export default class cex extends cexRest {
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
         await this.authenticate(params);
-        const messageHash = 'balance';
+        const messageHash = this.requestId();
         const url = this.urls['api']['ws'];
         const subscribe = {
             'e': 'get-balance',
@@ -100,7 +108,8 @@ export default class cex extends cexRest {
             result[code] = account;
         }
         this.balance = this.safeBalance(result);
-        client.resolve(this.balance, 'balance');
+        const messageHash = this.safeString(message, 'oid');
+        client.resolve(this.balance, messageHash);
     }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
@@ -290,6 +299,27 @@ export default class cex extends cexRest {
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
+    async fetchTickerWs(symbol, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchTickerWs
+         * @see https://docs.cex.io/#ws-api-ticker-deprecated
+         * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const url = this.urls['api']['ws'];
+        const messageHash = this.requestId();
+        const request = this.extend({
+            'e': 'ticker',
+            'oid': messageHash,
+            'data': [market['base'], market['quote']],
+        }, params);
+        return await this.watch(url, messageHash, request, messageHash);
+    }
     handleTicker(client, message) {
         //
         //     {
@@ -306,10 +336,12 @@ export default class cex extends cexRest {
         const data = this.safeValue(message, 'data', {});
         const ticker = this.parseWsTicker(data);
         const symbol = ticker['symbol'];
-        const messageHash = 'ticker:' + symbol;
         this.tickers[symbol] = ticker;
+        let messageHash = 'ticker:' + symbol;
         client.resolve(ticker, messageHash);
         client.resolve(ticker, 'tickers');
+        messageHash = this.safeString(message, 'oid');
+        client.resolve(ticker, messageHash);
     }
     parseWsTicker(ticker, market = undefined) {
         //
@@ -374,6 +406,25 @@ export default class cex extends cexRest {
             'info': ticker,
         }, market);
     }
+    async fetchBalanceWs(params = {}) {
+        /**
+         * @method
+         * @name cex#fetchBalanceWs
+         * @see https://docs.cex.io/#ws-api-get-balance
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/en/latest/manual.html?#balance-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        const url = this.urls['api']['ws'];
+        const messageHash = this.requestId();
+        const request = this.extend({
+            'e': 'get-balance',
+            'oid': messageHash,
+        }, params);
+        return await this.watch(url, messageHash, request, messageHash);
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -662,7 +713,8 @@ export default class cex extends cexRest {
             const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
             this.orders = new ArrayCacheBySymbolById(limit);
         }
-        const ordersBySymbol = this.safeValue(this.orders['hashmap'], symbol, {});
+        const storedOrders = this.orders;
+        const ordersBySymbol = this.safeValue(storedOrders.hashmap, symbol, {});
         let order = this.safeValue(ordersBySymbol, orderId);
         if (order === undefined) {
             order = this.parseWsOrderUpdate(data, market);
@@ -687,7 +739,6 @@ export default class cex extends cexRest {
         order['timestamp'] = timestamp;
         order['datetime'] = this.iso8601(timestamp);
         order = this.safeOrder(order);
-        const storedOrders = this.orders;
         storedOrders.append(order);
         const messageHash = 'orders:' + symbol;
         client.resolve(storedOrders, messageHash);
@@ -748,7 +799,10 @@ export default class cex extends cexRest {
         }
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
-        const symbol = base + '/' + quote;
+        let symbol = undefined;
+        if (base !== undefined && quote !== undefined) {
+            symbol = base + '/' + quote;
+        }
         market = this.safeMarket(symbol, market);
         const time = this.safeInteger(order, 'time', this.milliseconds());
         let timestamp = time;
@@ -1113,6 +1167,236 @@ export default class cex extends cexRest {
             client.resolve(stored, messageHash);
         }
     }
+    async fetchOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchOrderWs
+         * @description fetches information on an order made by the user
+         * @see https://docs.cex.io/#ws-api-get-order
+         * @param {string} symbol not used by cex fetchOrder
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+        }
+        const data = this.extend({
+            'order_id': id.toString(),
+        }, params);
+        const url = this.urls['api']['ws'];
+        const messageHash = this.requestId();
+        const request = {
+            'e': 'get-order',
+            'oid': messageHash,
+            'data': data,
+        };
+        const response = await this.watch(url, messageHash, request, messageHash);
+        return this.parseOrder(response, market);
+    }
+    async fetchOpenOrdersWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#fetchOpenOrdersWs
+         * @see https://docs.cex.io/#ws-api-open-orders
+         * @description fetch all unfilled currently open orders
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch open orders for
+         * @param {int} [limit] the maximum number of  open orders structures to retrieve
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (symbol === undefined) {
+            throw new ArgumentsRequired(this.id + 'fetchOpenOrdersWs requires a symbol.');
+        }
+        await this.loadMarkets();
+        await this.authenticate();
+        const market = this.market(symbol);
+        const url = this.urls['api']['ws'];
+        const messageHash = this.requestId();
+        const data = this.extend({
+            'pair': [market['baseId'], market['quoteId']],
+        }, params);
+        const request = {
+            'e': 'open-orders',
+            'oid': messageHash,
+            'data': data,
+        };
+        const response = await this.watch(url, messageHash, request, messageHash);
+        return this.parseOrders(response, market, since, limit, params);
+    }
+    async createOrderWs(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#createOrderWs
+         * @see https://docs.cex.io/#ws-api-order-placement
+         * @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 kraken api endpoint
+         * @param {boolean} [params.maker_only] Optional, maker only places an order only if offers best sell (<= max) or buy(>= max) price for this pair, if not order placement will be rejected with an error - "Order is not maker"
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/en/latest/manual.html#order-structure}
+         */
+        if (price === undefined) {
+            throw new BadRequest(this.id + ' createOrderWs requires a price argument');
+        }
+        await this.loadMarkets();
+        await this.authenticate();
+        const market = this.market(symbol);
+        const url = this.urls['api']['ws'];
+        const messageHash = this.requestId();
+        const data = this.extend({
+            'pair': [market['baseId'], market['quoteId']],
+            'amount': amount,
+            'price': price,
+            'type': side,
+        }, params);
+        const request = {
+            'e': 'place-order',
+            'oid': messageHash,
+            'data': data,
+        };
+        const rawOrder = await this.watch(url, messageHash, request, messageHash);
+        return this.parseOrder(rawOrder, market);
+    }
+    async editOrderWs(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#editOrderWs
+         * @description edit a trade order
+         * @see https://docs.cex.io/#ws-api-cancel-replace
+         * @param {string} id order id
+         * @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 the currency you want to trade in units of the base currency
+         * @param {float|undefined} [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 cex api endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/en/latest/manual.html#order-structure}
+         */
+        if (amount === undefined) {
+            throw new ArgumentsRequired(this.id + ' editOrder() requires a amount argument');
+        }
+        if (price === undefined) {
+            throw new ArgumentsRequired(this.id + ' editOrder() requires a price argument');
+        }
+        await this.loadMarkets();
+        await this.authenticate();
+        const market = this.market(symbol);
+        const data = this.extend({
+            'pair': [market['baseId'], market['quoteId']],
+            'type': side,
+            'amount': amount,
+            'price': price,
+            'order_id': id,
+        }, params);
+        const messageHash = this.requestId();
+        const url = this.urls['api']['ws'];
+        const request = {
+            'e': 'cancel-replace-order',
+            'oid': messageHash,
+            'data': data,
+        };
+        const response = await this.watch(url, messageHash, request, messageHash, messageHash);
+        return this.parseOrder(response, market);
+    }
+    async cancelOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#cancelOrderWs
+         * @see https://docs.cex.io/#ws-api-order-cancel
+         * @description cancels an open order
+         * @param {string} id order id
+         * @param {string} symbol not used by cex cancelOrder ()
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+        }
+        const data = this.extend({
+            'order_id': id,
+        }, params);
+        const messageHash = this.requestId();
+        const url = this.urls['api']['ws'];
+        const request = {
+            'e': 'cancel-order',
+            'oid': messageHash,
+            'data': data,
+        };
+        const response = await this.watch(url, messageHash, request, messageHash, messageHash);
+        return this.parseOrder(response, market);
+    }
+    async cancelOrdersWs(ids, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name cex#cancelOrdersWs
+         * @description cancel multiple orders
+         * @see https://docs.cex.io/#ws-api-mass-cancel-place
+         * @param {string[]} ids order ids
+         * @param {string} symbol not used by cex cancelOrders()
+         * @param {object} [params] extra parameters specific to the cex api endpoint
+         * @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (symbol !== undefined) {
+            throw new BadRequest(this.id + ' cancelOrderWs does not allow filtering by symbol');
+        }
+        await this.loadMarkets();
+        await this.authenticate();
+        const messageHash = this.requestId();
+        const data = this.extend({
+            'cancel-orders': ids,
+        }, params);
+        const url = this.urls['api']['ws'];
+        const request = {
+            'e': 'mass-cancel-place-orders',
+            'oid': messageHash,
+            'data': data,
+        };
+        const response = await this.watch(url, messageHash, request, messageHash, messageHash);
+        //
+        //    {
+        //        "cancel-orders": [{
+        //            "order_id": 69202557979,
+        //            "fremains": "0.15000000"
+        //        }],
+        //        "place-orders": [],
+        //        "placed-cancelled": []
+        //    }
+        //
+        const canceledOrders = this.safeValue(response, 'cancel-orders');
+        return this.parseOrders(canceledOrders, undefined, undefined, undefined, params);
+    }
+    resolveData(client, message) {
+        //
+        //    "e": "open-orders",
+        //    "data": [
+        //       {
+        //          "id": "2477098",
+        //          "time": "1435927928618",
+        //          "type": "buy",
+        //          "price": "241.9477",
+        //          "amount": "0.02000000",
+        //          "pending": "0.02000000"
+        //       },
+        //       ...
+        //    ],
+        //    "oid": "1435927928274_9_open-orders",
+        //    "ok": "ok"
+        //    }
+        //
+        const data = this.safeValue(message, 'data');
+        const messageHash = this.safeString(message, 'oid');
+        client.resolve(data, messageHash);
+    }
     handleConnected(client, message) {
         //
         //     {
@@ -1130,7 +1414,25 @@ export default class cex extends cexRest {
         //         "ok": "error"
         //     }
         //
-        throw new ExchangeError(this.id + ' ' + this.json(message));
+        try {
+            const data = this.safeValue(message, 'data', {});
+            const error = this.safeString(data, 'error');
+            const event = this.safeString(message, 'e', '');
+            const feedback = this.id + ' ' + event + ' ' + error;
+            this.throwExactlyMatchedException(this.exceptions['exact'], error, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], error, feedback);
+            throw new ExchangeError(feedback);
+        }
+        catch (error) {
+            const messageHash = this.safeString(message, 'oid');
+            const future = this.safeValue(client['futures'], messageHash);
+            if (future !== undefined) {
+                client.reject(error, messageHash);
+            }
+            else {
+                throw error;
+            }
+        }
     }
     handleMessage(client, message) {
         const ok = this.safeString(message, 'ok');
@@ -1150,11 +1452,16 @@ export default class cex extends cexRest {
             'get-balance': this.handleBalance,
             'order-book-subscribe': this.handleOrderBookSnapshot,
             'md_update': this.handleOrderBookUpdate,
-            'open-orders': this.handleOrdersSnapshot,
+            'open-orders': this.resolveData,
             'order': this.handleOrderUpdate,
             'history-update': this.handleTrade,
             'history': this.handleTradesSnapshot,
             'tx': this.handleTransaction,
+            'place-order': this.resolveData,
+            'cancel-replace-order': this.resolveData,
+            'cancel-order': this.resolveData,
+            'mass-cancel-place-orders': this.resolveData,
+            'get-order': this.resolveData,
         };
         const handler = this.safeValue(handlers, event);
         if (handler !== undefined) {

package/package.json

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

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

@@ -1,28 +0,0 @@
-import { implicitReturnType } from '../base/types.js';
-import { Exchange as _Exchange } from '../base/Exchange.js';
-interface Exchange {
-    webGetCurrency(params?: {}): Promise<implicitReturnType>;
-    webGetPairs(params?: {}): Promise<implicitReturnType>;
-    webGetTickers(params?: {}): Promise<implicitReturnType>;
-    webGetOrders(params?: {}): Promise<implicitReturnType>;
-    webGetOrdershistory(params?: {}): Promise<implicitReturnType>;
-    webGetTradeData(params?: {}): Promise<implicitReturnType>;
-    webGetTradeDataId(params?: {}): Promise<implicitReturnType>;
-    publicGetInfo(params?: {}): Promise<implicitReturnType>;
-    publicGetTickerPair(params?: {}): Promise<implicitReturnType>;
-    publicGetDepthPair(params?: {}): Promise<implicitReturnType>;
-    publicGetTradesPair(params?: {}): Promise<implicitReturnType>;
-    privatePostGetInfoExt(params?: {}): Promise<implicitReturnType>;
-    privatePostGetInfo(params?: {}): Promise<implicitReturnType>;
-    privatePostTrade(params?: {}): Promise<implicitReturnType>;
-    privatePostActiveOrders(params?: {}): Promise<implicitReturnType>;
-    privatePostOrderInfo(params?: {}): Promise<implicitReturnType>;
-    privatePostCancelOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostTradeHistory(params?: {}): Promise<implicitReturnType>;
-    privatePostGetDepositAddress(params?: {}): Promise<implicitReturnType>;
-    privatePostCreateWithdraw(params?: {}): Promise<implicitReturnType>;
-    privatePostGetWithdraw(params?: {}): Promise<implicitReturnType>;
-}
-declare abstract class Exchange extends _Exchange {
-}
-export default Exchange;

package/js/src/abstract/tidex.js

@@ -1,11 +0,0 @@
-// ----------------------------------------------------------------------------
-
-// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
-// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
-// EDIT THE CORRESPONDENT .ts FILE INSTEAD
-
-// -------------------------------------------------------------------------------
-import { Exchange as _Exchange } from '../base/Exchange.js';
-class Exchange extends _Exchange {
-}
-export default Exchange;