ccxt 4.4.71__py2.py3-none-any.whl → 4.4.72__py2.py3-none-any.whl

ccxt/gemini.py

@@ -1873,7 +1873,7 @@ class gemini(Exchange, ImplicitAPI):
             raise ExchangeError(feedback)  # unknown message
         return None
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 
@@ -1895,6 +1895,7 @@ class gemini(Exchange, ImplicitAPI):
             'currency': code,
             'address': address,
             'tag': None,
+            'network': None,
             'info': response,
         }
 

ccxt/hitbtc.py

@@ -1020,7 +1020,7 @@ class hitbtc(Exchange, ImplicitAPI):
             }
         return result
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/hyperliquid.py

@@ -1897,6 +1897,44 @@ class hyperliquid(Exchange, ImplicitAPI):
         statuses = self.safe_list(dataObject, 'statuses', [])
         return self.parse_orders(statuses)
 
+    def create_vault(self, name: str, description: str, initialUsd: int, params={}):
+        """
+        creates a value
+        :param str name: The name of the vault
+        :param str description: The description of the vault
+        :param number initialUsd: The initialUsd of the vault
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: the api result
+        """
+        self.check_required_credentials()
+        self.load_markets()
+        nonce = self.milliseconds()
+        request: dict = {
+            'nonce': nonce,
+        }
+        usd = self.parse_to_int(Precise.string_mul(self.number_to_string(initialUsd), '1000000'))
+        action: dict = {
+            'type': 'createVault',
+            'name': name,
+            'description': description,
+            'initialUsd': usd,
+            'nonce': nonce,
+        }
+        signature = self.sign_l1_action(action, nonce)
+        request['action'] = action
+        request['signature'] = signature
+        response = self.privatePostExchange(self.extend(request, params))
+        #
+        # {
+        #     "status": "ok",
+        #     "response": {
+        #         "type": "createVault",
+        #         "data": "0x04fddcbc9ce80219301bd16f18491bedf2a8c2b8"
+        #     }
+        # }
+        #
+        return response
+
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetches historical funding rate prices

ccxt/kraken.py

@@ -2900,7 +2900,7 @@ class kraken(Exchange, ImplicitAPI):
             data[dataLength - 1] = last
         return data
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/krakenfutures.py

@@ -51,6 +51,10 @@ class krakenfutures(Exchange, ImplicitAPI):
                 'cancelOrders': True,
                 'createMarketOrder': False,
                 'createOrder': True,
+                'createPostOnlyOrder': True,
+                'createReduceOnlyOrder': True,
+                'createStopLimitOrder': True,
+                'createStopMarketOrder': True,
                 'createStopOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': True,

ccxt/kucoin.py

@@ -1959,7 +1959,7 @@ class kucoin(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
 
         https://www.kucoin.com/docs/rest/funding/deposit/create-deposit-address-v3-

ccxt/kuna.py

@@ -1572,7 +1572,7 @@ class kuna(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data)
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/mexc.py

@@ -4537,7 +4537,7 @@ class mexc(Exchange, ImplicitAPI):
         addressStructures = self.parse_deposit_addresses(response, None, False)
         return self.index_by(addressStructures, 'network')
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/ndax.py

@@ -2083,7 +2083,7 @@ class ndax(Exchange, ImplicitAPI):
             'tag': tag,
         }
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
         :param str code: unified currency code of the currency for the deposit address

ccxt/okcoin.py

@@ -56,6 +56,10 @@ class okcoin(Exchange, ImplicitAPI):
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
                 'createOrder': True,
+                'createPostOnlyOrder': True,
+                'createReduceOnlyOrder': True,
+                'createStopLimitOrder': True,
+                'createStopMarketOrder': True,
                 'createStopOrder': True,
                 'createTriggerOrder': True,
                 'fetchBalance': True,

ccxt/okx.py

@@ -1623,11 +1623,12 @@ class okx(Exchange, ImplicitAPI):
         optionType = None
         if contract:
             symbol = symbol + ':' + settle
-            expiry = self.safe_integer(market, 'expTime')
             if future:
+                expiry = self.safe_integer(market, 'expTime')
                 ymd = self.yymmdd(expiry)
                 symbol = symbol + '-' + ymd
             elif option:
