ccxt 4.3.11__py2.py3-none-any.whl → 4.3.12__py2.py3-none-any.whl

ccxt/pro/coinbase.py

@@ -31,10 +31,12 @@ class coinbase(ccxt.async_support.coinbase):
                 'watchMyTrades': False,
                 'watchOHLCV': False,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchOrders': True,
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
             },
             'urls': {
                 'api': {
@@ -76,7 +78,6 @@ class coinbase(ccxt.async_support.coinbase):
             messageHash = name + '::' + market['id']
             productIds = [market['id']]
         url = self.urls['api']['ws']
-        timestamp = self.number_to_string(self.seconds())
         subscribe = {
             'type': 'subscribe',
             'product_ids': productIds,
@@ -86,27 +87,63 @@ class coinbase(ccxt.async_support.coinbase):
             # 'signature': self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256),
         }
         if isPrivate:
-            self.check_required_credentials()
-            isCloudAPiKey = (self.apiKey.find('organizations/') >= 0) or (self.secret.startswith('-----BEGIN'))
-            auth = timestamp + name + ','.join(productIds)
-            if not isCloudAPiKey:
-                subscribe['api_key'] = self.apiKey
-                subscribe['timestamp'] = timestamp
-                subscribe['signature'] = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
-            else:
-                if self.apiKey.startswith('-----BEGIN'):
-                    raise ArgumentsRequired(self.id + ' apiKey should contain the name(eg: organizations/3b910e93....) and not the public key')
-                currentToken = self.safe_string(self.options, 'wsToken')
-                tokenTimestamp = self.safe_integer(self.options, 'wsTokenTimestamp', 0)
-                seconds = self.seconds()
-                if currentToken is None or tokenTimestamp + 120 < seconds:
-                    # we should generate new token
-                    token = self.create_auth_token(seconds)
-                    self.options['wsToken'] = token
-                    self.options['wsTokenTimestamp'] = seconds
-                subscribe['jwt'] = self.safe_string(self.options, 'wsToken')
+            subscribe = self.extend(subscribe, self.create_ws_auth(name, productIds))
         return await self.watch(url, messageHash, subscribe, messageHash)
 
+    async def subscribe_multiple(self, name: str, isPrivate: bool, symbols: Strings = None, params={}):
+        """
+         * @ignore
+        subscribes to a websocket channel
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
+        :param str name: the name of the channel
+        :param str[] [symbols]: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: subscription to a websocket channel
+        """
+        await self.load_markets()
+        productIds = []
+        messageHashes = []
+        symbols = self.market_symbols(symbols, None, False)
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            marketId = market['id']
+            productIds.append(marketId)
+            messageHashes.append(name + '::' + marketId)
+        url = self.urls['api']['ws']
+        subscribe = {
+            'type': 'subscribe',
+            'product_ids': productIds,
+            'channel': name,
+        }
+        if isPrivate:
+            subscribe = self.extend(subscribe, self.create_ws_auth(name, productIds))
+        return await self.watch_multiple(url, messageHashes, subscribe, messageHashes)
+
+    def create_ws_auth(self, name: str, productIds: List[str]):
+        subscribe = {}
+        timestamp = self.number_to_string(self.seconds())
+        self.check_required_credentials()
+        isCloudAPiKey = (self.apiKey.find('organizations/') >= 0) or (self.secret.startswith('-----BEGIN'))
+        auth = timestamp + name + ','.join(productIds)
+        if not isCloudAPiKey:
+            subscribe['api_key'] = self.apiKey
+            subscribe['timestamp'] = timestamp
+            subscribe['signature'] = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
+        else:
+            if self.apiKey.startswith('-----BEGIN'):
+                raise ArgumentsRequired(self.id + ' apiKey should contain the name(eg: organizations/3b910e93....) and not the public key')
+            currentToken = self.safe_string(self.options, 'wsToken')
+            tokenTimestamp = self.safe_integer(self.options, 'wsTokenTimestamp', 0)
+            seconds = self.seconds()
+            if currentToken is None or tokenTimestamp + 120 < seconds:
+                # we should generate new token
+                token = self.create_auth_token(seconds)
+                self.options['wsToken'] = token
+                self.options['wsTokenTimestamp'] = seconds
+            subscribe['jwt'] = self.safe_string(self.options, 'wsToken')
+        return subscribe
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
@@ -289,6 +326,25 @@ class coinbase(ccxt.async_support.coinbase):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        get the list of most recent trades for a particular symbol
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
+        :param str[] 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 dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        name = 'market_trades'
+        trades = await self.subscribe_multiple(name, False, symbols, params)
+        if self.newUpdates:
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
@@ -322,6 +378,20 @@ class coinbase(ccxt.async_support.coinbase):
         orderbook = await self.subscribe(name, False, symbol, params)
         return orderbook.limit()
 
+    async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
+        """
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
+        :param str[] symbols: unified array of symbols
+        :param int [limit]: the maximum amount of order book entries to return
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        name = 'level2'
+        orderbook = await self.subscribe_multiple(name, False, symbols, params)
+        return orderbook.limit()
+
     def handle_trade(self, client, message):
         #
         #    {

ccxt/pro/mexc.py

@@ -665,6 +665,21 @@ class mexc(ccxt.async_support.mexc):
         #        "v": "5"
         #    }
         #
+        #
+        #   d: {
+        #       p: '1.0005',
+        #       v: '5.71',
+        #       a: '5.712855',
+        #       S: 1,
+        #       T: 1714325698237,
+        #       t: 'edafcd9fdc2f426e82443d114691f724',
+        #       c: '',
+        #       i: 'C02__413321238354677760043',
+        #       m: 0,
+        #       st: 0,
+        #       n: '0.005712855',
+        #       N: 'USDT'
+        #   }
         timestamp = self.safe_integer(trade, 'T')
         tradeId = self.safe_string(trade, 't')
         if timestamp is None:
@@ -675,6 +690,8 @@ class mexc(ccxt.async_support.mexc):
         rawSide = self.safe_string(trade, 'S')
         side = 'buy' if (rawSide == '1') else 'sell'
         isMaker = self.safe_integer(trade, 'm')
+        feeAmount = self.safe_number(trade, 'n')
+        feeCurrencyId = self.safe_string(trade, 'N')
         return self.safe_trade({
             'info': trade,
             'id': tradeId,
@@ -688,7 +705,10 @@ class mexc(ccxt.async_support.mexc):
             'price': priceString,
             'amount': amountString,
             'cost': None,
-            'fee': None,
+            'fee': {
+                'cost': feeAmount,
+                'currency': self.safe_currency_code(feeCurrencyId),
+            },
         }, market)
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:

ccxt/probit.py

@@ -1428,10 +1428,10 @@ class probit(Exchange, ImplicitAPI):
             request['start_time'] = self.iso8601(since)
         else:
             request['start_time'] = self.iso8601(1)
-        until = self.safe_integer_2(params, 'till', 'until')
+        until = self.safe_integer(params, 'until')
         if until is not None:
             request['end_time'] = self.iso8601(until)
-            params = self.omit(params, ['until', 'till'])
+            params = self.omit(params, ['until'])
         else:
             request['end_time'] = self.iso8601(self.milliseconds())
         if limit is not None:

ccxt/test/base/test_datetime.py

@@ -62,6 +62,12 @@ assert exchange.parse8601(33) is None
 assert exchange.parse_date('1986-04-26 00:00:00') == 514857600000
 assert exchange.parse_date('1986-04-26T01:23:47.000Z') == 514862627000
 assert exchange.parse_date('1986-13-13 00:00:00') is None
+# GMT formats
+assert exchange.parse_date('Mon, 29 Apr 2024 14:00:17 GMT') == 1714399217000
+assert exchange.parse_date('Mon, 29 Apr 2024 14:09:17 GMT') == 1714399757000
+assert exchange.parse_date('Sun, 29 Dec 2024 01:01:10 GMT') == 1735434070000
+assert exchange.parse_date('Sun, 29 Dec 2024 02:11:10 GMT') == 1735438270000
+assert exchange.parse_date('Sun, 08 Dec 2024 02:03:04 GMT') == 1733623384000
 
 
 assert exchange.roundTimeframe('5m', exchange.parse8601('2019-08-12 13:22:08'), ROUND_DOWN) == exchange.parse8601('2019-08-12 13:20:00')

ccxt/test/base/test_ledger_entry.py

@@ -20,8 +20,8 @@ def test_ledger_entry(exchange, skipped_properties, method, entry, requested_cod
         'id': 'x1234',
         'currency': 'BTC',
         'account': 'spot',
-        'referenceId': '',
-        'referenceAccount': '',
+        'referenceId': 'foo',
+        'referenceAccount': 'bar',
         'status': 'ok',
         'amount': exchange.parse_number('22'),
         'before': exchange.parse_number('111'),

ccxt/whitebit.py

@@ -60,6 +60,7 @@ class whitebit(Exchange, ImplicitAPI):
                 'fetchDeposit': True,
                 'fetchDepositAddress': True,
                 'fetchDeposits': True,
+                'fetchDepositsWithdrawals': True,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': True,
                 'fetchFundingHistory': False,
@@ -1852,6 +1853,7 @@ class whitebit(Exchange, ImplicitAPI):
         #     {
         #         "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE",                                              # deposit address
         #         "uniqueId": null,                                                                             # unique Id of deposit
+        #         "transactionId": "a6d71d69-2b17-4ad8-8b15-2d686c54a1a5",
         #         "createdAt": 1593437922,                                                                      # timestamp of deposit
         #         "currency": "Bitcoin",                                                                        # deposit currency
         #         "ticker": "BTC",                                                                              # deposit currency ticker
@@ -1875,6 +1877,7 @@ class whitebit(Exchange, ImplicitAPI):
         #             "actual": 1,                                                                              # current block confirmations
         #             "required": 2                                                                             # required block confirmation for successful deposit
         #         }
+        #         "centralized": False,
         #     }
         #
         currency = self.safe_currency(None, currency)
@@ -1885,7 +1888,7 @@ class whitebit(Exchange, ImplicitAPI):
         method = self.safe_string(transaction, 'method')
         return {
             'id': self.safe_string(transaction, 'uniqueId'),
-            'txid': self.safe_string(transaction, 'transactionHash'),
+            'txid': self.safe_string(transaction, 'transactionId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'network': self.safe_string(transaction, 'network'),
@@ -2263,6 +2266,74 @@ class whitebit(Exchange, ImplicitAPI):
             'previousFundingDatetime': None,
         }
 
+    def fetch_deposits_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+        """
+        fetch history of deposits and withdrawals
+        :see: https://github.com/whitebit-exchange/api-docs/blob/main/pages/private/http-main-v4.md#get-depositwithdraw-history
+        :param str [code]: unified currency code for the currency of the deposit/withdrawals, default is None
+        :param int [since]: timestamp in ms of the earliest deposit/withdrawal, default is None
+        :param int [limit]: max number of deposit/withdrawals to return, default = 50, Min: 1, Max: 100
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+        :param number [params.transactionMethod]: Method. Example: 1 to display deposits / 2 to display withdraws. Do not send self parameter in order to receive both deposits and withdraws.
+        :param str [params.address]: Can be used for filtering transactions by specific address or memo.
+        :param str[] [params.addresses]: Can be used for filtering transactions by specific addresses or memos(max: 20).
+        :param str [params.uniqueId]: Can be used for filtering transactions by specific unique id
+        :param int [params.offset]: If you want the request to return entries starting from a particular line, you can use OFFSET clause to tell it where it should start. Default: 0, Min: 0, Max: 10000
+        :param str[] [params.status]: Can be used for filtering transactions by status codes. Caution: You must use self parameter with appropriate transactionMethod and use valid status codes for self method. You can find them below. Example: "status": [3,7]
+        :returns dict: a list of `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        self.load_markets()
+        request = {}
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['ticker'] = currency['id']
+        if limit is not None:
+            request['limit'] = limit  # default 1000
+        response = self.v4PrivatePostMainAccountHistory(self.extend(request, params))
+        #
+        #    {
+        #        "limit": 100,
+        #        "offset": 0,
+        #        "records": [
+        #            {
+        #                "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE",                                        # deposit address
+        #                "uniqueId": null,                                                                       # unique Id of deposit
+        #                "createdAt": 1593437922,                                                                # timestamp of deposit
+        #                "currency": "Bitcoin",                                                                  # deposit currency
+        #                "ticker": "BTC",                                                                        # deposit currency ticker
+        #                "method": 1,                                                                            # called method 1 - deposit, 2 - withdraw
+        #                "amount": "0.0006",                                                                     # amount of deposit
+        #                "description": "",                                                                      # deposit description
+        #                "memo": "",                                                                             # deposit memo
+        #                "fee": "0",                                                                             # deposit fee
+        #                "status": 15,                                                                           # transactions status
+        #                "network": null,                                                                        # if currency is multinetwork
+        #                "transactionHash": "a275a514013e4e0f927fd0d1bed215e7f6f2c4c6ce762836fe135ec22529d886",  # deposit transaction hash
+        #                "transactionId": "5e112b38-9652-11ed-a1eb-0242ac120002",                                # transaction id
+        #                "details": {
+        #                    "partial": {                                                                       # details about partially successful withdrawals
+        #                        "requestAmount": "50000",                                                       # requested withdrawal amount
+        #                        "processedAmount": "39000",                                                     # processed withdrawal amount
+        #                        "processedFee": "273",                                                          # fee for processed withdrawal amount
+        #                        "normalizeTransaction": ""                                                      # deposit id
+        #                    }
+        #                },
+        #                "confirmations": {                                                                     # if transaction status == 15(Pending) you can see self object
+        #                    "actual": 1,                                                                        # current block confirmations
+        #                    "required": 2                                                                       # required block confirmation for successful deposit
+        #                }
+        #            },
+        #            {...},
+        #        ],
+        #        "total": 300                                                                                    # total number of  transactions, use self for calculating ‘limit’ and ‘offset'
+        #    }
+        #
+        records = self.safe_list(response, 'records')
+        return self.parse_transactions(records, currency, since, limit)
+
     def is_fiat(self, currency):
         fiatCurrencies = self.safe_value(self.options, 'fiatCurrencies', [])
         return self.in_array(currency, fiatCurrencies)

ccxt/woo.py

@@ -2156,8 +2156,8 @@ class woo(Exchange, ImplicitAPI):
             request['size'] = limit
         if since is not None:
             request['start_t'] = since
-        until = self.safe_integer_2(params, 'until', 'till')  # unified in milliseconds
-        params = self.omit(params, ['until', 'till'])
+        until = self.safe_integer(params, 'until')  # unified in milliseconds
+        params = self.omit(params, ['until'])
         if until is not None:
             request['end_t'] = until
         response = self.v1PrivateGetAssetMainSubTransferHistory(self.extend(request, params))

{ccxt-4.3.11.dist-info → ccxt-4.3.12.dist-info}/METADATA

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