ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/pro/idex.py

@@ -49,7 +49,7 @@ class idex(ccxt.async_support.idex):
 
     async def subscribe(self, subscribeObject, messageHash, subscription=True):
         url = self.urls['test']['ws']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'subscriptions': [
                 subscribeObject,
@@ -60,7 +60,7 @@ class idex(ccxt.async_support.idex):
     async def subscribe_private(self, subscribeObject, messageHash):
         token = await self.authenticate()
         url = self.urls['test']['ws']
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'token': token,
             'subscriptions': [
@@ -72,6 +72,9 @@ class idex(ccxt.async_support.idex):
     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
+
+        https://api-docs-v4.idex.io/#tickers
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -79,7 +82,7 @@ class idex(ccxt.async_support.idex):
         await self.load_markets()
         market = self.market(symbol)
         name = 'tickers'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
@@ -141,6 +144,9 @@ class idex(ccxt.async_support.idex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+
+        https://api-docs-v4.idex.io/#trades
+
         :param str symbol: 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
@@ -151,7 +157,7 @@ class idex(ccxt.async_support.idex):
         market = self.market(symbol)
         symbol = market['symbol']
         name = 'trades'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
@@ -231,6 +237,9 @@ class idex(ccxt.async_support.idex):
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+
+        https://api-docs-v4.idex.io/#candles
+
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -243,7 +252,7 @@ class idex(ccxt.async_support.idex):
         symbol = market['symbol']
         name = 'candles'
         interval = self.safe_string(self.timeframes, timeframe, timeframe)
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
             'interval': interval,
@@ -383,6 +392,9 @@ class idex(ccxt.async_support.idex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://api-docs-v4.idex.io/#l2-order-book
+
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -391,12 +403,12 @@ class idex(ccxt.async_support.idex):
         await self.load_markets()
         market = self.market(symbol)
         name = 'l2orderbook'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
             'markets': [market['id']],
         }
         messageHash = name + ':' + market['id']
-        subscription = {
+        subscription: dict = {
             'fetchingOrderBookSnapshot': False,
             'numAttempts': 0,
             'startTime': None,
@@ -456,7 +468,7 @@ class idex(ccxt.async_support.idex):
         price = self.safe_float(delta, 0)
         amount = self.safe_float(delta, 1)
         count = self.safe_integer(delta, 2)
-        bookside.store(price, amount, count)
+        bookside.storeArray([price, amount, count])
 
     def handle_deltas(self, bookside, deltas):
         for i in range(0, len(deltas)):
@@ -466,7 +478,7 @@ class idex(ccxt.async_support.idex):
         time = self.seconds()
         lastAuthenticatedTime = self.safe_integer(self.options, 'lastAuthenticatedTime', 0)
         if time - lastAuthenticatedTime > 900:
-            request = {
+            request: dict = {
                 'wallet': self.walletAddress,
                 'nonce': self.uuidv1(),
             }
@@ -478,6 +490,9 @@ class idex(ccxt.async_support.idex):
     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
+
+        https://api-docs-v4.idex.io/#orders
+
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -486,7 +501,7 @@ class idex(ccxt.async_support.idex):
         """
         await self.load_markets()
         name = 'orders'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
         }
         messageHash = name
@@ -602,7 +617,7 @@ class idex(ccxt.async_support.idex):
     async def watch_transactions(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         await self.load_markets()
         name = 'balances'
-        subscribeObject = {
+        subscribeObject: dict = {
             'name': name,
         }
         messageHash = name
@@ -629,7 +644,7 @@ class idex(ccxt.async_support.idex):
         messageHash = type + ':' + currencyId
         code = self.safe_currency_code(currencyId)
         address = self.safe_string(data, 'w')
-        transaction = {
+        transaction: dict = {
             'info': message,
             'id': None,
             'currency': code,
@@ -658,7 +673,7 @@ class idex(ccxt.async_support.idex):
 
     def handle_message(self, client: Client, message):
         type = self.safe_string(message, 'type')
-        methods = {
+        methods: dict = {
             'tickers': self.handle_ticker,
             'trades': self.handle_trade,
             'subscriptions': self.handle_subscribe_message,

ccxt/pro/independentreserve.py

@@ -9,7 +9,7 @@ from ccxt.base.types import Int, OrderBook, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import NotSupported
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import ChecksumError
 
 
 class independentreserve(ccxt.async_support.independentreserve):
@@ -22,6 +22,7 @@ class independentreserve(ccxt.async_support.independentreserve):
                 'watchTicker': False,
                 'watchTickers': False,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchMyTrades': False,
                 'watchOrders': False,
                 'watchOrderBook': True,
@@ -33,7 +34,9 @@ class independentreserve(ccxt.async_support.independentreserve):
                 },
             },
             'options': {
-                'checksum': False,  # TODO: currently only working for snapshot
+                'watchOrderBook': {
+                    'checksum': True,  # TODO: currently only working for snapshot
+                },
             },
             'streaming': {
             },
@@ -135,10 +138,10 @@ class independentreserve(ccxt.async_support.independentreserve):
         symbol = market['symbol']
         if limit is None:
             limit = 100
-        limit = self.number_to_string(limit)
-        url = self.urls['api']['ws'] + '/orderbook/' + limit + '?subscribe=' + market['base'] + '-' + market['quote']
-        messageHash = 'orderbook:' + symbol + ':' + limit
-        subscription = {
+        limitString = self.number_to_string(limit)
+        url = self.urls['api']['ws'] + '/orderbook/' + limitString + '?subscribe=' + market['base'] + '-' + market['quote']
+        messageHash = 'orderbook:' + symbol + ':' + limitString
+        subscription: dict = {
             'receivedSnapshot': False,
         }
         orderbook = await self.watch(url, messageHash, None, messageHash, subscription)
@@ -176,27 +179,27 @@ class independentreserve(ccxt.async_support.independentreserve):
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
         symbol = base + '/' + quote
-        orderBook = self.safe_value(message, 'Data', {})
+        orderBook = self.safe_dict(message, 'Data', {})
         messageHash = 'orderbook:' + symbol + ':' + depth
         subscription = self.safe_value(client.subscriptions, messageHash, {})
         receivedSnapshot = self.safe_bool(subscription, 'receivedSnapshot', False)
         timestamp = self.safe_integer(message, 'Time')
-        orderbook = self.safe_value(self.orderbooks, symbol)
-        if orderbook is None:
-            orderbook = self.order_book({})
-            self.orderbooks[symbol] = orderbook
+        # orderbook = self.safe_value(self.orderbooks, symbol)
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book({})
+        orderbook = self.orderbooks[symbol]
         if event == 'OrderBookSnapshot':
             snapshot = self.parse_order_book(orderBook, symbol, timestamp, 'Bids', 'Offers', 'Price', 'Volume')
             orderbook.reset(snapshot)
             subscription['receivedSnapshot'] = True
         else:
-            asks = self.safe_value(orderBook, 'Offers', [])
-            bids = self.safe_value(orderBook, 'Bids', [])
+            asks = self.safe_list(orderBook, 'Offers', [])
+            bids = self.safe_list(orderBook, 'Bids', [])
             self.handle_deltas(orderbook['asks'], asks)
             self.handle_deltas(orderbook['bids'], bids)
             orderbook['timestamp'] = timestamp
             orderbook['datetime'] = self.iso8601(timestamp)
-        checksum = self.safe_bool(self.options, 'checksum', True)
+        checksum = self.handle_option('watchOrderBook', 'checksum', True)
         if checksum and receivedSnapshot:
             storedAsks = orderbook['asks']
             storedBids = orderbook['bids']
@@ -212,7 +215,9 @@ class independentreserve(ccxt.async_support.independentreserve):
             calculatedChecksum = self.crc32(payload, True)
             responseChecksum = self.safe_integer(orderBook, 'Crc32')
             if calculatedChecksum != responseChecksum:
-                error = InvalidNonce(self.id + ' invalid checksum')
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+                del client.subscriptions[messageHash]
+                del self.orderbooks[symbol]
                 client.reject(error, messageHash)
         if receivedSnapshot:
             client.resolve(orderbook, messageHash)
@@ -254,7 +259,7 @@ class independentreserve(ccxt.async_support.independentreserve):
 
     def handle_message(self, client: Client, message):
         event = self.safe_string(message, 'Event')
-        handlers = {
+        handlers: dict = {
             'Subscriptions': self.handle_subscriptions,
             'Heartbeat': self.handle_heartbeat,
             'Trade': self.handle_trades,