ccxt 4.3.40 → 4.3.41

package/js/src/pro/phemex.js

@@ -709,11 +709,11 @@ export default class phemex extends phemexRest {
             client.resolve(orderbook, messageHash);
         }
         else {
-            const orderbook = this.safeValue(this.orderbooks, symbol);
-            if (orderbook !== undefined) {
-                const changes = this.safeValue2(message, 'book', 'orderbook_p', {});
-                const asks = this.safeValue(changes, 'asks', []);
-                const bids = this.safeValue(changes, 'bids', []);
+            if (symbol in this.orderbooks) {
+                const orderbook = this.orderbooks[symbol];
+                const changes = this.safeDict2(message, 'book', 'orderbook_p', {});
+                const asks = this.safeList(changes, 'asks', []);
+                const bids = this.safeList(changes, 'bids', []);
                 this.customHandleDeltas(orderbook['asks'], asks, market);
                 this.customHandleDeltas(orderbook['bids'], bids, market);
                 orderbook['nonce'] = nonce;

package/js/src/pro/probit.js

@@ -453,11 +453,11 @@ export default class probit extends probitRest {
         const symbol = this.safeSymbol(marketId);
         const dataBySide = this.groupBy(orderBook, 'side');
         const messageHash = 'orderbook:' + symbol;
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook({});
-            this.orderbooks[symbol] = orderbook;
+        // let orderbook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook({});
         }
+        const orderbook = this.orderbooks[symbol];
         const reset = this.safeBool(message, 'reset', false);
         if (reset) {
             const snapshot = this.parseOrderBook(dataBySide, symbol, undefined, 'buy', 'sell', 'price', 'quantity');

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

@@ -1,5 +1,5 @@
 import upbitRest from '../upbit.js';
-import type { Int, OrderBook, Trade, Ticker } from '../base/types.js';
+import type { Int, Str, Order, OrderBook, Trade, Ticker, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class upbit extends upbitRest {
     describe(): any;
@@ -10,5 +10,17 @@ export default class upbit extends upbitRest {
     handleTicker(client: Client, message: any): void;
     handleOrderBook(client: Client, message: any): void;
     handleTrades(client: Client, message: any): void;
+    authenticate(params?: {}): Promise<import("../base/ws/WsClient.js").default>;
+    watchPrivate(symbol: any, channel: any, messageHash: any, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    parseWsOrderStatus(status: Str): string;
+    parseWsOrder(order: any, market?: any): Order;
+    parseWsTrade(trade: any, market?: any): Trade;
+    handleMyOrder(client: Client, message: any): void;
+    handleMyTrade(client: Client, message: any): void;
+    handleOrder(client: Client, message: any): void;
+    watchBalance(params?: {}): Promise<Balances>;
+    handleBalance(client: Client, message: any): void;
     handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/upbit.js

@@ -6,7 +6,9 @@
 
 //  ---------------------------------------------------------------------------
 import upbitRest from '../upbit.js';
-import { ArrayCache } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
+import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
+import { jwt } from '../base/functions/rsa.js';
 //  ---------------------------------------------------------------------------
 export default class upbit extends upbitRest {
     describe() {
@@ -16,10 +18,13 @@ export default class upbit extends upbitRest {
                 'watchOrderBook': true,
                 'watchTicker': true,
                 'watchTrades': true,
+                'watchOrders': true,
+                'watchMyTrades': true,
+                'watchBalance': true,
             },
             'urls': {
                 'api': {
-                    'ws': 'wss://api.upbit.com/websocket/v1',
+                    'ws': 'wss://{hostname}/websocket/v1',
                 },
             },
             'options': {
@@ -32,7 +37,9 @@ export default class upbit extends upbitRest {
         const market = this.market(symbol);
         symbol = market['symbol'];
         const marketId = market['id'];
-        const url = this.urls['api']['ws'];
+        const url = this.implodeParams(this.urls['api']['ws'], {
+            'hostname': this.hostname,
+        });
         this.options[channel] = this.safeValue(this.options, channel, {});
         this.options[channel][symbol] = true;
         const symbols = Object.keys(this.options[channel]);
@@ -56,6 +63,7 @@ export default class upbit extends upbitRest {
          * @method
          * @name upbit#watchTicker
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://global-docs.upbit.com/reference/websocket-ticker
          * @param {string} symbol unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
@@ -67,6 +75,7 @@ export default class upbit extends upbitRest {
          * @method
          * @name upbit#watchTrades
          * @description get the list of most recent trades for a particular symbol
+         * @see https://global-docs.upbit.com/reference/websocket-trade
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
          * @param {int} [limit] the maximum amount of trades to fetch
@@ -86,6 +95,7 @@ export default class upbit extends upbitRest {
          * @method
          * @name upbit#watchOrderBook
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://global-docs.upbit.com/reference/websocket-orderbook
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -220,11 +230,317 @@ export default class upbit extends upbitRest {
         const messageHash = 'trade:' + marketId;
         client.resolve(stored, messageHash);
     }
+    async authenticate(params = {}) {
+        this.checkRequiredCredentials();
+        const authenticated = this.options['ws']['token'];
+        if (authenticated === undefined) {
+            const auth = {
+                'access_key': this.apiKey,
+                'nonce': this.uuid(),
+            };
+            const token = jwt(auth, this.encode(this.secret), sha256, false);
+            this.options['ws']['token'] = token;
+            this.options['ws']['options']['headers'] = {
+                'authorization': 'Bearer ' + token,
+            };
+        }
+        const url = this.urls['api']['ws'] + '/private';
+        const client = this.client(url);
+        return client;
+    }
+    async watchPrivate(symbol, channel, messageHash, params = {}) {
+        await this.authenticate();
+        const request = {
+            'type': channel,
+        };
+        if (symbol !== undefined) {
+            await this.loadMarkets();
+            const market = this.market(symbol);
+            symbol = market['symbol'];
+            const symbols = [symbol];
+            const marketIds = this.marketIds(symbols);
+            request['codes'] = marketIds;
+            messageHash = messageHash + ':' + symbol;
+        }
+        let url = this.implodeParams(this.urls['api']['ws'], {
+            'hostname': this.hostname,
+        });
+        url += '/private';
+        const message = [
+            {
+                'ticket': this.uuid(),
+            },
+            request,
+        ];
+        return await this.watch(url, messageHash, message, messageHash);
+    }
+    async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name upbit#watchOrders
+         * @description watches information on multiple orders made by the user
+         * @see https://global-docs.upbit.com/reference/websocket-myorder
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const channel = 'myOrder';
+        const messageHash = 'myOrder';
+        const orders = await this.watchPrivate(symbol, channel, messageHash);
+        if (this.newUpdates) {
+            limit = orders.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
+    }
+    async watchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name upbit#watchMyTrades
+         * @description watches information on multiple trades made by the user
+         * @see https://global-docs.upbit.com/reference/websocket-myorder
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+         */
+        await this.loadMarkets();
+        const channel = 'myOrder';
+        const messageHash = 'myTrades';
+        const trades = await this.watchPrivate(symbol, channel, messageHash);
+        if (this.newUpdates) {
+            limit = trades.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
+    }
+    parseWsOrderStatus(status) {
+        const statuses = {
+            'wait': 'open',
+            'done': 'closed',
+            'cancel': 'canceled',
+            'watch': 'open',
+            'trade': 'open',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseWsOrder(order, market = undefined) {
+        //
+        // {
+        //     "type": "myOrder",
+        //     "code": "SGD-XRP",
+        //     "uuid": "ac2dc2a3-fce9-40a2-a4f6-5987c25c438f",
+        //     "ask_bid": "BID",
+        //     "order_type": "limit",
+        //     "state": "trade",
+        //     "price": 0.001453,
+        //     "avg_price": 0.00145372,
+        //     "volume": 30925891.29839369,
+        //     "remaining_volume": 29968038.09235948,
+        //     "executed_volume": 30925891.29839369,
+        //     "trades_count": 1,
+        //     "reserved_fee": 44.23943970238218,
+        //     "remaining_fee": 21.77177967409916,
+        //     "paid_fee": 22.467660028283017,
+        //     "locked": 43565.33112787242,
+        //     "executed_funds": 44935.32005656603,
+        //     "order_timestamp": 1710751590000,
+        //     "timestamp": 1710751597500,
+        //     "stream_type": "REALTIME"
+        // }
+        //
+        const id = this.safeString(order, 'uuid');
+        let side = this.safeStringLower(order, 'ask_bid');
+        if (side === 'bid') {
+            side = 'buy';
+        }
+        else {
+            side = 'sell';
+        }
+        const timestamp = this.parse8601(this.safeString(order, 'order_timestamp'));
+        const status = this.parseWsOrderStatus(this.safeString(order, 'state'));
+        const marketId = this.safeString(order, 'code');
+        market = this.safeMarket(marketId, market);
+        let fee = undefined;
+        const feeCost = this.safeString(order, 'paid_fee');
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            };
+        }
+        return this.safeOrder({
+            'info': order,
+            'id': id,
+            'clientOrderId': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': this.safeString(order, 'trade_timestamp'),
+            'symbol': market['symbol'],
+            'type': this.safeString(order, 'order_type'),
+            'timeInForce': this.safeString(order, 'time_in_force'),
+            'postOnly': undefined,
+            'side': side,
+            'price': this.safeString(order, 'price'),
+            'stopPrice': undefined,
+            'triggerPrice': undefined,
+            'cost': this.safeString(order, 'executed_funds'),
+            'average': this.safeString(order, 'avg_price'),
+            'amount': this.safeString(order, 'volume'),
+            'filled': this.safeString(order, 'executed_volume'),
+            'remaining': this.safeString(order, 'remaining_volume'),
+            'status': status,
+            'fee': fee,
+            'trades': undefined,
+        });
+    }
+    parseWsTrade(trade, market = undefined) {
+        // see: parseWsOrder
+        let side = this.safeStringLower(trade, 'ask_bid');
+        if (side === 'bid') {
+            side = 'buy';
+        }
+        else {
+            side = 'sell';
+        }
+        const timestamp = this.parse8601(this.safeString(trade, 'trade_timestamp'));
+        const marketId = this.safeString(trade, 'code');
+        market = this.safeMarket(marketId, market);
+        let fee = undefined;
+        const feeCost = this.safeString(trade, 'paid_fee');
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            };
+        }
+        return this.safeTrade({
+            'id': this.safeString(trade, 'trade_uuid'),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': market['symbol'],
+            'side': side,
+            'price': this.safeString(trade, 'price'),
+            'amount': this.safeString(trade, 'volume'),
+            'cost': this.safeString(trade, 'executed_funds'),
+            'order': this.safeString(trade, 'uuid'),
+            'takerOrMaker': undefined,
+            'type': this.safeString(trade, 'order_type'),
+            'fee': fee,
+            'info': trade,
+        }, market);
+    }
+    handleMyOrder(client, message) {
+        // see: parseWsOrder
+        const tradeId = this.safeString(message, 'trade_uuid');
+        if (tradeId !== undefined) {
+            this.handleMyTrade(client, message);
+        }
+        this.handleOrder(client, message);
+    }
+    handleMyTrade(client, message) {
+        // see: parseWsOrder
+        let myTrades = this.myTrades;
+        if (myTrades === undefined) {
+            const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
+            myTrades = new ArrayCacheBySymbolById(limit);
+        }
+        const trade = this.parseWsTrade(message);
+        myTrades.append(trade);
+        let messageHash = 'myTrades';
+        client.resolve(myTrades, messageHash);
+        messageHash = 'myTrades:' + trade['symbol'];
+        client.resolve(myTrades, messageHash);
+    }
+    handleOrder(client, message) {
+        const parsed = this.parseWsOrder(message);
+        const symbol = this.safeString(parsed, 'symbol');
+        const orderId = this.safeString(parsed, 'id');
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new ArrayCacheBySymbolById(limit);
+        }
+        const cachedOrders = this.orders;
+        const orders = this.safeValue(cachedOrders.hashmap, symbol, {});
+        const order = this.safeValue(orders, orderId);
+        if (order !== undefined) {
+            const fee = this.safeValue(order, 'fee');
+            if (fee !== undefined) {
+                parsed['fee'] = fee;
+            }
+            const fees = this.safeValue(order, 'fees');
+            if (fees !== undefined) {
+                parsed['fees'] = fees;
+            }
+            parsed['trades'] = this.safeValue(order, 'trades');
+            parsed['timestamp'] = this.safeInteger(order, 'timestamp');
+            parsed['datetime'] = this.safeString(order, 'datetime');
+        }
+        cachedOrders.append(parsed);
+        let messageHash = 'myOrder';
+        client.resolve(this.orders, messageHash);
+        messageHash = messageHash + ':' + symbol;
+        client.resolve(this.orders, messageHash);
+    }
+    async watchBalance(params = {}) {
+        /**
+         * @method
+         * @name upbit#watchBalance
+         * @see https://global-docs.upbit.com/reference/websocket-myasset
+         * @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 exchange API endpoint
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+         */
+        await this.loadMarkets();
+        const channel = 'myAsset';
+        const messageHash = 'myAsset';
+        return await this.watchPrivate(undefined, channel, messageHash);
+    }
+    handleBalance(client, message) {
+        //
+        // {
+        //     "type": "myAsset",
+        //     "asset_uuid": "e635f223-1609-4969-8fb6-4376937baad6",
+        //     "assets": [
+        //       {
+        //         "currency": "SGD",
+        //         "balance": 1386929.37231066771348207123,
+        //         "locked": 10329.670127489597585685
+        //       }
+        //     ],
+        //     "asset_timestamp": 1710146517259,
+        //     "timestamp": 1710146517267,
+        //     "stream_type": "REALTIME"
+        // }
+        //
+        const data = this.safeList(message, 'assets', []);
+        const timestamp = this.safeInteger(message, 'timestamp');
+        this.balance['timestamp'] = timestamp;
+        this.balance['datetime'] = this.iso8601(timestamp);
+        for (let i = 0; i < data.length; i++) {
+            const balance = data[i];
+            const currencyId = this.safeString(balance, 'currency');
+            const code = this.safeCurrencyCode(currencyId);
+            const available = this.safeString(balance, 'balance');
+            const frozen = this.safeString(balance, 'locked');
+            const account = this.account();
+            account['free'] = available;
+            account['used'] = frozen;
+            this.balance[code] = account;
+            this.balance = this.safeBalance(this.balance);
+        }
+        const messageHash = this.safeString(message, 'type');
+        client.resolve(this.balance, messageHash);
+    }
     handleMessage(client, message) {
         const methods = {
             'ticker': this.handleTicker,
             'orderbook': this.handleOrderBook,
             'trade': this.handleTrades,
+            'myOrder': this.handleMyOrder,
+            'myAsset': this.handleBalance,
         };
         const methodName = this.safeString(message, 'type');
         const method = this.safeValue(methods, methodName);

package/js/src/pro/wazirx.js

@@ -523,21 +523,21 @@ export default class wazirx extends wazirxRest {
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
         const messageHash = 'orderbook:' + symbol;
-        const currentOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (currentOrderBook === undefined) {
+        // const currentOrderBook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
             const snapshot = this.parseOrderBook(data, symbol, timestamp, 'b', 'a');
-            const orderBook = this.orderBook(snapshot);
-            this.orderbooks[symbol] = orderBook;
+            this.orderbooks[symbol] = this.orderBook(snapshot);
         }
         else {
-            const asks = this.safeValue(data, 'a', []);
-            const bids = this.safeValue(data, 'b', []);
-            this.handleDeltas(currentOrderBook['asks'], asks);
-            this.handleDeltas(currentOrderBook['bids'], bids);
-            currentOrderBook['nonce'] = timestamp;
-            currentOrderBook['timestamp'] = timestamp;
-            currentOrderBook['datetime'] = this.iso8601(timestamp);
-            this.orderbooks[symbol] = currentOrderBook;
+            const orderbook = this.orderbooks[symbol];
+            const asks = this.safeList(data, 'a', []);
+            const bids = this.safeList(data, 'b', []);
+            this.handleDeltas(orderbook['asks'], asks);
+            this.handleDeltas(orderbook['bids'], bids);
+            orderbook['nonce'] = timestamp;
+            orderbook['timestamp'] = timestamp;
+            orderbook['datetime'] = this.iso8601(timestamp);
+            this.orderbooks[symbol] = orderbook;
         }
         client.resolve(this.orderbooks[symbol], messageHash);
     }

package/js/src/upbit.js

@@ -1887,25 +1887,33 @@ export default class upbit extends Exchange {
         }
         if (api === 'private') {
             this.checkRequiredCredentials();
+            headers = {};
             const nonce = this.uuid();
             const request = {
                 'access_key': this.apiKey,
                 'nonce': nonce,
             };
-            if (Object.keys(query).length) {
-                const auth = this.urlencode(query);
+            const hasQuery = Object.keys(query).length;
+            let auth = undefined;
+            if ((method !== 'GET') && (method !== 'DELETE')) {
+                body = this.json(params);
+                headers['Content-Type'] = 'application/json';
+                if (hasQuery) {
+                    auth = this.urlencode(query);
+                }
+            }
+            else {
+                if (hasQuery) {
+                    auth = this.urlencode(this.keysort(query));
+                }
+            }
+            if (auth !== undefined) {
                 const hash = this.hash(this.encode(auth), sha512);
                 request['query_hash'] = hash;
                 request['query_hash_alg'] = 'SHA512';
             }
             const token = jwt(request, this.encode(this.secret), sha256);
-            headers = {
-                'Authorization': 'Bearer ' + token,
-            };
-            if ((method !== 'GET') && (method !== 'DELETE')) {
-                body = this.json(params);
-                headers['Content-Type'] = 'application/json';
-            }
+            headers['Authorization'] = 'Bearer ' + token;
         }
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };
     }

package/js/src/woo.d.ts

@@ -28,7 +28,7 @@ export default class woo extends Exchange {
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
-    cancelAllOrdersAfter(timeout: Int, params?: {}): Promise<any>;
+    cancelAllOrdersAfter(timeout: Int, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/woo.js

@@ -1300,7 +1300,9 @@ export default class woo extends Exchange {
         //         "status":"CANCEL_ALL_SENT"
         //     }
         //
-        return response;
+        return [
+            this.safeOrder(response),
+        ];
     }
     async cancelAllOrdersAfter(timeout, params = {}) {
         /**
@@ -1327,7 +1329,9 @@ export default class woo extends Exchange {
         //         "timestamp": 1711534302943
         //     }
         //
-        return response;
+        return [
+            this.safeOrder(response),
+        ];
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**

package/package.json

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