ccxt 4.5.22 → 4.5.23

package/js/src/pro/coinbase.js

@@ -784,7 +784,7 @@ export default class coinbase extends coinbaseRest {
             'type': this.safeString(order, 'order_type'),
             'timeInForce': undefined,
             'postOnly': undefined,
-            'side': this.safeString2(order, 'side', 'order_side'),
+            'side': this.safeStringLower2(order, 'side', 'order_side'),
             'price': this.safeString(order, 'limit_price'),
             'stopPrice': stopPrice,
             'triggerPrice': stopPrice,
@@ -793,7 +793,7 @@ export default class coinbase extends coinbaseRest {
             'average': this.safeString(order, 'avg_price'),
             'filled': this.safeString(order, 'cumulative_quantity'),
             'remaining': this.safeString(order, 'leaves_quantity'),
-            'status': this.safeStringLower(order, 'status'),
+            'status': this.parseOrderStatus(this.safeString(order, 'status')),
             'fee': {
                 'amount': this.safeString(order, 'total_fees'),
                 'currency': this.safeString(market, 'quote'),

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

@@ -120,6 +120,7 @@ export default class hyperliquid extends hyperliquidRest {
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
      * @param {string[]} symbols unified symbol of the market to fetch the ticker for
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.dex] for for hip3 tokens subscription, eg: 'xyz' or 'flx`, if symbols are provided we will infer it from the first symbol's market
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
      */
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
@@ -146,9 +147,20 @@ export default class hyperliquid extends hyperliquidRest {
      * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    handleWsTickers(client: Client, message: any): void;
+    handleWsTickers(client: Client, message: any): boolean;
     parseWsTicker(rawTicker: any, market?: Market): Ticker;
     handleMyTrades(client: Client, message: any): void;
+    /**
+     * @method
+     * @name hyperliquid#watchTrades
+     * @description watches information on multiple trades made in a market
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+     * @param {string} symbol unified market symbol of the market trades were made in
+     * @param {int} [since] the earliest time in ms to fetch trades for
+     * @param {int} [limit] the maximum number of trade 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}
+     */
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     /**
      * @method

package/js/src/pro/hyperliquid.js

@@ -303,6 +303,11 @@ export default class hyperliquid extends hyperliquidRest {
     async watchTicker(symbol, params = {}) {
         const market = this.market(symbol);
         symbol = market['symbol'];
+        // try to infer dex from market
+        const dexName = this.safeString(this.safeDict(market, 'info', {}), 'dex');
+        if (dexName) {
+            params = this.extend(params, { 'dex': dexName });
+        }
         const tickers = await this.watchTickers([symbol], params);
         return tickers[symbol];
     }
@@ -313,12 +318,13 @@ export default class hyperliquid extends hyperliquidRest {
      * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
      * @param {string[]} symbols unified symbol of the market to fetch the ticker for
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.dex] for for hip3 tokens subscription, eg: 'xyz' or 'flx`, if symbols are provided we will infer it from the first symbol's market
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
      */
     async watchTickers(symbols = undefined, params = {}) {
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols, undefined, true);
-        const messageHash = 'tickers';
+        let messageHash = 'tickers';
         const url = this.urls['api']['ws']['public'];
         const request = {
             'method': 'subscribe',
@@ -327,6 +333,21 @@ export default class hyperliquid extends hyperliquidRest {
                 'user': '0x0000000000000000000000000000000000000000',
             },
         };
+        let defaultDex = this.safeString(params, 'dex');
+        const firstSymbol = this.safeString(symbols, 0);
+        if (firstSymbol !== undefined) {
+            const market = this.market(firstSymbol);
+            const dexName = this.safeString(this.safeDict(market, 'info', {}), 'dex');
+            if (dexName !== undefined) {
+                defaultDex = dexName;
+            }
+        }
+        if (defaultDex !== undefined) {
+            params = this.omit(params, 'dex');
+            messageHash = 'tickers:' + defaultDex;
+            request['subscription']['type'] = 'allMids';
+            request['subscription']['dex'] = defaultDex;
+        }
         const tickers = await this.watch(url, messageHash, this.extend(request, params), messageHash);
         if (this.newUpdates) {
             return this.filterByArrayTickers(tickers, 'symbol', symbols);
@@ -394,6 +415,19 @@ export default class hyperliquid extends hyperliquidRest {
         return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
     }
     handleWsTickers(client, message) {
+        // hip3 mids
+        // {
+        //     channel: 'allMids',
+        //     data: {
+        //         dex: 'flx',
+        //         mids: {
+        //         'flx:COIN': '270.075',
+        //         'flx:CRCL': '78.8175',
+        //         'flx:NVDA': '180.64',
+        //         'flx:TSLA': '436.075'
+        //         }
+        //     }
+        // }
         //
         //     {
         //         "channel": "webData2",
@@ -440,13 +474,36 @@ export default class hyperliquid extends hyperliquidRest {
         //         }
         //     }
         //
+        // handle hip3 mids
+        const channel = this.safeString(message, 'channel');
+        if (channel === 'allMids') {
+            const data = this.safeDict(message, 'data', {});
+            const mids = this.safeDict(data, 'mids', {});
+            if (mids !== undefined) {
+                const keys = Object.keys(mids);
+                for (let i = 0; i < keys.length; i++) {
+                    const name = keys[i];
+                    const marketId = this.coinToMarketId(name);
+                    const market = this.safeMarket(marketId, undefined, undefined, 'swap');
+                    const symbol = market['symbol'];
+                    const ticker = this.parseWsTicker({
+                        'price': this.safeNumber(mids, name),
+                    }, market);
+                    this.tickers[symbol] = ticker;
+                }
+                const messageHash = 'tickers:' + this.safeString(data, 'dex');
+                client.resolve(this.tickers, messageHash);
+                return true;
+            }
+        }
         // spot
         const rawData = this.safeDict(message, 'data', {});
         const spotAssets = this.safeList(rawData, 'spotAssetCtxs', []);
         const parsedTickers = [];
         for (let i = 0; i < spotAssets.length; i++) {
             const assetObject = spotAssets[i];
-            const marketId = this.safeString(assetObject, 'coin');
+            const coin = this.safeString(assetObject, 'coin');
+            const marketId = this.coinToMarketId(coin);
             const market = this.safeMarket(marketId, undefined, undefined, 'spot');
             const symbol = market['symbol'];
             const ticker = this.parseWsTicker(assetObject, market);
@@ -459,8 +516,9 @@ export default class hyperliquid extends hyperliquidRest {
         const assetCtxs = this.safeList(rawData, 'assetCtxs', []);
         for (let i = 0; i < universe.length; i++) {
             const data = this.extend(this.safeDict(universe, i, {}), this.safeDict(assetCtxs, i, {}));
-            const id = data['name'] + '/USDC:USDC';
-            const market = this.safeMarket(id, undefined, undefined, 'swap');
+            const coin = this.safeString(data, 'name');
+            const marketId = this.coinToMarketId(coin);
+            const market = this.safeMarket(marketId, undefined, undefined, 'swap');
             const symbol = market['symbol'];
             const ticker = this.parseWsTicker(data, market);
             this.tickers[symbol] = ticker;
@@ -468,6 +526,7 @@ export default class hyperliquid extends hyperliquidRest {
         }
         const tickers = this.indexBy(parsedTickers, 'symbol');
         client.resolve(tickers, 'tickers');
+        return true;
     }
     parseWsTicker(rawTicker, market = undefined) {
         return this.parseTicker(rawTicker, market);
@@ -529,18 +588,18 @@ export default class hyperliquid extends hyperliquidRest {
         const messageHash = 'myTrades';
         client.resolve(trades, messageHash);
     }
+    /**
+     * @method
+     * @name hyperliquid#watchTrades
+     * @description watches information on multiple trades made in a market
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+     * @param {string} symbol unified market symbol of the market trades were made in
+     * @param {int} [since] the earliest time in ms to fetch trades for
+     * @param {int} [limit] the maximum number of trade 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}
+     */
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
-        // s
-        // @method
-        // @name hyperliquid#watchTrades
-        // @description watches information on multiple trades made in a market
-        // @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
-        // @param {string} symbol unified market symbol of the market trades were made in
-        // @param {int} [since] the earliest time in ms to fetch trades for
-        // @param {int} [limit] the maximum number of trade 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 market = this.market(symbol);
         symbol = market['symbol'];
@@ -1078,6 +1137,7 @@ export default class hyperliquid extends hyperliquidRest {
             'orderUpdates': this.handleOrder,
             'userFills': this.handleMyTrades,
             'webData2': this.handleWsTickers,
+            'allMids': this.handleWsTickers,
             'post': this.handleWsPost,
             'subscriptionResponse': this.handleSubscriptionResponse,
         };

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

@@ -3,7 +3,6 @@ import type { Int, Str, Order, OrderBook, Trade, Ticker, Balances, Tickers, Stri
 import Client from '../base/ws/Client.js';
 export default class upbit extends upbitRest {
     describe(): any;
-    watchPublic(symbol: string, channel: any, params?: {}): Promise<any>;
     watchPublicMultiple(symbols: Strings, channel: any, params?: {}): Promise<any>;
     /**
      * @method

package/js/src/pro/upbit.js

@@ -30,11 +30,13 @@ export default class upbit extends upbitRest {
             },
         });
     }
-    async watchPublic(symbol, channel, params = {}) {
+    async watchPublicMultiple(symbols, channel, params = {}) {
         await this.loadMarkets();
-        const market = this.market(symbol);
-        symbol = market['symbol'];
-        const marketId = market['id'];
+        if (symbols === undefined) {
+            symbols = this.symbols;
+        }
+        symbols = this.marketSymbols(symbols);
+        const marketIds = this.marketIds(symbols);
         const url = this.implodeParams(this.urls['api']['ws'], {
             'hostname': this.hostname,
         });
@@ -44,16 +46,18 @@ export default class upbit extends upbitRest {
             client.subscriptions[subscriptionsKey] = {};
         }
         const subscriptions = client.subscriptions[subscriptionsKey];
-        let messageHash = channel;
-        const request = {
-            'type': channel,
-        };
-        if (symbol !== undefined) {
-            messageHash = channel + ':' + symbol;
-            request['codes'] = [marketId];
-        }
-        if (!(messageHash in subscriptions)) {
-            subscriptions[messageHash] = request;
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const marketId = marketIds[i];
+            const symbol = symbols[i];
+            const messageHash = channel + ':' + symbol;
+            messageHashes.push(messageHash);
+            if (!(messageHash in subscriptions)) {
+                subscriptions[messageHash] = {
+                    'type': channel,
+                    'codes': [marketId],
+                };
+            }
         }
         const finalMessage = [
             {
@@ -65,34 +69,7 @@ export default class upbit extends upbitRest {
             const key = channelKeys[i];
             finalMessage.push(subscriptions[key]);
         }
-        return await this.watch(url, messageHash, finalMessage, messageHash);
-    }
-    async watchPublicMultiple(symbols, channel, params = {}) {
-        await this.loadMarkets();
-        if (symbols === undefined) {
-            symbols = this.symbols;
-        }
-        symbols = this.marketSymbols(symbols);
-        const marketIds = this.marketIds(symbols);
-        const url = this.implodeParams(this.urls['api']['ws'], {
-            'hostname': this.hostname,
-        });
-        const messageHashes = [];
-        for (let i = 0; i < marketIds.length; i++) {
-            messageHashes.push(channel + ':' + marketIds[i]);
-        }
-        const request = [
-            {
-                'ticket': this.uuid(),
-            },
-            {
-                'type': channel,
-                'codes': marketIds,
-                // 'isOnlySnapshot': false,
-                // 'isOnlyRealtime': false,
-            },
-        ];
-        return await this.watchMultiple(url, messageHashes, request, messageHashes);
+        return await this.watchMultiple(url, messageHashes, finalMessage, messageHashes);
     }
     /**
      * @method
@@ -104,7 +81,7 @@ export default class upbit extends upbitRest {
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
      */
     async watchTicker(symbol, params = {}) {
-        return await this.watchPublic(symbol, 'ticker');
+        return await this.watchPublicMultiple([symbol], 'ticker');
     }
     /**
      * @method
@@ -150,37 +127,7 @@ export default class upbit extends upbitRest {
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
      */
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
-        await this.loadMarkets();
-        symbols = this.marketSymbols(symbols, undefined, false, true, true);
-        const channel = 'trade';
-        const messageHashes = [];
-        const url = this.implodeParams(this.urls['api']['ws'], {
-            'hostname': this.hostname,
-        });
-        if (symbols !== undefined) {
-            for (let i = 0; i < symbols.length; i++) {
-                const market = this.market(symbols[i]);
-                const marketId = market['id'];
-                const symbol = market['symbol'];
-                this.options[channel] = this.safeValue(this.options, channel, {});
-                this.options[channel][symbol] = true;
-                messageHashes.push(channel + ':' + marketId);
-            }
-        }
-        const optionSymbols = Object.keys(this.options[channel]);
-        const marketIds = this.marketIds(optionSymbols);
-        const request = [
-            {
-                'ticket': this.uuid(),
-            },
-            {
-                'type': channel,
-                'codes': marketIds,
-                // 'isOnlySnapshot': false,
-                // 'isOnlyRealtime': false,
-            },
-        ];
-        const trades = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        const trades = await this.watchPublicMultiple(symbols, 'trade');
         if (this.newUpdates) {
             const first = this.safeValue(trades, 0);
             const tradeSymbol = this.safeString(first, 'symbol');
@@ -199,7 +146,7 @@ export default class upbit extends upbitRest {
      * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
      */
     async watchOrderBook(symbol, limit = undefined, params = {}) {
-        const orderbook = await this.watchPublic(symbol, 'orderbook');
+        const orderbook = await this.watchPublicMultiple([symbol], 'orderbook');
         return orderbook.limit();
     }
     /**
@@ -220,7 +167,7 @@ export default class upbit extends upbitRest {
             throw new NotSupported(this.id + ' watchOHLCV does not support' + timeframe + ' candle.');
         }
         const timeFrameOHLCV = 'candle.' + timeframe;
-        return await this.watchPublic(symbol, timeFrameOHLCV);
+        return await this.watchPublicMultiple([symbol], timeFrameOHLCV);
     }
     handleTicker(client, message) {
         // 2020-03-17T23:07:36.511Z "onMessage" <Buffer 7b 22 74 79 70 65 22 3a 22 74 69 63 6b 65 72 22 2c 22 63 6f 64 65 22 3a 22 42 54 43 2d 45 54 48 22 2c 22 6f 70 65 6e 69 6e 67 5f 70 72 69 63 65 22 3a ... >
@@ -259,11 +206,10 @@ export default class upbit extends upbitRest {
         //   "acc_trade_price_24h": 2.5955306323568927,
         //   "acc_trade_volume_24h": 118.38798416,
         //   "stream_type": "SNAPSHOT" }
-        const marketId = this.safeString(message, 'code');
-        const messageHash = 'ticker:' + marketId;
         const ticker = this.parseTicker(message);
         const symbol = ticker['symbol'];
         this.tickers[symbol] = ticker;
+        const messageHash = 'ticker:' + symbol;
         client.resolve(ticker, messageHash);
     }
     handleOrderBook(client, message) {
@@ -317,7 +263,7 @@ export default class upbit extends upbitRest {
         const datetime = this.iso8601(timestamp);
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = datetime;
-        const messageHash = 'orderbook:' + marketId;
+        const messageHash = 'orderbook:' + symbol;
         client.resolve(orderbook, messageHash);
     }
     handleTrades(client, message) {
@@ -344,8 +290,7 @@ export default class upbit extends upbitRest {
             this.trades[symbol] = stored;
         }
         stored.append(trade);
-        const marketId = this.safeString(message, 'code');
-        const messageHash = 'trade:' + marketId;
+        const messageHash = 'trade:' + symbol;
         client.resolve(stored, messageHash);
     }
     handleOHLCV(client, message) {
@@ -364,7 +309,8 @@ export default class upbit extends upbitRest {
         //     stream_type: 'REALTIME'
         //   }
         const marketId = this.safeString(message, 'code');
-        const messageHash = 'candle.1s:' + marketId;
+        const symbol = this.safeSymbol(marketId, undefined);
+        const messageHash = 'candle.1s:' + symbol;
         const ohlcv = this.parseOHLCV(message);
         client.resolve(ohlcv, messageHash);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.5.22",
+  "version": "4.5.23",
   "description": "A cryptocurrency trading API with more than 100 exchanges in JavaScript / TypeScript / Python / C# / PHP / Go",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",
@@ -40,7 +40,7 @@
     "buildGO": "go build -C go ./v4 && go build -C go ./v4/pro",
     "formatGO": "go fmt -C go v4 tests",
     "transpileGOWs": "tsx build/goTranspiler.ts --ws",
-    "transpileGORest": "tsx build/goTranspiler.ts && tsx build/goTranspiler.ts --ws",
+    "transpileGORest": "tsx build/goTranspiler.ts",
     "transpileGO": "npm run transpileGORest && npm run transpileGOWs",
     "buildCSTests": "dotnet build cs/tests/tests.csproj",
     "buildCSRelease": "dotnet build cs --configuration Release",