ccxt 4.2.47__py2.py3-none-any.whl → 4.2.49__py2.py3-none-any.whl

ccxt/pro/ascendex.py

@@ -202,7 +202,7 @@ class ascendex(ccxt.async_support.ascendex):
         """
         await self.load_markets()
         market = self.market(symbol)
-        channel = 'depth-realtime' + ':' + market['id']
+        channel = 'depth' + ':' + market['id']
         params = self.extend(params, {
             'ch': channel,
         })
@@ -212,7 +212,7 @@ class ascendex(ccxt.async_support.ascendex):
     async def watch_order_book_snapshot(self, symbol: str, limit: Int = None, params={}):
         await self.load_markets()
         market = self.market(symbol)
-        action = 'depth-snapshot-realtime'
+        action = 'depth-snapshot'
         channel = action + ':' + market['id']
         params = self.extend(params, {
             'action': action,
@@ -224,6 +224,14 @@ class ascendex(ccxt.async_support.ascendex):
         orderbook = await self.watch_public(channel, params)
         return orderbook.limit()
 
+    async def fetch_order_book_snapshot(self, symbol: str, limit: Int = None, params={}):
+        restOrderBook = await self.fetch_rest_order_book_safe(symbol, limit, params)
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book()
+        orderbook = self.orderbooks[symbol]
+        orderbook.reset(restOrderBook)
+        return orderbook
+
     def handle_order_book_snapshot(self, client: Client, message):
         #
         # {
@@ -826,8 +834,8 @@ class ascendex(ccxt.async_support.ascendex):
             'ping': self.handle_ping,
             'auth': self.handle_authenticate,
             'sub': self.handle_subscription_status,
-            'depth-realtime': self.handle_order_book,
-            'depth-snapshot-realtime': self.handle_order_book_snapshot,
+            'depth': self.handle_order_book,
+            'depth-snapshot': self.handle_order_book_snapshot,
             'trades': self.handle_trades,
             'bar': self.handle_ohlcv,
             'balance': self.handle_balance,
@@ -851,7 +859,7 @@ class ascendex(ccxt.async_support.ascendex):
         #     {m: 'sub', id: "1647515701", ch: "depth:BTC/USDT", code: 0}
         #
         channel = self.safe_string(message, 'ch', '')
-        if channel.find('depth-realtime') > -1:
+        if channel.find('depth') > -1 and not (channel.find('depth-snapshot') > -1):
             self.handle_order_book_subscription(client, message)
         return message
 
@@ -859,11 +867,15 @@ class ascendex(ccxt.async_support.ascendex):
         channel = self.safe_string(message, 'ch')
         parts = channel.split(':')
         marketId = parts[1]
-        symbol = self.safe_symbol(marketId)
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
         if symbol in self.orderbooks:
             del self.orderbooks[symbol]
         self.orderbooks[symbol] = self.order_book({})
-        self.spawn(self.watch_order_book_snapshot, symbol)
+        if self.options['defaultType'] == 'swap' or market['contract']:
+            self.spawn(self.fetch_order_book_snapshot, symbol)
+        else:
+            self.spawn(self.watch_order_book_snapshot, symbol)
 
     async def pong(self, client, message):
         #

ccxt/pro/bitget.py

@@ -908,6 +908,7 @@ class bitget(ccxt.async_support.bitget):
         #                 "clientOid": "798d1425-d31d-4ada-a51b-ec701e00a1d9",
         #                 "price": "35000.00",
         #                 "size": "7.0000",
+        #                 "newSize": "500.0000",
         #                 "notional": "7.000000",
         #                 "orderType": "limit",
         #                 "force": "gtc",
@@ -1069,6 +1070,7 @@ class bitget(ccxt.async_support.bitget):
         #         "clientOid": "798d1425-d31d-4ada-a51b-ec701e00a1d9",
         #         "price": "35000.00",
         #         "size": "7.0000",
+        #         "newSize": "500.0000",
         #         "notional": "7.000000",
         #         "orderType": "limit",
         #         "force": "gtc",
@@ -1175,6 +1177,21 @@ class bitget(ccxt.async_support.bitget):
                 'currency': self.safe_currency_code(feeCurrency),
             }
         triggerPrice = self.safe_number(order, 'triggerPrice')
+        price = self.safe_string(order, 'price')
+        avgPrice = self.omit_zero(self.safe_string_2(order, 'priceAvg', 'fillPrice'))
+        cost = self.safe_string_n(order, ['notional', 'notionalUsd', 'quoteSize'])
+        side = self.safe_string(order, 'side')
+        type = self.safe_string(order, 'orderType')
+        if side == 'buy' and market['spot'] and (type == 'market'):
+            cost = self.safe_string(order, 'newSize', cost)
+        filled = self.safe_string_2(order, 'accBaseVolume', 'baseVolume')
+        if market['spot'] and (rawStatus != 'live'):
+            filled = Precise.string_div(cost, avgPrice)
+        amount = self.safe_string(order, 'baseVolume')
+        if not market['spot'] or not (side == 'buy' and type == 'market'):
+            amount = self.safe_string(order, 'newSize', amount)
+        if market['swap'] and (amount is None):
+            amount = self.safe_string(order, 'size')
         return self.safe_order({
             'info': order,
             'symbol': symbol,
@@ -1183,17 +1200,17 @@ class bitget(ccxt.async_support.bitget):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'lastTradeTimestamp': self.safe_integer(order, 'uTime'),
-            'type': self.safe_string(order, 'orderType'),
+            'type': type,
             'timeInForce': self.safe_string_upper(order, 'force'),
             'postOnly': None,
-            'side': self.safe_string(order, 'side'),
-            'price': self.safe_string(order, 'price'),
+            'side': side,
+            'price': price,
             'stopPrice': triggerPrice,
             'triggerPrice': triggerPrice,
-            'amount': self.safe_string(order, 'baseVolume'),
-            'cost': self.safe_string_n(order, ['notional', 'notionalUsd', 'quoteSize']),
-            'average': self.omit_zero(self.safe_string_2(order, 'priceAvg', 'fillPrice')),
-            'filled': self.safe_string_2(order, 'accBaseVolume', 'baseVolume'),
+            'amount': amount,
+            'cost': cost,
+            'average': avgPrice,
+            'filled': filled,
             'remaining': None,
             'status': self.parse_ws_order_status(rawStatus),
             'fee': feeObject,

ccxt/pro/bitstamp.py

@@ -111,7 +111,7 @@ class bitstamp(ccxt.async_support.bitstamp):
             # usually it takes at least 4-5 deltas to resolve
             snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 6)
             if cacheLength == snapshotDelay:
-                self.spawn(self.load_order_book, client, messageHash, symbol)
+                self.spawn(self.load_order_book, client, messageHash, symbol, None, {})
             storedOrderBook.cache.append(delta)
             return
         elif nonce >= deltaNonce:

ccxt/pro/hitbtc.py

@@ -215,7 +215,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        orderbook = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
+        orderbook = await self.subscribe_public(name, 'orderbooks', [symbol], self.deep_extend(request, params))
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
@@ -244,13 +244,12 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         data = self.safe_value_2(message, 'snapshot', 'update', {})
         marketIds = list(data.keys())
-        channel = self.safe_string(message, 'ch')
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             market = self.safe_market(marketId)
             symbol = market['symbol']
             item = data[marketId]
-            messageHash = channel + '::' + symbol
+            messageHash = 'orderbooks::' + symbol
             if not (symbol in self.orderbooks):
                 subscription = self.safe_value(client.subscriptions, messageHash, {})
                 limit = self.safe_integer(subscription, 'limit')
@@ -303,7 +302,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': [market['id']],
             },
         }
-        result = await self.subscribe_public(name, 'ticker', [symbol], self.deep_extend(request, params))
+        result = await self.subscribe_public(name, 'tickers', [symbol], self.deep_extend(request, params))
         return self.safe_value(result, symbol)
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
@@ -380,7 +379,6 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         data = self.safe_value(message, 'data', {})
         marketIds = list(data.keys())
-        channel = self.safe_string(message, 'ch')
         newTickers = {}
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
@@ -389,8 +387,6 @@ class hitbtc(ccxt.async_support.hitbtc):
             ticker = self.parse_ws_ticker(data[marketId], market)
             self.tickers[symbol] = ticker
             newTickers[symbol] = ticker
-            messageHash = channel + '::' + symbol
-            client.resolve(newTickers, messageHash)
         client.resolve(newTickers, 'tickers')
         messageHashes = self.find_message_hashes(client, 'tickers::')
         for i in range(0, len(messageHashes)):
@@ -403,7 +399,6 @@ class hitbtc(ccxt.async_support.hitbtc):
             numTickers = len(tickersSymbols)
             if numTickers > 0:
                 client.resolve(tickers, messageHash)
-        client.resolve(self.tickers, channel)
         return message
 
     def parse_ws_ticker(self, ticker, market=None):
@@ -481,7 +476,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         if limit is not None:
             request['limit'] = limit
         name = 'trades'
-        trades = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
+        trades = await self.subscribe_public(name, 'trades', [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp')
@@ -602,7 +597,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         }
         if limit is not None:
             request['params']['limit'] = limit
-        ohlcv = await self.subscribe_public(name, name, [symbol], self.deep_extend(request, params))
+        ohlcv = await self.subscribe_public(name, 'candles', [symbol], self.deep_extend(request, params))
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
         return self.filter_by_since_limit(ohlcv, since, limit, 0)
@@ -660,7 +655,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             ohlcvs = self.parse_ws_ohlcvs(data[marketId], market)
             for j in range(0, len(ohlcvs)):
                 stored.append(ohlcvs[j])
-            messageHash = channel + '::' + symbol
+            messageHash = 'candles::' + symbol
             client.resolve(stored, messageHash)
         return message
 

ccxt/pro/mexc.py

@@ -439,6 +439,7 @@ class mexc(ccxt.async_support.mexc):
         symbol = self.safe_symbol(marketId)
         messageHash = 'orderbook:' + symbol
         subscription = self.safe_value(client.subscriptions, messageHash)
+        limit = self.safe_integer(subscription, 'limit')
         if subscription is True:
             # we set client.subscriptions[messageHash] to 1
             # once we have received the first delta and initialized the orderbook
@@ -450,7 +451,7 @@ class mexc(ccxt.async_support.mexc):
             cacheLength = len(storedOrderBook.cache)
             snapshotDelay = self.handle_option('watchOrderBook', 'snapshotDelay', 25)
             if cacheLength == snapshotDelay:
-                self.spawn(self.load_order_book, client, messageHash, symbol)
+                self.spawn(self.load_order_book, client, messageHash, symbol, limit, {})
             storedOrderBook.cache.append(data)
             return
         try:

ccxt/test/test_async.py

@@ -158,8 +158,9 @@ def json_stringify(elem):
     return json.dumps(elem)
 
 
-def convert_to_snake_case(conent):
-    return re.sub(r'(?<!^)(?=[A-Z])', '_', conent).lower()
+def convert_to_snake_case(content):
+    res = re.sub(r'(?<!^)(?=[A-Z])', '_', content).lower()
+    return res.replace('o_h_l_c_v', 'ohlcv')
 
 
 def get_test_name(methodName):
@@ -185,8 +186,7 @@ def io_dir_read(path):
 
 
 async def call_method(test_files, methodName, exchange, skippedProperties, args):
-    methodNameToCall = convert_to_snake_case(methodName)
-    methodNameToCall = 'test_' + methodNameToCall.replace('o_h_l_c_v', 'ohlcv')
+    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
     return await getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
 
 
@@ -583,7 +583,7 @@ class testMainClass(baseMainTestClass):
         result = await self.test_safe('loadMarkets', exchange, [], True)
         if not result:
             return False
-        symbols = ['BTC/CNY', 'BTC/USD', 'BTC/USDT', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
+        symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/CNY', 'BTC/USD', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
         result_symbols = []
         exchange_specific_symbols = exchange.symbols
         for i in range(0, len(exchange_specific_symbols)):
@@ -638,8 +638,8 @@ class testMainClass(baseMainTestClass):
     def get_valid_symbol(self, exchange, spot=True):
         current_type_markets = self.get_markets_from_exchange(exchange, spot)
         codes = ['BTC', 'ETH', 'XRP', 'LTC', 'BCH', 'EOS', 'BNB', 'BSV', 'USDT', 'ATOM', 'BAT', 'BTG', 'DASH', 'DOGE', 'ETC', 'IOTA', 'LSK', 'MKR', 'NEO', 'PAX', 'QTUM', 'TRX', 'TUSD', 'USD', 'USDC', 'WAVES', 'XEM', 'XMR', 'ZEC', 'ZRX']
-        spot_symbols = ['BTC/USD', 'BTC/USDT', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
-        swap_symbols = ['BTC/USDT:USDT', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
+        spot_symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/USD', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
+        swap_symbols = ['BTC/USDT:USDT', 'BTC/USDC:USDC', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
         target_symbols = spot_symbols if spot else swap_symbols
         symbol = self.get_test_symbol(exchange, spot, target_symbols)
         # if symbols wasn't found from above hardcoded list, then try to locate any symbol which has our target hardcoded 'base' code
@@ -688,16 +688,16 @@ class testMainClass(baseMainTestClass):
         if swap_symbol is not None:
             dump('[INFO:MAIN] Selected SWAP SYMBOL:', swap_symbol)
         if not self.private_test_only:
-            # note, spot & swap tests should run sequentially, because of conflicting `exchange.options['type']` setting
+            # note, spot & swap tests should run sequentially, because of conflicting `exchange.options['defaultType']` setting
             if exchange.has['spot'] and spot_symbol is not None:
                 if self.info:
                     dump('[INFO] ### SPOT TESTS ###')
-                exchange.options['type'] = 'spot'
+                exchange.options['defaultType'] = 'spot'
                 await self.run_public_tests(exchange, spot_symbol)
             if exchange.has['swap'] and swap_symbol is not None:
                 if self.info:
                     dump('[INFO] ### SWAP TESTS ###')
-                exchange.options['type'] = 'swap'
+                exchange.options['defaultType'] = 'swap'
                 await self.run_public_tests(exchange, swap_symbol)
         if self.private_test or self.private_test_only:
             if exchange.has['spot'] and spot_symbol is not None:

ccxt/test/test_sync.py

@@ -157,8 +157,9 @@ def json_stringify(elem):
     return json.dumps(elem)
 
 
-def convert_to_snake_case(conent):
-    return re.sub(r'(?<!^)(?=[A-Z])', '_', conent).lower()
+def convert_to_snake_case(content):
+    res = re.sub(r'(?<!^)(?=[A-Z])', '_', content).lower()
+    return res.replace('o_h_l_c_v', 'ohlcv')
 
 
 def get_test_name(methodName):
@@ -184,8 +185,7 @@ def io_dir_read(path):
 
 
 def call_method(test_files, methodName, exchange, skippedProperties, args):
-    methodNameToCall = convert_to_snake_case(methodName)
-    methodNameToCall = 'test_' + methodNameToCall.replace('o_h_l_c_v', 'ohlcv')
+    methodNameToCall = 'test_' + convert_to_snake_case(methodName)
     return getattr(test_files[methodName], methodNameToCall)(exchange, skippedProperties, *args)
 
 
@@ -582,7 +582,7 @@ class testMainClass(baseMainTestClass):
         result = self.test_safe('loadMarkets', exchange, [], True)
         if not result:
             return False
-        symbols = ['BTC/CNY', 'BTC/USD', 'BTC/USDT', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
+        symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/CNY', 'BTC/USD', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'BTC/JPY', 'ETH/EUR', 'ETH/JPY', 'ETH/CNY', 'ETH/USD', 'LTC/CNY', 'DASH/BTC', 'DOGE/BTC', 'BTC/AUD', 'BTC/PLN', 'USD/SLL', 'BTC/RUB', 'BTC/UAH', 'LTC/BTC', 'EUR/USD']
         result_symbols = []
         exchange_specific_symbols = exchange.symbols
         for i in range(0, len(exchange_specific_symbols)):
@@ -637,8 +637,8 @@ class testMainClass(baseMainTestClass):
     def get_valid_symbol(self, exchange, spot=True):
         current_type_markets = self.get_markets_from_exchange(exchange, spot)
         codes = ['BTC', 'ETH', 'XRP', 'LTC', 'BCH', 'EOS', 'BNB', 'BSV', 'USDT', 'ATOM', 'BAT', 'BTG', 'DASH', 'DOGE', 'ETC', 'IOTA', 'LSK', 'MKR', 'NEO', 'PAX', 'QTUM', 'TRX', 'TUSD', 'USD', 'USDC', 'WAVES', 'XEM', 'XMR', 'ZEC', 'ZRX']
-        spot_symbols = ['BTC/USD', 'BTC/USDT', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
-        swap_symbols = ['BTC/USDT:USDT', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
+        spot_symbols = ['BTC/USDT', 'BTC/USDC', 'BTC/USD', 'BTC/CNY', 'BTC/EUR', 'BTC/ETH', 'ETH/BTC', 'ETH/USD', 'ETH/USDT', 'BTC/JPY', 'LTC/BTC', 'ZRX/WETH', 'EUR/USD']
+        swap_symbols = ['BTC/USDT:USDT', 'BTC/USDC:USDC', 'BTC/USD:USD', 'ETH/USDT:USDT', 'ETH/USD:USD', 'LTC/USDT:USDT', 'DOGE/USDT:USDT', 'ADA/USDT:USDT', 'BTC/USD:BTC', 'ETH/USD:ETH']
         target_symbols = spot_symbols if spot else swap_symbols
         symbol = self.get_test_symbol(exchange, spot, target_symbols)
         # if symbols wasn't found from above hardcoded list, then try to locate any symbol which has our target hardcoded 'base' code
@@ -687,16 +687,16 @@ class testMainClass(baseMainTestClass):
         if swap_symbol is not None:
             dump('[INFO:MAIN] Selected SWAP SYMBOL:', swap_symbol)
         if not self.private_test_only:
-            # note, spot & swap tests should run sequentially, because of conflicting `exchange.options['type']` setting
+            # note, spot & swap tests should run sequentially, because of conflicting `exchange.options['defaultType']` setting
             if exchange.has['spot'] and spot_symbol is not None:
                 if self.info:
                     dump('[INFO] ### SPOT TESTS ###')
-                exchange.options['type'] = 'spot'
+                exchange.options['defaultType'] = 'spot'
                 self.run_public_tests(exchange, spot_symbol)
             if exchange.has['swap'] and swap_symbol is not None:
                 if self.info:
                     dump('[INFO] ### SWAP TESTS ###')
-                exchange.options['type'] = 'swap'
+                exchange.options['defaultType'] = 'swap'
                 self.run_public_tests(exchange, swap_symbol)
         if self.private_test or self.private_test_only:
             if exchange.has['spot'] and spot_symbol is not None:

ccxt/upbit.py

@@ -48,6 +48,7 @@ class upbit(Exchange, ImplicitAPI):
                 'fetchBalance': True,
                 'fetchCanceledOrders': True,
                 'fetchClosedOrders': True,
+                'fetchDeposit': True,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': True,
                 'fetchDeposits': True,
@@ -75,6 +76,7 @@ class upbit(Exchange, ImplicitAPI):
                 'fetchTradingFee': True,
                 'fetchTradingFees': False,
                 'fetchTransactions': False,
+                'fetchWithdrawal': True,
                 'fetchWithdrawals': True,
                 'transfer': False,
                 'withdraw': True,
@@ -988,6 +990,7 @@ class upbit(Exchange, ImplicitAPI):
         """
         create a trade order
         :see: https://docs.upbit.com/reference/%EC%A3%BC%EB%AC%B8%ED%95%98%EA%B8%B0
+        :see: https://global-docs.upbit.com/reference/order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
@@ -995,6 +998,7 @@ class upbit(Exchange, ImplicitAPI):
         :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param float [params.cost]: for market buy orders, the quote quantity that can be used alternative for the amount
+        :param str [params.timeInForce]: 'IOC' or 'FOK'
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
@@ -1039,6 +1043,11 @@ class upbit(Exchange, ImplicitAPI):
         clientOrderId = self.safe_string_2(params, 'clientOrderId', 'identifier')
         if clientOrderId is not None:
             request['identifier'] = clientOrderId
+        if type != 'market':
+            timeInForce = self.safe_string_lower_2(params, 'timeInForce', 'time_in_force')
+            params = self.omit(params, 'timeInForce')
+            if timeInForce is not None:
+                request['time_in_force'] = timeInForce
         params = self.omit(params, ['clientOrderId', 'identifier'])
         response = self.privatePostOrders(self.extend(request, params))
         #
@@ -1138,6 +1147,42 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_transactions(response, currency, since, limit)
 
+    def fetch_deposit(self, id: str, code: Str = None, params={}):
+        """
+        fetch information on a deposit
+        :see: https://global-docs.upbit.com/reference/individual-deposit-inquiry
+        :param str id: the unique id for the deposit
+        :param str [code]: unified currency code of the currency deposited
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.txid]: withdrawal transaction id, the id argument is reserved for uuid
+        :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        self.load_markets()
+        request = {
+            'uuid': id,
+        }
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['currency'] = currency['id']
+        response = self.privateGetDeposit(self.extend(request, params))
+        #
+        #     {
+        #         "type": "deposit",
+        #         "uuid": "7f54527e-2eee-4268-860e-fd8b9d7fe3c7",
+        #         "currency": "ADA",
+        #         "net_type": "ADA",
+        #         "txid": "99795bbfeca91eaa071068bb659b33eeb65d8aaff2551fdf7c78f345d188952b",
+        #         "state": "ACCEPTED",
+        #         "created_at": "2023-12-12T04:58:41Z",
+        #         "done_at": "2023-12-12T05:31:50Z",
+        #         "amount": "35.72344",
+        #         "fee": "0.0",
+        #         "transaction_type": "default"
+        #     }
+        #
+        return self.parse_transaction(response, currency)
+
     def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         :see: https://docs.upbit.com/reference/%EC%A0%84%EC%B2%B4-%EC%B6%9C%EA%B8%88-%EC%A1%B0%ED%9A%8C
@@ -1178,13 +1223,49 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_transactions(response, currency, since, limit)
 
+    def fetch_withdrawal(self, id: str, code: Str = None, params={}):
+        """
+        fetch data on a currency withdrawal via the withdrawal id
+        :see: https://global-docs.upbit.com/reference/individual-withdrawal-inquiry
+        :param str id: the unique id for the withdrawal
+        :param str [code]: unified currency code of the currency withdrawn
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.txid]: withdrawal transaction id, the id argument is reserved for uuid
+        :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        self.load_markets()
+        request = {
+            'uuid': id,
+        }
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['currency'] = currency['id']
+        response = self.privateGetWithdraw(self.extend(request, params))
+        #
+        #     {
+        #         "type": "withdraw",
+        #         "uuid": "95ef274b-23a6-4de4-95b0-5cbef4ca658f",
+        #         "currency": "ADA",
+        #         "net_type": "ADA",
+        #         "txid": "b1528f149297a71671b86636f731f8fdb0ff53da0f1d8c19093d59df96f34583",
+        #         "state": "DONE",
+        #         "created_at": "2023-12-14T02:46:52Z",
+        #         "done_at": "2023-12-14T03:10:11Z",
+        #         "amount": "35.22344",
+        #         "fee": "0.5",
+        #         "transaction_type": "default"
+        #     }
+        #
+        return self.parse_transaction(response, currency)
+
     def parse_transaction_status(self, status):
         statuses = {
             'submitting': 'pending',  # 처리 중
             'submitted': 'pending',  # 처리 완료
             'almost_accepted': 'pending',  # 출금대기중
             'rejected': 'failed',  # 거부
-            'accepted': 'pending',  # 승인됨
+            'accepted': 'ok',  # 승인됨
             'processing': 'pending',  # 처리 중
             'done': 'ok',  # 완료
             'canceled': 'canceled',  # 취소됨
@@ -1193,7 +1274,7 @@ class upbit(Exchange, ImplicitAPI):
 
     def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
         #
-        # fetchDeposits
+        # fetchDeposits, fetchDeposit
         #
         #     {
         #         "type": "deposit",
@@ -1207,7 +1288,7 @@ class upbit(Exchange, ImplicitAPI):
         #         "fee": "0.0"
         #     }
         #
-        # fetchWithdrawals
+        # fetchWithdrawals, fetchWithdrawal
         #
         #     {
         #         "type": "withdraw",
@@ -1222,26 +1303,20 @@ class upbit(Exchange, ImplicitAPI):
         #         "krw_amount": "80420.0"
         #     }
         #
-        id = self.safe_string(transaction, 'uuid')
-        amount = self.safe_number(transaction, 'amount')
         address = None  # not present in the data structure received from the exchange
         tag = None  # not present in the data structure received from the exchange
-        txid = self.safe_string(transaction, 'txid')
         updatedRaw = self.safe_string(transaction, 'done_at')
-        updated = self.parse8601(updatedRaw)
         timestamp = self.parse8601(self.safe_string(transaction, 'created_at', updatedRaw))
         type = self.safe_string(transaction, 'type')
         if type == 'withdraw':
             type = 'withdrawal'
         currencyId = self.safe_string(transaction, 'currency')
-        code = self.safe_currency_code(currencyId)
-        status = self.parse_transaction_status(self.safe_string_lower(transaction, 'state'))
-        feeCost = self.safe_number(transaction, 'fee')
+        code = self.safe_currency_code(currencyId, currency)
         return {
             'info': transaction,
-            'id': id,
+            'id': self.safe_string(transaction, 'uuid'),
             'currency': code,
-            'amount': amount,
+            'amount': self.safe_number(transaction, 'amount'),
             'network': None,
             'address': address,
             'addressTo': None,
@@ -1249,17 +1324,17 @@ class upbit(Exchange, ImplicitAPI):
             'tag': tag,
             'tagTo': None,
             'tagFrom': None,
-            'status': status,
+            'status': self.parse_transaction_status(self.safe_string_lower(transaction, 'state')),
             'type': type,
-            'updated': updated,
-            'txid': txid,
+            'updated': self.parse8601(updatedRaw),
+            'txid': self.safe_string(transaction, 'txid'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'internal': None,
             'comment': None,
             'fee': {
                 'currency': code,
-                'cost': feeCost,
+                'cost': self.safe_number(transaction, 'fee'),
             },
         }
 
@@ -1705,7 +1780,7 @@ class upbit(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(query)
         if api == 'private':
             self.check_required_credentials()
-            nonce = self.nonce()
+            nonce = self.uuid()
             request = {
                 'access_key': self.apiKey,
                 'nonce': nonce,

{ccxt-4.2.47.dist-info → ccxt-4.2.49.dist-info}/METADATA

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