ccxt 4.2.24 → 4.2.26

package/js/src/bitfinex2.js

@@ -53,6 +53,7 @@ export default class bitfinex2 extends Exchange {
                 'fetchFundingRates': true,
                 'fetchIndexOHLCV': false,
                 'fetchLedger': true,
+                'fetchLiquidations': true,
                 'fetchMarginMode': false,
                 'fetchMarkOHLCV': false,
                 'fetchMyTrades': true,
@@ -3174,4 +3175,94 @@ export default class bitfinex2 extends Exchange {
             'info': interest,
         }, market);
     }
+    async fetchLiquidations(symbol, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitfinex2#fetchLiquidations
+         * @description retrieves the public liquidations of a trading pair
+         * @see https://docs.bitfinex.com/reference/rest-public-liquidations
+         * @param {string} symbol unified CCXT market symbol
+         * @param {int} [since] the earliest time in ms to fetch liquidations for
+         * @param {int} [limit] the maximum number of liquidation structures to retrieve
+         * @param {object} [params] exchange specific parameters
+         * @param {int} [params.until] timestamp in ms of the latest liquidation
+         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         * @returns {object} an array of [liquidation structures]{@link https://docs.ccxt.com/#/?id=liquidation-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchLiquidations', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchLiquidations', symbol, since, limit, '8h', params, 500);
+        }
+        const market = this.market(symbol);
+        let request = {};
+        if (since !== undefined) {
+            request['start'] = since;
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        [request, params] = this.handleUntilOption('end', request, params);
+        const response = await this.publicGetLiquidationsHist(this.extend(request, params));
+        //
+        //     [
+        //         [
+        //             [
+        //                 "pos",
+        //                 171085137,
+        //                 1706395919788,
+        //                 null,
+        //                 "tAVAXF0:USTF0",
+        //                 -8,
+        //                 32.868,
+        //                 null,
+        //                 1,
+        //                 1,
+        //                 null,
+        //                 33.255
+        //             ]
+        //         ],
+        //     ]
+        //
+        return this.parseLiquidations(response, market, since, limit);
+    }
+    parseLiquidation(liquidation, market = undefined) {
+        //
+        //     [
+        //         [
+        //             "pos",
+        //             171085137,       // position id
+        //             1706395919788,   // timestamp
+        //             null,
+        //             "tAVAXF0:USTF0", // market id
+        //             -8,              // amount in contracts
+        //             32.868,          // base price
+        //             null,
+        //             1,
+        //             1,
+        //             null,
+        //             33.255           // acquired price
+        //         ]
+        //     ]
+        //
+        const entry = liquidation[0];
+        const timestamp = this.safeInteger(entry, 2);
+        const marketId = this.safeString(entry, 4);
+        const contracts = Precise.stringAbs(this.safeString(entry, 5));
+        const contractSize = this.safeString(market, 'contractSize');
+        const baseValue = Precise.stringMul(contracts, contractSize);
+        const price = this.safeString(entry, 11);
+        return this.safeLiquidation({
+            'info': entry,
+            'symbol': this.safeSymbol(marketId, market, undefined, 'contract'),
+            'contracts': this.parseNumber(contracts),
+            'contractSize': this.parseNumber(contractSize),
+            'price': this.parseNumber(price),
+            'baseValue': this.parseNumber(baseValue),
+            'quoteValue': this.parseNumber(Precise.stringMul(baseValue, price)),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+        });
+    }
 }

package/js/src/gate.js

@@ -3440,7 +3440,7 @@ export default class gate extends Exchange {
         //         "price": "333"
         //     }
         //
-        const id = this.safeString(trade, 'id');
+        const id = this.safeString2(trade, 'id', 'trade_id');
         let timestamp = this.safeTimestamp2(trade, 'time', 'create_time');
         timestamp = this.safeInteger(trade, 'create_time_ms', timestamp);
         const marketId = this.safeString2(trade, 'currency_pair', 'contract');

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

@@ -1,8 +1,11 @@
 import bingxRest from '../bingx.js';
-import type { Int, OHLCV, Str, OrderBook, Order, Trade, Balances } from '../base/types.js';
+import type { Int, OHLCV, Str, OrderBook, Order, Trade, Balances, Ticker } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bingx extends bingxRest {
     describe(): any;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    handleTicker(client: Client, message: any): void;
+    parseWsTicker(message: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;

package/js/src/pro/bingx.js

@@ -20,7 +20,7 @@ export default class bingx extends bingxRest {
                 'watchOHLCV': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
-                'watchTicker': false,
+                'watchTicker': true,
                 'watchTickers': false,
                 'watchBalance': true,
             },
@@ -75,6 +75,151 @@ export default class bingx extends bingxRest {
             },
         });
     }
+    async watchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchTicker
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes
+         * @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}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const [marketType, query] = this.handleMarketTypeAndParams('watchTrades', market, params);
+        const url = this.safeValue(this.urls['api']['ws'], marketType);
+        if (url === undefined) {
+            throw new BadRequest(this.id + ' watchTrades is not supported for ' + marketType + ' markets.');
+        }
+        const messageHash = market['id'] + '@ticker';
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': messageHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        return await this.watch(url, messageHash, this.extend(request, query), messageHash);
+    }
+    handleTicker(client, message) {
+        //
+        // swap
+        //
+        //     {
+        //         "code": 0,
+        //         "dataType": "BTC-USDT@ticker",
+        //         "data": {
+        //             "e": "24hTicker",
+        //             "E": 1706498923556,
+        //             "s": "BTC-USDT",
+        //             "p": "346.4",
+        //             "P": "0.82",
+        //             "c": "42432.5",
+        //             "L": "0.0529",
+        //             "h": "42855.4",
+        //             "l": "41578.3",
+        //             "v": "64310.9754",
+        //             "q": "2728360284.15",
+        //             "o": "42086.1",
+        //             "O": 1706498922655,
+        //             "C": 1706498883023,
+        //             "A": "42437.8",
+        //             "a": "1.4160",
+        //             "B": "42437.1",
+        //             "b": "2.5747"
+        //         }
+        //     }
+        //
+        // spot
+        //
+        //     {
+        //         "code": 0,
+        //         "timestamp": 1706506795473,
+        //         "data": {
+        //             "e": "24hTicker",
+        //             "E": 1706506795472,
+        //             "s": "BTC-USDT",
+        //             "p": -372.12,
+        //             "P": "-0.87%",
+        //             "o": 42548.95,
+        //             "h": 42696.1,
+        //             "l": 41621.29,
+        //             "c": 42176.83,
+        //             "v": 4943.33,
+        //             "q": 208842236.5,
+        //             "O": 1706420395472,
+        //             "C": 1706506795472,
+        //             "A": 42177.23,
+        //             "a": 5.14484,
+        //             "B": 42176.38,
+        //             "b": 5.36117
+        //         }
+        //     }
+        //
+        const data = this.safeValue(message, 'data', {});
+        const marketId = this.safeString(data, 's');
+        // const marketId = messageHash.split('@')[0];
+        const isSwap = client.url.indexOf('swap') >= 0;
+        const marketType = isSwap ? 'swap' : 'spot';
+        const market = this.safeMarket(marketId, undefined, undefined, marketType);
+        const symbol = market['symbol'];
+        const ticker = this.parseWsTicker(data, market);
+        this.tickers[symbol] = ticker;
+        const messageHash = market['id'] + '@ticker';
+        client.resolve(ticker, messageHash);
+    }
+    parseWsTicker(message, market = undefined) {
+        //
+        //     {
+        //         "e": "24hTicker",
+        //         "E": 1706498923556,
+        //         "s": "BTC-USDT",
+        //         "p": "346.4",
+        //         "P": "0.82",
+        //         "c": "42432.5",
+        //         "L": "0.0529",
+        //         "h": "42855.4",
+        //         "l": "41578.3",
+        //         "v": "64310.9754",
+        //         "q": "2728360284.15",
+        //         "o": "42086.1",
+        //         "O": 1706498922655,
+        //         "C": 1706498883023,
+        //         "A": "42437.8",
+        //         "a": "1.4160",
+        //         "B": "42437.1",
+        //         "b": "2.5747"
+        //     }
+        //
+        const timestamp = this.safeInteger(message, 'ts');
+        const marketId = this.safeString(message, 's');
+        market = this.safeMarket(marketId, market);
+        const close = this.safeString(message, 'c');
+        return this.safeTicker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'high': this.safeString(message, 'h'),
+            'low': this.safeString(message, 'l'),
+            'bid': this.safeString(message, 'B'),
+            'bidVolume': this.safeString(message, 'b'),
+            'ask': this.safeString(message, 'A'),
+            'askVolume': this.safeString(message, 'a'),
+            'vwap': undefined,
+            'open': this.safeString(message, 'o'),
+            'close': close,
+            'last': close,
+            'previousClose': undefined,
+            'change': this.safeString(message, 'p'),
+            'percentage': undefined,
+            'average': undefined,
+            'baseVolume': this.safeString(message, 'v'),
+            'quoteVolume': this.safeString(message, 'q'),
+            'info': message,
+        }, market);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -911,6 +1056,10 @@ export default class bingx extends bingxRest {
             this.handleOrderBook(client, message);
             return;
         }
+        if (dataType.indexOf('@ticker') >= 0) {
+            this.handleTicker(client, message);
+            return;
+        }
         if (dataType.indexOf('@trade') >= 0) {
             this.handleTrades(client, message);
             return;
@@ -941,5 +1090,10 @@ export default class bingx extends bingxRest {
                 this.handleMyTrades(client, message);
             }
         }
+        const msgData = this.safeValue(message, 'data');
+        const msgEvent = this.safeString(msgData, 'e');
+        if (msgEvent === '24hTicker') {
+            this.handleTicker(client, message);
+        }
     }
 }

package/package.json

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