ccxt 4.3.71__py2.py3-none-any.whl → 4.3.73__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.71'
+__version__ = '4.3.73'
 
 # ----------------------------------------------------------------------------
 

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.71'
+__version__ = '4.3.73'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.71'
+__version__ = '4.3.73'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/ws/client.py

@@ -15,7 +15,7 @@ class Client(object):
     subscriptions = {}
     rejections = {}
     message_queue = {}
-    useMessageQueue = True
+    useMessageQueue = False
     on_message_callback = None
     on_error_callback = None
     on_close_callback = None

ccxt/async_support/paradex.py

@@ -130,7 +130,7 @@ class paradex(Exchange, ImplicitAPI):
             },
             'hostname': 'paradex.trade',
             'urls': {
-                'logo': 'https://github.com/user-attachments/assets/5dadc09a-74ba-466a-a8f2-3f55c7e4654a',
+                'logo': 'https://github.com/user-attachments/assets/84628770-784e-4ec4-a759-ec2fbb2244ea',
                 'api': {
                     'v1': 'https://api.prod.{hostname}/v1',
                 },

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.71'
+__version__ = '4.3.73'
 
 # -----------------------------------------------------------------------------
 

ccxt/paradex.py

@@ -130,7 +130,7 @@ class paradex(Exchange, ImplicitAPI):
             },
             'hostname': 'paradex.trade',
             'urls': {
-                'logo': 'https://github.com/user-attachments/assets/5dadc09a-74ba-466a-a8f2-3f55c7e4654a',
+                'logo': 'https://github.com/user-attachments/assets/84628770-784e-4ec4-a759-ec2fbb2244ea',
                 'api': {
                     'v1': 'https://api.prod.{hostname}/v1',
                 },

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.71'
+__version__ = '4.3.73'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -1098,11 +1098,15 @@ class binance(ccxt.async_support.binance):
     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
+        :see: https://binance-docs.github.io/apidocs/spot/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/futures/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#kline-candlestick-data
         :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
         :param int [limit]: the maximum amount of candles to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         params['callerMethodName'] = 'watchOHLCV'
@@ -1112,10 +1116,14 @@ class binance(ccxt.async_support.binance):
     async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://binance-docs.github.io/apidocs/spot/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/futures/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#kline-candlestick-data
         :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
         :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 exchange API endpoint
+        :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
@@ -1127,6 +1135,10 @@ class binance(ccxt.async_support.binance):
         type = firstMarket['type']
         if firstMarket['contract']:
             type = 'future' if firstMarket['linear'] else 'delivery'
+        isSpot = (type == 'spot')
+        timezone = None
+        timezone, params = self.handle_param_string(params, 'timezone', None)
+        isUtc8 = (timezone is not None) and ((timezone == '+08:00') or Precise.string_eq(timezone, '8'))
         rawHashes = []
         messageHashes = []
         for i in range(0, len(symbolsAndTimeframes)):
@@ -1139,7 +1151,10 @@ class binance(ccxt.async_support.binance):
             if klineType == 'indexPriceKline':
                 # weird behavior for index price kline we can't use the perp suffix
                 marketId = marketId.replace('_perp', '')
-            rawHashes.append(marketId + '@' + klineType + '_' + interval)
+            shouldUseUTC8 = (isUtc8 and isSpot)
+            suffix = '@+08:00'
+            utcSuffix = suffix if shouldUseUTC8 else ''
+            rawHashes.append(marketId + '@' + klineType + '_' + interval + utcSuffix)
             messageHashes.append('ohlcv::' + symbolString + '::' + timeframeString)
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, 'multipleOHLCV')
         requestId = self.request_id(url)

ccxt/pro/kucoin.py

@@ -1024,6 +1024,10 @@ class kucoin(ccxt.async_support.kucoin):
         tradeId = self.safe_string(trade, 'tradeId')
         price = self.safe_string(trade, 'matchPrice')
         amount = self.safe_string(trade, 'matchSize')
+        if price is None:
+            # /spot/tradeFills
+            price = self.safe_string(trade, 'price')
+            amount = self.safe_string(trade, 'size')
         order = self.safe_string(trade, 'orderId')
         timestamp = self.safe_integer_product_2(trade, 'ts', 'time', 0.000001)
         feeCurrency = market['quote']

ccxt/pro/woo.py

