ccxt 4.4.27__py2.py3-none-any.whl → 4.4.29__py2.py3-none-any.whl

ccxt/pro/mexc.py

@@ -82,15 +82,23 @@ class mexc(ccxt.async_support.mexc):
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
         :see: https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#miniticker
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.miniTicker]: set to True for using the miniTicker endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
         messageHash = 'ticker:' + market['symbol']
         if market['spot']:
-            channel = 'spot@public.bookTicker.v3.api@' + market['id']
+            miniTicker = False
+            miniTicker, params = self.handle_option_and_params(params, 'watchTicker', 'miniTicker')
+            channel = None
+            if miniTicker:
+                channel = 'spot@public.miniTicker.v3.api@' + market['id'] + '@UTC+8'
+            else:
+                channel = 'spot@public.bookTicker.v3.api@' + market['id']
             return await self.watch_spot_public(channel, messageHash, params)
         else:
             channel = 'sub.ticker'
@@ -100,6 +108,38 @@ class mexc(ccxt.async_support.mexc):
             return await self.watch_swap_public(channel, messageHash, requestParams, params)
 
     def handle_ticker(self, client: Client, message):
+        #
+        # swap
+        #
+        #     {
+        #         "symbol": "BTC_USDT",
+        #         "data": {
+        #             "symbol": "BTC_USDT",
+        #             "lastPrice": 76376.2,
+        #             "riseFallRate": -0.0006,
+        #             "fairPrice": 76374.4,
+        #             "indexPrice": 76385.8,
+        #             "volume24": 962062810,
+        #             "amount24": 7344207079.96768,
+        #             "maxBidPrice": 84024.3,
+        #             "minAskPrice": 68747.2,
+        #             "lower24Price": 75620.2,
+        #             "high24Price": 77210,
+        #             "timestamp": 1731137509138,
+        #             "bid1": 76376.2,
+        #             "ask1": 76376.3,
+        #             "holdVol": 95479623,
+        #             "riseFallValue": -46.5,
+        #             "fundingRate": 0.0001,
+        #             "zone": "UTC+8",
+        #             "riseFallRates": [-0.0006, 0.1008, 0.2262, 0.2628, 0.2439, 1.0564],
+        #             "riseFallRatesOfTimezone": [0.0065, -0.0013, -0.0006]
+        #         },
+        #         "channel": "push.ticker",
+        #         "ts": 1731137509138
+        #     }
+        #
+        # spot
         #
         #    {
         #        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
@@ -113,8 +153,30 @@ class mexc(ccxt.async_support.mexc):
         #        "t": 1678643605721
         #    }
         #
+        # spot miniTicker
+        #
+        #     {
+        #         "d": {
+        #             "s": "BTCUSDT",
+        #             "p": "76522",
+        #             "r": "0.0012",
+        #             "tr": "0.0012",
+        #             "h": "77196.3",
+        #             "l": "75630.77",
+        #             "v": "584664223.92",
+        #             "q": "7666.720258",
+        #             "lastRT": "-1",
+        #             "MT": "0",
+        #             "NV": "--",
+        #             "t": "1731135533126"
+        #         },
+        #         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        #         "t": 1731135533126,
+        #         "s": "BTCUSDT"
+        #     }
+        #
         self.handle_bid_ask(client, message)
-        rawTicker = self.safe_value_2(message, 'd', 'data')
+        rawTicker = self.safe_dict_2(message, 'd', 'data')
         marketId = self.safe_string_2(message, 's', 'symbol')
         timestamp = self.safe_integer(message, 't')
         market = self.safe_market(marketId)
@@ -135,24 +197,44 @@ class mexc(ccxt.async_support.mexc):
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
         :see: https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#minitickers
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.miniTicker]: set to True for using the miniTicker endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
-        symbols = self.market_symbols(symbols, None, False)
+        symbols = self.market_symbols(symbols, None)
         messageHashes = []
