ccxt 4.4.59__py2.py3-none-any.whl → 4.4.61__py2.py3-none-any.whl

ccxt/gate.py

@@ -674,23 +674,67 @@ class gate(Exchange, ImplicitAPI):
                 },
                 'createMarketBuyOrderRequiresPrice': True,
                 'networks': {
-                    'LINEA': 'LINEAETH',
-                    'KON': 'KONET',
-                    'AVAXC': 'AVAX_C',
+                    'BTC': 'BTC',
+                    'BRC20': 'BTCBRC',  # for eg: ORDI, RATS, ...
+                    'ETH': 'ETH',
+                    'ERC20': 'ETH',
+                    'TRX': 'TRX',
+                    'TRC20': 'TRX',
+                    'HECO': 'HT',
+                    'HRC20': 'HT',
+                    'BSC': 'BSC',
                     'BEP20': 'BSC',
+                    'SOL': 'SOL',
+                    'POLYGON': 'POL',
+                    'MATIC': 'POL',
+                    'OP': 'OPETH',
+                    'OPTIMISM': 'OPETH',
+                    'ADA': 'ADA',  # CARDANO
+                    'AVAXC': 'AVAX_C',
+                    'NEAR': 'NEAR',
+                    'ARBONE': 'ARBEVM',
+                    'BASE': 'BASEEVM',
+                    'SUI': 'SUI',
+                    'CRONOS': 'CRO',
+                    'CRO': 'CRO',
+                    'APT': 'APT',
+                    'SCROLL': 'SCROLLETH',
+                    'TAIKO': 'TAIKOETH',
+                    'HYPE': 'HYPE',
+                    'ALGO': 'ALGO',
+                    # KAVA: ['KAVA', 'KAVAEVM']
+                    # SEI: ['SEI', 'SEIEVM']
+                    'LINEA': 'LINEAETH',
+                    'BLAST': 'BLASTETH',
+                    'XLM': 'XLM',
+                    'RSK': 'RBTC',
+                    'TON': 'TON',
+                    'MNT': 'MNT',
+                    # 'RUNE': 'BTCRUNES', probably, cant verify atm
+                    'CELO': 'CELO',
+                    'HBAR': 'HBAR',
+                    # 'FTM': SONIC REBRAND, todo
+                    'ZKSERA': 'ZKSERA',
+                    'KLAY': 'KLAY',
                     'EOS': 'EOS',
-                    'ERC20': 'ETH',
+                    'ACA': 'ACA',
+                    # TLOS: ['TLOS', 'TLOSEVM']
+                    # ASTR: ['ASTR', 'ASTREVM']
+                    # CFX: ['CFX', 'CFXEVM']
+                    'XTZ': 'XTZ',
+                    'EGLD': 'EGLD',
+                    'GLMR': 'GLMR',
+                    'AURORA': 'AURORAEVM',
+                    # others
+                    'KON': 'KONET',
                     'GATECHAIN': 'GTEVM',
-                    'HRC20': 'HT',
                     'KUSAMA': 'KSMSM',
-                    'NEAR': 'NEAR',
                     'OKC': 'OKT',
-                    'OPTIMISM': 'OPETH',
-                    'POLKADOT': 'DOTSM',
-                    'TRC20': 'TRX',
+                    'POLKADOT': 'DOTSM',  # todo: DOT for main DOT
                     'LUNA': 'LUNC',
-                    'BASE': 'BASEEVM',
-                    'BRC20': 'BTCBRC',
+                },
+                'networksById': {
+                    'OPETH': 'OP',
                 },
                 'timeInForce': {
                     'GTC': 'gtc',
@@ -3525,6 +3569,7 @@ class gate(Exchange, ImplicitAPI):
         #
         # public
         #
+        #  spot:
         #     {
         #         "id": "1334253759",
         #         "create_time": "1626342738",
@@ -3535,6 +3580,18 @@ class gate(Exchange, ImplicitAPI):
         #         "price": "32452.16"
         #     }
         #
+        #  swap:
+        #
+        #    {
+        #        "id": "442288327",
+        #        "contract": "BTC_USDT",
+        #        "create_time": "1739814676.707",
+        #        "create_time_ms": "1739814676.707",
+        #        "size": "-105",
+        #        "price": "95594.8"
+        #    }
+        #
+        #
         # public ws
         #
         #     {
@@ -3611,8 +3668,14 @@ class gate(Exchange, ImplicitAPI):
         #     }
         #
         id = self.safe_string_2(trade, 'id', 'trade_id')
-        timestamp = self.safe_timestamp_2(trade, 'time', 'create_time')
-        timestamp = self.safe_integer(trade, 'create_time_ms', timestamp)
+        timestamp: Int = None
+        msString = self.safe_string(trade, 'create_time_ms')
+        if msString is not None:
+            msString = Precise.string_mul(msString, '1000')
+            msString = msString[0:13]
+            timestamp = self.parse_to_int(msString)
+        else:
+            timestamp = self.safe_timestamp_2(trade, 'time', 'create_time')
         marketId = self.safe_string_2(trade, 'currency_pair', 'contract')
         marketType = 'contract' if ('contract' in trade) else 'spot'
         market = self.safe_market(marketId, market, '_', marketType)

ccxt/hollaex.py

@@ -1882,7 +1882,7 @@ class hollaex(Exchange, ImplicitAPI):
         #         "network":"https://api.hollaex.network"
         #     }
         #
-        coins = self.safe_list(response, 'coins')
+        coins = self.safe_dict(response, 'coins', {})
         return self.parse_deposit_withdraw_fees(coins, codes, 'symbol')
 
     def normalize_number_if_needed(self, number):

ccxt/oxfun.py

@@ -2884,7 +2884,7 @@ class oxfun(Exchange, ImplicitAPI):
                 'AccessKey': self.apiKey,
                 'Timestamp': datetime,
                 'Signature': signature,
-                'Nonce': nonce,
+                'Nonce': str(nonce),
             }
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 