+                expiry = self.safe_integer(market, 'expTime')
                 strikePrice = self.safe_string(market, 'stk')
                 optionType = self.safe_string(market, 'optType')
                 ymd = self.yymmdd(expiry)
@@ -1818,38 +1819,24 @@ class okx(Exchange, ImplicitAPI):
             code = currency['code']
             chains = dataByCurrencyId[currencyId]
             networks: dict = {}
-            currencyActive = False
-            depositEnabled = False
-            withdrawEnabled = False
-            maxPrecision = None
-            for j in range(0, len(chains)):
+            type = 'crypto'
+            chainsLength = len(chains)
+            for j in range(0, chainsLength):
                 chain = chains[j]
-                canDeposit = self.safe_bool(chain, 'canDep')
-                depositEnabled = canDeposit if (canDeposit) else depositEnabled
-                canWithdraw = self.safe_bool(chain, 'canWd')
-                withdrawEnabled = canWithdraw if (canWithdraw) else withdrawEnabled
-                canInternal = self.safe_bool(chain, 'canInternal')
-                active = True if (canDeposit and canWithdraw and canInternal) else False
-                currencyActive = active if (active) else currencyActive
-                networkId = self.safe_string(chain, 'chain')
-                if (networkId is not None) and (networkId.find('-') >= 0):
+                networkId = self.safe_string(chain, 'chain')  # USDT-BEP20, USDT-Avalance-C, etc
+                if networkId is not None:
                     idParts = networkId.split('-')
                     parts = self.array_slice(idParts, 1)
                     chainPart = '-'.join(parts)
                     networkCode = self.network_id_to_code(chainPart, currency['code'])
-                    precision = self.parse_precision(self.safe_string(chain, 'wdTickSz'))
-                    if maxPrecision is None:
-                        maxPrecision = precision
-                    else:
-                        maxPrecision = Precise.string_min(maxPrecision, precision)
                     networks[networkCode] = {
                         'id': networkId,
                         'network': networkCode,
-                        'active': active,
-                        'deposit': canDeposit,
-                        'withdraw': canWithdraw,
+                        'active': None,
+                        'deposit': self.safe_bool(chain, 'canDep'),
+                        'withdraw': self.safe_bool(chain, 'canWd'),
                         'fee': self.safe_number(chain, 'fee'),
-                        'precision': self.parse_number(precision),
+                        'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
                         'limits': {
                             'withdraw': {
                                 'min': self.safe_number(chain, 'minWd'),
@@ -1858,25 +1845,29 @@ class okx(Exchange, ImplicitAPI):
                         },
                         'info': chain,
                     }
+                else:
+                    # only happens for FIAT currency
+                    type = 'fiat'
             firstChain = self.safe_dict(chains, 0, {})
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': chains,
                 'code': code,
                 'id': currencyId,
                 'name': self.safe_string(firstChain, 'name'),
-                'active': currencyActive,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
                 'fee': None,
-                'precision': self.parse_number(maxPrecision),
+                'precision': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                 },
+                'type': type,
                 'networks': networks,
-            }
+            })
         return result
 
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:

ccxt/paradex.py

@@ -496,6 +496,57 @@ class paradex(Exchange, ImplicitAPI):
         #         "max_tob_spread": "0.2"
         #     }
         #
+        # {
+        #     "symbol":"BTC-USD-96000-C",
+        #     "base_currency":"BTC",
+        #     "quote_currency":"USD",
+        #     "settlement_currency":"USDC",
+        #     "order_size_increment":"0.001",
+        #     "price_tick_size":"0.01",
+        #     "min_notional":"100",
+        #     "open_at":"1736764200000",
+        #     "expiry_at":"0",
+        #     "asset_kind":"PERP_OPTION",
+        #     "market_kind":"cross",
+        #     "position_limit":"10",
+        #     "price_bands_width":"0.05",
+        #     "iv_bands_width":"0.05",
+        #     "max_open_orders":"100",
+        #     "max_funding_rate":"0.02",
+        #     "option_cross_margin_params":{
+        #        "imf":{
+        #           "long_itm":"0.2",
+        #           "short_itm":"0.15",
+        #           "short_otm":"0.1",
+        #           "short_put_cap":"0.5",
+        #           "premium_multiplier":"1"
+        #        },
+        #        "mmf":{
+        #           "long_itm":"0.1",
+        #           "short_itm":"0.075",
+        #           "short_otm":"0.05",
+        #           "short_put_cap":"0.5",
+        #           "premium_multiplier":"0.5"
+        #        }
+        #     },
+        #     "price_feed_id":"GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU",
+        #     "oracle_ewma_factor":"0.20000046249626113",
+        #     "max_order_size":"2",
+        #     "max_funding_rate_change":"0.02",
+        #     "max_tob_spread":"0.2",
+        #     "interest_rate":"0.0001",
+        #     "clamp_rate":"0.02",
+        #     "option_type":"CALL",
+        #     "strike_price":"96000",
+        #     "funding_period_hours":"24",
+        #     "tags":[
+        #     ]
+        #  }
+        #
+        assetKind = self.safe_string(market, 'asset_kind')
+        isOption = (assetKind == 'PERP_OPTION')
+        type = 'option' if (isOption) else 'swap'
+        isSwap = (type == 'swap')
         marketId = self.safe_string(market, 'symbol')
         quoteId = self.safe_string(market, 'quote_currency')
         baseId = self.safe_string(market, 'base_currency')
@@ -505,6 +556,13 @@ class paradex(Exchange, ImplicitAPI):
         settle = self.safe_currency_code(settleId)
         symbol = base + '/' + quote + ':' + settle
         expiry = self.safe_integer(market, 'expiry_at')
+        optionType = self.safe_string(market, 'option_type')
+        strikePrice = self.safe_string(market, 'strike_price')
+        if isOption:
+            optionTypeSuffix = 'C' if (optionType == 'CALL') else 'P'
+            symbol = symbol + '-' + strikePrice + '-' + optionTypeSuffix
+        else:
+            expiry = None
         takerFee = self.parse_number('0.0003')
         makerFee = self.parse_number('-0.00005')
         return self.safe_market_structure({
@@ -516,23 +574,23 @@ class paradex(Exchange, ImplicitAPI):
             'baseId': baseId,
             'quoteId': quoteId,
             'settleId': settleId,
-            'type': 'swap',
+            'type': type,
             'spot': False,
             'margin': None,
-            'swap': True,
+            'swap': isSwap,
             'future': False,
-            'option': False,
+            'option': isOption,
             'active': self.safe_bool(market, 'enableTrading'),
             'contract': True,
             'linear': True,
-            'inverse': None,
+            'inverse': False,
             'taker': takerFee,
             'maker': makerFee,
             'contractSize': self.parse_number('1'),
-            'expiry': None if (expiry == 0) else expiry,
+            'expiry': expiry,
             'expiryDatetime': None if (expiry == 0) else self.iso8601(expiry),
-            'strike': None,
-            'optionType': None,
+            'strike': self.parse_number(strikePrice),
+            'optionType': self.safe_string_lower(market, 'option_type'),
             'precision': {
                 'amount': self.safe_number(market, 'order_size_increment'),
                 'price': self.safe_number(market, 'price_tick_size'),

ccxt/paymium.py

@@ -333,7 +333,7 @@ class paymium(Exchange, ImplicitAPI):
         response = self.publicGetDataCurrencyTrades(self.extend(request, params))
         return self.parse_trades(response, market, since, limit)
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/poloniex.py

@@ -428,6 +428,7 @@ class poloniex(Exchange, ImplicitAPI):
                         'untilDays': None,
                         'trigger': False,
                         'trailing': False,
+                        'symbolRequired': False,
                     },
                     'fetchMyTrades': {
                         'limit': 100,
@@ -2571,7 +2572,7 @@ class poloniex(Exchange, ImplicitAPI):
             'nonce': None,
         }
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         create a currency deposit address
 

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.71'
+__version__ = '4.4.72'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bingx.py

@@ -42,7 +42,7 @@ class bingx(ccxt.async_support.bingx):
                 },
             },
             'options': {
-                'listenKeyRefreshRate': 3540000,  # 1 hour(59 mins so we have 1min to renew the token)
+                'listenKeyRefreshRate': 3540000,  # 1 hour(59 mins so we have 1 min to renew the token)
                 'ws': {
                     'gunzip': True,
                 },

ccxt/pro/bitmart.py

@@ -858,15 +858,12 @@ class bitmart(ccxt.async_support.bitmart):
         #        "data":[
         #           {
         #              "trade_id":6798697637,
-        #              "contract_id":1,
         #              "symbol":"BTCUSDT",
         #              "deal_price":"39735.8",
         #              "deal_vol":"2",
-        #              "type":0,
         #              "way":1,
-        #              "create_time":1701618503,
-        #              "create_time_mill":1701618503517,
-        #              "created_at":"2023-12-03T15:48:23.517518538Z"
+        #              "created_at":"2023-12-03T15:48:23.517518538Z",
+        #              "m": True,
         #           }
         #        ]
         #    }
@@ -899,6 +896,7 @@ class bitmart(ccxt.async_support.bitmart):
         return symbol
 
     def parse_ws_trade(self, trade: dict, market: Market = None):
+        #
         # spot
         #     {
         #         "ms_t": 1740320841473,
@@ -929,6 +927,16 @@ class bitmart(ccxt.async_support.bitmart):
             timestamp = self.parse8601(datetime)
         else:
             datetime = self.iso8601(timestamp)
+        takerOrMaker = None  # True for public trades
+        side = self.safe_string(trade, 'side')
+        buyerMaker = self.safe_bool(trade, 'm')
+        if buyerMaker is not None:
+            if side is None:
+                if buyerMaker:
+                    side = 'sell'
+                else:
+                    side = 'buy'
+            takerOrMaker = 'taker'
         return self.safe_trade({
             'info': trade,
             'id': self.safe_string(trade, 'trade_id'),
@@ -937,11 +945,11 @@ class bitmart(ccxt.async_support.bitmart):
             'datetime': datetime,
             'symbol': market['symbol'],
             'type': None,
-            'side': self.safe_string(trade, 'side'),
+            'side': side,
             'price': self.safe_string_2(trade, 'price', 'deal_price'),
             'amount': self.safe_string_2(trade, 'size', 'deal_vol'),
             'cost': None,
-            'takerOrMaker': None,
+            'takerOrMaker': takerOrMaker,
             'fee': None,
         }, market)
 

ccxt/pro/derive.py

@@ -417,12 +417,12 @@ class derive(ccxt.async_support.derive):
             requestId = self.request_id(url)
             now = str(self.milliseconds())
             signature = self.signMessage(now, self.privateKey)
-            contractWalletAddress = self.safe_string(self.options, 'contractWalletAddress')
+            deriveWalletAddress = self.safe_string(self.options, 'deriveWalletAddress')
             request: dict = {
                 'id': requestId,
                 'method': 'public/login',
                 'params': {
-                    'wallet': contractWalletAddress,
+                    'wallet': deriveWalletAddress,
                     'timestamp': now,
                     'signature': signature,
                 },

ccxt/pro/krakenfutures.py

@@ -460,7 +460,7 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         #            {
         #                "feed": "trade",
         #                "product_id": "PI_XBTUSD",
-        #                "uid": "caa9c653-420b-4c24-a9f1-462a054d86f1",
+        #                "uid": "caa9c653-420b-4c24-a9f2-462a054d86f1",
         #                "side": "sell",
         #                "type": "fill",
         #                "seq": 655508,

ccxt/upbit.py

@@ -1886,7 +1886,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_deposit_address(response)
 
-    def create_deposit_address(self, code: str, params={}):
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
 
         https://docs.upbit.com/reference/%EC%9E%85%EA%B8%88-%EC%A3%BC%EC%86%8C-%EC%83%9D%EC%84%B1-%EC%9A%94%EC%B2%AD

ccxt/whitebit.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.whitebit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Any, Balances, BorrowInterest, Bool, Conversion, Currencies, Currency, DepositAddress, FundingHistory, Int, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Any, Balances, BorrowInterest, Bool, Conversion, CrossBorrowRate, Currencies, Currency, DepositAddress, FundingHistory, Int, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -46,13 +46,16 @@ class whitebit(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'cancelOrders': False,
                 'createConvertTrade': True,
+                'createDepositAddress': True,
                 'createMarketBuyOrderWithCost': True,
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
                 'createOrder': True,
+                'createPostOnlyOrder': True,
                 'createStopLimitOrder': True,
                 'createStopMarketOrder': True,
                 'createStopOrder': True,
+                'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchBalance': True,
                 'fetchBorrowRateHistories': False,
@@ -61,7 +64,7 @@ class whitebit(Exchange, ImplicitAPI):
                 'fetchConvertQuote': True,
                 'fetchConvertTrade': False,
                 'fetchConvertTradeHistory': True,
-                'fetchCrossBorrowRate': False,
+                'fetchCrossBorrowRate': True,
                 'fetchCrossBorrowRates': False,
                 'fetchCurrencies': True,
                 'fetchDeposit': True,
@@ -1375,6 +1378,10 @@ class whitebit(Exchange, ImplicitAPI):
         :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.cost]: *market orders only* the cost of the order in units of the base currency
+        :param float [params.triggerPrice]: The price at which a trigger order is triggered at
+        :param bool [params.postOnly]: If True, the order will only be posted to the order book and not executed immediately
+        :param str [params.clientOrderId]: a unique id for the order
+        :param str [params.marginMode]: 'cross' or 'isolated', for margin trading, uses self.options.defaultMarginMode if not passed, defaults to None/None/None
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
@@ -2001,6 +2008,60 @@ class whitebit(Exchange, ImplicitAPI):
             'tag': tag,
         }
 
+    def create_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        create a currency deposit address
+
+        https://docs.whitebit.com/private/http-main-v4/#create-new-address-for-deposit
+
+        :param str code: unified currency code of the currency for the deposit address
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.network]: the blockchain network to create a deposit address on
+        :param str [params.type]: address type, available for specific currencies
+        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'ticker': currency['id'],
+        }
+        response = self.v4PrivatePostMainAccountCreateNewAddress(self.extend(request, params))
+        #
+        #     {
+        #         "account": {
+        #             "address": "GDTSOI56XNVAKJNJBLJGRNZIVOCIZJRBIDKTWSCYEYNFAZEMBLN75RMN",
+        #             "memo": "48565488244493"
+        #         },
+        #         "required": {
+        #             "maxAmount": "0",
+        #             "minAmount": "1",
+        #             "fixedFee": "0",
+        #             "flexFee": {
+        #                 "maxFee": "0",
+        #                 "minFee": "0",
+        #                 "percent": "0"
+        #             }
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'account', {})
+        return self.parse_deposit_address(data, currency)
+
+    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
+        #
+        #     {
+        #         "address": "GDTSOI56XNVAKJNJBLJGRNZIVOCIZJRBIDKTWSCYEYNFAZEMBLN75RMN",
+        #         "memo": "48565488244493"
+        #     },
+        #
+        return {
+            'info': depositAddress,
+            'currency': self.safe_currency_code(None, currency),
+            'network': None,
+            'address': self.safe_string(depositAddress, 'address'),
+            'tag': self.safe_string(depositAddress, 'memo'),
+        }
+
     def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         """
         set the level of leverage for a market
@@ -3069,6 +3130,41 @@ class whitebit(Exchange, ImplicitAPI):
             'takeProfitPrice': self.safe_number(tpsl, 'takeProfit'),
         })
 
+    def fetch_cross_borrow_rate(self, code: str, params={}) -> CrossBorrowRate:
+        """
+        fetch the rate of interest to borrow a currency for margin trading
+
+        https://docs.whitebit.com/private/http-main-v4/#get-plans
+
+        :param str code: unified currency code
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `borrow rate structure <https://docs.ccxt.com/#/?id=borrow-rate-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'ticker': currency['id'],
+        }
+        response = self.v4PrivatePostMainAccountSmartPlans(self.extend(request, params))
+        #
+        #
+        data = self.safe_list(response, 0, [])
+        return self.parse_borrow_rate(data, currency)
+
+    def parse_borrow_rate(self, info, currency: Currency = None):
+        #
+        #
+        currencyId = self.safe_string(info, 'ticker')
+        percent = self.safe_string(info, 'percent')
+        return {
+            'currency': self.safe_currency_code(currencyId, currency),
+            'rate': self.parse_number(Precise.string_div(percent, '100')),
+            'period': self.safe_integer(info, 'duration'),
+            'timestamp': None,
+            'datetime': None,
+            'info': info,
+        }
+
     def is_fiat(self, currency: str) -> bool:
         fiatCurrencies = self.safe_value(self.options, 'fiatCurrencies', [])
         return self.in_array(currency, fiatCurrencies)