ccxt 4.4.80__py2.py3-none-any.whl → 4.4.82__py2.py3-none-any.whl

ccxt/async_support/hyperliquid.py

@@ -2179,6 +2179,10 @@ class hyperliquid(Exchange, ImplicitAPI):
         return self.parse_order(data, market)
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
+        #
+        # createOrdersWs error
+        #
+        #  {error: 'Insufficient margin to place order. asset=159'}
         #
         #  fetchOpenOrders
         #
@@ -2270,6 +2274,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         #     "triggerPx": "0.6"
         # }
         #
+        error = self.safe_string(order, 'error')
+        if error is not None:
+            return self.safe_order({
+                'info': order,
+                'status': 'rejected',
+            })
         entry = self.safe_dict_n(order, ['order', 'resting', 'filled'])
         if entry is None:
             entry = order
@@ -3445,9 +3455,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         # {"status":"ok","response":{"type":"order","data":{"statuses":[{"error":"Insufficient margin to place order. asset=84"}]}}}
         #
         status = self.safe_string(response, 'status', '')
+        error = self.safe_string(response, 'error')
         message = None
         if status == 'err':
             message = self.safe_string(response, 'response')
+        elif error is not None:
+            message = error
         else:
             responsePayload = self.safe_dict(response, 'response', {})
             data = self.safe_dict(responsePayload, 'data', {})

ccxt/async_support/okx.py

@@ -1648,7 +1648,6 @@ class okx(Exchange, ImplicitAPI):
                     ymd = self.yymmdd(expiry)
                     symbol = symbol + '-' + ymd + '-' + strikePrice + '-' + optionType
                     optionType = 'put' if (optionType == 'P') else 'call'
-        tickSize = self.safe_string(market, 'tickSz')
         fees = self.safe_dict_2(self.fees, type, 'trading', {})
         maxLeverage = self.safe_string(market, 'lever', '1')
         maxLeverage = Precise.string_max(maxLeverage, '1')
@@ -1680,7 +1679,7 @@ class okx(Exchange, ImplicitAPI):
             'created': self.safe_integer(market, 'listTime'),
             'precision': {
                 'amount': self.safe_number(market, 'lotSz'),
-                'price': self.parse_number(tickSize),
+                'price': self.safe_number(market, 'tickSz'),
             },
             'limits': {
                 'leverage': {

ccxt/async_support/oxfun.py

@@ -84,7 +84,7 @@ class oxfun(Exchange, ImplicitAPI):
                 'fetchDepositWithdrawFee': False,
                 'fetchDepositWithdrawFees': False,
                 'fetchFundingHistory': True,
-                'fetchFundingRate': 'emulated',
+                'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
                 'fetchFundingRates': True,
                 'fetchIndexOHLCV': False,
@@ -1104,6 +1104,26 @@ class oxfun(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_funding_rates(data, symbols)
 
+    async def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
+        """
+        fetch the current funding rates for a symbol
+
+        https://docs.ox.fun/?json#get-v3-funding-estimates
+
+        :param str symbol: unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
+        """
+        await self.load_markets()
+        request: dict = {
+            'marketCode': self.market_id(symbol),
+        }
+        response = await self.publicGetV3FundingEstimates(self.extend(request, params))
+        #
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        return self.parse_funding_rate(first, self.market(symbol))
+
     def parse_funding_rate(self, fundingRate, market: Market = None) -> FundingRate:
         #
         #     {

ccxt/base/errors.py

@@ -1,3 +1,9 @@
+# ----------------------------------------------------------------------------
+
+# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+# EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
 error_hierarchy = {
     'BaseError': {
         'ExchangeError': {

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.82'
 
 # -----------------------------------------------------------------------------
 
@@ -1000,7 +1000,7 @@ class Exchange(object):
         return string
 
     @staticmethod
-    def urlencode(params={}, doseq=False):
+    def urlencode(params={}, doseq=False, sort=False):
         newParams = params.copy()
         for key, value in params.items():
             if isinstance(value, bool):
@@ -5522,6 +5522,24 @@ class Exchange(object):
     def create_expired_option_market(self, symbol: str):
         raise NotSupported(self.id + ' createExpiredOptionMarket() is not supported yet')
 
+    def is_leveraged_currency(self, currencyCode, checkBaseCoin: Bool = False, existingCurrencies: dict = None):
+        leverageSuffixes = [
+            '2L', '2S', '3L', '3S', '4L', '4S', '5L', '5S',  # Leveraged Tokens(LT)
+            'UP', 'DOWN',  # exchange-specific(e.g. BLVT)
+            'BULL', 'BEAR',  # similar
+        ]
+        for i in range(0, len(leverageSuffixes)):
+            leverageSuffix = leverageSuffixes[i]
+            if currencyCode.endswith(leverageSuffix):
+                if not checkBaseCoin:
+                    return True
+                else:
+                    # check if base currency is inside dict
+                    baseCurrencyCode = currencyCode.replace(leverageSuffix, '')
+                    if baseCurrencyCode in existingCurrencies:
+                        return True
+        return False
+
     def handle_withdraw_tag_and_params(self, tag, params):
         if (tag is not None) and (isinstance(tag, dict)):
             params = self.extend(tag, params)

ccxt/bigone.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.bigone import ImplicitAPI
-from ccxt.base.types import Any, Balances, Bool, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, 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
@@ -509,19 +509,15 @@ class bigone(Exchange, ImplicitAPI):
             id = self.safe_string(currency, 'symbol')
             code = self.safe_currency_code(id)
             name = self.safe_string(currency, 'name')
-            type = 'fiat' if self.safe_bool(currency, 'is_fiat') else 'crypto'
             networks: dict = {}
             chains = self.safe_list(currency, 'binding_gateways', [])
             currencyMaxPrecision = self.parse_precision(self.safe_string_2(currency, 'withdrawal_scale', 'scale'))
-            currencyDepositEnabled: Bool = None
-            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'gateway_name')
                 networkCode = self.network_id_to_code(networkId)
                 deposit = self.safe_bool(chain, 'is_deposit_enabled')
                 withdraw = self.safe_bool(chain, 'is_withdrawal_enabled')
-                isActive = (deposit and withdraw)
                 minDepositAmount = self.safe_string(chain, 'min_deposit_amount')
                 minWithdrawalAmount = self.safe_string(chain, 'min_withdrawal_amount')
                 withdrawalFee = self.safe_string(chain, 'withdrawal_fee')
@@ -532,7 +528,7 @@ class bigone(Exchange, ImplicitAPI):
                     'margin': None,
                     'deposit': deposit,
                     'withdraw': withdraw,
-                    'active': isActive,
+                    'active': None,
                     'fee': self.parse_number(withdrawalFee),
                     'precision': self.parse_number(precision),
                     'limits': {
@@ -547,19 +543,26 @@ class bigone(Exchange, ImplicitAPI):
                     },
                     'info': chain,
                 }
-                # fill global values
-                currencyDepositEnabled = (currencyDepositEnabled is None) or deposit if deposit else currencyDepositEnabled
-                currencyWithdrawEnabled = (currencyWithdrawEnabled is None) or withdraw if withdraw else currencyWithdrawEnabled
-                currencyMaxPrecision = (currencyMaxPrecision is None) or precision if Precise.string_gt(currencyMaxPrecision, precision) else currencyMaxPrecision
-            result[code] = {
+            chainLength = len(chains)
+            type: Str = None
+            if self.safe_bool(currency, 'is_fiat'):
+                type = 'fiat'
+            elif chainLength == 0:
+                if self.is_leveraged_currency(id):
+                    type = 'leveraged'
+                else:
+                    type = 'other'
+            else:
+                type = 'crypto'
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': name,
                 'type': type,
                 'active': None,
-                'deposit': currencyDepositEnabled,
-                'withdraw': currencyWithdrawEnabled,
+                'deposit': None,
+                'withdraw': None,
                 'fee': None,
                 'precision': self.parse_number(currencyMaxPrecision),
                 'limits': {
@@ -573,7 +576,7 @@ class bigone(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:

ccxt/bingx.py

@@ -766,56 +766,41 @@ class bingx(Exchange, ImplicitAPI):
             name = self.safe_string(entry, 'name')
             networkList = self.safe_list(entry, 'networkList')
             networks: dict = {}
-            fee = None
-            depositEnabled = False
-            withdrawEnabled = False
-            defaultLimits: dict = {}
             for j in range(0, len(networkList)):
                 rawNetwork = networkList[j]
                 network = self.safe_string(rawNetwork, 'network')
                 networkCode = self.network_id_to_code(network)
-                isDefault = self.safe_bool(rawNetwork, 'isDefault')
-                networkDepositEnabled = self.safe_bool(rawNetwork, 'depositEnable')
-                if networkDepositEnabled:
-                    depositEnabled = True
-                networkWithdrawEnabled = self.safe_bool(rawNetwork, 'withdrawEnable')
-                if networkWithdrawEnabled:
-                    withdrawEnabled = True
                 limits: dict = {
                     'withdraw': {
                         'min': self.safe_number(rawNetwork, 'withdrawMin'),
                         'max': self.safe_number(rawNetwork, 'withdrawMax'),
                     },
                 }
-                fee = self.safe_number(rawNetwork, 'withdrawFee')
-                if isDefault:
-                    defaultLimits = limits
-                precision = self.safe_number(rawNetwork, 'withdrawPrecision')
-                networkActive = networkDepositEnabled or networkWithdrawEnabled
+                precision = self.parse_number(self.parse_precision(self.safe_string(rawNetwork, 'withdrawPrecision')))
                 networks[networkCode] = {
                     'info': rawNetwork,
                     'id': network,
                     'network': networkCode,
-                    'fee': fee,
-                    'active': networkActive,
-                    'deposit': networkDepositEnabled,
-                    'withdraw': networkWithdrawEnabled,
+                    'fee': self.safe_number(rawNetwork, 'withdrawFee'),
+                    'active': None,
+                    'deposit': self.safe_bool(rawNetwork, 'depositEnable'),
+                    'withdraw': self.safe_bool(rawNetwork, 'withdrawEnable'),
                     'precision': precision,
                     'limits': limits,
                 }
-            active = depositEnabled or withdrawEnabled
             result[code] = self.safe_currency_structure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
                 'precision': None,
                 'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
                 'networks': networks,
-                'fee': fee,
-                'limits': defaultLimits,
+                'fee': None,
+                'limits': None,
+                'type': 'crypto',  # only cryptos now
             })
         return result
 
@@ -5535,18 +5520,14 @@ class bingx(Exchange, ImplicitAPI):
         :param str address: the address to withdraw to
         :param str [tag]:
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param int [params.walletType]: 1 fund account, 2 standard account, 3 perpetual account
+        :param int [params.walletType]: 1 fund account, 2 standard account, 3 perpetual account, 15 spot account
         :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         self.check_address(address)
         self.load_markets()
         currency = self.currency(code)
-        walletType = self.safe_integer(params, 'walletType')
-        if walletType is None:
-            walletType = 1
-        if not self.in_array(walletType, [1, 2, 3]):
-            raise BadRequest(self.id + ' withdraw() requires either 1 fund account, 2 standard futures account, 3 perpetual account for walletType')
+        walletType = self.safe_integer(params, 'walletType', 1)
         request: dict = {
             'coin': currency['id'],
             'address': address,

ccxt/bitfinex.py

@@ -751,6 +751,7 @@ class bitfinex(Exchange, ImplicitAPI):
             'pub:map:currency:explorer',  # maps symbols to their recognised block explorer URLs
             'pub:map:currency:tx:fee',  # maps currencies to their withdrawal fees https://github.com/ccxt/ccxt/issues/7745,
             'pub:map:tx:method',  # maps withdrawal/deposit methods to their API symbols
+            'pub:info:tx:status',  # maps withdrawal/deposit statuses, coins: 1 = enabled, 0 = maintenance
         ]
         config = ','.join(labels)
         request: dict = {
@@ -833,40 +834,81 @@ class bitfinex(Exchange, ImplicitAPI):
         #             ["ABS",[0,131.3]],
         #             ["ADA",[0,0.3]],
         #         ],
+        #         # deposit/withdrawal data
+        #         [
+        #           ["BITCOIN", 1, 1, null, null, null, null, 0, 0, null, null, 3],
+        #           ...
+        #         ]
         #     ]
         #
         indexed: dict = {
-            'sym': self.index_by(self.safe_value(response, 1, []), 0),
-            'label': self.index_by(self.safe_value(response, 2, []), 0),
-            'unit': self.index_by(self.safe_value(response, 3, []), 0),
-            'undl': self.index_by(self.safe_value(response, 4, []), 0),
-            'pool': self.index_by(self.safe_value(response, 5, []), 0),
-            'explorer': self.index_by(self.safe_value(response, 6, []), 0),
-            'fees': self.index_by(self.safe_value(response, 7, []), 0),
+            'sym': self.index_by(self.safe_list(response, 1, []), 0),
+            'label': self.index_by(self.safe_list(response, 2, []), 0),
+            'unit': self.index_by(self.safe_list(response, 3, []), 0),
+            'undl': self.index_by(self.safe_list(response, 4, []), 0),
+            'pool': self.index_by(self.safe_list(response, 5, []), 0),
+            'explorer': self.index_by(self.safe_list(response, 6, []), 0),
+            'fees': self.index_by(self.safe_list(response, 7, []), 0),
+            'networks': self.safe_list(response, 8, []),
+            'statuses': self.index_by(self.safe_list(response, 9, []), 0),
         }
-        ids = self.safe_value(response, 0, [])
+        indexedNetworks: dict = {}
+        for i in range(0, len(indexed['networks'])):
+            networkObj = indexed['networks'][i]
+            networkId = self.safe_string(networkObj, 0)
+            valuesList = self.safe_list(networkObj, 1)
+            networkName = self.safe_string(valuesList, 0)
+            # for GOlang transpiler, do with "safe" method
+            networksList = self.safe_list(indexedNetworks, networkName, [])
+            networksList.append(networkId)
+            indexedNetworks[networkName] = networksList
+        ids = self.safe_list(response, 0, [])
         result: dict = {}
         for i in range(0, len(ids)):
             id = ids[i]
-            if id.find('F0') >= 0:
+            if id.endswith('F0'):
                 # we get a lot of F0 currencies, skip those
                 continue
             code = self.safe_currency_code(id)
-            label = self.safe_value(indexed['label'], id, [])
+            label = self.safe_list(indexed['label'], id, [])
             name = self.safe_string(label, 1)
-            pool = self.safe_value(indexed['pool'], id, [])
+            pool = self.safe_list(indexed['pool'], id, [])
             rawType = self.safe_string(pool, 1)
             isCryptoCoin = (rawType is not None) or (id in indexed['explorer'])  # "hacky" solution
             type = None
             if isCryptoCoin:
                 type = 'crypto'
-            feeValues = self.safe_value(indexed['fees'], id, [])
-            fees = self.safe_value(feeValues, 1, [])
+            feeValues = self.safe_list(indexed['fees'], id, [])
+            fees = self.safe_list(feeValues, 1, [])
             fee = self.safe_number(fees, 1)
-            undl = self.safe_value(indexed['undl'], id, [])
+            undl = self.safe_list(indexed['undl'], id, [])
             precision = '8'  # default precision, todo: fix "magic constants"
             fid = 'f' + id
-            result[code] = {
+            dwStatuses = self.safe_list(indexed['statuses'], id, [])
+            depositEnabled = self.safe_integer(dwStatuses, 1) == 1
+            withdrawEnabled = self.safe_integer(dwStatuses, 2) == 1
+            networks: dict = {}
+            netwokIds = self.safe_list(indexedNetworks, id, [])
+            for j in range(0, len(netwokIds)):
+                networkId = netwokIds[j]
+                network = self.network_id_to_code(networkId)
+                networks[network] = {
+                    'info': networkId,
+                    'id': networkId.lower(),
+                    'network': networkId,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
                 'id': fid,
                 'uppercaseId': id,
                 'code': code,
@@ -874,8 +916,8 @@ class bitfinex(Exchange, ImplicitAPI):
                 'type': type,
                 'name': name,
                 'active': True,
-                'deposit': None,
-                'withdraw': None,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
                 'fee': fee,
                 'precision': int(precision),
                 'limits': {
@@ -888,37 +930,8 @@ class bitfinex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
-            }
-            networks: dict = {}
-            currencyNetworks = self.safe_value(response, 8, [])
-            cleanId = id.replace('F0', '')
-            for j in range(0, len(currencyNetworks)):
-                pair = currencyNetworks[j]
-                networkId = self.safe_string(pair, 0)
-                currencyId = self.safe_string(self.safe_value(pair, 1, []), 0)
-                if currencyId == cleanId:
-                    network = self.network_id_to_code(networkId)
-                    networks[network] = {
-                        'info': networkId,
-                        'id': networkId.lower(),
-                        'network': networkId,
-                        'active': None,
-                        'deposit': None,
-                        'withdraw': None,
-                        'fee': None,
-                        'precision': None,
-                        'limits': {
-                            'withdraw': {
-                                'min': None,
-                                'max': None,
-                            },
-                        },
-                    }
-            keysNetworks = list(networks.keys())
-            networksLength = len(keysNetworks)
-            if networksLength > 0:
-                result[code]['networks'] = networks
+                'networks': networks,
+            })
         return result
 
     def fetch_balance(self, params={}) -> Balances:

ccxt/bitget.py

@@ -3407,6 +3407,7 @@ class bitget(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: timestamp in ms of the latest candle to fetch
         :param boolean [params.useHistoryEndpoint]: whether to force to use historical endpoint(it has max limit of 200)
+        :param boolean [params.useHistoryEndpointForPagination]: whether to force to use historical endpoint for pagination(default True)
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :param str [params.price]: *swap only* "mark"(to fetch mark price candles) or "index"(to fetch index price candles)
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
@@ -3415,11 +3416,13 @@ class bitget(Exchange, ImplicitAPI):
         defaultLimit = 100  # default 100, max 1000
         maxLimitForRecentEndpoint = 1000
         maxLimitForHistoryEndpoint = 200  # note, max 1000 bars are supported for "recent-candles" endpoint, but "historical-candles" support only max 200
+        useHistoryEndpoint = self.safe_bool(params, 'useHistoryEndpoint', False)
+        useHistoryEndpointForPagination = self.safe_bool(params, 'useHistoryEndpointForPagination', True)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate')
         if paginate:
-            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimitForRecentEndpoint)
-        useHistoryEndpoint = self.safe_bool(params, 'useHistoryEndpoint', False)
+            limitForPagination = maxLimitForHistoryEndpoint if useHistoryEndpointForPagination else maxLimitForRecentEndpoint
+            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, limitForPagination)
         market = self.market(symbol)
         marketType = 'spot' if market['spot'] else 'swap'
         timeframes = self.options['timeframes'][marketType]
@@ -4038,6 +4041,7 @@ class bitget(Exchange, ImplicitAPI):
         timestamp = self.safe_integer_2(order, 'cTime', 'ctime')
         updateTimestamp = self.safe_integer(order, 'uTime')
         rawStatus = self.safe_string_2(order, 'status', 'state')
+        rawStatus = self.safe_string(order, 'planStatus', rawStatus)
         fee = None
         feeCostString = self.safe_string(order, 'fee')
         if feeCostString is not None:

ccxt/bybit.py

@@ -1704,6 +1704,7 @@ class bybit(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
+                'type': 'crypto',  # atm exchange api provides only cryptos
             }
         return result
 
@@ -2127,6 +2128,7 @@ class bybit(Exchange, ImplicitAPI):
             strike = self.safe_string(splitId, 2)
             optionLetter = self.safe_string(splitId, 3)
             isActive = (status == 'Trading')
+            isInverse = base == settle
             if isActive or (self.options['loadAllOptions']) or (self.options['loadExpiredOptions']):
                 result.append(self.safe_market_structure({
                     'id': id,
@@ -2146,8 +2148,8 @@ class bybit(Exchange, ImplicitAPI):
                     'option': True,
                     'active': isActive,
                     'contract': True,
-                    'linear': None,
-                    'inverse': None,
+                    'linear': not isInverse,
+                    'inverse': isInverse,
                     'taker': self.safe_number(market, 'takerFee', self.parse_number('0.0006')),
                     'maker': self.safe_number(market, 'makerFee', self.parse_number('0.0001')),
                     'contractSize': self.parse_number('1'),

ccxt/htx.py

@@ -6945,7 +6945,7 @@ class htx(Exchange, ImplicitAPI):
                 if method != 'POST':
                     request = self.extend(request, query)
                 sortedRequest = self.keysort(request)
-                auth = self.urlencode(sortedRequest)
+                auth = self.urlencode(sortedRequest, True)  # True is a go only requirment
                 # unfortunately, PHP demands double quotes for the escaped newline symbol
                 payload = "\n".join([method, self.hostname, url, auth])  # eslint-disable-line quotes
                 signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha256, 'base64')
@@ -7011,7 +7011,7 @@ class htx(Exchange, ImplicitAPI):
                 if method != 'POST':
                     sortedQuery = self.keysort(query)
                     request = self.extend(request, sortedQuery)
-                auth = self.urlencode(request).replace('%2c', '%2C')  # in c# it manually needs to be uppercased
+                auth = self.urlencode(request, True).replace('%2c', '%2C')  # in c# it manually needs to be uppercased
                 # unfortunately, PHP demands double quotes for the escaped newline symbol
                 payload = "\n".join([method, hostname, url, auth])  # eslint-disable-line quotes
                 signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha256, 'base64')

ccxt/hyperliquid.py

@@ -2178,6 +2178,10 @@ class hyperliquid(Exchange, ImplicitAPI):
         return self.parse_order(data, market)
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
+        #
+        # createOrdersWs error
+        #
+        #  {error: 'Insufficient margin to place order. asset=159'}
         #
         #  fetchOpenOrders
         #
@@ -2269,6 +2273,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         #     "triggerPx": "0.6"
         # }
         #
+        error = self.safe_string(order, 'error')
+        if error is not None:
+            return self.safe_order({
+                'info': order,
+                'status': 'rejected',
+            })
         entry = self.safe_dict_n(order, ['order', 'resting', 'filled'])
         if entry is None:
             entry = order
@@ -3444,9 +3454,12 @@ class hyperliquid(Exchange, ImplicitAPI):
         # {"status":"ok","response":{"type":"order","data":{"statuses":[{"error":"Insufficient margin to place order. asset=84"}]}}}
         #
         status = self.safe_string(response, 'status', '')
+        error = self.safe_string(response, 'error')
         message = None
         if status == 'err':
             message = self.safe_string(response, 'response')
+        elif error is not None:
+            message = error
         else:
             responsePayload = self.safe_dict(response, 'response', {})
             data = self.safe_dict(responsePayload, 'data', {})

ccxt/okx.py

@@ -1647,7 +1647,6 @@ class okx(Exchange, ImplicitAPI):
                     ymd = self.yymmdd(expiry)
                     symbol = symbol + '-' + ymd + '-' + strikePrice + '-' + optionType
                     optionType = 'put' if (optionType == 'P') else 'call'
-        tickSize = self.safe_string(market, 'tickSz')
         fees = self.safe_dict_2(self.fees, type, 'trading', {})
         maxLeverage = self.safe_string(market, 'lever', '1')
         maxLeverage = Precise.string_max(maxLeverage, '1')
@@ -1679,7 +1678,7 @@ class okx(Exchange, ImplicitAPI):
             'created': self.safe_integer(market, 'listTime'),
             'precision': {
                 'amount': self.safe_number(market, 'lotSz'),
-                'price': self.parse_number(tickSize),
+                'price': self.safe_number(market, 'tickSz'),
             },
             'limits': {
                 'leverage': {

ccxt/oxfun.py

@@ -83,7 +83,7 @@ class oxfun(Exchange, ImplicitAPI):
                 'fetchDepositWithdrawFee': False,
                 'fetchDepositWithdrawFees': False,
                 'fetchFundingHistory': True,
-                'fetchFundingRate': 'emulated',
+                'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
                 'fetchFundingRates': True,
                 'fetchIndexOHLCV': False,
@@ -1103,6 +1103,26 @@ class oxfun(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_funding_rates(data, symbols)
 
+    def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
+        """
+        fetch the current funding rates for a symbol
+
+        https://docs.ox.fun/?json#get-v3-funding-estimates
+
+        :param str symbol: unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
+        """
+        self.load_markets()
+        request: dict = {
+            'marketCode': self.market_id(symbol),
+        }
+        response = self.publicGetV3FundingEstimates(self.extend(request, params))
+        #
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        return self.parse_funding_rate(first, self.market(symbol))
+
     def parse_funding_rate(self, fundingRate, market: Market = None) -> FundingRate:
         #
         #     {

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.82'
 
 # ----------------------------------------------------------------------------