ccxt 4.3.39__py2.py3-none-any.whl → 4.3.41__py2.py3-none-any.whl

ccxt/pro/upbit.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
-from ccxt.base.types import Int, OrderBook, Ticker, Trade
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
+from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 
@@ -19,10 +19,13 @@ class upbit(ccxt.async_support.upbit):
                 'watchOrderBook': True,
                 'watchTicker': True,
                 'watchTrades': True,
+                'watchOrders': True,
+                'watchMyTrades': True,
+                'watchBalance': True,
             },
             'urls': {
                 'api': {
-                    'ws': 'wss://api.upbit.com/websocket/v1',
+                    'ws': 'wss://{hostname}/websocket/v1',
                 },
             },
             'options': {
@@ -35,7 +38,9 @@ class upbit(ccxt.async_support.upbit):
         market = self.market(symbol)
         symbol = market['symbol']
         marketId = market['id']
-        url = self.urls['api']['ws']
+        url = self.implode_params(self.urls['api']['ws'], {
+            'hostname': self.hostname,
+        })
         self.options[channel] = self.safe_value(self.options, channel, {})
         self.options[channel][symbol] = True
         symbols = list(self.options[channel].keys())
@@ -57,6 +62,7 @@ class upbit(ccxt.async_support.upbit):
     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
+        :see: https://global-docs.upbit.com/reference/websocket-ticker
         :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>`
@@ -66,6 +72,7 @@ class upbit(ccxt.async_support.upbit):
     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
+        :see: https://global-docs.upbit.com/reference/websocket-trade
         :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
@@ -82,6 +89,7 @@ class upbit(ccxt.async_support.upbit):
     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
+        :see: https://global-docs.upbit.com/reference/websocket-orderbook
         :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
@@ -213,11 +221,294 @@ class upbit(ccxt.async_support.upbit):
         messageHash = 'trade:' + marketId
         client.resolve(stored, messageHash)
 
+    async def authenticate(self, params={}):
+        self.check_required_credentials()
+        authenticated = self.options['ws']['token']
+        if authenticated is None:
+            auth: dict = {
+                'access_key': self.apiKey,
+                'nonce': self.uuid(),
+            }
+            token = self.jwt(auth, self.encode(self.secret), 'sha256', False)
+            self.options['ws']['token'] = token
+            self.options['ws']['options']['headers'] = {
+                'authorization': 'Bearer ' + token,
+            }
+        url = self.urls['api']['ws'] + '/private'
+        client = self.client(url)
+        return client
+
+    async def watch_private(self, symbol, channel, messageHash, params={}):
+        await self.authenticate()
+        request = {
+            'type': channel,
+        }
+        if symbol is not None:
+            await self.load_markets()
+            market = self.market(symbol)
+            symbol = market['symbol']
+            symbols = [symbol]
+            marketIds = self.market_ids(symbols)
+            request['codes'] = marketIds
+            messageHash = messageHash + ':' + symbol
+        url = self.implode_params(self.urls['api']['ws'], {
+            'hostname': self.hostname,
+        })
+        url += '/private'
+        message = [
+            {
+                'ticket': self.uuid(),
+            },
+            request,
+        ]
+        return await self.watch(url, messageHash, message, messageHash)
+
+    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
+        :see: https://global-docs.upbit.com/reference/websocket-myorder
+        :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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        channel = 'myOrder'
+        messageHash = 'myOrder'
+        orders = await self.watch_private(symbol, channel, messageHash)
+        if self.newUpdates:
+            limit = orders.getLimit(symbol, limit)
+        return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
+
+    async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made by the user
+        :see: https://global-docs.upbit.com/reference/websocket-myorder
+        :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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+        """
+        await self.load_markets()
+        channel = 'myOrder'
+        messageHash = 'myTrades'
+        trades = await self.watch_private(symbol, channel, messageHash)
+        if self.newUpdates:
+            limit = trades.getLimit(symbol, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
+
+    def parse_ws_order_status(self, status: Str):
+        statuses: dict = {
+            'wait': 'open',
+            'done': 'closed',
+            'cancel': 'canceled',
+            'watch': 'open',  # not sure what self status means
+            'trade': 'open',
+        }
+        return self.safe_string(statuses, status, status)
+
+    def parse_ws_order(self, order, market=None):
+        #
+        # {
+        #     "type": "myOrder",
+        #     "code": "SGD-XRP",
+        #     "uuid": "ac2dc2a3-fce9-40a2-a4f6-5987c25c438f",
+        #     "ask_bid": "BID",
+        #     "order_type": "limit",
+        #     "state": "trade",
+        #     "price": 0.001453,
+        #     "avg_price": 0.00145372,
+        #     "volume": 30925891.29839369,
+        #     "remaining_volume": 29968038.09235948,
+        #     "executed_volume": 30925891.29839369,
+        #     "trades_count": 1,
+        #     "reserved_fee": 44.23943970238218,
+        #     "remaining_fee": 21.77177967409916,
+        #     "paid_fee": 22.467660028283017,
+        #     "locked": 43565.33112787242,
+        #     "executed_funds": 44935.32005656603,
+        #     "order_timestamp": 1710751590000,
+        #     "timestamp": 1710751597500,
+        #     "stream_type": "REALTIME"
+        # }
+        #
+        id = self.safe_string(order, 'uuid')
+        side = self.safe_string_lower(order, 'ask_bid')
+        if side == 'bid':
+            side = 'buy'
+        else:
+            side = 'sell'
+        timestamp = self.parse8601(self.safe_string(order, 'order_timestamp'))
+        status = self.parse_ws_order_status(self.safe_string(order, 'state'))
+        marketId = self.safe_string(order, 'code')
+        market = self.safe_market(marketId, market)
+        fee = None
+        feeCost = self.safe_string(order, 'paid_fee')
+        if feeCost is not None:
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            }
+        return self.safe_order({
+            'info': order,
+            'id': id,
+            'clientOrderId': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'lastTradeTimestamp': self.safe_string(order, 'trade_timestamp'),
+            'symbol': market['symbol'],
+            'type': self.safe_string(order, 'order_type'),
+            'timeInForce': self.safe_string(order, 'time_in_force'),
+            'postOnly': None,
+            'side': side,
+            'price': self.safe_string(order, 'price'),
+            'stopPrice': None,
+            'triggerPrice': None,
+            'cost': self.safe_string(order, 'executed_funds'),
+            'average': self.safe_string(order, 'avg_price'),
+            'amount': self.safe_string(order, 'volume'),
+            'filled': self.safe_string(order, 'executed_volume'),
+            'remaining': self.safe_string(order, 'remaining_volume'),
+            'status': status,
+            'fee': fee,
+            'trades': None,
+        })
+
+    def parse_ws_trade(self, trade, market=None):
+        # see: parseWsOrder
+        side = self.safe_string_lower(trade, 'ask_bid')
+        if side == 'bid':
+            side = 'buy'
+        else:
+            side = 'sell'
+        timestamp = self.parse8601(self.safe_string(trade, 'trade_timestamp'))
+        marketId = self.safe_string(trade, 'code')
+        market = self.safe_market(marketId, market)
+        fee = None
+        feeCost = self.safe_string(trade, 'paid_fee')
+        if feeCost is not None:
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            }
+        return self.safe_trade({
+            'id': self.safe_string(trade, 'trade_uuid'),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': market['symbol'],
+            'side': side,
+            'price': self.safe_string(trade, 'price'),
+            'amount': self.safe_string(trade, 'volume'),
+            'cost': self.safe_string(trade, 'executed_funds'),
+            'order': self.safe_string(trade, 'uuid'),
+            'takerOrMaker': None,
+            'type': self.safe_string(trade, 'order_type'),
+            'fee': fee,
+            'info': trade,
+        }, market)
+
+    def handle_my_order(self, client: Client, message):
+        # see: parseWsOrder
+        tradeId = self.safe_string(message, 'trade_uuid')
+        if tradeId is not None:
+            self.handle_my_trade(client, message)
+        self.handle_order(client, message)
+
+    def handle_my_trade(self, client: Client, message):
+        # see: parseWsOrder
+        myTrades = self.myTrades
+        if myTrades is None:
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            myTrades = ArrayCacheBySymbolById(limit)
+        trade = self.parse_ws_trade(message)
+        myTrades.append(trade)
+        messageHash = 'myTrades'
+        client.resolve(myTrades, messageHash)
+        messageHash = 'myTrades:' + trade['symbol']
+        client.resolve(myTrades, messageHash)
+
+    def handle_order(self, client: Client, message):
+        parsed = self.parse_ws_order(message)
+        symbol = self.safe_string(parsed, 'symbol')
+        orderId = self.safe_string(parsed, 'id')
+        if self.orders is None:
+            limit = self.safe_integer(self.options, 'ordersLimit', 1000)
+            self.orders = ArrayCacheBySymbolById(limit)
+        cachedOrders = self.orders
+        orders = self.safe_value(cachedOrders.hashmap, symbol, {})
+        order = self.safe_value(orders, orderId)
+        if order is not None:
+            fee = self.safe_value(order, 'fee')
+            if fee is not None:
+                parsed['fee'] = fee
+            fees = self.safe_value(order, 'fees')
+            if fees is not None:
+                parsed['fees'] = fees
+            parsed['trades'] = self.safe_value(order, 'trades')
+            parsed['timestamp'] = self.safe_integer(order, 'timestamp')
+            parsed['datetime'] = self.safe_string(order, 'datetime')
+        cachedOrders.append(parsed)
+        messageHash = 'myOrder'
+        client.resolve(self.orders, messageHash)
+        messageHash = messageHash + ':' + symbol
+        client.resolve(self.orders, messageHash)
+
+    async def watch_balance(self, params={}) -> Balances:
+        """
+        :see: https://global-docs.upbit.com/reference/websocket-myasset
+        query for balance and get the amount of funds available for trading or funds locked in orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
+        """
+        await self.load_markets()
+        channel = 'myAsset'
+        messageHash = 'myAsset'
+        return await self.watch_private(None, channel, messageHash)
+
+    def handle_balance(self, client: Client, message):
+        #
+        # {
+        #     "type": "myAsset",
+        #     "asset_uuid": "e635f223-1609-4969-8fb6-4376937baad6",
+        #     "assets": [
+        #       {
+        #         "currency": "SGD",
+        #         "balance": 1386929.37231066771348207123,
+        #         "locked": 10329.670127489597585685
+        #       }
+        #     ],
+        #     "asset_timestamp": 1710146517259,
+        #     "timestamp": 1710146517267,
+        #     "stream_type": "REALTIME"
+        # }
+        #
+        data = self.safe_list(message, 'assets', [])
+        timestamp = self.safe_integer(message, 'timestamp')
+        self.balance['timestamp'] = timestamp
+        self.balance['datetime'] = self.iso8601(timestamp)
+        for i in range(0, len(data)):
+            balance = data[i]
+            currencyId = self.safe_string(balance, 'currency')
+            code = self.safe_currency_code(currencyId)
+            available = self.safe_string(balance, 'balance')
+            frozen = self.safe_string(balance, 'locked')
+            account = self.account()
+            account['free'] = available
+            account['used'] = frozen
+            self.balance[code] = account
+            self.balance = self.safe_balance(self.balance)
+        messageHash = self.safe_string(message, 'type')
+        client.resolve(self.balance, messageHash)
+
     def handle_message(self, client: Client, message):
         methods: dict = {
             'ticker': self.handle_ticker,
             'orderbook': self.handle_order_book,
             'trade': self.handle_trades,
+            'myOrder': self.handle_my_order,
+            'myAsset': self.handle_balance,
         }
         methodName = self.safe_string(message, 'type')
         method = self.safe_value(methods, methodName)

ccxt/pro/wazirx.py

@@ -505,20 +505,20 @@ class wazirx(ccxt.async_support.wazirx):
         market = self.safe_market(marketId)
         symbol = market['symbol']
         messageHash = 'orderbook:' + symbol
-        currentOrderBook = self.safe_value(self.orderbooks, symbol)
-        if currentOrderBook is None:
+        # currentOrderBook = self.safe_value(self.orderbooks, symbol)
+        if not (symbol in self.orderbooks):
             snapshot = self.parse_order_book(data, symbol, timestamp, 'b', 'a')
-            orderBook = self.order_book(snapshot)
-            self.orderbooks[symbol] = orderBook
+            self.orderbooks[symbol] = self.order_book(snapshot)
         else:
-            asks = self.safe_value(data, 'a', [])
-            bids = self.safe_value(data, 'b', [])
-            self.handle_deltas(currentOrderBook['asks'], asks)
-            self.handle_deltas(currentOrderBook['bids'], bids)
-            currentOrderBook['nonce'] = timestamp
-            currentOrderBook['timestamp'] = timestamp
-            currentOrderBook['datetime'] = self.iso8601(timestamp)
-            self.orderbooks[symbol] = currentOrderBook
+            orderbook = self.orderbooks[symbol]
+            asks = self.safe_list(data, 'a', [])
+            bids = self.safe_list(data, 'b', [])
+            self.handle_deltas(orderbook['asks'], asks)
+            self.handle_deltas(orderbook['bids'], bids)
+            orderbook['nonce'] = timestamp
+            orderbook['timestamp'] = timestamp
+            orderbook['datetime'] = self.iso8601(timestamp)
+            self.orderbooks[symbol] = orderbook
         client.resolve(self.orderbooks[symbol], messageHash)
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:

ccxt/upbit.py

@@ -1782,23 +1782,28 @@ class upbit(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(query)
         if api == 'private':
             self.check_required_credentials()
+            headers = {}
             nonce = self.uuid()
             request: dict = {
                 'access_key': self.apiKey,
                 'nonce': nonce,
             }
-            if query:
-                auth = self.urlencode(query)
+            hasQuery = query
+            auth = None
+            if (method != 'GET') and (method != 'DELETE'):
+                body = self.json(params)
+                headers['Content-Type'] = 'application/json'
+                if hasQuery:
+                    auth = self.urlencode(query)
+            else:
+                if hasQuery:
+                    auth = self.urlencode(self.keysort(query))
+            if auth is not None:
                 hash = self.hash(self.encode(auth), 'sha512')
                 request['query_hash'] = hash
                 request['query_hash_alg'] = 'SHA512'
             token = self.jwt(request, self.encode(self.secret), 'sha256')
-            headers = {
-                'Authorization': 'Bearer ' + token,
-            }
-            if (method != 'GET') and (method != 'DELETE'):
-                body = self.json(params)
-                headers['Content-Type'] = 'application/json'
+            headers['Authorization'] = 'Bearer ' + token
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def handle_errors(self, httpCode: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):

ccxt/woo.py

@@ -1212,7 +1212,9 @@ class woo(Exchange, ImplicitAPI):
         #         "status":"CANCEL_ALL_SENT"
         #     }
         #
-        return response
+        return [
+            self.safe_order(response),
+        ]
 
     def cancel_all_orders_after(self, timeout: Int, params={}):
         """
@@ -1237,7 +1239,9 @@ class woo(Exchange, ImplicitAPI):
         #         "timestamp": 1711534302943
         #     }
         #
-        return response
+        return [
+            self.safe_order(response),
+        ]
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """

ccxt/woofipro.py

@@ -1561,7 +1561,9 @@ class woofipro(Exchange, ImplicitAPI):
         #     }
         # }
         #
-        return response
+        return [self.safe_order({
+            'info': response,
+        })]
 
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -1600,7 +1602,11 @@ class woofipro(Exchange, ImplicitAPI):
         #     }
         # }
         #
-        return response
+        return [
+            {
+                'info': response,
+            },
+        ]
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """

{ccxt-4.3.39.dist-info → ccxt-4.3.41.dist-info}/METADATA

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