ccxt/phemex.py

@@ -1078,7 +1078,7 @@ class phemex(Exchange, ImplicitAPI):
         for i in range(0, len(products)):
             market = products[i]
             type = self.safe_string_lower(market, 'type')
-            if (type == 'perpetual') or (type == 'perpetualv2'):
+            if (type == 'perpetual') or (type == 'perpetualv2') or (type == 'PerpetualPilot'):
                 id = self.safe_string(market, 'symbol')
                 riskLimitValues = self.safe_value(riskLimitsById, id, {})
                 market = self.extend(market, riskLimitValues)

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.59'
+__version__ = '4.4.61'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/gate.py

@@ -1493,6 +1493,27 @@ class gate(ccxt.async_support.gate):
         #       data: {errs: {label: 'AUTHENTICATION_FAILED', message: 'Not login'}},
         #       request_id: '10406147'
         #     }
+        #     {
+        #         "time": 1739853211,
+        #         "time_ms": 1739853211201,
+        #         "id": 1,
+        #         "conn_id": "62f2c1dabbe186d7",
+        #         "trace_id": "cdb02a8c0b61086b2fe6f8fad2f98c54",
+        #         "channel": "spot.trades",
+        #         "event": "subscribe",
+        #         "payload": [
+        #             "LUNARLENS_USDT",
+        #             "ETH_USDT"
+        #         ],
+        #         "error": {
+        #             "code": 2,
+        #             "message": "unknown currency pair: LUNARLENS_USDT"
+        #         },
+        #         "result": {
+        #             "status": "fail"
+        #         },
+        #         "requestId": "cdb02a8c0b61086b2fe6f8fad2f98c54"
+        #     }
         #
         data = self.safe_dict(message, 'data')
         errs = self.safe_dict(data, 'errs')
@@ -1511,6 +1532,17 @@ class gate(ccxt.async_support.gate):
                 client.reject(e, messageHash)
                 if (messageHash is not None) and (messageHash in client.subscriptions):
                     del client.subscriptions[messageHash]
+                # remove subscriptions for watchSymbols
+                channel = self.safe_string(message, 'channel')
+                if (channel is not None) and (channel.find('.') > 0):
+                    parsedChannel = channel.split('.')
+                    payload = self.safe_list(message, 'payload', [])
+                    for i in range(0, len(payload)):
+                        marketType = parsedChannel[0] == 'swap' if 'futures' else parsedChannel[0]
+                        symbol = self.safe_symbol(payload[i], None, '_', marketType)
+                        messageHashSymbol = parsedChannel[1] + ':' + symbol
+                        if (messageHashSymbol is not None) and (messageHashSymbol in client.subscriptions):
+                            del client.subscriptions[messageHashSymbol]
             if (id is not None) and (id in client.subscriptions):
                 del client.subscriptions[id]
             return True

ccxt/pro/xt.py

