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

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.28'
+__version__ = '4.4.29'
 
 # ----------------------------------------------------------------------------
 

ccxt/abstract/bybit.py

@@ -181,19 +181,6 @@ class ImplicitAPI:
     private_get_v5_broker_earnings_info = privateGetV5BrokerEarningsInfo = Entry('v5/broker/earnings-info', 'private', 'GET', {'cost': 5})
     private_get_v5_broker_account_info = privateGetV5BrokerAccountInfo = Entry('v5/broker/account-info', 'private', 'GET', {'cost': 5})
     private_get_v5_broker_asset_query_sub_member_deposit_record = privateGetV5BrokerAssetQuerySubMemberDepositRecord = Entry('v5/broker/asset/query-sub-member-deposit-record', 'private', 'GET', {'cost': 10})
-    private_post_option_usdc_openapi_private_v1_place_order = privatePostOptionUsdcOpenapiPrivateV1PlaceOrder = Entry('option/usdc/openapi/private/v1/place-order', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_replace_order = privatePostOptionUsdcOpenapiPrivateV1ReplaceOrder = Entry('option/usdc/openapi/private/v1/replace-order', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_cancel_order = privatePostOptionUsdcOpenapiPrivateV1CancelOrder = Entry('option/usdc/openapi/private/v1/cancel-order', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_cancel_all = privatePostOptionUsdcOpenapiPrivateV1CancelAll = Entry('option/usdc/openapi/private/v1/cancel-all', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_query_active_orders = privatePostOptionUsdcOpenapiPrivateV1QueryActiveOrders = Entry('option/usdc/openapi/private/v1/query-active-orders', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_query_order_history = privatePostOptionUsdcOpenapiPrivateV1QueryOrderHistory = Entry('option/usdc/openapi/private/v1/query-order-history', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_execution_list = privatePostOptionUsdcOpenapiPrivateV1ExecutionList = Entry('option/usdc/openapi/private/v1/execution-list', 'private', 'POST', {'cost': 2.5})
-    private_post_option_usdc_openapi_private_v1_query_position = privatePostOptionUsdcOpenapiPrivateV1QueryPosition = Entry('option/usdc/openapi/private/v1/query-position', 'private', 'POST', {'cost': 2.5})
-    private_post_perpetual_usdc_openapi_private_v1_place_order = privatePostPerpetualUsdcOpenapiPrivateV1PlaceOrder = Entry('perpetual/usdc/openapi/private/v1/place-order', 'private', 'POST', {'cost': 2.5})
-    private_post_perpetual_usdc_openapi_private_v1_replace_order = privatePostPerpetualUsdcOpenapiPrivateV1ReplaceOrder = Entry('perpetual/usdc/openapi/private/v1/replace-order', 'private', 'POST', {'cost': 2.5})
-    private_post_perpetual_usdc_openapi_private_v1_cancel_order = privatePostPerpetualUsdcOpenapiPrivateV1CancelOrder = Entry('perpetual/usdc/openapi/private/v1/cancel-order', 'private', 'POST', {'cost': 2.5})
-    private_post_perpetual_usdc_openapi_private_v1_cancel_all = privatePostPerpetualUsdcOpenapiPrivateV1CancelAll = Entry('perpetual/usdc/openapi/private/v1/cancel-all', 'private', 'POST', {'cost': 2.5})
-    private_post_perpetual_usdc_openapi_private_v1_position_leverage_save = privatePostPerpetualUsdcOpenapiPrivateV1PositionLeverageSave = Entry('perpetual/usdc/openapi/private/v1/position/leverage/save', 'private', 'POST', {'cost': 2.5})
     private_post_spot_v3_private_order = privatePostSpotV3PrivateOrder = Entry('spot/v3/private/order', 'private', 'POST', {'cost': 2.5})
     private_post_spot_v3_private_cancel_order = privatePostSpotV3PrivateCancelOrder = Entry('spot/v3/private/cancel-order', 'private', 'POST', {'cost': 2.5})
     private_post_spot_v3_private_cancel_orders = privatePostSpotV3PrivateCancelOrders = Entry('spot/v3/private/cancel-orders', 'private', 'POST', {'cost': 2.5})

ccxt/alpaca.py

@@ -1289,7 +1289,7 @@ class alpaca(Exchange, ImplicitAPI):
             'tag': None,
         }
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
         :see: https://docs.alpaca.markets/reference/createcryptotransferforaccount

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.28'
+__version__ = '4.4.29'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/alpaca.py

@@ -1289,7 +1289,7 @@ class alpaca(Exchange, ImplicitAPI):
             'tag': 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://docs.alpaca.markets/reference/createcryptotransferforaccount

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.28'
+__version__ = '4.4.29'
 
 # -----------------------------------------------------------------------------
 
@@ -631,6 +631,9 @@ class Exchange(BaseExchange):
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}):
         raise NotSupported(self.id + ' fetchOrderBook() is not supported yet')
 
+    async def fetch_order_book_ws(self, symbol: str, limit: Int = None, params={}):
+        raise NotSupported(self.id + ' fetchOrderBookWs() is not supported yet')
+
     async def fetch_margin_mode(self, symbol: str, params={}):
         if self.has['fetchMarginModes']:
             marginModes = await self.fetch_margin_modes([symbol], params)

ccxt/async_support/bigone.py

@@ -2019,7 +2019,7 @@ class bigone(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://open.big.one/docs/spot_withdrawal.html#create-withdrawal-of-user

ccxt/async_support/binance.py

@@ -8481,7 +8481,7 @@ class binance(Exchange, ImplicitAPI):
             }
         return result
 
-    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://developers.binance.com/docs/wallet/capital/withdraw

ccxt/async_support/bingx.py

@@ -4978,7 +4978,7 @@ class bingx(Exchange, ImplicitAPI):
         coins = self.safe_list(response, 'data')
         return self.parse_deposit_withdraw_fees(coins, codes, 'coin')
 
-    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://bingx-api.github.io/docs/#/en-us/spot/wallet-api.html#Withdraw

ccxt/async_support/bitbank.py

@@ -814,7 +814,7 @@ class bitbank(Exchange, ImplicitAPI):
             'tag': 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://github.com/bitbankinc/bitbank-api-docs/blob/38d6d7c6f486c793872fd4b4087a0d090a04cd0a/rest-api.md#new-withdrawal-request

ccxt/async_support/bitfinex.py

@@ -1529,7 +1529,7 @@ class bitfinex(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.bitfinex.com/v1/reference/rest-auth-withdrawal

ccxt/async_support/bitfinex2.py

@@ -2459,7 +2459,7 @@ class bitfinex2(Exchange, ImplicitAPI):
         #
         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:
         """
         make a withdrawal
         :see: https://docs.bitfinex.com/reference/rest-auth-withdraw

ccxt/async_support/bitflyer.py

@@ -775,7 +775,7 @@ class bitflyer(Exchange, ImplicitAPI):
         # todo unify parsePosition/parsePositions
         return 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://lightning.bitflyer.com/docs?lang=en#withdrawing-funds

ccxt/async_support/bitget.py

@@ -8,7 +8,7 @@ from ccxt.abstract.bitget import ImplicitAPI
 import asyncio
 import hashlib
 import json
-from ccxt.base.types import Balances, BorrowInterest, Conversion, CrossBorrowRate, Currencies, Currency, DepositAddress, FundingHistory, Int, IsolatedBorrowRate, LedgerEntry, Leverage, LeverageTier, Liquidation, LongShortRatio, MarginMode, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Balances, BorrowInterest, Conversion, CrossBorrowRate, Currencies, Currency, DepositAddress, FundingHistory, Int, IsolatedBorrowRate, LedgerEntry, Leverage, LeverageTier, Liquidation, LongShortRatio, MarginMode, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -106,7 +106,7 @@ class bitget(Exchange, ImplicitAPI):
                 'fetchFundingIntervals': False,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
-                'fetchFundingRates': False,
+                'fetchFundingRates': True,
                 'fetchIndexOHLCV': True,
                 'fetchIsolatedBorrowRate': True,
                 'fetchIsolatedBorrowRates': False,
@@ -2143,7 +2143,7 @@ class bitget(Exchange, ImplicitAPI):
         rawTransactions = self.safe_list(response, 'data', [])
         return self.parse_transactions(rawTransactions, 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://www.bitget.com/api-doc/spot/account/Wallet-Withdrawal
@@ -6351,6 +6351,66 @@ class bitget(Exchange, ImplicitAPI):
         data = self.safe_value(response, 'data', [])
         return self.parse_funding_rate(data[0], market)
 
+    async def fetch_funding_rates(self, symbols: Strings = None, params={}) -> FundingRates:
+        """
+        fetch the current funding rates for all markets
+        :see: https://www.bitget.com/api-doc/contract/market/Get-All-Symbol-Ticker
+        :param str[] [symbols]: list of unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.subType]: *contract only* 'linear', 'inverse'
+        :param str [params.productType]: *contract only* 'USDT-FUTURES', 'USDC-FUTURES', 'COIN-FUTURES', 'SUSDT-FUTURES', 'SUSDC-FUTURES' or 'SCOIN-FUTURES'
+        :returns dict: a dictionary of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rates-structure>`, indexed by market symbols
+        """
+        await self.load_markets()
+        market = None
+        if symbols is not None:
+            symbol = self.safe_value(symbols, 0)
+            sandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
+            if sandboxMode:
+                sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
+                market = self.market(sandboxSymbol)
+            else:
+                market = self.market(symbol)
+        request: dict = {}
+        productType = None
+        productType, params = self.handle_product_type_and_params(market, params)
+        request['productType'] = productType
+        response = await self.publicMixGetV2MixMarketTickers(self.extend(request, params))
+        # {
+        #     "code": "00000",
+        #     "msg": "success",
+        #     "requestTime": 1700533773477,
+        #     "data": [
+        #         {
+        #             "symbol": "BTCUSD",
+        #             "lastPr": "29904.5",
+        #             "askPr": "29904.5",
+        #             "bidPr": "29903.5",
+        #             "bidSz": "0.5091",
+        #             "askSz": "2.2694",
+        #             "high24h": "0",
+        #             "low24h": "0",
+        #             "ts": "1695794271400",
+        #             "change24h": "0",
+        #             "baseVolume": "0",
+        #             "quoteVolume": "0",
+        #             "usdtVolume": "0",
+        #             "openUtc": "0",
+        #             "changeUtc24h": "0",
+        #             "indexPrice": "29132.353333",
+        #             "fundingRate": "-0.0007",
+        #             "holdingAmount": "125.6844",
+        #             "deliveryStartTime": null,
+        #             "deliveryTime": null,
+        #             "deliveryStatus": "delivery_normal",
+        #             "open24h": "0",
+        #             "markPrice": "12345"
+        #         },
+        #     ]
+        # }
+        data = self.safe_list(response, 'data', [])
+        return self.parse_funding_rates(data, market)
+
     def parse_funding_rate(self, contract, market: Market = None) -> FundingRate:
         #
         # fetchFundingRate
@@ -6367,23 +6427,51 @@ class bitget(Exchange, ImplicitAPI):
         #         "nextFundingTime": "1727942400000",
         #         "ratePeriod": "8"
         #     }
-        #
+        # fetchFundingRates
+        #     {
+        #         "symbol": "BTCUSD",
+        #         "lastPr": "29904.5",
+        #         "askPr": "29904.5",
+        #         "bidPr": "29903.5",
+        #         "bidSz": "0.5091",
+        #         "askSz": "2.2694",
+        #         "high24h": "0",
+        #         "low24h": "0",
+        #         "ts": "1695794271400",
+        #         "change24h": "0",
+        #         "baseVolume": "0",
+        #         "quoteVolume": "0",
+        #         "usdtVolume": "0",
+        #         "openUtc": "0",
+        #         "changeUtc24h": "0",
+        #         "indexPrice": "29132.353333",
+        #         "fundingRate": "-0.0007",
+        #         "holdingAmount": "125.6844",
+        #         "deliveryStartTime": null,
+        #         "deliveryTime": null,
+        #         "deliveryStatus": "delivery_normal",
+        #         "open24h": "0",
+        #         "markPrice": "12345"
+        #     }
         marketId = self.safe_string(contract, 'symbol')
         symbol = self.safe_symbol(marketId, market, None, 'swap')
         fundingTimestamp = self.safe_integer(contract, 'nextFundingTime')
         interval = self.safe_string(contract, 'ratePeriod')
+        timestamp = self.safe_integer(contract, 'ts')
+        markPrice = self.safe_number(contract, 'markPrice')
+        indexPrice = self.safe_number(contract, 'indexPrice')
         intervalString = None
         if interval is not None:
             intervalString = interval + 'h'
         return {
             'info': contract,
             'symbol': symbol,
-            'markPrice': None,
-            'indexPrice': None,
+            'markPrice': markPrice,
+            'indexPrice': indexPrice,
             'interestRate': None,
             'estimatedSettlePrice': None,
-            'timestamp': None,
-            'datetime': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'fundingRate': self.safe_number(contract, 'fundingRate'),
             'fundingTimestamp': fundingTimestamp,
             'fundingDatetime': self.iso8601(fundingTimestamp),

ccxt/async_support/bithumb.py

@@ -983,7 +983,7 @@ class bithumb(Exchange, ImplicitAPI):
         }
         return await self.cancel_order(order['id'], order['symbol'], self.extend(request, 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://apidocs.bithumb.com/v1.2.0/reference/%EC%BD%94%EC%9D%B8-%EC%B6%9C%EA%B8%88%ED%95%98%EA%B8%B0-%EA%B0%9C%EC%9D%B8

ccxt/async_support/bitmart.py

@@ -3277,7 +3277,7 @@ class bitmart(Exchange, ImplicitAPI):
             'tag': self.safe_string(depositAddress, 'address_memo'),
         }
 
-    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/bitmex.py

@@ -2285,7 +2285,7 @@ class bitmex(Exchange, ImplicitAPI):
             'takeProfitPrice': 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://www.bitmex.com/api/explorer/#not /User/User_requestWithdrawal

ccxt/async_support/bitopro.py

@@ -233,7 +233,7 @@ class bitopro(Exchange, ImplicitAPI):
         :returns dict: an associative dictionary of currencies
         """
         response = await self.publicGetProvisioningCurrencies(params)
-        currencies = self.safe_value(response, 'data', [])
+        currencies = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -255,8 +255,8 @@ class bitopro(Exchange, ImplicitAPI):
             currency = currencies[i]
             currencyId = self.safe_string(currency, 'currency')
             code = self.safe_currency_code(currencyId)
-            deposit = self.safe_value(currency, 'deposit')
-            withdraw = self.safe_value(currency, 'withdraw')
+            deposit = self.safe_bool(currency, 'deposit')
+            withdraw = self.safe_bool(currency, 'withdraw')
             fee = self.safe_number(currency, 'withdrawFee')
             withdrawMin = self.safe_number(currency, 'minWithdraw')
             withdrawMax = self.safe_number(currency, 'maxWithdraw')
@@ -293,7 +293,7 @@ class bitopro(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         response = await self.publicGetProvisioningTradingPairs()
-        markets = self.safe_value(response, 'data', [])
+        markets = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -317,7 +317,7 @@ class bitopro(Exchange, ImplicitAPI):
         return self.parse_markets(markets)
 
     def parse_market(self, market: dict) -> Market:
-        active = not self.safe_value(market, 'maintain')
+        active = not self.safe_bool(market, 'maintain')
         id = self.safe_string(market, 'pair')
         uppercaseId = id.upper()
         baseId = self.safe_string(market, 'base')
@@ -429,7 +429,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = await self.publicGetTickersPair(self.extend(request, params))
-        ticker = self.safe_value(response, 'data', {})
+        ticker = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -455,7 +455,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         response = await self.publicGetTickers()
-        tickers = self.safe_value(response, 'data', [])
+        tickers = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -551,7 +551,7 @@ class bitopro(Exchange, ImplicitAPI):
         type = self.safe_string_lower(trade, 'type')
         side = self.safe_string_lower(trade, 'action')
         if side is None:
-            isBuyer = self.safe_value(trade, 'isBuyer')
+            isBuyer = self.safe_bool(trade, 'isBuyer')
             if isBuyer:
                 side = 'buy'
             else:
@@ -568,7 +568,7 @@ class bitopro(Exchange, ImplicitAPI):
                 'currency': feeSymbol,
                 'rate': None,
             }
-        isTaker = self.safe_value(trade, 'isTaker')
+        isTaker = self.safe_bool(trade, 'isTaker')
         takerOrMaker = None
         if isTaker is not None:
             if isTaker:
@@ -607,7 +607,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = await self.publicGetTradesPair(self.extend(request, params))
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -631,7 +631,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         response = await self.publicGetProvisioningLimitationsAndFees(params)
-        tradingFeeRate = self.safe_value(response, 'tradingFeeRate', {})
+        tradingFeeRate = self.safe_dict(response, 'tradingFeeRate', {})
         first = self.safe_value(tradingFeeRate, 0)
         #
         #     {
@@ -753,7 +753,7 @@ class bitopro(Exchange, ImplicitAPI):
             request['from'] = int(math.floor(since / 1000))
             request['to'] = self.sum(request['from'], limit * timeframeInSeconds)
         response = await self.publicGetTradingHistoryPair(self.extend(request, params))
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -841,7 +841,7 @@ class bitopro(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         response = await self.privateGetAccountsBalance(params)
-        balances = self.safe_value(response, 'data', [])
+        balances = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1101,7 +1101,7 @@ class bitopro(Exchange, ImplicitAPI):
             response = await self.privateDeleteOrdersPair(self.extend(request, params))
         else:
             response = await self.privateDeleteOrdersAll(self.extend(request, params))
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -1183,7 +1183,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = await self.privateGetOrdersAllPair(self.extend(request, params))
-        orders = self.safe_value(response, 'data')
+        orders = self.safe_list(response, 'data', [])
         if orders is None:
             orders = []
         #
@@ -1253,7 +1253,7 @@ class bitopro(Exchange, ImplicitAPI):
             'pair': market['id'],
         }
         response = await self.privateGetOrdersTradesPair(self.extend(request, params))
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1395,7 +1395,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = await self.privateGetWalletDepositHistoryCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', [])
+        result = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1442,7 +1442,7 @@ class bitopro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit
         response = await self.privateGetWalletWithdrawHistoryCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', [])
+        result = self.safe_list(response, 'data', [])
         #
         #     {
         #         "data":[
@@ -1481,7 +1481,7 @@ class bitopro(Exchange, ImplicitAPI):
             'currency': currency['id'],
         }
         response = await self.privateGetWalletWithdrawCurrencySerial(self.extend(request, params))
-        result = self.safe_value(response, 'data', {})
+        result = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{
@@ -1500,7 +1500,7 @@ class bitopro(Exchange, ImplicitAPI):
         #
         return self.parse_transaction(result, 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://github.com/bitoex/bitopro-offical-api-docs/blob/master/api/v3/private/create_an_withdraw_invoice.md
@@ -1521,7 +1521,7 @@ class bitopro(Exchange, ImplicitAPI):
             'address': address,
         }
         if 'network' in params:
-            networks = self.safe_value(self.options, 'networks', {})
+            networks = self.safe_dict(self.options, 'networks', {})
             requestedNetwork = self.safe_string_upper(params, 'network')
             params = self.omit(params, ['network'])
             networkId = self.safe_string(networks, requestedNetwork)
@@ -1531,7 +1531,7 @@ class bitopro(Exchange, ImplicitAPI):
         if tag is not None:
             request['message'] = tag
         response = await self.privatePostWalletWithdrawCurrency(self.extend(request, params))
-        result = self.safe_value(response, 'data', {})
+        result = self.safe_dict(response, 'data', {})
         #
         #     {
         #         "data":{