-        marketIds = self.market_ids(symbols)
-        firstMarket = self.market(symbols[0])
-        isSpot = firstMarket['spot']
+        firstSymbol = self.safe_string(symbols, 0)
+        market = None
+        if firstSymbol is not None:
+            market = self.market(firstSymbol)
+        type = None
+        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        isSpot = (type == 'spot')
         url = self.urls['api']['ws']['spot'] if (isSpot) else self.urls['api']['ws']['swap']
         request: dict = {}
         if isSpot:
+            miniTicker = False
+            miniTicker, params = self.handle_option_and_params(params, 'watchTickers', 'miniTicker')
             topics = []
-            for i in range(0, len(marketIds)):
-                marketId = marketIds[i]
-                messageHashes.append('ticker:' + symbols[i])
-                topics.append('spot@public.bookTicker.v3.api@' + marketId)
+            if not miniTicker:
+                if symbols is None:
+                    raise ArgumentsRequired(self.id + 'watchTickers required symbols argument for the bookTicker channel')
+                marketIds = self.market_ids(symbols)
+                for i in range(0, len(marketIds)):
+                    marketId = marketIds[i]
+                    messageHashes.append('ticker:' + symbols[i])
+                    channel = 'spot@public.bookTicker.v3.api@' + marketId
+                    topics.append(channel)
+            else:
+                topics.append('spot@public.miniTickers.v3.api@UTC+8')
+                if symbols is None:
+                    messageHashes.append('spot:ticker')
+                else:
+                    for i in range(0, len(symbols)):
+                        messageHashes.append('ticker:' + symbols[i])
             request['method'] = 'SUBSCRIPTION'
             request['params'] = topics
         else:
@@ -167,6 +249,8 @@ class mexc(ccxt.async_support.mexc):
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
     def handle_tickers(self, client: Client, message):
+        #
+        # swap
         #
         #     {
         #       "channel": "push.tickers",
@@ -189,36 +273,108 @@ class mexc(ccxt.async_support.mexc):
         #       "ts": 1725872514111
         #     }
         #
-        data = self.safe_list(message, 'data')
-        topic = 'ticker'
+        # spot
+        #
+        #    {
+        #        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
+        #        "d": {
+        #            "A": "4.70432",
+        #            "B": "6.714863",
+        #            "a": "20744.54",
+        #            "b": "20744.17"
+        #        },
+        #        "s": "BTCUSDT",
+        #        "t": 1678643605721
+        #    }
+        #
+        # spot miniTicker
+        #
+        #     {
+        #         "d": {
+        #             "s": "BTCUSDT",
+        #             "p": "76522",
+        #             "r": "0.0012",
+        #             "tr": "0.0012",
+        #             "h": "77196.3",
+        #             "l": "75630.77",
+        #             "v": "584664223.92",
+        #             "q": "7666.720258",
+        #             "lastRT": "-1",
+        #             "MT": "0",
+        #             "NV": "--",
+        #             "t": "1731135533126"
+        #         },
+        #         "c": "spot@public.miniTicker.v3.api@BTCUSDT@UTC+8",
+        #         "t": 1731135533126,
+        #         "s": "BTCUSDT"
+        #     }
+        #
+        data = self.safe_list_2(message, 'data', 'd')
+        channel = self.safe_string(message, 'c', '')
+        marketId = self.safe_string(message, 's')
+        market = self.safe_market(marketId)
+        channelStartsWithSpot = channel.startswith('spot')
+        marketIdIsUndefined = marketId is None
+        isSpot = channelStartsWithSpot if marketIdIsUndefined else market['spot']
+        spotPrefix = 'spot:'
+        messageHashPrefix = spotPrefix if isSpot else ''
+        topic = messageHashPrefix + 'ticker'
         result = []
         for i in range(0, len(data)):
-            ticker = self.parse_ticker(data[i])
+            entry = data[i]
+            ticker = None
+            if isSpot:
+                ticker = self.parse_ws_ticker(entry, market)
+            else:
+                ticker = self.parse_ticker(entry)
             symbol = ticker['symbol']
             self.tickers[symbol] = ticker
             result.append(ticker)
