ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/async_support/bitrue.py

@@ -8,9 +8,10 @@ from ccxt.abstract.bitrue import ImplicitAPI
 import asyncio
 import hashlib
 import json
-from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currencies, Currency, Int, MarginModification, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
@@ -26,7 +27,6 @@ from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import InvalidNonce
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TRUNCATE
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
@@ -73,7 +73,10 @@ class bitrue(Exchange, ImplicitAPI):
                 'fetchDepositsWithdrawals': False,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': True,
+                'fetchFundingHistory': False,
                 'fetchFundingRate': False,
+                'fetchFundingRateHistory': False,
+                'fetchFundingRates': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
                 'fetchMarginMode': False,
@@ -113,7 +116,7 @@ class bitrue(Exchange, ImplicitAPI):
                 '1w': '1W',
             },
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/139516488-243a830d-05dd-446b-91c6-c1f18fe30c63.jpg',
+                'logo': 'https://github.com/user-attachments/assets/67abe346-1273-461a-bd7c-42fa32907c8e',
                 'api': {
                     'spot': 'https://www.bitrue.com/api',
                     'fapi': 'https://fapi.bitrue.com/fapi',
@@ -345,6 +348,7 @@ class bitrue(Exchange, ImplicitAPI):
                 # 'fetchTradesMethod': 'publicGetAggTrades',  # publicGetTrades, publicGetHistoricalTrades
                 'fetchMyTradesMethod': 'v2PrivateGetMyTrades',  # spotV1PrivateGetMyTrades
                 'hasAlreadyAuthenticatedSuccessfully': False,
+                'currencyToPrecisionRoundingMode': TRUNCATE,
                 'recvWindow': 5 * 1000,  # 5 sec, binance default
                 'timeDifference': 0,  # the difference between system clock and Binance clock
                 'adjustForTimeDifference': False,  # controls the adjustment logic upon instantiation
@@ -356,6 +360,67 @@ class bitrue(Exchange, ImplicitAPI):
                 'networks': {
                     'ERC20': 'ETH',
                     'TRC20': 'TRX',
+                    'AETERNITY': 'Aeternity',
+                    'AION': 'AION',
+                    'ALGO': 'Algorand',
+                    'ASK': 'ASK',
+                    'ATOM': 'ATOM',
+                    'AVAXC': 'AVAX C-Chain',
+                    'BCH': 'BCH',
+                    'BEP2': 'BEP2',
+                    'BEP20': 'BEP20',
+                    'Bitcoin': 'Bitcoin',
+                    'BRP20': 'BRP20',
+                    'ADA': 'Cardano',
+                    'CASINOCOIN': 'CasinoCoin',
+                    'CASINOCOIN-XRPL': 'CasinoCoin XRPL',
+                    'CONTENTOS': 'Contentos',
+                    'DASH': 'Dash',
+                    'DECOIN': 'Decoin',
+                    'DFI': 'DeFiChain',
+                    'DGB': 'DGB',
+                    'DIVI': 'Divi',
+                    'DOGE': 'dogecoin',
+                    'EOS': 'EOS',
+                    'ETC': 'ETC',
+                    'FILECOIN': 'Filecoin',
+                    'FREETON': 'FREETON',
+                    'HBAR': 'HBAR',
+                    'HEDERA': 'Hedera Hashgraph',
+                    'HRC20': 'HRC20',
+                    'ICON': 'ICON',
+                    'ICP': 'ICP',
+                    'IGNIS': 'Ignis',
+                    'INTERNETCOMPUTER': 'Internet Computer',
+                    'IOTA': 'IOTA',
+                    'KAVA': 'KAVA',
+                    'KSM': 'KSM',
+                    'LTC': 'LiteCoin',
+                    'LUNA': 'Luna',
+                    'MATIC': 'MATIC',
+                    'MOBILECOIN': 'Mobile Coin',
+                    'MONACOIN': 'MonaCoin',
+                    'XMR': 'Monero',
+                    'NEM': 'NEM',
+                    'NEP5': 'NEP5',
+                    'OMNI': 'OMNI',
+                    'PAC': 'PAC',
+                    'DOT': 'Polkadot',
+                    'RAVEN': 'Ravencoin',
+                    'SAFEX': 'Safex',
+                    'SOL': 'SOLANA',
+                    'SGB': 'Songbird',
+                    'XML': 'Stellar Lumens',
+                    'XYM': 'Symbol',
+                    'XTZ': 'Tezos',
+                    'theta': 'theta',
+                    'THETA': 'THETA',
+                    'VECHAIN': 'VeChain',
+                    'WANCHAIN': 'Wanchain',
+                    'XINFIN': 'XinFin Network',
+                    'XRP': 'XRP',
+                    'XRPL': 'XRPL',
+                    'ZIL': 'ZIL',
                 },
                 'defaultType': 'spot',
                 'timeframes': {
@@ -395,7 +460,92 @@ class bitrue(Exchange, ImplicitAPI):
                 'MIM': 'MIM Swarm',
             },
             'precisionMode': TICK_SIZE,
-            # https://binance-docs.github.io/apidocs/spot/en/#error-codes-2
+            'features': {
+                'default': {
+                    'sandbox': False,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': True,
+                        'triggerPriceType': None,
+                        'triggerDirection': None,
+                        'stopLossPrice': False,  # todo
+                        'takeProfitPrice': False,  # todo
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': True,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        'leverage': False,
+                        'marketBuyRequiresPrice': True,  # todo revise
+                        'marketBuyByCost': True,
+                        'selfTradePrevention': False,
+                        'iceberg': True,  # todo implement
+                    },
+                    'createOrders': None,
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'daysBack': 100000,
+                        'untilDays': 100000,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': None,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'daysBack': 90,
+                        'daysBackCanceled': 1,
+                        'untilDays': 90,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 1440,
+                    },
+                },
+                'spot': {
+                    'extends': 'default',
+                },
+                'forDerivatives': {
+                    'extends': 'default',
+                    'createOrder': {
+                        'marginMode': True,
+                        'leverage': True,
+                        'marketBuyRequiresPrice': False,
+                        'marketBuyByCost': False,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 300,
+                    },
+                    'fetchClosedOrders': None,
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'forDerivatives',
+                    },
+                    'inverse': {
+                        'extends': 'forDerivatives',
+                    },
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
             'exceptions': {
                 'exact': {
                     'System is under maintenance.': OnMaintenance,  # {"code":1,"msg":"System is under maintenance."}
@@ -422,7 +572,7 @@ class bitrue(Exchange, ImplicitAPI):
                     '-1022': AuthenticationError,  # {"code":-1022,"msg":"Signature for self request is not valid."}
                     '-1100': BadRequest,  # createOrder(symbol, 1, asdf) -> 'Illegal characters found in parameter 'price'
                     '-1101': BadRequest,  # Too many parameters; expected %s and received %s.
-                    '-1102': BadRequest,  # Param %s or %s must be sent, but both were empty
+                    '-1102': BadRequest,  # Param %s or %s must be sent, but both were empty  # {"code":-1102,"msg":"timestamp IllegalArgumentException.","data":null}
                     '-1103': BadRequest,  # An unknown parameter was sent.
                     '-1104': BadRequest,  # Not all sent parameters were read, read 8 parameters but was sent 9
                     '-1105': BadRequest,  # Parameter %s was empty.
@@ -467,26 +617,22 @@ class bitrue(Exchange, ImplicitAPI):
                     '-4051': InsufficientFunds,  # {"code":-4051,"msg":"Isolated balance insufficient."}
                 },
                 'broad': {
+                    'Insufficient account balance': InsufficientFunds,  # {"code":-2010,"msg":"Insufficient account balance.","data":null}
                     'has no operation privilege': PermissionDenied,
                     'MAX_POSITION': InvalidOrder,  # {"code":-2010,"msg":"Filter failure: MAX_POSITION"}
                 },
             },
         })
 
-    def currency_to_precision(self, code, fee, networkCode=None):
-        # info is available in currencies only if the user has configured his api keys
-        if self.safe_value(self.currencies[code], 'precision') is not None:
-            return self.decimal_to_precision(fee, TRUNCATE, self.currencies[code]['precision'], self.precisionMode, self.paddingMode)
-        else:
-            return self.number_to_string(fee)
-
     def nonce(self):
         return self.milliseconds() - self.options['timeDifference']
 
     async def fetch_status(self, params={}):
         """
         the latest known information on the availability of the exchange API
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#test-connectivity
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#test-connectivity
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `status structure <https://docs.ccxt.com/#/?id=exchange-status-structure>`
         """
@@ -510,7 +656,9 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_time(self, params={}):
         """
         fetches the current integer timestamp in milliseconds from the exchange server
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#check-server-time
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#check-server-time
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns int: the current integer timestamp in milliseconds from the exchange server
         """
@@ -522,78 +670,7 @@ class bitrue(Exchange, ImplicitAPI):
         #
         return self.safe_integer(response, 'serverTime')
 
-    def safe_network(self, networkId):
-        uppercaseNetworkId = networkId.upper()
-        networksById = {
-            'Aeternity': 'Aeternity',
-            'AION': 'AION',
-            'Algorand': 'Algorand',
-            'ASK': 'ASK',
-            'ATOM': 'ATOM',
-            'AVAX C-Chain': 'AVAX C-Chain',
-            'bch': 'bch',
-            'BCH': 'BCH',
-            'BEP2': 'BEP2',
-            'BEP20': 'BEP20',
-            'Bitcoin': 'Bitcoin',
-            'BRP20': 'BRP20',
-            'Cardano': 'ADA',
-            'CasinoCoin': 'CasinoCoin',
-            'CasinoCoin XRPL': 'CasinoCoin XRPL',
-            'Contentos': 'Contentos',
-            'Dash': 'Dash',
-            'Decoin': 'Decoin',
-            'DeFiChain': 'DeFiChain',
-            'DGB': 'DGB',
-            'Divi': 'Divi',
-            'dogecoin': 'DOGE',
-            'EOS': 'EOS',
-            'ERC20': 'ERC20',
-            'ETC': 'ETC',
-            'Filecoin': 'Filecoin',
-            'FREETON': 'FREETON',
-            'HBAR': 'HBAR',
-            'Hedera Hashgraph': 'Hedera Hashgraph',
-            'HRC20': 'HRC20',
-            'ICON': 'ICON',
-            'ICP': 'ICP',
-            'Ignis': 'Ignis',
-            'Internet Computer': 'Internet Computer',
-            'IOTA': 'IOTA',
-            'KAVA': 'KAVA',
-            'KSM': 'KSM',
-            'LiteCoin': 'LiteCoin',
-            'Luna': 'Luna',
-            'MATIC': 'MATIC',
-            'Mobile Coin': 'Mobile Coin',
-            'MonaCoin': 'MonaCoin',
-            'Monero': 'Monero',
-            'NEM': 'NEM',
-            'NEP5': 'NEP5',
-            'OMNI': 'OMNI',
-            'PAC': 'PAC',
-            'Polkadot': 'Polkadot',
-            'Ravencoin': 'Ravencoin',
-            'Safex': 'Safex',
-            'SOLANA': 'SOL',
-            'Songbird': 'Songbird',
-            'Stellar Lumens': 'Stellar Lumens',
-            'Symbol': 'Symbol',
-            'Tezos': 'XTZ',
-            'theta': 'theta',
-            'THETA': 'THETA',
-            'TRC20': 'TRC20',
-            'VeChain': 'VeChain',
-            'VECHAIN': 'VECHAIN',
-            'Wanchain': 'Wanchain',
-            'XinFin Network': 'XinFin Network',
-            'XRP': 'XRP',
-            'XRPL': 'XRPL',
-            'ZIL': 'ZIL',
-        }
-        return self.safe_string_2(networksById, networkId, uppercaseNetworkId, networkId)
-
-    async def fetch_currencies(self, params={}):
+    async def fetch_currencies(self, params={}) -> Currencies:
         """
         fetches all available currencies on an exchange
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -646,8 +723,8 @@ class bitrue(Exchange, ImplicitAPI):
         #         ],
         #     }
         #
-        result = {}
-        coins = self.safe_value(response, 'coins', [])
+        result: dict = {}
+        coins = self.safe_list(response, 'coins', [])
         for i in range(0, len(coins)):
             currency = coins[i]
             id = self.safe_string(currency, 'coin')
@@ -658,15 +735,15 @@ class bitrue(Exchange, ImplicitAPI):
             minWithdrawString = None
             maxWithdrawString = None
             minWithdrawFeeString = None
-            networkDetails = self.safe_value(currency, 'chainDetail', [])
-            networks = {}
+            networkDetails = self.safe_list(currency, 'chainDetail', [])
+            networks: dict = {}
             for j in range(0, len(networkDetails)):
                 entry = networkDetails[j]
                 networkId = self.safe_string(entry, 'chain')
                 network = self.network_id_to_code(networkId, code)
-                enableDeposit = self.safe_value(entry, 'enableDeposit')
+                enableDeposit = self.safe_bool(entry, 'enableDeposit')
                 deposit = enableDeposit if (enableDeposit) else deposit
-                enableWithdraw = self.safe_value(entry, 'enableWithdraw')
+                enableWithdraw = self.safe_bool(entry, 'enableWithdraw')
                 withdraw = enableWithdraw if (enableWithdraw) else withdraw
                 networkWithdrawFeeString = self.safe_string(entry, 'withdrawFee')
                 if networkWithdrawFeeString is not None:
@@ -714,12 +791,14 @@ class bitrue(Exchange, ImplicitAPI):
             }
         return result
 
-    async def fetch_markets(self, params={}):
+    async def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for bitrue
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#exchangeInfo_endpoint
-        :see: https://www.bitrue.com/api-docs#current-open-contract
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#current-open-contract
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#exchangeInfo_endpoint
+        https://www.bitrue.com/api-docs#current-open-contract
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#current-open-contract
+
         :param dict [params]: extra parameters specific to the exchange api endpoint
         :returns dict[]: an array of objects representing market data
         """
@@ -810,7 +889,7 @@ class bitrue(Exchange, ImplicitAPI):
             await self.load_time_difference()
         return self.parse_markets(markets)
 
-    def parse_market(self, market) -> Market:
+    def parse_market(self, market: dict) -> Market:
         id = self.safe_string(market, 'symbol')
         lowercaseId = self.safe_string_lower(market, 'symbol')
         side = self.safe_integer(market, 'side')  # 1 linear, 0 inverse, None spot
@@ -842,11 +921,11 @@ class bitrue(Exchange, ImplicitAPI):
         symbol = base + '/' + quote
         if settle is not None:
             symbol += ':' + settle
-        filters = self.safe_value(market, 'filters', [])
+        filters = self.safe_list(market, 'filters', [])
         filtersByType = self.index_by(filters, 'filterType')
         status = self.safe_string(market, 'status')
-        priceFilter = self.safe_value(filtersByType, 'PRICE_FILTER', {})
-        amountFilter = self.safe_value(filtersByType, 'LOT_SIZE', {})
+        priceFilter = self.safe_dict(filtersByType, 'PRICE_FILTER', {})
+        amountFilter = self.safe_dict(filtersByType, 'LOT_SIZE', {})
         defaultPricePrecision = self.safe_string(market, 'pricePrecision')
         defaultAmountPrecision = self.safe_string(market, 'quantityPrecision')
         pricePrecision = self.safe_string(priceFilter, 'priceScale', defaultPricePrecision)
@@ -956,7 +1035,7 @@ class bitrue(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        result = {
+        result: dict = {
             'info': response,
         }
         timestamp = self.safe_integer(response, 'updateTime')
@@ -976,9 +1055,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_balance(self, params={}) -> Balances:
         """
         query for balance and get the amount of funds available for trading or funds locked in orders
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#account-information-user_data
-        :see: https://www.bitrue.com/api-docs#account-information-v2-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#account-information-v2-user_data-hmac-sha256
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#account-information-user_data
+        https://www.bitrue.com/api-docs#account-information-v2-user_data-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#account-information-v2-user_data-hmac-sha256
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.type]: 'future', 'delivery', 'spot', 'swap'
         :param str [params.subType]: 'linear', 'inverse'
@@ -994,7 +1075,7 @@ class bitrue(Exchange, ImplicitAPI):
         if type == 'swap':
             if subType is not None and subType == 'inverse':
                 response = await self.dapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 # {
                 #         "code":"0",
@@ -1027,7 +1108,7 @@ class bitrue(Exchange, ImplicitAPI):
                 #
             else:
                 response = await self.fapiV2PrivateGetAccount(params)
-                result = self.safe_value(response, 'data', {})
+                result = self.safe_dict(response, 'data', {})
                 #
                 #     {
                 #         "code":"0",
@@ -1083,9 +1164,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#order-book
-        :see: https://www.bitrue.com/api-docs#order-book
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#order-book
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#order-book
+        https://www.bitrue.com/api-docs#order-book
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#order-book
+
         :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
@@ -1095,7 +1178,7 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(symbol)
         response = None
         if market['swap']:
-            request = {
+            request: dict = {
                 'contractName': market['id'],
             }
             if limit is not None:
@@ -1107,7 +1190,7 @@ class bitrue(Exchange, ImplicitAPI):
             elif market['inverse']:
                 response = await self.dapiV1PublicGetDepth(self.extend(request, params))
         elif market['spot']:
-            request = {
+            request: dict = {
                 'symbol': market['id'],
             }
             if limit is not None:
@@ -1147,7 +1230,7 @@ class bitrue(Exchange, ImplicitAPI):
         orderbook['nonce'] = self.safe_integer(response, 'lastUpdateId')
         return orderbook
 
-    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
+    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
         #
         # fetchBidsAsks
         #
@@ -1217,9 +1300,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#24hr-ticker-price-change-statistics
-        :see: https://www.bitrue.com/api-docs#ticker
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#ticker
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#24hr-ticker-price-change-statistics
+        https://www.bitrue.com/api-docs#ticker
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#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>`
@@ -1229,7 +1314,7 @@ class bitrue(Exchange, ImplicitAPI):
         response = None
         data = None
         if market['swap']:
-            request = {
+            request: dict = {
                 'contractName': market['id'],
             }
             if market['linear']:
@@ -1238,11 +1323,11 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.dapiV1PublicGetTicker(self.extend(request, params))
             data = response
         elif market['spot']:
-            request = {
+            request: dict = {
                 'symbol': market['id'],
             }
             response = await self.spotV1PublicGetTicker24hr(self.extend(request, params))
-            data = self.safe_value(response, 0, {})
+            data = self.safe_dict(response, 0, {})
         else:
             raise NotSupported(self.id + ' fetchTicker only support spot & swap markets')
         #
@@ -1288,9 +1373,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#kline-data
-        :see: https://www.bitrue.com/api-docs#kline-candlestick-data
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#kline-candlestick-data
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#kline-data
+        https://www.bitrue.com/api_docs_includes_file/futures/index.html#kline-candlestick-data
+
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -1300,19 +1386,17 @@ class bitrue(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        timeframes = self.safe_value(self.options, 'timeframes', {})
+        timeframes = self.safe_dict(self.options, 'timeframes', {})
         response = None
         data = None
         if market['swap']:
-            timeframesFuture = self.safe_value(timeframes, 'future', {})
-            request = {
+            timeframesFuture = self.safe_dict(timeframes, 'future', {})
+            request: dict = {
                 'contractName': market['id'],
                 # 1min / 5min / 15min / 30min / 1h / 1day / 1week / 1month
                 'interval': self.safe_string(timeframesFuture, timeframe, '1min'),
             }
             if limit is not None:
-                if limit > 300:
-                    limit = 300
                 request['limit'] = limit
             if market['linear']:
                 response = await self.fapiV1PublicGetKlines(self.extend(request, params))
@@ -1320,20 +1404,18 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.dapiV1PublicGetKlines(self.extend(request, params))
             data = response
         elif market['spot']:
-            timeframesSpot = self.safe_value(timeframes, 'spot', {})
-            request = {
+            timeframesSpot = self.safe_dict(timeframes, 'spot', {})
+            request: dict = {
                 'symbol': market['id'],
                 # 1m / 5m / 15m / 30m / 1H / 2H / 4H / 12H / 1D / 1W
                 'scale': self.safe_string(timeframesSpot, timeframe, '1m'),
             }
             if limit is not None:
-                if limit > 1440:
-                    limit = 1440
                 request['limit'] = limit
             if since is not None:
                 request['fromIdx'] = since
             response = await self.spotV1PublicGetMarketKline(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         else:
             raise NotSupported(self.id + ' fetchOHLCV only support spot & swap markets')
         #
@@ -1410,9 +1492,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_bids_asks(self, symbols: Strings = None, params={}):
         """
         fetches the bid and ask price and volume for multiple markets
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#symbol-order-book-ticker
-        :see: https://www.bitrue.com/api-docs#ticker
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#ticker
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#symbol-order-book-ticker
+        https://www.bitrue.com/api-docs#ticker
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#ticker
+
         :param str[]|None symbols: unified symbols of the markets to fetch the bids and asks for, all markets are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -1423,7 +1507,7 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(first)
         response = None
         if market['swap']:
-            request = {
+            request: dict = {
                 'contractName': market['id'],
             }
             if market['linear']:
@@ -1431,7 +1515,7 @@ class bitrue(Exchange, ImplicitAPI):
             elif market['inverse']:
                 response = await self.dapiV1PublicGetTicker(self.extend(request, params))
         elif market['spot']:
-            request = {
+            request: dict = {
                 'symbol': market['id'],
             }
             response = await self.spotV1PublicGetTickerBookTicker(self.extend(request, params))
@@ -1461,16 +1545,18 @@ class bitrue(Exchange, ImplicitAPI):
         #         "time": 1699348013000
         #     }
         #
-        data = {}
+        data: dict = {}
         data[market['id']] = response
         return self.parse_tickers(data, symbols)
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#24hr-ticker-price-change-statistics
-        :see: https://www.bitrue.com/api-docs#ticker
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#ticker
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#24hr-ticker-price-change-statistics
+        https://www.bitrue.com/api-docs#ticker
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#ticker
+
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -1479,7 +1565,7 @@ class bitrue(Exchange, ImplicitAPI):
         symbols = self.market_symbols(symbols)
         response = None
         data = None
-        request = {}
+        request: dict = {}
         type = None
         if symbols is not None:
             first = self.safe_string(symbols, 0)
@@ -1538,14 +1624,14 @@ class bitrue(Exchange, ImplicitAPI):
         # the exchange returns market ids with an underscore from the tickers endpoint
         # the market ids do not have an underscore, so it has to be removed
         # https://github.com/ccxt/ccxt/issues/13856
-        tickers = {}
+        tickers: dict = {}
         for i in range(0, len(data)):
-            ticker = self.safe_value(data, i, {})
+            ticker = self.safe_dict(data, i, {})
             market = self.market(self.safe_value(ticker, 'symbol'))
             tickers[market['id']] = ticker
         return self.parse_tickers(tickers, symbols)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades
         #
@@ -1602,8 +1688,8 @@ class bitrue(Exchange, ImplicitAPI):
         orderId = self.safe_string(trade, 'orderId')
         id = self.safe_string_2(trade, 'id', 'tradeId')
         side = None
-        buyerMaker = self.safe_value(trade, 'isBuyerMaker')  # ignore "m" until Bitrue fixes api
-        isBuyer = self.safe_value(trade, 'isBuyer')
+        buyerMaker = self.safe_bool(trade, 'isBuyerMaker')  # ignore "m" until Bitrue fixes api
+        isBuyer = self.safe_bool(trade, 'isBuyer')
         if buyerMaker is not None:
             side = 'sell' if buyerMaker else 'buy'
         if isBuyer is not None:
@@ -1615,7 +1701,7 @@ class bitrue(Exchange, ImplicitAPI):
                 'currency': self.safe_currency_code(self.safe_string(trade, 'commissionAssert')),
             }
         takerOrMaker = None
-        isMaker = self.safe_value(trade, 'isMaker')
+        isMaker = self.safe_bool(trade, 'isMaker')
         if isMaker is not None:
             takerOrMaker = 'maker' if isMaker else 'taker'
         return self.safe_trade({
@@ -1637,7 +1723,9 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_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://github.com/Bitrue-exchange/Spot-official-api-docs#recent-trades-list
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#recent-trades-list
+
         :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
@@ -1648,7 +1736,7 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(symbol)
         response = None
         if market['spot']:
-            request = {
+            request: dict = {
                 'symbol': market['id'],
                 # 'limit': 100,  # default 100, max = 1000
             }
@@ -1673,8 +1761,8 @@ class bitrue(Exchange, ImplicitAPI):
         #
         return self.parse_trades(response, market, since, limit)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'INIT': 'open',
             'PENDING_CREATE': 'open',
             'NEW': 'open',
@@ -1687,7 +1775,7 @@ class bitrue(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # createOrder - spot
         #
@@ -1768,14 +1856,13 @@ class bitrue(Exchange, ImplicitAPI):
         id = self.safe_string(order, 'orderId')
         type = self.safe_string_lower(order, 'type')
         side = self.safe_string_lower(order, 'side')
-        fills = self.safe_value(order, 'fills', [])
+        fills = self.safe_list(order, 'fills', [])
         clientOrderId = self.safe_string(order, 'clientOrderId')
         timeInForce = self.safe_string(order, 'timeInForce')
         postOnly = (type == 'limit_maker') or (timeInForce == 'GTX') or (type == 'post_only')
         if type == 'limit_maker':
             type = 'limit'
-        stopPriceString = self.safe_string(order, 'stopPrice')
-        stopPrice = self.parse_number(self.omit_zero(stopPriceString))
+        triggerPrice = self.parse_number(self.omit_zero(self.safe_string(order, 'stopPrice')))
         return self.safe_order({
             'info': order,
             'id': id,
@@ -1789,8 +1876,7 @@ class bitrue(Exchange, ImplicitAPI):
             'postOnly': postOnly,
             'side': side,
             'price': price,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'triggerPrice': triggerPrice,
             'amount': amount,
             'cost': cost,
             'average': average,
@@ -1804,8 +1890,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """
         create a market buy order by providing the symbol and cost
-        :see: https://www.bitrue.com/api-docs#new-order-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#new-order-trade-hmac-sha256
+
+        https://www.bitrue.com/api-docs#new-order-trade-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#new-order-trade-hmac-sha256
+
         :param str symbol: unified symbol of the market to create an order in
         :param float cost: how much you want to trade in units of the quote currency
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1821,14 +1909,15 @@ class bitrue(Exchange, ImplicitAPI):
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
         create a trade order
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#recent-trades-list
-        :see: https://www.bitrue.com/api-docs#new-order-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#new-order-trade-hmac-sha256
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#new-order-trade
+        https://www.bitrue.com/api_docs_includes_file/futures/index.html#new-order-trade-hmac-sha256
+
         :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'
         :param float amount: how much of currency you want to trade in units of base currency
-        :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param float [params.triggerPrice]: *spot only* the price at which a trigger order is triggered at
         :param str [params.clientOrderId]: a unique id for the order, automatically generated if not sent
@@ -1836,7 +1925,7 @@ class bitrue(Exchange, ImplicitAPI):
         :param str [params.timeInForce]: 'fok', 'ioc' or 'po'
         :param bool [params.postOnly]: default False
         :param bool [params.reduceOnly]: default False
-         * EXCHANGE SPECIFIC PARAMETERS
+ EXCHANGE SPECIFIC PARAMETERS
         :param decimal [params.icebergQty]:
         :param long [params.recvWindow]:
         :param float [params.cost]: *swap market buy only* the quote quantity that can be used alternative for the amount
@@ -1847,7 +1936,7 @@ class bitrue(Exchange, ImplicitAPI):
         response = None
         data = None
         uppercaseType = type.upper()
-        request = {
+        request: dict = {
             'side': side.upper(),
             'type': uppercaseType,
             # 'timeInForce': '',
@@ -1898,7 +1987,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivatePostOrder(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivatePostOrder(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['symbol'] = market['id']
             request['quantity'] = self.amount_to_precision(symbol, amount)
@@ -1909,10 +1998,10 @@ class bitrue(Exchange, ImplicitAPI):
             if clientOrderId is not None:
                 params = self.omit(params, ['newClientOrderId', 'clientOrderId'])
                 request['newClientOrderId'] = clientOrderId
-            stopPrice = self.safe_value_2(params, 'triggerPrice', 'stopPrice')
-            if stopPrice is not None:
+            triggerPrice = self.safe_value_2(params, 'triggerPrice', 'stopPrice')
+            if triggerPrice is not None:
                 params = self.omit(params, ['triggerPrice', 'stopPrice'])
-                request['stopPrice'] = self.price_to_precision(symbol, stopPrice)
+                request['stopPrice'] = self.price_to_precision(symbol, triggerPrice)
             response = await self.spotV1PrivatePostOrder(self.extend(request, params))
             data = response
         else:
@@ -1943,9 +2032,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#query-order-user_data
-        :see: https://www.bitrue.com/api-docs#query-order-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#query-order-user_data-hmac-sha256
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#query-order-user_data
+        https://www.bitrue.com/api_docs_includes_file/futures/index.html#query-order-user_data-hmac-sha256
+
+        :param str id: the order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1958,7 +2049,7 @@ class bitrue(Exchange, ImplicitAPI):
         params = self.omit(params, ['origClientOrderId', 'clientOrderId'])
         response = None
         data = None
-        request = {}
+        request: dict = {}
         if origClientOrderId is None:
             request['orderId'] = id
         else:
@@ -1972,7 +2063,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivateGetOrder(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivateGetOrder(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['orderId'] = id  # spot market id is mandatory
             request['symbol'] = market['id']
@@ -2028,7 +2119,9 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple closed orders made by the user
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#all-orders-user_data
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#all-orders-user_data
+
         :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
@@ -2041,7 +2134,7 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['spot']:
             raise NotSupported(self.id + ' fetchClosedOrders only support spot markets')
-        request = {
+        request: dict = {
             'symbol': market['id'],
             # 'orderId': 123445,  # long
             # 'startTime': since,
@@ -2080,9 +2173,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetch all unfilled currently open orders
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#current-open-orders-user_data
-        :see: https://www.bitrue.com/api-docs#current-all-open-orders-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#current-all-open-orders-user_data-hmac-sha256
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#current-open-orders-user_data
+        https://www.bitrue.com/api_docs_includes_file/futures/index.html#cancel-all-open-orders-trade-hmac-sha256
+
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of open order structures to retrieve
@@ -2095,14 +2189,14 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(symbol)
         response = None
         data = None
-        request = {}
+        request: dict = {}
         if market['swap']:
             request['contractName'] = market['id']
             if market['linear']:
                 response = await self.fapiV2PrivateGetOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivateGetOpenOrders(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         elif market['spot']:
             request['symbol'] = market['id']
             response = await self.spotV1PrivateGetOpenOrders(self.extend(request, params))
@@ -2160,9 +2254,11 @@ class bitrue(Exchange, ImplicitAPI):
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#cancel-order-trade
-        :see: https://www.bitrue.com/api-docs#cancel-order-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#cancel-order-trade-hmac-sha256
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#cancel-order-trade
+        https://www.bitrue.com/api-docs#cancel-order-trade-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#cancel-order-trade-hmac-sha256
+
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2176,7 +2272,7 @@ class bitrue(Exchange, ImplicitAPI):
         params = self.omit(params, ['origClientOrderId', 'clientOrderId'])
         response = None
         data = None
-        request = {}
+        request: dict = {}
         if origClientOrderId is None:
             request['orderId'] = id
         else:
@@ -2190,7 +2286,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivatePostCancel(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivatePostCancel(self.extend(request, params))
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
         elif market['spot']:
             request['symbol'] = market['id']
             response = await self.spotV1PrivateDeleteOrder(self.extend(request, params))
@@ -2222,8 +2318,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
         cancel all open orders in a market
-        :see: https://www.bitrue.com/api-docs#cancel-all-open-orders-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#cancel-all-open-orders-trade-hmac-sha256
+
+        https://www.bitrue.com/api-docs#cancel-all-open-orders-trade-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#cancel-all-open-orders-trade-hmac-sha256
+
         :param str symbol: unified market symbol of the market to cancel orders in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.marginMode]: 'cross' or 'isolated', for spot margin trading
@@ -2234,14 +2332,14 @@ class bitrue(Exchange, ImplicitAPI):
         response = None
         data = None
         if market['swap']:
-            request = {
+            request: dict = {
                 'contractName': market['id'],
             }
             if market['linear']:
                 response = await self.fapiV2PrivatePostAllOpenOrders(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivatePostAllOpenOrders(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         else:
             raise NotSupported(self.id + ' cancelAllOrders only support future markets')
         #
@@ -2258,9 +2356,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#account-trade-list-user_data
-        :see: https://www.bitrue.com/api-docs#account-trade-list-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#account-trade-list-user_data-hmac-sha256
+
+        https://www.bitrue.com/api_docs_includes_file/spot/index.html#account-trade-list-user_data
+        https://www.bitrue.com/api_docs_includes_file/futures/index.html#account-trade-list-user_data-hmac-sha256
+
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trades structures to retrieve
@@ -2273,7 +2372,7 @@ class bitrue(Exchange, ImplicitAPI):
         market = self.market(symbol)
         response = None
         data = None
-        request = {}
+        request: dict = {}
         if since is not None:
             request['startTime'] = since
         if limit is not None:
@@ -2286,7 +2385,7 @@ class bitrue(Exchange, ImplicitAPI):
                 response = await self.fapiV2PrivateGetMyTrades(self.extend(request, params))
             elif market['inverse']:
                 response = await self.dapiV2PrivateGetMyTrades(self.extend(request, params))
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
         elif market['spot']:
             request['symbol'] = market['id']
             response = await self.spotV2PrivateGetMyTrades(self.extend(request, params))
@@ -2343,7 +2442,9 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch all deposits made to an account
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#deposit-history--withdraw_data
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#deposit-history--withdraw_data
+
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch deposits for
         :param int [limit]: the maximum number of deposits structures to retrieve
@@ -2354,7 +2455,7 @@ class bitrue(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchDeposits() requires a code argument')
         await self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'coin': currency['id'],
             'status': 1,  # 0 init, 1 finished, default 0
             # 'offset': 0,
@@ -2404,13 +2505,15 @@ class bitrue(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_transactions(data, currency, since, limit)
 
     async def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch all withdrawals made from an account
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#withdraw-history--withdraw_data
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#withdraw-history--withdraw_data
+
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch withdrawals for
         :param int [limit]: the maximum number of withdrawals structures to retrieve
@@ -2421,7 +2524,7 @@ class bitrue(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchWithdrawals() requires a code argument')
         await self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'coin': currency['id'],
             'status': 5,  # 0 init, 5 finished, 6 canceled, default 0
             # 'offset': 0,
@@ -2462,7 +2565,7 @@ class bitrue(Exchange, ImplicitAPI):
         return self.parse_transactions(data, currency)
 
     def parse_transaction_status_by_type(self, status, type=None):
-        statusesByType = {
+        statusesByType: dict = {
             'deposit': {
                 '0': 'pending',
                 '1': 'ok',
@@ -2473,10 +2576,10 @@ class bitrue(Exchange, ImplicitAPI):
                 '6': 'canceled',
             },
         }
-        statuses = self.safe_value(statusesByType, type, {})
+        statuses = self.safe_dict(statusesByType, type, {})
         return self.safe_string(statuses, status, status)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         # fetchDeposits
         #
@@ -2596,10 +2699,12 @@ class bitrue(Exchange, ImplicitAPI):
             'fee': fee,
         }
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
         make a withdrawal
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#withdraw-commit--withdraw_data
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#withdraw-commit--withdraw_data
+
         :param str code: unified currency code
         :param float amount: the amount to withdraw
         :param str address: the address to withdraw to
@@ -2611,7 +2716,7 @@ class bitrue(Exchange, ImplicitAPI):
         self.check_address(address)
         await self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'coin': currency['id'],
             'amount': amount,
             'addressTo': address,
@@ -2642,7 +2747,7 @@ class bitrue(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data, currency)
 
     def parse_deposit_withdraw_fee(self, fee, currency: Currency = None):
@@ -2654,9 +2759,9 @@ class bitrue(Exchange, ImplicitAPI):
         #       "chainDetail": [[Object]]
         #   }
         #
-        chainDetails = self.safe_value(fee, 'chainDetail', [])
+        chainDetails = self.safe_list(fee, 'chainDetail', [])
         chainDetailLength = len(chainDetails)
-        result = {
+        result: dict = {
             'info': fee,
             'withdraw': {
                 'fee': None,
@@ -2686,14 +2791,16 @@ class bitrue(Exchange, ImplicitAPI):
     async def fetch_deposit_withdraw_fees(self, codes: Strings = None, params={}):
         """
         fetch deposit and withdraw fees
-        :see: https://github.com/Bitrue-exchange/Spot-official-api-docs#exchangeInfo_endpoint
+
+        https://github.com/Bitrue-exchange/Spot-official-api-docs#exchangeInfo_endpoint
+
         :param str[]|None codes: list of unified currency codes
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a list of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>`
         """
         await self.load_markets()
         response = await self.spotV1PublicGetExchangeInfo(params)
-        coins = self.safe_value(response, 'coins')
+        coins = self.safe_list(response, 'coins')
         return self.parse_deposit_withdraw_fees(coins, codes, 'coin')
 
     def parse_transfer(self, transfer, currency=None):
@@ -2732,11 +2839,13 @@ class bitrue(Exchange, ImplicitAPI):
             'status': 'ok',
         }
 
-    async def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
+    async def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[TransferEntry]:
         """
         fetch a history of internal transfers made on an account
-        :see: https://www.bitrue.com/api-docs#get-future-account-transfer-history-list-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#get-future-account-transfer-history-list-user_data-hmac-sha256
+
+        https://www.bitrue.com/api-docs#get-future-account-transfer-history-list-user_data-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#get-future-account-transfer-history-list-user_data-hmac-sha256
+
         :param str code: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
         :param int [limit]: the maximum number of transfers structures to retrieve
@@ -2747,7 +2856,7 @@ class bitrue(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         type = self.safe_string_2(params, 'type', 'transferType')
-        request = {
+        request: dict = {
             'transferType': type,
         }
         currency = None
@@ -2784,8 +2893,10 @@ class bitrue(Exchange, ImplicitAPI):
     async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
-        :see: https://www.bitrue.com/api-docs#new-future-account-transfer-user_data-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#user-commission-rate-user_data-hmac-sha256
+
+        https://www.bitrue.com/api-docs#new-future-account-transfer-user_data-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#user-commission-rate-user_data-hmac-sha256
+
         :param str code: unified currency code
         :param float amount: amount to transfer
         :param str fromAccount: account to transfer from
@@ -2795,10 +2906,10 @@ class bitrue(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         currency = self.currency(code)
-        accountTypes = self.safe_value(self.options, 'accountsByType', {})
+        accountTypes = self.safe_dict(self.options, 'accountsByType', {})
         fromId = self.safe_string(accountTypes, fromAccount, fromAccount)
         toId = self.safe_string(accountTypes, toAccount, toAccount)
-        request = {
+        request: dict = {
             'coinSymbol': currency['id'],
             'amount': self.currency_to_precision(code, amount),
             'transferType': fromId + '_to_' + toId,
@@ -2811,14 +2922,16 @@ class bitrue(Exchange, ImplicitAPI):
         #         'data': null
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transfer(data, currency)
 
     async def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         """
         set the level of leverage for a market
-        :see: https://www.bitrue.com/api-docs#change-initial-leverage-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#change-initial-leverage-trade-hmac-sha256
+
+        https://www.bitrue.com/api-docs#change-initial-leverage-trade-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#change-initial-leverage-trade-hmac-sha256
+
         :param float leverage: the rate of leverage
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2831,7 +2944,7 @@ class bitrue(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         response = None
-        request = {
+        request: dict = {
             'contractName': market['id'],
             'leverage': leverage,
         }
@@ -2843,21 +2956,36 @@ class bitrue(Exchange, ImplicitAPI):
             response = await self.dapiV2PrivatePostLevelEdit(self.extend(request, params))
         return response
 
-    def parse_margin_modification(self, data, market=None):
+    def parse_margin_modification(self, data, market=None) -> MarginModification:
+        #
+        # setMargin
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "success"
+        #         "data": null
+        #     }
+        #
         return {
             'info': data,
+            'symbol': market['symbol'],
             'type': None,
+            'marginMode': 'isolated',
             'amount': None,
+            'total': None,
             'code': None,
-            'symbol': market['symbol'],
             'status': None,
+            'timestamp': None,
+            'datetime': None,
         }
 
-    async def set_margin(self, symbol: str, amount: float, params={}):
+    async def set_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
         """
         Either adds or reduces margin in an isolated position in order to set the margin to a specific value
-        :see: https://www.bitrue.com/api-docs#modify-isolated-position-margin-trade-hmac-sha256
-        :see: https://www.bitrue.com/api_docs_includes_file/delivery.html#modify-isolated-position-margin-trade-hmac-sha256
+
+        https://www.bitrue.com/api-docs#modify-isolated-position-margin-trade-hmac-sha256
+        https://www.bitrue.com/api_docs_includes_file/delivery.html#modify-isolated-position-margin-trade-hmac-sha256
+
         :param str symbol: unified market symbol of the market to set margin in
         :param float amount: the amount to set the margin to
         :param dict [params]: parameters specific to the exchange API endpoint
@@ -2868,7 +2996,7 @@ class bitrue(Exchange, ImplicitAPI):
         if not market['swap']:
             raise NotSupported(self.id + ' setMargin only support swap markets')
         response = None
-        request = {
+        request: dict = {
             'contractName': market['id'],
             'amount': self.parse_to_numeric(amount),
         }
@@ -2890,7 +3018,7 @@ class bitrue(Exchange, ImplicitAPI):
         version = self.safe_string(api, 1)
         access = self.safe_string(api, 2)
         url = None
-        if type == 'api' and version == 'kline':
+        if (type == 'api' and version == 'kline') or (type == 'open' and path.find('listenKey') >= 0):
             url = self.urls['api'][type]
         else:
             url = self.urls['api'][type] + '/' + version
@@ -2899,7 +3027,7 @@ class bitrue(Exchange, ImplicitAPI):
         if access == 'private':
             self.check_required_credentials()
             recvWindow = self.safe_integer(self.options, 'recvWindow', 5000)
-            if type == 'spot':
+            if type == 'spot' or type == 'open':
                 query = self.urlencode(self.extend({
                     'timestamp': self.nonce(),
                     'recvWindow': recvWindow,
@@ -2924,6 +3052,10 @@ class bitrue(Exchange, ImplicitAPI):
                 signPath = signPath + '/' + version + '/' + path
                 signMessage = timestamp + method + signPath
                 if method == 'GET':
+                    keys = list(params.keys())
+                    keysLength = len(keys)
+                    if keysLength > 0:
+                        signMessage += '?' + self.urlencode(params)
                     signature = self.hmac(self.encode(signMessage), self.encode(self.secret), hashlib.sha256)
                     headers = {
                         'X-CH-APIKEY': self.apiKey,
@@ -2936,7 +3068,7 @@ class bitrue(Exchange, ImplicitAPI):
                         'recvWindow': recvWindow,
                     }, params)
                     body = self.json(query)
-                    signMessage = signMessage + json.dumps(body)
+                    signMessage += body
                     signature = self.hmac(self.encode(signMessage), self.encode(self.secret), hashlib.sha256)
                     headers = {
                         'Content-Type': 'application/json',
@@ -2949,7 +3081,7 @@ class bitrue(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(params)
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
+    def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
         if (code == 418) or (code == 429):
             raise DDoSProtection(self.id + ' ' + str(code) + ' ' + reason + ' ' + body)
         # error response in a form: {"code": -1013, "msg": "Invalid quantity."}