ccxt 4.2.36 → 4.2.38

package/js/src/bybit.js

@@ -3741,10 +3741,22 @@ export default class bybit extends Exchange {
             if (isStopLoss) {
                 const slTriggerPrice = this.safeValue2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss);
                 request['stopLoss'] = this.priceToPrecision(symbol, slTriggerPrice);
+                const slLimitPrice = this.safeValue(stopLoss, 'price');
+                if (slLimitPrice !== undefined) {
+                    request['tpslMode'] = 'Partial';
+                    request['slOrderType'] = 'Limit';
+                    request['slLimitPrice'] = this.priceToPrecision(symbol, slLimitPrice);
+                }
             }
             if (isTakeProfit) {
                 const tpTriggerPrice = this.safeValue2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit);
                 request['takeProfit'] = this.priceToPrecision(symbol, tpTriggerPrice);
+                const tpLimitPrice = this.safeValue(takeProfit, 'price');
+                if (tpLimitPrice !== undefined) {
+                    request['tpslMode'] = 'Partial';
+                    request['tpOrderType'] = 'Limit';
+                    request['tpLimitPrice'] = this.priceToPrecision(symbol, tpLimitPrice);
+                }
             }
         }
         if (market['spot']) {
@@ -6026,9 +6038,6 @@ export default class bybit extends Exchange {
         if (timestamp === undefined) {
             timestamp = this.safeIntegerN(position, ['updatedTime', 'updatedAt']);
         }
-        // default to cross of USDC margined positions
-        const tradeMode = this.safeInteger(position, 'tradeMode', 0);
-        const marginMode = tradeMode ? 'isolated' : 'cross';
         let collateralString = this.safeString(position, 'positionBalance');
         const entryPrice = this.omitZero(this.safeString2(position, 'entryPrice', 'avgPrice'));
         const liquidationPrice = this.omitZero(this.safeString(position, 'liqPrice'));
@@ -6092,7 +6101,7 @@ export default class bybit extends Exchange {
             'markPrice': this.safeNumber(position, 'markPrice'),
             'lastPrice': undefined,
             'collateral': this.parseNumber(collateralString),
-            'marginMode': marginMode,
+            'marginMode': undefined,
             'side': side,
             'percentage': undefined,
             'stopLossPrice': this.safeNumber2(position, 'stop_loss', 'stopLoss'),

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

@@ -4,13 +4,18 @@ import Client from '../base/ws/Client.js';
 export default class gemini extends geminiRest {
     describe(): any;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseWsTrade(trade: any, market?: any): Trade;
     handleTrade(client: Client, message: any): void;
     handleTrades(client: Client, message: any): void;
+    handleTradesForMultidata(client: Client, trades: any, timestamp: Int): void;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): any;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    helperForWatchMultipleConstruct(itemHashName: string, symbols: string[], params?: {}): Promise<any>;
+    handleOrderBookForMultidata(client: Client, rawOrderBookChanges: any, timestamp: Int, nonce: Int): void;
     handleL2Updates(client: Client, message: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleHeartbeat(client: Client, message: any): any;

package/js/src/pro/gemini.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import geminiRest from '../gemini.js';
 import { ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp } from '../base/ws/Cache.js';
-import { ExchangeError } from '../base/errors.js';
+import { ExchangeError, NotSupported } from '../base/errors.js';
 import { sha384 } from '../static_dependencies/noble-hashes/sha512.js';
 //  ---------------------------------------------------------------------------
 export default class gemini extends geminiRest {
@@ -19,9 +19,11 @@ export default class gemini extends geminiRest {
                 'watchTicker': false,
                 'watchTickers': false,
                 'watchTrades': true,
+                'watchTradesForSymbols': true,
                 'watchMyTrades': false,
                 'watchOrders': true,
                 'watchOrderBook': true,
+                'watchOrderBookForSymbols': true,
                 'watchOHLCV': true,
             },
             'hostname': 'api.gemini.com',
@@ -70,7 +72,29 @@ export default class gemini extends geminiRest {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gemini#watchTradesForSymbols
+         * @see https://docs.gemini.com/websocket-api/#multi-market-data
+         * @description get the list of most recent trades for a list of symbols
+         * @param {string[]} symbols 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
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        const trades = await this.helperForWatchMultipleConstruct('trades', symbols, params);
+        if (this.newUpdates) {
+            const first = this.safeList(trades, 0);
+            const tradeSymbol = this.safeString(first, 'symbol');
+            limit = trades.getLimit(tradeSymbol, limit);
+        }
+        return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
+    }
     parseWsTrade(trade, market = undefined) {
+        //
+        // regular v2 trade
         //
         //     {
         //         "type": "trade",
@@ -82,11 +106,31 @@ export default class gemini extends geminiRest {
         //         "side": "buy"
         //     }
         //
+        // multi data trade
+        //
+        //    {
+        //        "type": "trade",
+        //        "symbol": "ETHUSD",
+        //        "tid": "1683002242170204", // this is not TS, but somewhat ID
+        //        "price": "2299.24",
+        //        "amount": "0.002662",
+        //        "makerSide": "bid"
+        //    }
+        //
         const timestamp = this.safeInteger(trade, 'timestamp');
-        const id = this.safeString(trade, 'event_id');
+        const id = this.safeString2(trade, 'event_id', 'tid');
         const priceString = this.safeString(trade, 'price');
-        const amountString = this.safeString(trade, 'quantity');
-        const side = this.safeStringLower(trade, 'side');
+        const amountString = this.safeString2(trade, 'quantity', 'amount');
+        let side = this.safeStringLower(trade, 'side');
+        if (side === undefined) {
+            const marketSide = this.safeStringLower(trade, 'makerSide');
+            if (marketSide === 'bid') {
+                side = 'sell';
+            }
+            else if (marketSide === 'ask') {
+                side = 'buy';
+            }
+        }
         const marketId = this.safeStringLower(trade, 'symbol');
         const symbol = this.safeSymbol(marketId, market);
         return this.safeTrade({
@@ -186,6 +230,34 @@ export default class gemini extends geminiRest {
             client.resolve(stored, messageHash);
         }
     }
+    handleTradesForMultidata(client, trades, timestamp) {
+        if (trades !== undefined) {
+            const tradesLimit = this.safeInteger(this.options, 'tradesLimit', 1000);
+            const storesForSymbols = {};
+            for (let i = 0; i < trades.length; i++) {
+                const marketId = trades[i]['symbol'];
+                const market = this.safeMarket(marketId.toLowerCase());
+                const symbol = market['symbol'];
+                const trade = this.parseWsTrade(trades[i], market);
+                trade['timestamp'] = timestamp;
+                trade['datetime'] = this.iso8601(timestamp);
+                let stored = this.safeValue(this.trades, symbol);
+                if (stored === undefined) {
+                    stored = new ArrayCache(tradesLimit);
+                    this.trades[symbol] = stored;
+                }
+                stored.append(trade);
+                storesForSymbols[symbol] = stored;
+            }
+            const symbols = Object.keys(storesForSymbols);
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                const stored = storesForSymbols[symbol];
+                const messageHash = 'trades:' + symbol;
+                client.resolve(stored, messageHash);
+            }
+        }
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -331,6 +403,93 @@ export default class gemini extends geminiRest {
         this.orderbooks[symbol] = orderbook;
         client.resolve(orderbook, messageHash);
     }
+    async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gemini#watchOrderBookForSymbols
+         * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://docs.gemini.com/websocket-api/#multi-market-data
+         * @param {string[]} symbols unified array of symbols
+         * @param {int} [limit] the maximum amount of order book entries to return
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        const orderbook = await this.helperForWatchMultipleConstruct('orderbook', symbols, params);
+        return orderbook.limit();
+    }
+    async helperForWatchMultipleConstruct(itemHashName, symbols, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false, true, true);
+        const firstMarket = this.market(symbols[0]);
+        if (!firstMarket['spot'] && !firstMarket['linear']) {
+            throw new NotSupported(this.id + ' watchMultiple supports only spot or linear-swap symbols');
+        }
+        const messageHashes = [];
+        const marketIds = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const messageHash = itemHashName + ':' + symbol;
+            messageHashes.push(messageHash);
+            const market = this.market(symbol);
+            marketIds.push(market['id']);
+        }
+        const queryStr = marketIds.join(',');
+        let url = this.urls['api']['ws'] + '/v1/multimarketdata?symbols=' + queryStr + '&heartbeat=true&';
+        if (itemHashName === 'orderbook') {
+            url += 'trades=false&bids=true&offers=true';
+        }
+        else if (itemHashName === 'trades') {
+            url += 'trades=true&bids=false&offers=false';
+        }
+        return await this.watchMultiple(url, messageHashes, undefined);
+    }
+    handleOrderBookForMultidata(client, rawOrderBookChanges, timestamp, nonce) {
+        //
+        // rawOrderBookChanges
+        //
+        // [
+        //   {
+        //     delta: "4105123935484.817624",
+        //     price: "0.000000001",
+        //     reason: "initial", // initial|cancel|place
+        //     remaining: "4105123935484.817624",
+        //     side: "bid", // bid|ask
+        //     symbol: "SHIBUSD",
+        //     type: "change", // seems always change
+        //   },
+        //   ...
+        //
+        const marketId = rawOrderBookChanges[0]['symbol'];
+        const market = this.safeMarket(marketId.toLowerCase());
+        const symbol = market['symbol'];
+        const messageHash = 'orderbook:' + symbol;
+        let orderbook = this.safeDict(this.orderbooks, symbol);
+        if (orderbook === undefined) {
+            orderbook = this.orderBook();
+        }
+        const bids = orderbook['bids'];
+        const asks = orderbook['asks'];
+        for (let i = 0; i < rawOrderBookChanges.length; i++) {
+            const entry = rawOrderBookChanges[i];
+            const price = this.safeNumber(entry, 'price');
+            const size = this.safeNumber(entry, 'remaining');
+            const rawSide = this.safeString(entry, 'side');
+            if (rawSide === 'bid') {
+                bids.store(price, size);
+            }
+            else {
+                asks.store(price, size);
+            }
+        }
+        orderbook['bids'] = bids;
+        orderbook['asks'] = asks;
+        orderbook['symbol'] = symbol;
+        orderbook['nonce'] = nonce;
+        orderbook['timestamp'] = timestamp;
+        orderbook['datetime'] = this.iso8601(timestamp);
+        this.orderbooks[symbol] = orderbook;
+        client.resolve(orderbook, messageHash);
+    }
     handleL2Updates(client, message) {
         //
         //     {
@@ -411,6 +570,7 @@ export default class gemini extends geminiRest {
         //         "socket_sequence": 7
         //     }
         //
+        client.lastPong = this.milliseconds();
         return message;
     }
     handleSubscription(client, message) {
@@ -613,6 +773,33 @@ export default class gemini extends geminiRest {
         if (method !== undefined) {
             method.call(this, client, message);
         }
+        // handle multimarketdata
+        if (type === 'update') {
+            const ts = this.safeInteger(message, 'timestampms', this.milliseconds());
+            const eventId = this.safeInteger(message, 'eventId');
+            const events = this.safeList(message, 'events');
+            const orderBookItems = [];
+            const collectedEventsOfTrades = [];
+            for (let i = 0; i < events.length; i++) {
+                const event = events[i];
+                const eventType = this.safeString(event, 'type');
+                const isOrderBook = (eventType === 'change') && ('side' in event) && this.inArray(event['side'], ['ask', 'bid']);
+                if (isOrderBook) {
+                    orderBookItems.push(event);
+                }
+                else if (eventType === 'trade') {
+                    collectedEventsOfTrades.push(events[i]);
+                }
+            }
+            const lengthOb = orderBookItems.length;
+            if (lengthOb > 0) {
+                this.handleOrderBookForMultidata(client, orderBookItems, ts, eventId);
+            }
+            const lengthTrades = collectedEventsOfTrades.length;
+            if (lengthTrades > 0) {
+                this.handleTradesForMultidata(client, collectedEventsOfTrades, ts);
+            }
+        }
     }
     async authenticate(params = {}) {
         const url = this.safeString(params, 'url');

package/js/src/pro/kucoin.js

@@ -40,6 +40,7 @@ export default class kucoin extends kucoinRest {
                 'watchOrderBook': {
                     'snapshotDelay': 5,
                     'snapshotMaxRetries': 3,
+                    'method': '/market/level2', // '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50'
                 },
             },
             'streaming': {
@@ -441,10 +442,15 @@ export default class kucoin extends kucoinRest {
         /**
          * @method
          * @name kucoin#watchOrderBook
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level1-bbo-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-5-best-ask-bid-orders
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-50-best-ask-bid-orders
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @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
+         * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         //
@@ -468,10 +474,15 @@ export default class kucoin extends kucoinRest {
         /**
          * @method
          * @name kucoin#watchOrderBookForSymbols
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level1-bbo-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-5-best-ask-bid-orders
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-50-best-ask-bid-orders
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @param {string[]} symbols unified array of symbols
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         const symbolsLength = symbols.length;
@@ -479,28 +490,36 @@ export default class kucoin extends kucoinRest {
             throw new ArgumentsRequired(this.id + ' watchOrderBookForSymbols() requires a non-empty array of symbols');
         }
         if (limit !== undefined) {
-            if ((limit !== 20) && (limit !== 100)) {
-                throw new ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 20 or 100");
+            if ((limit !== 20) && (limit !== 100) && (limit !== 50) && (limit !== 5)) {
+                throw new ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 5, 20, 50 or 100");
             }
         }
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
         const marketIds = this.marketIds(symbols);
         const url = await this.negotiate(false);
-        const topic = '/market/level2:' + marketIds.join(',');
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'watchOrderBook', 'method', '/market/level2');
+        if ((limit === 5) || (limit === 50)) {
+            method = '/spotMarket/level2Depth' + limit.toString();
+        }
+        const topic = method + ':' + marketIds.join(',');
         const messageHashes = [];
         const subscriptionHashes = [];
         for (let i = 0; i < symbols.length; i++) {
             const symbol = symbols[i];
             messageHashes.push('orderbook:' + symbol);
             const marketId = marketIds[i];
-            subscriptionHashes.push('/market/level2:' + marketId);
+            subscriptionHashes.push(method + ':' + marketId);
+        }
+        let subscription = {};
+        if (method === '/market/level2') { // other streams return the entire orderbook, so we don't need to fetch the snapshot through REST
+            subscription = {
+                'method': this.handleOrderBookSubscription,
+                'symbols': symbols,
+                'limit': limit,
+            };
         }
-        const subscription = {
-            'method': this.handleOrderBookSubscription,
-            'symbols': symbols,
-            'limit': limit,
-        };
         const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params, subscription);
         return orderbook.limit();
     }
@@ -524,41 +543,74 @@ export default class kucoin extends kucoinRest {
         //         }
         //     }
         //
+        //     {
+        //         "topic": "/spotMarket/level2Depth5:BTC-USDT",
+        //         "type": "message",
+        //         "data": {
+        //             "asks": [
+        //                 [
+        //                     "42815.6",
+        //                     "1.24016245"
+        //                 ]
+        //             ],
+        //             "bids": [
+        //                 [
+        //                     "42815.5",
+        //                     "0.08652716"
+        //                 ]
+        //             ],
+        //             "timestamp": 1707204474018
+        //         },
+        //         "subject": "level2"
+        //     }
+        //
         const data = this.safeValue(message, 'data');
-        const marketId = this.safeString(data, 'symbol');
+        const subject = this.safeString(message, 'subject');
+        const topic = this.safeString(message, 'topic');
+        const topicParts = topic.split(':');
+        const topicSymbol = this.safeString(topicParts, 1);
+        const topicChannel = this.safeString(topicParts, 0);
+        const marketId = this.safeString(data, 'symbol', topicSymbol);
         const symbol = this.safeSymbol(marketId, undefined, '-');
         const messageHash = 'orderbook:' + symbol;
-        const storedOrderBook = this.orderbooks[symbol];
-        const nonce = this.safeInteger(storedOrderBook, 'nonce');
-        const deltaEnd = this.safeInteger(data, 'sequenceEnd');
-        if (nonce === undefined) {
-            const cacheLength = storedOrderBook.cache.length;
-            const topic = this.safeString(message, 'topic');
-            const topicParts = topic.split(':');
-            const topicSymbol = this.safeString(topicParts, 1);
-            const topicChannel = this.safeString(topicParts, 0);
-            const subscriptions = Object.keys(client.subscriptions);
-            let subscription = undefined;
-            for (let i = 0; i < subscriptions.length; i++) {
-                const key = subscriptions[i];
-                if ((key.indexOf(topicSymbol) >= 0) && (key.indexOf(topicChannel) >= 0)) {
-                    subscription = client.subscriptions[key];
-                    break;
-                }
+        let orderbook = this.safeDict(this.orderbooks, symbol);
+        if (subject === 'level2') {
+            if (orderbook === undefined) {
+                orderbook = this.orderBook();
             }
-            const limit = this.safeInteger(subscription, 'limit');
-            const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
-            if (cacheLength === snapshotDelay) {
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
+            else {
+                orderbook.reset();
             }
-            storedOrderBook.cache.push(data);
-            return;
+            orderbook['symbol'] = symbol;
         }
-        else if (nonce >= deltaEnd) {
-            return;
+        else {
+            const nonce = this.safeInteger(orderbook, 'nonce');
+            const deltaEnd = this.safeInteger2(data, 'sequenceEnd', 'timestamp');
+            if (nonce === undefined) {
+                const cacheLength = orderbook.cache.length;
+                const subscriptions = Object.keys(client.subscriptions);
+                let subscription = undefined;
+                for (let i = 0; i < subscriptions.length; i++) {
+                    const key = subscriptions[i];
+                    if ((key.indexOf(topicSymbol) >= 0) && (key.indexOf(topicChannel) >= 0)) {
+                        subscription = client.subscriptions[key];
+                        break;
+                    }
+                }
+                const limit = this.safeInteger(subscription, 'limit');
+                const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
+                if (cacheLength === snapshotDelay) {
+                    this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
+                }
+                orderbook.cache.push(data);
+                return;
+            }
+            else if (nonce >= deltaEnd) {
+                return;
+            }
         }
-        this.handleDelta(storedOrderBook, data);
-        client.resolve(storedOrderBook, messageHash);
+        this.handleDelta(orderbook, data);
+        client.resolve(orderbook, messageHash);
     }
     getCacheIndex(orderbook, cache) {
         const firstDelta = this.safeValue(cache, 0);
@@ -578,11 +630,11 @@ export default class kucoin extends kucoinRest {
         return cache.length;
     }
     handleDelta(orderbook, delta) {
-        orderbook['nonce'] = this.safeInteger(delta, 'sequenceEnd');
-        const timestamp = this.safeInteger(delta, 'time');
+        const timestamp = this.safeInteger2(delta, 'time', 'timestamp');
+        orderbook['nonce'] = this.safeInteger(delta, 'sequenceEnd', timestamp);
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = this.iso8601(timestamp);
-        const changes = this.safeValue(delta, 'changes');
+        const changes = this.safeValue(delta, 'changes', delta);
         const bids = this.safeValue(changes, 'bids', []);
         const asks = this.safeValue(changes, 'asks', []);
         const storedBids = orderbook['bids'];
@@ -996,6 +1048,7 @@ export default class kucoin extends kucoinRest {
         }
         const subject = this.safeString(message, 'subject');
         const methods = {
+            'level2': this.handleOrderBook,
             'trade.l2update': this.handleOrderBook,
             'trade.ticker': this.handleTicker,
             'trade.snapshot': this.handleTicker,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.2.36",
+  "version": "4.2.38",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",
@@ -144,7 +144,7 @@
     "as-table": "1.0.37",
     "asciichart": "^1.5.25",
     "assert": "^2.0.0",
-    "ast-transpiler": "^0.0.41",
+    "ast-transpiler": "^0.0.43",
     "docsify": "^4.11.4",
     "eslint": "8.22.0",
     "eslint-config-airbnb-base": "15.0.0",