-            messageHash = topic + ':' + symbol
+            messageHash = 'ticker:' + symbol
             client.resolve(ticker, messageHash)
         client.resolve(result, topic)
 
     def parse_ws_ticker(self, ticker, market=None):
         #
         # spot
-        #    {
-        #        "A": "4.70432",
-        #        "B": "6.714863",
-        #        "a": "20744.54",
-        #        "b": "20744.17"
-        #    }
         #
+        #     {
+        #         "A": "4.70432",
+        #         "B": "6.714863",
+        #         "a": "20744.54",
+        #         "b": "20744.17"
+        #     }
+        #
+        # spot miniTicker
+        #
+        #     {
+        #         "s": "BTCUSDT",
+        #         "p": "76522",
+        #         "r": "0.0012",
+        #         "tr": "0.0012",
+        #         "h": "77196.3",
+        #         "l": "75630.77",
+        #         "v": "584664223.92",
+        #         "q": "7666.720258",
+        #         "lastRT": "-1",
+        #         "MT": "0",
+        #         "NV": "--",
+        #         "t": "1731135533126"
+        #     }
+        #
+        marketId = self.safe_string(ticker, 's')
+        timestamp = self.safe_integer(ticker, 't')
+        price = self.safe_string(ticker, 'p')
         return self.safe_ticker({
-            'symbol': self.safe_symbol(None, market),
-            'timestamp': None,
-            'datetime': None,
+            'info': ticker,
+            'symbol': self.safe_symbol(marketId, market),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'open': None,
-            'high': None,
-            'low': None,
-            'close': None,
+            'high': self.safe_number(ticker, 'h'),
+            'low': self.safe_number(ticker, 'l'),
+            'close': price,
+            'last': price,
             'bid': self.safe_number(ticker, 'b'),
             'bidVolume': self.safe_number(ticker, 'B'),
             'ask': self.safe_number(ticker, 'a'),
@@ -226,11 +382,10 @@ class mexc(ccxt.async_support.mexc):
             'vwap': None,
             'previousClose': None,
             'change': None,
-            'percentage': None,
+            'percentage': self.safe_number(ticker, 'tr'),
             'average': None,
-            'baseVolume': None,
-            'quoteVolume': None,
-            'info': ticker,
+            'baseVolume': self.safe_number(ticker, 'v'),
+            'quoteVolume': self.safe_number(ticker, 'q'),
         }, market)
 
     async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
@@ -1258,6 +1413,8 @@ class mexc(ccxt.async_support.mexc):
             'public.kline.v3.api': self.handle_ohlcv,
             'push.kline': self.handle_ohlcv,
             'public.bookTicker.v3.api': self.handle_ticker,
+            'public.miniTicker.v3.api': self.handle_ticker,
+            'public.miniTickers.v3.api': self.handle_tickers,
             'push.ticker': self.handle_ticker,
             'push.tickers': self.handle_tickers,
             'public.increase.depth.v3.api': self.handle_order_book,

ccxt/probit.py

@@ -1319,7 +1319,7 @@ class probit(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_deposit_addresses(data, codes)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://docs-en.probit.com/reference/withdrawal
         make a withdrawal

ccxt/tokocrypto.py

@@ -2235,7 +2235,7 @@ class tokocrypto(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://www.tokocrypto.com/apidocs/#withdraw-signed
         make a withdrawal

ccxt/upbit.py

@@ -1815,7 +1815,7 @@ class upbit(Exchange, ImplicitAPI):
             raise AddressPending(self.id + ' is generating ' + code + ' deposit address, call fetchDepositAddress or createDepositAddress one more time later to retrieve the generated address')
         return self.parse_deposit_address(response)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://docs.upbit.com/reference/디지털자산-출금하기
         :see: https://docs.upbit.com/reference/%EC%9B%90%ED%99%94-%EC%B6%9C%EA%B8%88%ED%95%98%EA%B8%B0

ccxt/vertex.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.vertex import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees
+from ccxt.base.types import Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -2735,7 +2735,7 @@ class vertex(Exchange, ImplicitAPI):
         #
         return self.safe_dict(response, 'data', {})
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.vertexprotocol.com/developer-resources/api/withdrawing-on-chain
@@ -2773,13 +2773,57 @@ class vertex(Exchange, ImplicitAPI):
         }
         response = self.v1GatewayPostExecute(self.extend(request, params))
         #
-        # {
-        #     "status": "success",
-        #     "signature": {signature},
-        #     "request_type": "execute_withdraw_collateral"
-        # }
+        #     {
+        #         "status": "success",
+        #         "signature": {signature},
+        #         "request_type": "execute_withdraw_collateral"
+        #     }
         #
-        return response
+        transaction = self.parse_transaction(response, currency)
+        return self.extend(transaction, {
+            'amount': amount,
+            'address': address,
+        })
+
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
+        #
+        #     {
+        #         "status": "success",
+        #         "signature": {signature},
+        #         "request_type": "execute_withdraw_collateral"
+        #     }
+        #
+        code = None
+        if currency is not None:
+            code = currency['code']
+        return {
+            'info': transaction,
+            'id': None,
+            'txid': None,
+            'timestamp': None,
+            'datetime': None,
+            'addressFrom': None,
+            'address': None,
+            'addressTo': None,
+            'tagFrom': None,
+            'tag': None,
+            'tagTo': None,
+            'type': 'withdrawal',
+            'amount': None,
+            'currency': code,
+            'status': self.parse_transaction_status(self.safe_string(transaction, 'status')),
+            'updated': None,
+            'network': None,
+            'comment': None,
+            'internal': None,
+            'fee': None,
+        }
+
+    def parse_transaction_status(self, status: Str):
+        statuses: dict = {
+            'success': 'ok',
+        }
+        return self.safe_string(statuses, status, status)
 
     def handle_public_address(self, methodName: str, params: dict):
         userAux = None

ccxt/wavesexchange.py

@@ -1442,6 +1442,7 @@ class wavesexchange(Exchange, ImplicitAPI):
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
+        :see: https://matcher.waves.exchange/api-docs/index.html#/status/getOrderStatusByPKAndIdWithSig
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -2289,7 +2290,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' ' + body)
         return None
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/whitebit.py

@@ -1896,7 +1896,7 @@ class whitebit(Exchange, ImplicitAPI):
             'status': None,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.whitebit.com/private/http-main-v4/#create-withdraw-request

ccxt/woo.py

@@ -2293,7 +2293,7 @@ class woo(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.woo.org/#token-withdraw

ccxt/woofipro.py

@@ -2184,7 +2184,7 @@ class woofipro(Exchange, ImplicitAPI):
     def sign_message(self, message, privateKey):
         return self.sign_hash(self.hash_message(message), privateKey[-64:])
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://orderly.network/docs/build-on-evm/evm-api/restful-api/private/create-withdraw-request

ccxt/xt.py

@@ -3587,7 +3587,7 @@ class xt(Exchange, ImplicitAPI):
         withdrawals = self.safe_value(data, 'items', [])
         return self.parse_transactions(withdrawals, currency, since, limit, params)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://doc.xt.com/#deposit_withdrawalwithdraw

ccxt/yobit.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.yobit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees
+from ccxt.base.types import Balances, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -1185,7 +1185,7 @@ class yobit(Exchange, ImplicitAPI):
             'tag': None,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://yobit.net/en/api
         make a withdrawal

ccxt/zaif.py

@@ -585,7 +585,7 @@ class zaif(Exchange, ImplicitAPI):
         response = self.privatePostTradeHistory(self.extend(request, params))
         return self.parse_orders(response['return'], market, since, limit)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://zaif-api-document.readthedocs.io/ja/latest/TradingAPI.html#id41
         make a withdrawal

ccxt/zonda.py

@@ -1689,7 +1689,7 @@ class zonda(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://docs.zondacrypto.exchange/reference/crypto-withdrawal-1
         make a withdrawal

{ccxt-4.4.27.dist-info → ccxt-4.4.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.27
+Version: 4.4.29
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -273,13 +273,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.27/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.27/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.29/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.29/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.27/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.29/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: