ccxt 4.4.45 → 4.4.46

package/js/src/ascendex.js

@@ -1117,6 +1117,7 @@ export default class ascendex extends Exchange {
      * @param {int} [since] timestamp in ms of the earliest candle to fetch
      * @param {int} [limit] the maximum amount of candles to fetch
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {int} [params.until] timestamp in ms of the latest candle to fetch
      * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
      */
     async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
@@ -1131,6 +1132,7 @@ export default class ascendex extends Exchange {
         const duration = this.parseTimeframe(timeframe);
         const options = this.safeDict(this.options, 'fetchOHLCV', {});
         const defaultLimit = this.safeInteger(options, 'limit', 500);
+        const until = this.safeInteger(params, 'until');
         if (since !== undefined) {
             request['from'] = since;
             if (limit === undefined) {
@@ -1139,11 +1141,28 @@ export default class ascendex extends Exchange {
             else {
                 limit = Math.min(limit, defaultLimit);
             }
-            request['to'] = this.sum(since, limit * duration * 1000, 1);
+            const toWithLimit = this.sum(since, limit * duration * 1000, 1);
+            if (until !== undefined) {
+                request['to'] = Math.min(toWithLimit, until + 1);
+            }
+            else {
+                request['to'] = toWithLimit;
+            }
+        }
+        else if (until !== undefined) {
+            request['to'] = until + 1;
+            if (limit === undefined) {
+                limit = defaultLimit;
+            }
+            else {
+                limit = Math.min(limit, defaultLimit);
+            }
+            request['from'] = until - (limit * duration * 1000);
         }
         else if (limit !== undefined) {
             request['n'] = limit; // max 500
         }
+        params = this.omit(params, 'until');
         const response = await this.v1PublicGetBarhist(this.extend(request, params));
         //
         //     {

package/js/src/binance.js

@@ -2475,7 +2475,7 @@ export default class binance extends Exchange {
                         //
                         '-2010': InvalidOrder,
                         '-2011': OperationRejected,
-                        '-2013': BadRequest,
+                        '-2013': OrderNotFound,
                         '-2014': OperationRejected,
                         '-2015': OperationRejected,
                         '-2016': OperationFailed,

package/js/src/bitget.js

@@ -1426,16 +1426,102 @@ export default class bitget extends Exchange {
                 },
                 'sandboxMode': false,
                 'networks': {
+                    // 'TRX': 'TRX', // different code for mainnet
                     'TRC20': 'TRC20',
+                    // 'ETH': 'ETH', // different code for mainnet
                     'ERC20': 'ERC20',
                     'BEP20': 'BSC',
-                    'ARB': 'ArbitrumOne',
-                    'ZKSYNC': 'zkSyncEra',
-                    'STARKNET': 'Starknet',
+                    // 'BEP20': 'BEP20', // different for BEP20
+                    'BSC': 'BEP20',
+                    'ATOM': 'ATOM',
+                    'ACA': 'AcalaToken',
                     'APT': 'Aptos',
+                    'ARBONE': 'ArbitrumOne',
+                    'ARBNOVA': 'ArbitrumNova',
+                    'AVAXC': 'C-Chain',
+                    'AVAXX': 'X-Chain',
+                    'AR': 'Arweave',
+                    'BCH': 'BCH',
+                    'BCHA': 'BCHA',
+                    'BITCI': 'BITCI',
+                    'BTC': 'BTC',
+                    'CELO': 'CELO',
+                    'CSPR': 'CSPR',
+                    'ADA': 'Cardano',
+                    'CHZ': 'ChilizChain',
+                    'CRC20': 'CronosChain',
+                    'DOGE': 'DOGE',
+                    'DOT': 'DOT',
+                    'EOS': 'EOS',
+                    'ETHF': 'ETHFAIR',
+                    'ETHW': 'ETHW',
+                    'ETC': 'ETC',
+                    'EGLD': 'Elrond',
+                    'FIL': 'FIL',
+                    'FIO': 'FIO',
+                    'FTM': 'Fantom',
+                    'HRC20': 'HECO',
+                    'ONE': 'Harmony',
+                    'HNT': 'Helium',
+                    'ICP': 'ICP',
+                    'IOTX': 'IoTeX',
+                    'KARDIA': 'KAI',
+                    'KAVA': 'KAVA',
+                    'KDA': 'KDA',
+                    'KLAY': 'Klaytn',
+                    'KSM': 'Kusama',
+                    'LAT': 'LAT',
+                    'LTC': 'LTC',
+                    'MINA': 'MINA',
+                    'MOVR': 'MOVR',
+                    'METIS': 'MetisToken',
+                    'GLMR': 'Moonbeam',
+                    'NEAR': 'NEARProtocol',
+                    'NULS': 'NULS',
+                    'OASYS': 'OASYS',
+                    'OASIS': 'ROSE',
+                    'OMNI': 'OMNI',
+                    'ONT': 'Ontology',
+                    'OPTIMISM': 'Optimism',
+                    'OSMO': 'Osmosis',
+                    'POKT': 'PocketNetwork',
                     'MATIC': 'Polygon',
+                    'QTUM': 'QTUM',
+                    'REEF': 'REEF',
+                    'SOL': 'SOL',
+                    'SYS': 'SYS',
+                    'SXP': 'Solar',
+                    'XYM': 'Symbol',
+                    'TON': 'TON',
+                    'TT': 'TT',
+                    'TLOS': 'Telos',
+                    'THETA': 'ThetaToken',
+                    'VITE': 'VITE',
+                    'WAVES': 'WAVES',
+                    'WAX': 'WAXP',
+                    'WEMIX': 'WEMIXMainnet',
+                    'XDC': 'XDCNetworkXDC',
+                    'XRP': 'XRP',
+                    'FET': 'FETCH',
+                    'NEM': 'NEM',
+                    'REI': 'REINetwork',
+                    'ZIL': 'ZIL',
+                    'ABBC': 'ABBCCoin',
+                    'RSK': 'RSK',
+                    'AZERO': 'AZERO',
+                    'TRC10': 'TRC10',
+                    'JUNO': 'JUNO',
+                    // undetected: USDSP, more info at https://www.bitget.com/v1/spot/public/coinChainList
+                    // todo: uncomment below after unification
+                    // 'TERRACLASSIC': 'Terra', // tbd, that network id is also assigned to TERRANEW network
+                    // 'CUBENETWORK': 'CUBE',
+                    // 'CADUCEUS': 'CMP',
+                    // 'CONFLUX': 'CFX', // CFXeSpace is different
+                    // 'CERE': 'CERE',
+                    // 'CANTO': 'CANTO',
+                    'ZKSYNC': 'zkSyncEra',
+                    'STARKNET': 'Starknet',
                     'VIC': 'VICTION',
-                    'AVAXC': 'C-Chain',
                 },
                 'networksById': {},
                 'fetchPositions': {
@@ -2341,14 +2427,14 @@ export default class bitget extends Exchange {
      */
     async withdraw(code, amount, address, tag = undefined, params = {}) {
         this.checkAddress(address);
-        const chain = this.safeString2(params, 'chain', 'network');
-        params = this.omit(params, 'network');
-        if (chain === undefined) {
-            throw new ArgumentsRequired(this.id + ' withdraw() requires a chain parameter or a network parameter');
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        if (networkCode === undefined) {
+            throw new ArgumentsRequired(this.id + ' withdraw() requires a "network" parameter');
         }
         await this.loadMarkets();
         const currency = this.currency(code);
-        const networkId = this.networkCodeToId(chain);
+        const networkId = this.networkCodeToId(networkCode);
         const request = {
             'coin': currency['id'],
             'address': address,
@@ -2372,27 +2458,8 @@ export default class bitget extends Exchange {
         //      }
         //
         const data = this.safeValue(response, 'data', {});
-        const result = {
-            'id': this.safeString(data, 'orderId'),
-            'info': response,
-            'txid': undefined,
-            'timestamp': undefined,
-            'datetime': undefined,
-            'network': undefined,
-            'addressFrom': undefined,
-            'address': undefined,
-            'addressTo': undefined,
-            'amount': undefined,
-            'type': 'withdrawal',
-            'currency': undefined,
-            'status': undefined,
-            'updated': undefined,
-            'tagFrom': undefined,
-            'tag': undefined,
-            'tagTo': undefined,
-            'comment': undefined,
-            'fee': undefined,
-        };
+        const result = this.parseTransaction(data, currency);
+        result['type'] = 'withdrawal';
         const withdrawOptions = this.safeValue(this.options, 'withdraw', {});
         const fillResponseFromRequest = this.safeBool(withdrawOptions, 'fillResponseFromRequest', true);
         if (fillResponseFromRequest) {
@@ -2403,7 +2470,7 @@ export default class bitget extends Exchange {
             result['tag'] = tag;
             result['address'] = address;
             result['addressTo'] = address;
-            result['network'] = chain;
+            result['network'] = networkCode;
         }
         return result;
     }
@@ -2571,18 +2638,14 @@ export default class bitget extends Exchange {
      */
     async fetchDepositAddress(code, params = {}) {
         await this.loadMarkets();
-        const networkCode = this.safeString2(params, 'chain', 'network');
-        params = this.omit(params, 'network');
-        let networkId = undefined;
-        if (networkCode !== undefined) {
-            networkId = this.networkCodeToId(networkCode, code);
-        }
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
         const currency = this.currency(code);
         const request = {
             'coin': currency['id'],
         };
-        if (networkId !== undefined) {
-            request['chain'] = networkId;
+        if (networkCode !== undefined) {
+            request['chain'] = this.networkCodeToId(networkCode, code);
         }
         const response = await this.privateSpotGetV2SpotWalletDepositAddress(this.extend(request, params));
         //

package/js/src/bybit.js

@@ -1058,8 +1058,78 @@ export default class bybit extends Exchange {
                     'ERC20': 'ETH',
                     'TRC20': 'TRX',
                     'BEP20': 'BSC',
+                    'SOL': 'SOL',
+                    'ACA': 'ACA',
+                    'ADA': 'ADA',
+                    'ALGO': 'ALGO',
+                    'APT': 'APTOS',
+                    'AR': 'AR',
+                    'ARBONE': 'ARBI',
+                    'AVAXC': 'CAVAX',
+                    'AVAXX': 'XAVAX',
+                    'ATOM': 'ATOM',
+                    'BCH': 'BCH',
+                    'BEP2': 'BNB',
+                    'CHZ': 'CHZ',
+                    'DCR': 'DCR',
+                    'DGB': 'DGB',
+                    'DOGE': 'DOGE',
+                    'DOT': 'DOT',
+                    'EGLD': 'EGLD',
+                    'EOS': 'EOS',
+                    'ETC': 'ETC',
+                    'ETHF': 'ETHF',
+                    'ETHW': 'ETHW',
+                    'FIL': 'FIL',
+                    'STEP': 'FITFI',
+                    'FLOW': 'FLOW',
+                    'FTM': 'FTM',
+                    'GLMR': 'GLMR',
+                    'HBAR': 'HBAR',
+                    'HNT': 'HNT',
+                    'ICP': 'ICP',
+                    'ICX': 'ICX',
+                    'KDA': 'KDA',
+                    'KLAY': 'KLAY',
+                    'KMA': 'KMA',
+                    'KSM': 'KSM',
+                    'LTC': 'LTC',
+                    // 'TERRA': 'LUNANEW',
+                    // 'TERRACLASSIC': 'LUNA',
+                    'MATIC': 'MATIC',
+                    'MINA': 'MINA',
+                    'MOVR': 'MOVR',
+                    'NEAR': 'NEAR',
+                    'NEM': 'NEM',
+                    'OASYS': 'OAS',
+                    'OASIS': 'ROSE',
                     'OMNI': 'OMNI',
-                    'SPL': 'SOL',
+                    'ONE': 'ONE',
+                    'OPTIMISM': 'OP',
+                    'POKT': 'POKT',
+                    'QTUM': 'QTUM',
+                    'RVN': 'RVN',
+                    'SC': 'SC',
+                    'SCRT': 'SCRT',
+                    'STX': 'STX',
+                    'THETA': 'THETA',
+                    'TON': 'TON',
+                    'WAVES': 'WAVES',
+                    'WAX': 'WAXP',
+                    'XDC': 'XDC',
+                    'XEC': 'XEC',
+                    'XLM': 'XLM',
+                    'XRP': 'XRP',
+                    'XTZ': 'XTZ',
+                    'XYM': 'XYM',
+                    'ZEN': 'ZEN',
+                    'ZIL': 'ZIL',
+                    'ZKSYNC': 'ZKSYNC',
+                    // todo: uncomment after consensus
+                    // 'CADUCEUS': 'CMP',
+                    // 'KON': 'KON', // konpay, "konchain"
+                    // 'AURORA': 'AURORA',
+                    // 'BITCOINGOLD': 'BTG',
                 },
                 'networksById': {
                     'ETH': 'ERC20',
@@ -5359,12 +5429,11 @@ export default class bybit extends Exchange {
         const address = this.safeString(depositAddress, 'addressDeposit');
         const tag = this.safeString(depositAddress, 'tagDeposit');
         const code = this.safeString(currency, 'code');
-        const chain = this.safeString(depositAddress, 'chain');
         this.checkAddress(address);
         return {
             'info': depositAddress,
             'currency': code,
-            'network': chain,
+            'network': this.networkIdToCode(this.safeString(depositAddress, 'chain'), code),
             'address': address,
             'tag': tag,
         };
@@ -5384,6 +5453,11 @@ export default class bybit extends Exchange {
         const request = {
             'coin': currency['id'],
         };
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        if (networkCode !== undefined) {
+            request['chainType'] = this.networkCodeToId(networkCode, code);
+        }
         const response = await this.privateGetV5AssetDepositQueryAddress(this.extend(request, params));
         //
         //     {
@@ -5424,41 +5498,11 @@ export default class bybit extends Exchange {
      */
     async fetchDepositAddress(code, params = {}) {
         await this.loadMarkets();
-        const [networkCode, query] = this.handleNetworkCodeAndParams(params);
-        const networkId = this.networkCodeToId(networkCode);
         const currency = this.currency(code);
-        const request = {
-            'coin': currency['id'],
-        };
-        if (networkId !== undefined) {
-            request['chainType'] = networkId;
-        }
-        const response = await this.privateGetV5AssetDepositQueryAddress(this.extend(request, query));
-        //
-        //     {
-        //         "retCode": 0,
-        //         "retMsg": "success",
-        //         "result": {
-        //             "coin": "USDT",
-        //             "chains": [
-        //                 {
-        //                     "chainType": "ERC20",
-        //                     "addressDeposit": "0xd9e1cd77afa0e50b452a62fbb68a3340602286c3",
-        //                     "tagDeposit": "",
-        //                     "chain": "ETH"
-        //                 }
-        //             ]
-        //         },
-        //         "retExtInfo": {},
-        //         "time": 1672192792860
-        //     }
-        //
-        const result = this.safeDict(response, 'result', {});
-        const chains = this.safeList(result, 'chains', []);
-        const chainsIndexedById = this.indexBy(chains, 'chain');
-        const selectedNetworkId = this.selectNetworkIdFromRawNetworks(code, networkCode, chainsIndexedById);
-        const addressObject = this.safeDict(chainsIndexedById, selectedNetworkId, {});
-        return this.parseDepositAddress(addressObject, currency);
+        const [networkCode, paramsOmited] = this.handleNetworkCodeAndParams(params);
+        const indexedAddresses = await this.fetchDepositAddressesByNetwork(code, paramsOmited);
+        const selectedNetworkCode = this.selectNetworkCodeFromUnifiedNetworks(currency['code'], networkCode, indexedAddresses);
+        return indexedAddresses[selectedNetworkCode];
     }
     /**
      * @method

package/js/src/delta.d.ts

@@ -100,12 +100,13 @@ export default class delta extends Exchange {
      * @method
      * @name delta#fetchOHLCV
      * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-     * @see https://docs.delta.exchange/#get-ohlc-candles
+     * @see https://docs.delta.exchange/#delta-exchange-api-v2-historical-ohlc-candles-sparklines
      * @param {string} symbol unified symbol of the market to fetch OHLCV data for
      * @param {string} timeframe the length of time each candle represents
      * @param {int} [since] timestamp in ms of the earliest candle to fetch
      * @param {int} [limit] the maximum amount of candles to fetch
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.until] timestamp in ms of the latest candle to fetch
      * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
      */
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;

package/js/src/delta.js

@@ -1469,12 +1469,13 @@ export default class delta extends Exchange {
      * @method
      * @name delta#fetchOHLCV
      * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-     * @see https://docs.delta.exchange/#get-ohlc-candles
+     * @see https://docs.delta.exchange/#delta-exchange-api-v2-historical-ohlc-candles-sparklines
      * @param {string} symbol unified symbol of the market to fetch OHLCV data for
      * @param {string} timeframe the length of time each candle represents
      * @param {int} [since] timestamp in ms of the earliest candle to fetch
      * @param {int} [limit] the maximum amount of candles to fetch
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.until] timestamp in ms of the latest candle to fetch
      * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
      */
     async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
@@ -1485,15 +1486,20 @@ export default class delta extends Exchange {
         };
         const duration = this.parseTimeframe(timeframe);
         limit = limit ? limit : 2000; // max 2000
+        let until = this.safeIntegerProduct(params, 'until', 0.001);
+        const untilIsDefined = (until !== undefined);
+        if (untilIsDefined) {
+            until = this.parseToInt(until);
+        }
         if (since === undefined) {
-            const end = this.seconds();
+            const end = untilIsDefined ? until : this.seconds();
             request['end'] = end;
             request['start'] = end - limit * duration;
         }
         else {
             const start = this.parseToInt(since / 1000);
             request['start'] = start;
-            request['end'] = this.sum(start, limit * duration);
+            request['end'] = untilIsDefined ? until : this.sum(start, limit * duration);
         }
         const price = this.safeString(params, 'price');
         if (price === 'mark') {
@@ -1505,7 +1511,7 @@ export default class delta extends Exchange {
         else {
             request['symbol'] = market['id'];
         }
-        params = this.omit(params, 'price');
+        params = this.omit(params, ['price', 'until']);
         const response = await this.publicGetHistoryCandles(this.extend(request, params));
         //
         //     {

package/js/src/gate.js

@@ -719,7 +719,6 @@ export default class gate extends Exchange {
                         'takeProfitPrice': true,
                         'attachedStopLossTakeProfit': undefined,
                         'timeInForce': {
-                            'GTC': true,
                             'IOC': true,
                             'FOK': true,
                             'PO': true,

package/js/src/hyperliquid.js

@@ -230,7 +230,6 @@ export default class hyperliquid extends Exchange {
                         'takeProfitPrice': false,
                         'attachedStopLossTakeProfit': undefined,
                         'timeInForce': {
-                            'GTC': true,
                             'IOC': true,
                             'FOK': false,
                             'PO': true,
@@ -2258,7 +2257,7 @@ export default class hyperliquid extends Exchange {
             market = this.safeMarket(marketId, market);
         }
         const symbol = market['symbol'];
-        const timestamp = this.safeInteger2(order, 'timestamp', 'statusTimestamp');
+        const timestamp = this.safeInteger(entry, 'timestamp');
         const status = this.safeString2(order, 'status', 'ccxtStatus');
         order = this.omit(order, ['ccxtStatus']);
         let side = this.safeString(entry, 'side');
@@ -2274,7 +2273,7 @@ export default class hyperliquid extends Exchange {
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'lastTradeTimestamp': undefined,
-            'lastUpdateTimestamp': undefined,
+            'lastUpdateTimestamp': this.safeInteger(order, 'statusTimestamp'),
             'symbol': symbol,
             'type': this.parseOrderType(this.safeStringLower(entry, 'orderType')),
             'timeInForce': this.safeStringUpper(entry, 'tif'),

package/js/src/mexc.js

@@ -446,6 +446,7 @@ export default class mexc extends Exchange {
                         '1h': '60m',
                         '4h': '4h',
                         '1d': '1d',
+                        '1w': '1W',
                         '1M': '1M',
                     },
                     'swap': {

package/js/src/onetrading.d.ts

@@ -109,6 +109,7 @@ export default class onetrading extends Exchange {
     fetchBalance(params?: {}): Promise<Balances>;
     parseOrderStatus(status: Str): string;
     parseOrder(order: Dict, market?: Market): Order;
+    parseOrderType(type: Str): string;
     parseTimeInForce(timeInForce: Str): string;
     /**
      * @method
@@ -135,7 +136,7 @@ export default class onetrading extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     /**
      * @method
      * @name onetrading#cancelAllOrders

package/js/src/onetrading.js

@@ -278,7 +278,9 @@ export default class onetrading extends Exchange {
                     'CF_RATELIMIT': DDoSProtection,
                     'INTERNAL_SERVER_ERROR': ExchangeError,
                 },
-                'broad': {},
+                'broad': {
+                    'Order not found.': OrderNotFound,
+                },
             },
             'commonCurrencies': {
                 'MIOTA': 'IOTA', // https://github.com/ccxt/ccxt/issues/7487
@@ -1005,6 +1007,7 @@ export default class onetrading extends Exchange {
             'CLOSED': 'canceled',
             'FAILED': 'failed',
             'STOP_TRIGGERED': 'triggered',
+            'DONE': 'closed',
         };
         return this.safeString(statuses, status, status);
     }
@@ -1099,7 +1102,7 @@ export default class onetrading extends Exchange {
             'datetime': this.iso8601(timestamp),
             'lastTradeTimestamp': undefined,
             'symbol': symbol,
-            'type': type,
+            'type': this.parseOrderType(type),
             'timeInForce': timeInForce,
             'postOnly': postOnly,
             'side': side,
@@ -1115,6 +1118,12 @@ export default class onetrading extends Exchange {
             'trades': rawTrades,
         }, market);
     }
+    parseOrderType(type) {
+        const types = {
+            'booked': 'limit',
+        };
+        return this.safeString(types, type, type);
+    }
     parseTimeInForce(timeInForce) {
         const timeInForces = {
             'GOOD_TILL_CANCELLED': 'GTC',
@@ -1178,6 +1187,9 @@ export default class onetrading extends Exchange {
             request['client_id'] = clientOrderId;
             params = this.omit(params, ['clientOrderId', 'client_id']);
         }
+        const timeInForce = this.safeString2(params, 'timeInForce', 'time_in_force', 'GOOD_TILL_CANCELLED');
+        params = this.omit(params, 'timeInForce');
+        request['time_in_force'] = timeInForce;
         const response = await this.privatePostAccountOrders(this.extend(request, params));
         //
         //     {
@@ -1219,11 +1231,17 @@ export default class onetrading extends Exchange {
         else {
             request['order_id'] = id;
         }
-        const response = await this[method](this.extend(request, params));
+        let response = undefined;
+        if (method === 'privateDeleteAccountOrdersOrderId') {
+            response = await this.privateDeleteAccountOrdersOrderId(this.extend(request, params));
+        }
+        else {
+            response = await this.privateDeleteAccountOrdersClientClientId(this.extend(request, params));
+        }
         //
         // responds with an empty body
         //
-        return response;
+        return this.parseOrder(response);
     }
     /**
      * @method

package/js/src/pro/coinex.js

@@ -1289,7 +1289,7 @@ export default class coinex extends coinexRest {
         const defaultType = this.safeString(this.options, 'defaultType');
         const marketId = this.safeString(ticker, 'market');
         market = this.safeMarket(marketId, market, undefined, defaultType);
-        const timestamp = this.safeTimestamp(ticker, 'updated_at');
+        const timestamp = this.safeInteger(ticker, 'updated_at');
         return this.safeTicker({
             'symbol': this.safeSymbol(marketId, market, undefined, defaultType),
             'timestamp': timestamp,

package/package.json

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