@@ -90,32 +90,48 @@ class woo(ccxt.async_support.woo):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
+        :see: https://docs.woo.org/#orderbookupdate
         :see: https://docs.woo.org/#orderbook
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :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
+        :param str [params.method]: either(default) 'orderbook' or 'orderbookupdate', default is 'orderbook'
         :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 = 'orderbook'
+        method = None
+        method, params = self.handle_option_and_params(params, 'watchOrderBook', 'method', 'orderbook')
         market = self.market(symbol)
-        topic = market['id'] + '@' + name
+        topic = market['id'] + '@' + method
+        urlUid = '/' + self.uid if (self.uid) else ''
+        url = self.urls['api']['ws']['public'] + urlUid
+        requestId = self.request_id(url)
         request: dict = {
             'event': 'subscribe',
             'topic': topic,
+            'id': requestId,
         }
-        message = self.extend(request, params)
-        orderbook = await self.watch_public(topic, message)
+        subscription: dict = {
+            'id': str(requestId),
+            'name': method,
+            'symbol': symbol,
+            'limit': limit,
+            'params': params,
+        }
+        if method == 'orderbookupdate':
+            subscription['method'] = self.handle_order_book_subscription
+        orderbook = await self.watch(url, topic, self.extend(request, params), topic, subscription)
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
         #
         #     {
-        #         "topic": "PERP_BTC_USDT@orderbook",
-        #         "ts": 1650121915308,
+        #         "topic": "PERP_BTC_USDT@orderbookupdate",
+        #         "ts": 1722500373999,
         #         "data": {
         #             "symbol": "PERP_BTC_USDT",
+        #             "prevTs": 1722500373799,
         #             "bids": [
         #                 [
         #                     0.30891,
@@ -136,13 +152,89 @@ class woo(ccxt.async_support.woo):
         market = self.safe_market(marketId)
         symbol = market['symbol']
         topic = self.safe_string(message, 'topic')
-        if not (symbol in self.orderbooks):
-            self.orderbooks[symbol] = self.order_book({})
-        orderbook = self.orderbooks[symbol]
+        method = self.safe_string(topic.split('@'), 1)
+        if method == 'orderbookupdate':
+            if not (symbol in self.orderbooks):
+                return
+            orderbook = self.orderbooks[symbol]
+            timestamp = self.safe_integer(orderbook, 'timestamp')
+            if timestamp is None:
+                orderbook.cache.append(message)
+            else:
+                try:
+                    ts = self.safe_integer(message, 'ts')
+                    if ts > timestamp:
+                        self.handle_order_book_message(client, message, orderbook)
+                        client.resolve(orderbook, topic)
+                except Exception as e:
+                    del self.orderbooks[symbol]
+                    del client.subscriptions[topic]
+                    client.reject(e, topic)
+        else:
+            if not (symbol in self.orderbooks):
+                defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+                subscription = client.subscriptions[topic]
+                limit = self.safe_integer(subscription, 'limit', defaultLimit)
+                self.orderbooks[symbol] = self.order_book({}, limit)
+            orderbook = self.orderbooks[symbol]
+            timestamp = self.safe_integer(message, 'ts')
+            snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
+            orderbook.reset(snapshot)
+            client.resolve(orderbook, topic)
+
+    def handle_order_book_subscription(self, client: Client, message, subscription):
+        defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+        limit = self.safe_integer(subscription, 'limit', defaultLimit)
+        symbol = self.safe_string(subscription, 'symbol')  # watchOrderBook
+        if symbol in self.orderbooks:
+            del self.orderbooks[symbol]
+        self.orderbooks[symbol] = self.order_book({}, limit)
+        self.spawn(self.fetch_order_book_snapshot, client, message, subscription)
+
+    async def fetch_order_book_snapshot(self, client, message, subscription):
+        symbol = self.safe_string(subscription, 'symbol')
+        messageHash = self.safe_string(message, 'topic')
+        try:
+            defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+            limit = self.safe_integer(subscription, 'limit', defaultLimit)
+            params = self.safe_value(subscription, 'params')
+            snapshot = await self.fetch_rest_order_book_safe(symbol, limit, params)
+            if self.safe_value(self.orderbooks, symbol) is None:
+                # if the orderbook is dropped before the snapshot is received
+                return
+            orderbook = self.orderbooks[symbol]
+            orderbook.reset(snapshot)
+            messages = orderbook.cache
+            for i in range(0, len(messages)):
+                messageItem = messages[i]
+                ts = self.safe_integer(messageItem, 'ts')
+                if ts < orderbook['timestamp']:
+                    continue
+                else:
+                    self.handle_order_book_message(client, messageItem, orderbook)
+            self.orderbooks[symbol] = orderbook
+            client.resolve(orderbook, messageHash)
+        except Exception as e:
+            del client.subscriptions[messageHash]
+            client.reject(e, messageHash)
+
+    def handle_order_book_message(self, client: Client, message, orderbook):
+        data = self.safe_dict(message, 'data')
+        self.handle_deltas(orderbook['asks'], self.safe_value(data, 'asks', []))
+        self.handle_deltas(orderbook['bids'], self.safe_value(data, 'bids', []))
         timestamp = self.safe_integer(message, 'ts')
-        snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
-        orderbook.reset(snapshot)
-        client.resolve(orderbook, topic)
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = self.iso8601(timestamp)
+        return orderbook
+
+    def handle_delta(self, bookside, delta):
+        price = self.safe_float_2(delta, 'price', 0)
+        amount = self.safe_float_2(delta, 'quantity', 1)
+        bookside.store(price, amount)
+
+    def handle_deltas(self, bookside, deltas):
+        for i in range(0, len(deltas)):
+            self.handle_delta(bookside, deltas[i])
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
@@ -998,6 +1090,7 @@ class woo(ccxt.async_support.woo):
             'pong': self.handle_pong,
             'subscribe': self.handle_subscribe,
             'orderbook': self.handle_order_book,
+            'orderbookupdate': self.handle_order_book,
             'ticker': self.handle_ticker,
             'tickers': self.handle_tickers,
             'kline': self.handle_ohlcv,
@@ -1056,6 +1149,12 @@ class woo(ccxt.async_support.woo):
         #         "ts": 1657117712212
         #     }
         #
+        id = self.safe_string(message, 'id')
+        subscriptionsById = self.index_by(client.subscriptions, 'id')
+        subscription = self.safe_value(subscriptionsById, id, {})
+        method = self.safe_value(subscription, 'method')
+        if method is not None:
+            method(client, message, subscription)
         return message
 
     def handle_auth(self, client: Client, message):

ccxt/static_dependencies/starknet/models/typed_data.py