@@ -4,8 +4,8 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 import ccxt.async_support
-from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Any, Balances, Int, Market, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
+from ccxt.base.types import Any, Balances, Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 
@@ -25,7 +25,7 @@ class xt(ccxt.async_support.xt):
                 'watchBalance': True,
                 'watchOrders': True,
                 'watchMyTrades': True,
-                'watchPositions': None,  # TODO https://doc.xt.com/#futures_user_websocket_v2position
+                'watchPositions': True,
             },
             'urls': {
                 'api': {
@@ -45,6 +45,11 @@ class xt(ccxt.async_support.xt):
                 'watchTickers': {
                     'method': 'tickers',  # agg_tickers(contract only)
                 },
+                'watchPositions': {
+                    'type': 'swap',
+                    'fetchPositionsSnapshot': True,
+                    'awaitPositionsSnapshot': True,
+                },
             },
             'streaming': {
                 'keepAlive': 20000,
@@ -352,6 +357,106 @@ class xt(ccxt.async_support.xt):
         name = 'balance'
         return await self.subscribe(name, 'private', 'watchBalance', None, None, params)
 
+    async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
+        """
+
+        https://doc.xt.com/#futures_user_websocket_v2position
+
+        watch all open positions
+        :param str[]|None symbols: list of unified market symbols
+        :param number [since]: since timestamp
+        :param number [limit]: limit
+        :param dict params: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
+        """
+        await self.load_markets()
+        url = self.urls['api']['ws']['contract'] + '/' + 'user'
+        client = self.client(url)
+        self.set_positions_cache(client)
+        fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.handle_option('watchPositions', 'awaitPositionsSnapshot', True)
+        cache = self.positions
+        if fetchPositionsSnapshot and awaitPositionsSnapshot and self.is_empty(cache):
+            snapshot = await client.future('fetchPositionsSnapshot')
+            return self.filter_by_symbols_since_limit(snapshot, symbols, since, limit, True)
+        name = 'position'
+        newPositions = await self.subscribe(name, 'private', 'watchPositions', None, None, params)
+        if self.newUpdates:
+            return newPositions
+        return self.filter_by_symbols_since_limit(cache, symbols, since, limit, True)
+
+    def set_positions_cache(self, client: Client):
+        if self.positions is None:
+            self.positions = ArrayCacheBySymbolBySide()
+        fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot')
+        if fetchPositionsSnapshot:
+            messageHash = 'fetchPositionsSnapshot'
+            if not (messageHash in client.futures):
+                client.future(messageHash)
+                self.spawn(self.load_positions_snapshot, client, messageHash)
+
+    async def load_positions_snapshot(self, client, messageHash):
+        positions = await self.fetch_positions(None)
+        self.positions = ArrayCacheBySymbolBySide()
+        cache = self.positions
+        for i in range(0, len(positions)):
+            position = positions[i]
+            contracts = self.safe_number(position, 'contracts', 0)
+            if contracts > 0:
+                cache.append(position)
+        # don't remove the future from the .futures cache
+        future = client.futures[messageHash]
+        future.resolve(cache)
+        client.resolve(cache, 'position::contract')
+
+    def handle_position(self, client, message):
+        #
+        #    {
+        #      topic: 'position',
+        #      event: 'position',
+        #      data: {
+        #        accountId: 245296,
+        #        accountType: 0,
+        #        symbol: 'eth_usdt',
+        #        contractType: 'PERPETUAL',
+        #        positionType: 'CROSSED',
+        #        positionSide: 'LONG',
+        #        positionSize: '1',
+        #        closeOrderSize: '0',
+        #        availableCloseSize: '1',
+        #        realizedProfit: '-0.0121',
+        #        entryPrice: '2637.87',
+        #        openOrderSize: '1',
+        #        isolatedMargin: '2.63787',
+        #        openOrderMarginFrozen: '2.78832014',
+        #        underlyingType: 'U_BASED',
+        #        leverage: 10,
+        #        welfareAccount: False,
+        #        profitFixedLatest: {},
+        #        closeProfit: '0.0000',
+        #        totalFee: '-0.0158',
+        #        totalFundFee: '0.0037',
+        #        markPrice: '2690.96'
+        #      }
+        #    }
+        #
+        if self.positions is None:
+            self.positions = ArrayCacheBySymbolBySide()
+        cache = self.positions
+        data = self.safe_dict(message, 'data', {})
+        position = self.parse_position(data)
+        cache.append(position)
+        messageHashes = self.find_message_hashes(client, 'position::contract')
+        for i in range(0, len(messageHashes)):
+            messageHash = messageHashes[i]
+            parts = messageHash.split('::')
+            symbolsString = parts[1]
+            symbols = symbolsString.split(',')
+            positions = self.filter_by_array([position], 'symbol', symbols, False)
+            if not self.is_empty(positions):
+                client.resolve(positions, messageHash)
+        client.resolve([position], 'position::contract')
+
     def handle_ticker(self, client: Client, message: dict):
         #
         # spot
@@ -1036,6 +1141,7 @@ class xt(ccxt.async_support.xt):
                 'agg_tickers': self.handle_tickers,
                 'balance': self.handle_balance,
                 'order': self.handle_order,
+                'position': self.handle_position,
             }
             method = self.safe_value(methods, topic)
             if topic == 'trade':

ccxt/test/tests_async.py

@@ -620,10 +620,21 @@ class testMainClass:
             dump('[TEST_WARNING]' + error_message)
         return True
 
+    def check_constructor(self, exchange):
+        # todo: this might be moved in base tests later
+        if exchange.id == 'binance':
+            assert exchange.hostname is None, 'binance.com hostname should be empty'
+            assert exchange.urls['api']['public'] == 'https://api.binance.com/api/v3', 'https://api.binance.com/api/v3 does not match: ' + exchange.urls['api']['public']
+            assert ('lending/union/account' in exchange.api['sapi']['get']), 'SAPI should contain the endpoint lending/union/account, ' + json_stringify(exchange.api['sapi']['get'])
+        elif exchange.id == 'binanceus':
+            assert exchange.hostname == 'binance.us', 'binance.us hostname does not match ' + exchange.hostname
+            assert exchange.urls['api']['public'] == 'https://api.binance.us/api/v3', 'https://api.binance.us/api/v3 does not match: ' + exchange.urls['api']['public']
+
     async def start_test(self, exchange, symbol):
         # we do not need to test aliases
         if exchange.alias:
             return True
+        self.check_constructor(exchange)
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):
             exchange.set_sandbox_mode(True)
         try:

ccxt/test/tests_sync.py

@@ -617,10 +617,21 @@ class testMainClass:
             dump('[TEST_WARNING]' + error_message)
         return True
 
+    def check_constructor(self, exchange):
+        # todo: this might be moved in base tests later
+        if exchange.id == 'binance':
+            assert exchange.hostname is None, 'binance.com hostname should be empty'
+            assert exchange.urls['api']['public'] == 'https://api.binance.com/api/v3', 'https://api.binance.com/api/v3 does not match: ' + exchange.urls['api']['public']
+            assert ('lending/union/account' in exchange.api['sapi']['get']), 'SAPI should contain the endpoint lending/union/account, ' + json_stringify(exchange.api['sapi']['get'])
+        elif exchange.id == 'binanceus':
+            assert exchange.hostname == 'binance.us', 'binance.us hostname does not match ' + exchange.hostname
+            assert exchange.urls['api']['public'] == 'https://api.binance.us/api/v3', 'https://api.binance.us/api/v3 does not match: ' + exchange.urls['api']['public']
+
     def start_test(self, exchange, symbol):
         # we do not need to test aliases
         if exchange.alias:
             return True
+        self.check_constructor(exchange)
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):
             exchange.set_sandbox_mode(True)
         try:

ccxt/xt.py

@@ -1393,9 +1393,15 @@ class xt(Exchange, ImplicitAPI):
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: the maximum amount of candles to fetch
         :param dict params: extra parameters specific to the xt api endpoint
+        :param int [params.until]: timestamp in ms of the latest candle to fetch
+        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         self.load_markets()
+        paginate = False
+        paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate', False)
+        if paginate:
+            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 1000)
         market = self.market(symbol)
         request = {
             'symbol': market['id'],
@@ -1405,6 +1411,12 @@ class xt(Exchange, ImplicitAPI):
             request['startTime'] = since
         if limit is not None:
             request['limit'] = limit
+        else:
+            request['limit'] = 1000
+        until = self.safe_integer(params, 'until')
+        params = self.omit(params, ['until'])
+        if until is not None:
+            request['endTime'] = until
         response = None
         if market['linear']:
             response = self.publicLinearGetFutureMarketV1PublicQKline(self.extend(request, params))

{ccxt-4.4.59.dist-info → ccxt-4.4.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.59
+Version: 4.4.61
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -277,13 +277,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.59/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.59/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.61/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.61/dist/ccxt.browser.min.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.59/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.61/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: