ccxt 4.4.27__py2.py3-none-any.whl → 4.4.29__py2.py3-none-any.whl

ccxt/async_support/coinbase.py

@@ -3705,7 +3705,7 @@ class coinbase(Exchange, ImplicitAPI):
         tickers = self.safe_list(response, 'pricebooks', [])
         return self.parse_tickers(tickers, symbols)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/sign-in-with-coinbase/docs/api-transactions#send-money

ccxt/async_support/coinbaseexchange.py

@@ -1284,7 +1284,7 @@ class coinbaseexchange(Exchange, ImplicitAPI):
     async def fetch_payment_methods(self, params={}):
         return await self.privateGetPaymentMethods(params)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/exchange/reference/exchangerestapi_postwithdrawpaymentmethod

ccxt/async_support/coinbaseinternational.py

@@ -1997,7 +1997,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
         trades = self.safe_list(response, 'results', [])
         return self.parse_trades(trades, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.cloud.coinbase.com/intx/reference/withdraw

ccxt/async_support/coincatch.py

@@ -1954,7 +1954,7 @@ class coincatch(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_transactions(data, currency, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://coincatch.github.io/github.io/en/spot/#withdraw
@@ -1983,13 +1983,23 @@ class coincatch(Exchange, ImplicitAPI):
         if networkCode is not None:
             request['chain'] = self.network_code_to_id(networkCode)
         response = await self.privatePostApiSpotV1WalletWithdrawalV2(self.extend(request, params))
-        # todo add after withdrawal
         #
-        return response
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "data": {
+        #             "orderId":888291686266343424",
+        #             "clientOrderId":"123"
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_transaction(data, currency)
 
     def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
         #
         # fetchDeposits
+        #
         #     {
         #         "id": "1213046466852196352",
         #         "txId": "824246b030cd84d56400661303547f43a1d9fef66cf968628dd5112f362053ff",
@@ -2009,7 +2019,17 @@ class coincatch(Exchange, ImplicitAPI):
         #         "uTime": "1724938746015"
         #     }
         #
-        id = self.safe_string(transaction, 'id')
+        # withdraw
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "data": {
+        #             "orderId":888291686266343424",
+        #             "clientOrderId":"123"
+        #         }
+        #     }
+        #
         status = self.safe_string(transaction, 'status')
         if status == 'success':
             status = 'ok'
@@ -2033,7 +2053,7 @@ class coincatch(Exchange, ImplicitAPI):
             }
         return {
             'info': transaction,
-            'id': id,
+            'id': self.safe_string_2(transaction, 'id', 'orderId'),
             'txid': txid,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),

ccxt/async_support/coinex.py

@@ -4425,7 +4425,7 @@ class coinex(Exchange, ImplicitAPI):
         result = self.parse_funding_rates(data, market)
         return self.filter_by_array(result, 'symbol', symbols)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.coinex.com/api/v2/assets/deposit-withdrawal/http/withdrawal

ccxt/async_support/coinlist.py

@@ -1886,7 +1886,7 @@ class coinlist(Exchange, ImplicitAPI):
         # coinlist returns both internal transfers and blockchain transactions
         return self.parse_transactions(response, currency, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         request a withdrawal from CoinList wallet.(Disabled by default. Contact CoinList to apply for an exception.)
         :see: https://trade-docs.coinlist.co/?javascript--nodejs#request-withdrawal-from-wallet

ccxt/async_support/coinmate.py

@@ -587,7 +587,7 @@ class coinmate(Exchange, ImplicitAPI):
             },
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://coinmate.docs.apiary.io/#reference/bitcoin-withdrawal-and-deposit/withdraw-bitcoins/post

ccxt/async_support/coinsph.py

@@ -1501,7 +1501,7 @@ class coinsph(Exchange, ImplicitAPI):
             'tierBased': None,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal to coins_ph account
         :see: https://coins-docs.github.io/rest-api/#withdrawuser_data

ccxt/async_support/cryptocom.py

@@ -1556,7 +1556,7 @@ class cryptocom(Exchange, ImplicitAPI):
             address = addressString
         return [address, tag]
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-create-withdrawal

ccxt/async_support/deribit.py

@@ -2768,7 +2768,7 @@ class deribit(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.deribit.com/#private-withdraw

ccxt/async_support/digifinex.py

@@ -2786,7 +2786,7 @@ class digifinex(Exchange, ImplicitAPI):
         #
         return self.parse_transfer(response, currency)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/exmo.py

@@ -1988,7 +1988,7 @@ class exmo(Exchange, ImplicitAPI):
             return self.markets[symbols[0]]
         return None
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://documenter.getpostman.com/view/10287440/SzYXWKPi#3ab9c34d-ad58-4f87-9c57-2e2ea88a8325

ccxt/async_support/gate.py

@@ -3528,7 +3528,7 @@ class gate(Exchange, ImplicitAPI):
         response = await self.privateWalletGetWithdrawals(self.extend(request, params))
         return self.parse_transactions(response, currency)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://www.gate.io/docs/developers/apiv4/en/#withdraw

ccxt/async_support/gemini.py

@@ -1527,7 +1527,7 @@ class gemini(Exchange, ImplicitAPI):
         response = await self.privatePostV1Mytrades(self.extend(request, params))
         return self.parse_trades(response, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.gemini.com/rest-api/#withdraw-crypto-funds

ccxt/async_support/hashkey.py

@@ -1874,7 +1874,7 @@ class hashkey(Exchange, ImplicitAPI):
         #
         return self.parse_transactions(response, currency, since, limit, {'type': 'withdrawal'})
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://hashkeyglobal-apidoc.readme.io/reference/withdraw

ccxt/async_support/hitbtc.py

@@ -2491,7 +2491,7 @@ class hitbtc(Exchange, ImplicitAPI):
             'info': response,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://api.hitbtc.com/#withdraw-crypto

ccxt/async_support/hollaex.py

@@ -1611,7 +1611,7 @@ class hollaex(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://apidocs.hollaex.com/#withdrawal

ccxt/async_support/htx.py

@@ -6118,7 +6118,7 @@ class htx(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://www.htx.com/en-us/opend/newApiPages/?id=7ec4cc41-7773-11ed-9966-0242ac110003
         make a withdrawal

ccxt/async_support/huobijp.py

@@ -1745,7 +1745,7 @@ class huobijp(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/idex.py

@@ -1292,7 +1292,7 @@ class idex(Exchange, ImplicitAPI):
             response = await self.privatePostOrders(request)
         return self.parse_order(response, market)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://api-docs-v3.idex.io/#withdraw-funds

ccxt/async_support/independentreserve.py

@@ -756,7 +756,7 @@ class independentreserve(Exchange, ImplicitAPI):
             'tag': self.safe_string(depositAddress, 'Tag'),
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://www.independentreserve.com/features/api#WithdrawDigitalCurrency

ccxt/async_support/indodax.py

@@ -1018,7 +1018,7 @@ class indodax(Exchange, ImplicitAPI):
             transactions = self.array_concat(withdraws, deposits)
         return self.parse_transactions(transactions, currency, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#withdraw-coin-endpoints

ccxt/async_support/kraken.py

@@ -1436,7 +1436,7 @@ class kraken(Exchange, ImplicitAPI):
         #     {
         #         "error": [],
         #         "result": {
-        #             "descr": {order: 'buy 0.02100000 ETHUSDT @ limit 330.00'},
+        #             "descr": {order: 'buy 0.02100000 ETHUSDT @ limit 330.00'},  # see more examples in "parseOrder"
         #             "txid": ['OEKVV2-IH52O-TPL6GZ']
         #         }
         #     }
@@ -1496,9 +1496,10 @@ class kraken(Exchange, ImplicitAPI):
 
     def parse_order_type(self, status):
         statuses: dict = {
+            # we dont add "space" delimited orders here(eg. stop loss) because they need separate parsing
             'take-profit': 'market',
-            'stop-loss-limit': 'limit',
             'stop-loss': 'market',
+            'stop-loss-limit': 'limit',
             'take-profit-limit': 'limit',
             'trailing-stop-limit': 'limit',
         }
@@ -1506,30 +1507,19 @@ class kraken(Exchange, ImplicitAPI):
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
         #
-        # createOrder for regular orders
+        # createOrder
         #
         #     {
-        #         "descr": {order: 'buy 0.02100000 ETHUSDT @ limit 330.00'},
+        #         "descr": {
+        #            "order": "buy 0.02100000 ETHUSDT @ limit 330.00"  # limit orders
+        #                     "buy 0.12345678 ETHUSDT @ market"  # market order
+        #                     "sell 0.28002676 ETHUSDT @ stop loss 0.0123 -> limit 0.0.1222"  # stop order
+        #                     "sell 0.00100000 ETHUSDT @ stop loss 2677.00 -> limit 2577.00 with 5:1 leverage"
+        #                     "buy 0.10000000 LTCUSDT @ take profit 75.00000 -> limit 74.00000"
+        #                     "sell 10.00000000 XRPEUR @ trailing stop +50.0000%"  # trailing stop
+        #         },
         #         "txid": ['OEKVV2-IH52O-TPL6GZ']
         #     }
-        #     {
-        #         "txid": ["TX_ID_HERE"],
-        #         "descr": {"order":"buy 0.12345678 ETHEUR @ market"},
-        #     }
-        #
-        #
-        # createOrder for stop orders
-        #
-        #     {
-        #         "txid":["OSILNC-VQI5Q-775ZDQ"],
-        #         "descr":{"order":"sell 167.28002676 ADAXBT @ stop loss 0.00003280 -> limit 0.00003212"}
-        #     }
-        #
-        #
-        #     {
-        #         "txid":["OVHMJV-BZW2V-6NZFWF"],
-        #         "descr":{"order":"sell 0.00100000 ETHUSD @ stop loss 2677.00 -> limit 2577.00 with 5:1 leverage"}
-        #     }
         #
         # editOrder
         #
@@ -1607,24 +1597,29 @@ class kraken(Exchange, ImplicitAPI):
         else:
             orderDescription = self.safe_string(order, 'descr')
         side = None
-        type = None
+        rawType = None
         marketId = None
         price = None
         amount = None
-        stopPrice = None
+        triggerPrice = None
         if orderDescription is not None:
             parts = orderDescription.split(' ')
             side = self.safe_string(parts, 0)
             amount = self.safe_string(parts, 1)
             marketId = self.safe_string(parts, 2)
-            type = self.safe_string(parts, 4)
-            if type == 'stop':
-                stopPrice = self.safe_string(parts, 6)
+            part4 = self.safe_string(parts, 4)
+            part5 = self.safe_string(parts, 5)
+            if part4 == 'limit' or part4 == 'market':
+                rawType = part4  # eg, limit, market
+            else:
+                rawType = part4 + ' ' + part5  # eg. stop loss, take profit, trailing stop
+            if rawType == 'stop loss' or rawType == 'take profit':
+                triggerPrice = self.safe_string(parts, 6)
                 price = self.safe_string(parts, 9)
-            elif type == 'limit':
+            elif rawType == 'limit':
                 price = self.safe_string(parts, 5)
         side = self.safe_string(description, 'type', side)
-        type = self.safe_string(description, 'ordertype', type)
+        rawType = self.safe_string(description, 'ordertype', rawType)  # orderType has dash, e.g. trailing-stop
         marketId = self.safe_string(description, 'pair', marketId)
         foundMarket = self.find_market_by_altname_or_id(marketId)
         symbol = None
@@ -1676,15 +1671,28 @@ class kraken(Exchange, ImplicitAPI):
                 trades.append(self.safe_trade({'id': rawTrade, 'orderId': id, 'symbol': symbol, 'info': {}}))
             else:
                 trades.append(rawTrade)
-        stopPrice = self.omit_zero(self.safe_string(order, 'stopprice', stopPrice))
+        # in  #24192 PR, self field is not something consistent/actual
+        # triggerPrice = self.omit_zero(self.safe_string(order, 'stopprice', triggerPrice))
         stopLossPrice = None
         takeProfitPrice = None
-        if type.startswith('take-profit'):
+        # the dashed strings are not provided from fields(eg. fetch order)
+        # while spaced strings from "order" sentence(when other fields not available)
+        if rawType.startswith('take-profit'):
             takeProfitPrice = self.safe_string(description, 'price')
             price = self.omit_zero(self.safe_string(description, 'price2'))
-        elif type.startswith('stop-loss'):
+        elif rawType.startswith('stop-loss'):
             stopLossPrice = self.safe_string(description, 'price')
             price = self.omit_zero(self.safe_string(description, 'price2'))
+        elif rawType == 'take profit':
+            takeProfitPrice = triggerPrice
+        elif rawType == 'stop loss':
+            stopLossPrice = triggerPrice
+        finalType = self.parse_order_type(rawType)
+        # unlike from endpoints which provide eg: "take-profit-limit"
+        # for "space-delimited" orders we dont have market/limit suffixes, their format is
+        # eg: `stop loss > limit 123`, so we need to parse them manually
+        if self.in_array(finalType, ['stop loss', 'take profit']):
+            finalType = 'market' if (price is None) else 'limit'
         return self.safe_order({
             'id': id,
             'clientOrderId': clientOrderId,
@@ -1694,13 +1702,13 @@ class kraken(Exchange, ImplicitAPI):
             'lastTradeTimestamp': None,
             'status': status,
             'symbol': symbol,
-            'type': self.parse_order_type(type),
+            'type': finalType,
             'timeInForce': None,
             'postOnly': isPostOnly,
             'side': side,
             'price': price,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'stopPrice': triggerPrice,
+            'triggerPrice': triggerPrice,
             'takeProfitPrice': takeProfitPrice,
             'stopLossPrice': stopLossPrice,
             'cost': None,
@@ -2698,7 +2706,7 @@ class kraken(Exchange, ImplicitAPI):
             'tag': tag,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.kraken.com/rest/#tag/Funding/operation/withdrawFunds

ccxt/async_support/kucoin.py

@@ -3258,7 +3258,7 @@ class kucoin(Exchange, ImplicitAPI):
             'tierBased': True,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://www.kucoin.com/docs/rest/funding/withdrawals/apply-withdraw-v3-

ccxt/async_support/kuna.py

@@ -1333,7 +1333,7 @@ class kuna(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data')
         return self.parse_trades(data, market, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.kuna.io/docs/create-a-withdraw

ccxt/async_support/lbank.py

@@ -1155,6 +1155,11 @@ class lbank(Exchange, ImplicitAPI):
         indexPrice = self.safe_number(ticker, 'underlyingPrice')
         fundingRate = self.safe_number(ticker, 'fundingRate')
         fundingTime = self.safe_integer(ticker, 'nextFeeTime')
+        positionFeeTime = self.safe_integer(ticker, 'positionFeeTime')
+        intervalString = None
+        if positionFeeTime is not None:
+            interval = self.parse_to_int(positionFeeTime / 60 / 60)
+            intervalString = interval + 'h'
         return {
             'info': ticker,
             'symbol': symbol,
@@ -1171,7 +1176,7 @@ class lbank(Exchange, ImplicitAPI):
             'previousFundingRate': None,
             'previousFundingTimestamp': None,
             'previousFundingDatetime': None,
-            'interval': None,
+            'interval': intervalString,
         }
 
     async def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:

ccxt/async_support/lykke.py

@@ -1207,7 +1207,7 @@ class lykke(Exchange, ImplicitAPI):
             currency = self.currency(code)
         return self.parse_transactions(payload, currency, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://lykkecity.github.io/Trading-API/#withdrawal

ccxt/async_support/mercado.py

@@ -601,7 +601,7 @@ class mercado(Exchange, ImplicitAPI):
         order = self.safe_dict(responseData, 'order')
         return self.parse_order(order, market)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/mexc.py

@@ -4976,7 +4976,7 @@ class mexc(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#withdraw-new

ccxt/async_support/ndax.py

@@ -2229,7 +2229,7 @@ class ndax(Exchange, ImplicitAPI):
             'network': None,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/novadax.py

@@ -1157,7 +1157,7 @@ class novadax(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, 'failed')
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://doc.novadax.com/en-US/#send-cryptocurrencies

ccxt/async_support/okcoin.py

@@ -2307,7 +2307,7 @@ class okcoin(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://www.okcoin.com/docs-v5/en/#rest-api-funding-withdrawal
         make a withdrawal

ccxt/async_support/okx.py

@@ -4644,7 +4644,7 @@ class okx(Exchange, ImplicitAPI):
         first = self.safe_string(keys, 0)
         return self.safe_dict(response, first)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-withdrawal

ccxt/async_support/onetrading.py

@@ -1183,7 +1183,7 @@ class onetrading(Exchange, ImplicitAPI):
         withdrawalHistory = self.safe_list(response, 'withdrawal_history', [])
         return self.parse_transactions(withdrawalHistory, currency, since, limit, {'type': 'withdrawal'})
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :param str code: unified currency code

ccxt/async_support/oxfun.py

@@ -1967,7 +1967,7 @@ class oxfun(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.ox.fun/?json#post-v3-withdrawal

ccxt/async_support/phemex.py

@@ -4431,7 +4431,7 @@ class phemex(Exchange, ImplicitAPI):
         sorted = self.sort_by(result, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://phemex-docs.github.io/#create-withdraw-request

ccxt/async_support/poloniex.py

@@ -1799,7 +1799,7 @@ class poloniex(Exchange, ImplicitAPI):
             'status': None,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://api-docs.poloniex.com/spot/api/private/wallet#withdraw-currency

ccxt/async_support/probit.py

@@ -1319,7 +1319,7 @@ class probit(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_deposit_addresses(data, codes)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://docs-en.probit.com/reference/withdrawal
         make a withdrawal

ccxt/async_support/tokocrypto.py

@@ -2235,7 +2235,7 @@ class tokocrypto(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://www.tokocrypto.com/apidocs/#withdraw-signed
         make a withdrawal

ccxt/async_support/upbit.py

@@ -1815,7 +1815,7 @@ class upbit(Exchange, ImplicitAPI):
             raise AddressPending(self.id + ' is generating ' + code + ' deposit address, call fetchDepositAddress or createDepositAddress one more time later to retrieve the generated address')
         return self.parse_deposit_address(response)
 
-    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         :see: https://docs.upbit.com/reference/디지털자산-출금하기
         :see: https://docs.upbit.com/reference/%EC%9B%90%ED%99%94-%EC%B6%9C%EA%B8%88%ED%95%98%EA%B8%B0