@@ -0,0 +1,45 @@
+"""
+TypedDict structures for TypedData
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, TypedDict
+
+class Revision(Enum):
+    """
+    Enum representing the revision of the specification to be used.
+    """
+
+    V0 = 0
+    V1 = 1
+
+
+class ParameterDict(TypedDict):
+    """
+    TypedDict representing a Parameter object
+    """
+
+    name: str
+    type: str
+
+
+class StarkNetDomainDict(TypedDict):
+    """
+    TypedDict representing a domain object (both StarkNetDomain, StarknetDomain).
+    """
+
+    name: str
+    version: str
+    chainId: str
+    revision: Optional[Revision]
+
+
+class TypedDataDict(TypedDict):
+    """
+    TypedDict representing a TypedData object
+    """
+
+    types: Dict[str, List[ParameterDict]]
+    primaryType: str
+    domain: StarkNetDomainDict
+    message: Dict[str, Any]

ccxt/static_dependencies/starkware/crypto/fast_pedersen_hash.py

@@ -0,0 +1,50 @@
+from ...ecdsa.curves import Curve
+from ...ecdsa.ellipticcurve import CurveFp, Point
+
+from .signature import (
+    ALPHA,
+    BETA,
+    CONSTANT_POINTS,
+    EC_ORDER,
+    FIELD_PRIME,
+    N_ELEMENT_BITS_HASH,
+    SHIFT_POINT,
+)
+from .utils import from_bytes, to_bytes
+
+curve_stark = CurveFp(FIELD_PRIME, ALPHA, BETA)
+LOW_PART_BITS = 248
+LOW_PART_MASK = 2**248 - 1
+HASH_SHIFT_POINT = Point(curve_stark, SHIFT_POINT[0], SHIFT_POINT[1], EC_ORDER)
+P_0 = Point(curve_stark, CONSTANT_POINTS[2][0], CONSTANT_POINTS[2][1], EC_ORDER)
+P_1 = Point(curve_stark, CONSTANT_POINTS[2 + LOW_PART_BITS][0], CONSTANT_POINTS[2 + LOW_PART_BITS][1], EC_ORDER)
+P_2 = Point(curve_stark, CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH][0], CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH][1], EC_ORDER)
+P_3 = Point(curve_stark, CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH + LOW_PART_BITS][0], CONSTANT_POINTS[2 + N_ELEMENT_BITS_HASH + LOW_PART_BITS][1], EC_ORDER)
+
+def process_single_element(element: int, p1, p2) -> Point:
+    assert 0 <= element < FIELD_PRIME, "Element integer value is out of range"
+
+    high_nibble = element >> LOW_PART_BITS
+    low_part = element & LOW_PART_MASK
+    return low_part * p1 + high_nibble * p2
+
+
+def pedersen_hash(x: int, y: int) -> int:
+    """
+    Computes the Starkware version of the Pedersen hash of x and y.
+    The hash is defined by:
+        shift_point + x_low * P_0 + x_high * P1 + y_low * P2  + y_high * P3
+    where x_low is the 248 low bits of x, x_high is the 4 high bits of x and similarly for y.
+    shift_point, P_0, P_1, P_2, P_3 are constant points generated from the digits of pi.
+    """
+    return (
+        HASH_SHIFT_POINT + process_single_element(x, P_0, P_1) + process_single_element(y, P_2, P_3)
+    ).x()
+
+
+def pedersen_hash_func(x: bytes, y: bytes) -> bytes:
+    """
+    A variant of 'pedersen_hash', where the elements and their resulting hash are in bytes.
+    """
+    assert len(x) == len(y) == 32, "Unexpected element length."
+    return to_bytes(pedersen_hash(*(from_bytes(element) for element in (x, y))))

ccxt/static_dependencies/starkware/crypto/math_utils.py

@@ -0,0 +1,78 @@
+###############################################################################
+# Copyright 2019 StarkWare Industries Ltd.                                    #
+#                                                                             #
+# Licensed under the Apache License, Version 2.0 (the "License").             #
+# You may not use this file except in compliance with the License.            #
+# You may obtain a copy of the License at                                     #
+#                                                                             #
+# https://www.starkware.co/open-source-license/                               #
+#                                                                             #
+# Unless required by applicable law or agreed to in writing,                  #
+# software distributed under the License is distributed on an "AS IS" BASIS,  #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    #
+# See the License for the specific language governing permissions             #
+# and limitations under the License.                                          #
+###############################################################################
+
+
+from typing import Tuple
+
+from ...sympy.core.intfunc import igcdex
+
+# A type that represents a point (x,y) on an elliptic curve.
+ECPoint = Tuple[int, int]
+
+def div_mod(n: int, m: int, p: int) -> int:
+    """
+    Finds a nonnegative integer 0 <= x < p such that (m * x) % p == n
+    """
+    a, b, c = igcdex(m, p)
+    assert c == 1
+    return (n * a) % p
+
+def div_ceil(x, y):
+    assert isinstance(x, int) and isinstance(y, int)
+    return -((-x) // y)
+    
+def ec_add(point1: ECPoint, point2: ECPoint, p: int) -> ECPoint:
+    """
+    Gets two points on an elliptic curve mod p and returns their sum.
+    Assumes the points are given in affine form (x, y) and have different x coordinates.
+    """
+    assert (point1[0] - point2[0]) % p != 0
+    m = div_mod(point1[1] - point2[1], point1[0] - point2[0], p)
+    x = (m * m - point1[0] - point2[0]) % p
+    y = (m * (point1[0] - x) - point1[1]) % p
+    return x, y
+
+
+def ec_neg(point: ECPoint, p: int) -> ECPoint:
+    """
+    Given a point (x,y) return (x, -y)
+    """
+    x, y = point
+    return (x, (-y) % p)
+
+
+def ec_double(point: ECPoint, alpha: int, p: int) -> ECPoint:
+    """
+    Doubles a point on an elliptic curve with the equation y^2 = x^3 + alpha*x + beta mod p.
+    Assumes the point is given in affine form (x, y) and has y != 0.
+    """
+    assert point[1] % p != 0
+    m = div_mod(3 * point[0] * point[0] + alpha, 2 * point[1], p)
+    x = (m * m - 2 * point[0]) % p
+    y = (m * (point[0] - x) - point[1]) % p
+    return x, y
+
+
+def ec_mult(m: int, point: ECPoint, alpha: int, p: int) -> ECPoint:
+    """
+    Multiplies by m a point on the elliptic curve with equation y^2 = x^3 + alpha*x + beta mod p.
+    Assumes the point is given in affine form (x, y) and that 0 < m < order(point).
+    """
+    if m == 1:
+        return point
+    if m % 2 == 0:
+        return ec_mult(m // 2, ec_double(point, alpha, p), alpha, p)
+    return ec_add(ec_mult(m - 1, point, alpha, p), point, p)