ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/async_support/paradex.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.paradex import ImplicitAPI
-from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Any, Balances, Currency, Greeks, Int, Leverage, MarginMode, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -20,7 +20,7 @@ from ccxt.base.precise import Precise
 
 class paradex(Exchange, ImplicitAPI):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(paradex, self).describe(), {
             'id': 'paradex',
             'name': 'Paradex',
@@ -53,8 +53,11 @@ class paradex(Exchange, ImplicitAPI):
                 'createOrder': True,
                 'createOrders': False,
                 'createReduceOnlyOrder': False,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchAccounts': False,
+                'fetchAllGreeks': True,
                 'fetchBalance': True,
                 'fetchBorrowInterest': False,
                 'fetchBorrowRateHistories': False,
@@ -73,14 +76,15 @@ class paradex(Exchange, ImplicitAPI):
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': True,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
                 'fetchLedger': False,
-                'fetchLeverage': False,
+                'fetchLeverage': True,
                 'fetchLeverageTiers': False,
                 'fetchLiquidations': True,
-                'fetchMarginMode': None,
+                'fetchMarginMode': True,
                 'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
@@ -114,8 +118,8 @@ class paradex(Exchange, ImplicitAPI):
                 'repayCrossMargin': False,
                 'repayIsolatedMargin': False,
                 'sandbox': True,
-                'setLeverage': False,
-                'setMarginMode': False,
+                'setLeverage': True,
+                'setMarginMode': True,
                 'setPositionMode': False,
                 'transfer': False,
                 'withdraw': False,
@@ -157,12 +161,23 @@ class paradex(Exchange, ImplicitAPI):
                         'system/state': 1,
                         'system/time': 1,
                         'trades': 1,
+                        'vaults': 1,
+                        'vaults/balance': 1,
+                        'vaults/config': 1,
+                        'vaults/history': 1,
+                        'vaults/positions': 1,
+                        'vaults/summary': 1,
+                        'vaults/transfers': 1,
                     },
                 },
                 'private': {
                     'get': {
                         'account': 1,
+                        'account/info': 1,
+                        'account/history': 1,
+                        'account/margin': 1,
                         'account/profile': 1,
+                        'account/subaccounts': 1,
                         'balance': 1,
                         'fills': 1,
                         'funding/payments': 1,
@@ -175,20 +190,34 @@ class paradex(Exchange, ImplicitAPI):
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
                         'points_data/{market}/{program}': 1,
+                        'referrals/qr-code': 1,
                         'referrals/summary': 1,
                         'transfers': 1,
+                        'algo/orders': 1,
+                        'algo/orders-history': 1,
+                        'algo/orders/{algo_id}': 1,
+                        'vaults/account-summary': 1,
                     },
                     'post': {
+                        'account/margin/{market}': 1,
+                        'account/profile/max_slippage': 1,
                         'account/profile/referral_code': 1,
                         'account/profile/username': 1,
                         'auth': 1,
                         'onboarding': 1,
                         'orders': 1,
+                        'orders/batch': 1,
+                        'algo/orders': 1,
+                        'vaults': 1,
+                    },
+                    'put': {
+                        'orders/{order_id}': 1,
                     },
                     'delete': {
                         'orders': 1,
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
+                        'algo/orders/{algo_id}': 1,
                     },
                 },
             },
@@ -268,17 +297,91 @@ class paradex(Exchange, ImplicitAPI):
                     '40112': PermissionDenied,  # Geo IP blocked
                 },
                 'broad': {
+                    'missing or malformed jwt': AuthenticationError,
                 },
             },
             'precisionMode': TICK_SIZE,
             'commonCurrencies': {
             },
             'options': {
+                'paradexAccount': None,  # add {"privateKey": A, "publicKey": B, "address": C}
                 'broker': 'CCXT',
             },
+            'features': {
+                'spot': None,
+                'forSwap': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': True,
+                        'triggerDirection': True,  # todo
+                        'triggerPriceType': None,
+                        'stopLossPrice': False,  # todo
+                        'takeProfitPrice': False,  # todo
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': False,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': False,
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': True,  # todo
+                        'iceberg': False,
+                    },
+                    'createOrders': None,  # todo
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 100,  # todo
+                        'daysBack': 100000,  # todo
+                        'untilDays': 100000,  # todo
+                        'symbolRequired': False,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                        'symbolRequired': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': 100,  # todo
+                        'trigger': False,
+                        'trailing': False,
+                        'symbolRequired': False,
+                    },
+                    'fetchOrders': {
+                        'marginMode': False,
+                        'limit': 100,
+                        'daysBack': 100000,  # todo
+                        'untilDays': 100000,  # todo
+                        'trigger': False,
+                        'trailing': False,
+                        'symbolRequired': False,
+                    },
+                    'fetchClosedOrders': None,  # todo
+                    'fetchOHLCV': {
+                        'limit': None,  # todo by from/to
+                    },
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'forSwap',
+                    },
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
         })
 
-    async def fetch_time(self, params={}):
+    async def fetch_time(self, params={}) -> Int:
         """
         fetches the current integer timestamp in milliseconds from the exchange server
 
@@ -395,6 +498,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')
@@ -404,8 +558,16 @@ 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')
         takerFee = self.parse_number('0.0003')
         makerFee = self.parse_number('-0.00005')
+        if isOption:
+            optionTypeSuffix = 'C' if (optionType == 'CALL') else 'P'
+            symbol = symbol + '-' + strikePrice + '-' + optionTypeSuffix
+            makerFee = self.parse_number('0.0003')
+        else:
+            expiry = None
         return self.safe_market_structure({
             'id': marketId,
             'symbol': symbol,
@@ -415,23 +577,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'),
@@ -544,14 +706,9 @@ class paradex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
-        request: dict = {}
-        if symbols is not None:
-            if isinstance(symbols, list):
-                request['market'] = self.market_id(symbols[0])
-            else:
-                request['market'] = self.market_id(symbols)
-        else:
-            request['market'] = 'ALL'
+        request: dict = {
+            'market': 'ALL',
+        }
         response = await self.publicGetMarketsSummary(self.extend(request, params))
         #
         #     {
@@ -629,7 +786,7 @@ class paradex(Exchange, ImplicitAPI):
         #         "ask": "69578.2",
         #         "volume_24h": "5815541.397939004",
         #         "total_volume": "584031465.525259686",
-        #         "created_at": 1718170156580,
+        #         "created_at": 1718170156581,
         #         "underlying_price": "67367.37268422",
         #         "open_interest": "162.272",
         #         "funding_rate": "0.01629574927887",
@@ -871,7 +1028,7 @@ class paradex(Exchange, ImplicitAPI):
         #
         #     {
         #         "symbol": "BTC-USD-PERP",
-        #         "oracle_price": "68465.17449906",
+        #         "oracle_price": "68465.17449904",
         #         "mark_price": "68465.17449906",
         #         "last_traded_price": "68495.1",
         #         "bid": "68477.6",
@@ -950,22 +1107,24 @@ class paradex(Exchange, ImplicitAPI):
     async def prepare_paradex_domain(self, l1=False):
         systemConfig = await self.get_system_config()
         if l1 is True:
-            return {
+            l1D = {
                 'name': 'Paradex',
                 'chainId': systemConfig['l1_chain_id'],
                 'version': '1',
             }
-        return {
+            return l1D
+        domain = {
             'name': 'Paradex',
             'chainId': systemConfig['starknet_chain_id'],
             'version': 1,
         }
+        return domain
 
     async def retrieve_account(self):
-        self.check_required_credentials()
         cachedAccount: dict = self.safe_dict(self.options, 'paradexAccount')
         if cachedAccount is not None:
             return cachedAccount
+        self.check_required_credentials()
         systemConfig = await self.get_system_config()
         domain = await self.prepare_paradex_domain(True)
         messageTypes = {
@@ -1013,7 +1172,8 @@ class paradex(Exchange, ImplicitAPI):
             if now < cachedExpires:
                 return cachedToken
         account = await self.retrieve_account()
-        expires = now + 86400 * 7
+        # https://docs.paradex.trade/api-reference/general-information/authentication
+        expires = now + 180
         req = {
             'method': 'POST',
             'path': '/v1/auth',
@@ -1086,12 +1246,21 @@ class paradex(Exchange, ImplicitAPI):
         price = self.safe_string(order, 'price')
         amount = self.safe_string(order, 'size')
         orderType = self.safe_string(order, 'type')
+        cancelReason = self.safe_string(order, 'cancel_reason')
         status = self.safe_string(order, 'status')
+        if cancelReason is not None:
+            if cancelReason == 'NOT_ENOUGH_MARGIN' or cancelReason == 'ORDER_EXCEEDS_POSITION_LIMIT':
+                status = 'rejected'
+            else:
+                status = 'canceled'
         side = self.safe_string_lower(order, 'side')
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))
-        stopPrice = self.safe_string(order, 'trigger_price')
         lastUpdateTimestamp = self.safe_integer(order, 'last_updated_at')
+        flags = self.safe_list(order, 'flags', [])
+        reduceOnly = None
+        if 'REDUCE_ONLY' in flags:
+            reduceOnly = True
         return self.safe_order({
             'id': orderId,
             'clientOrderId': clientOrderId,
@@ -1102,13 +1271,12 @@ class paradex(Exchange, ImplicitAPI):
             'status': self.parse_order_status(status),
             'symbol': symbol,
             'type': self.parse_order_type(orderType),
-            'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instrunction')),
+            'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instruction')),
             'postOnly': None,
-            'reduceOnly': None,
+            'reduceOnly': reduceOnly,
             'side': side,
             'price': price,
-            'stopPrice': stopPrice,
-            'triggerPrice': stopPrice,
+            'triggerPrice': self.safe_string(order, 'trigger_price'),
             'takeProfitPrice': None,
             'stopLossPrice': None,
             'average': average,
@@ -1171,8 +1339,10 @@ class paradex(Exchange, ImplicitAPI):
         :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 dict [params]: extra parameters specific to the exchange API endpoint
-        :param float [params.stopPrice]: The price a trigger order is triggered at
+        :param float [params.stopPrice]: alias for triggerPrice
         :param float [params.triggerPrice]: The price a trigger order is triggered at
+        :param float [params.stopLossPrice]: the price that a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: the price that a take profit order is triggered at
         :param str [params.timeInForce]: "GTC", "IOC", or "POST_ONLY"
         :param bool [params.postOnly]: True or False
         :param bool [params.reduceOnly]: Ensures that the executed order does not flip the opened position.
@@ -1188,11 +1358,15 @@ class paradex(Exchange, ImplicitAPI):
         request: dict = {
             'market': market['id'],
             'side': orderSide,
-            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET
-            'size': self.amount_to_precision(symbol, amount),
+            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET,STOP_LOSS_MARKET,STOP_LOSS_LIMIT,TAKE_PROFIT_MARKET,TAKE_PROFIT_LIMIT
         }
-        stopPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        stopLossPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
         isMarket = orderType == 'MARKET'
+        isTakeProfitOrder = (takeProfitPrice is not None)
+        isStopLossOrder = (stopLossPrice is not None)
+        isStopOrder = (triggerPrice is not None) or isTakeProfitOrder or isStopLossOrder
         timeInForce = self.safe_string_upper(params, 'timeInForce')
         postOnly = self.is_post_only(isMarket, None, params)
         if not isMarket:
@@ -1200,22 +1374,51 @@ class paradex(Exchange, ImplicitAPI):
                 request['instruction'] = 'POST_ONLY'
             elif timeInForce == 'ioc':
                 request['instruction'] = 'IOC'
-        if reduceOnly:
-            request['flags'] = [
-                'REDUCE_ONLY',
-            ]
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
         clientOrderId = self.safe_string_n(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         if clientOrderId is not None:
             request['client_id'] = clientOrderId
-        if stopPrice is not None:
+        sizeString = '0'
+        stopPrice = None
+        if isStopOrder:
+            # flags: Reduce_Only must be provided for TPSL orders.
             if isMarket:
-                request['type'] = 'STOP_MARKET'
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_MARKET'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_MARKET'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_MARKET'
             else:
-                request['type'] = 'STOP_LIMIT'
-            request['trigger_price'] = self.price_to_precision(symbol, stopPrice)
-        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice'])
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_LIMIT'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_LIMIT'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_LIMIT'
+        else:
+            sizeString = self.amount_to_precision(symbol, amount)
+        if stopPrice is not None:
+            request['trigger_price'] = stopPrice
+        request['size'] = sizeString
+        if reduceOnly:
+            request['flags'] = [
+                'REDUCE_ONLY',
+            ]
+        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
         account = await self.retrieve_account()
         now = self.nonce()
         orderReq = {
@@ -1324,7 +1527,7 @@ class paradex(Exchange, ImplicitAPI):
         #
         # if success, no response...
         #
-        return response
+        return [self.safe_order({'info': response})]
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
@@ -1621,7 +1824,7 @@ class paradex(Exchange, ImplicitAPI):
         positions = await self.fetch_positions([market['symbol']], params)
         return self.safe_dict(positions, 0, {})
 
-    async def fetch_positions(self, symbols: Strings = None, params={}):
+    async def fetch_positions(self, symbols: Strings = None, params={}) -> List[Position]:
         """
         fetch all open positions
 
@@ -1768,6 +1971,7 @@ class paradex(Exchange, ImplicitAPI):
             'contracts': None,
             'contractSize': None,
             'price': None,
+            'side': None,
             'baseValue': None,
             'quoteValue': None,
             'timestamp': timestamp,
@@ -1947,6 +2151,316 @@ class paradex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
+    async def fetch_margin_mode(self, symbol: str, params={}) -> MarginMode:
+        """
+        fetches the margin mode of a specific symbol
+
+        https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+
+        :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: a `margin mode structure <https://docs.ccxt.com/#/?id=margin-mode-structure>`
+        """
+        await self.authenticate_rest()
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.privateGetAccountMargin(self.extend(request, params))
+        #
+        # {
+        #     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        #     "configs": [
+        #         {
+        #             "market": "SOL-USD-PERP",
+        #             "leverage": 50,
+        #             "margin_type": "CROSS"
+        #         }
+        #     ]
+        # }
+        #
+        configs = self.safe_list(response, 'configs')
+        return self.parse_margin_mode(self.safe_dict(configs, 0), market)
+
+    def parse_margin_mode(self, rawMarginMode: dict, market=None) -> MarginMode:
+        marketId = self.safe_string(rawMarginMode, 'market')
+        market = self.safe_market(marketId, market)
+        marginMode = self.safe_string_lower(rawMarginMode, 'margin_type')
+        return {
+            'info': rawMarginMode,
+            'symbol': market['symbol'],
+            'marginMode': marginMode,
+        }
+
+    async def set_margin_mode(self, marginMode: str, symbol: Str = None, params={}):
+        """
+        set margin mode to 'cross' or 'isolated'
+
+        https://docs.api.testnet.paradex.trade/#set-margin-configuration
+
+        :param str marginMode: 'cross' or 'isolated'
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.leverage]: the rate of leverage
+        :returns dict: response from the exchange
+        """
+        self.check_required_argument('setMarginMode', symbol, 'symbol')
+        await self.authenticate_rest()
+        await self.load_markets()
+        market: Market = self.market(symbol)
+        leverage: Str = None
+        leverage, params = self.handle_option_and_params(params, 'setMarginMode', 'leverage', 1)
+        request: dict = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': self.encode_margin_mode(marginMode),
+        }
+        return await self.privatePostAccountMarginMarket(self.extend(request, params))
+
+    async def fetch_leverage(self, symbol: str, params={}) -> Leverage:
+        """
+        fetch the set leverage for a market
+
+        https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `leverage structure <https://docs.ccxt.com/#/?id=leverage-structure>`
+        """
+        await self.authenticate_rest()
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.privateGetAccountMargin(self.extend(request, params))
+        #
+        # {
+        #     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        #     "configs": [
+        #         {
+        #             "market": "SOL-USD-PERP",
+        #             "leverage": 50,
+        #             "margin_type": "CROSS"
+        #         }
+        #     ]
+        # }
+        #
+        configs = self.safe_list(response, 'configs')
+        return self.parse_leverage(self.safe_dict(configs, 0), market)
+
+    def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
+        marketId = self.safe_string(leverage, 'market')
+        market = self.safe_market(marketId, market)
+        marginMode = self.safe_string_lower(leverage, 'margin_type')
+        return {
+            'info': leverage,
+            'symbol': self.safe_symbol(marketId, market),
+            'marginMode': marginMode,
+            'longLeverage': self.safe_integer(leverage, 'leverage'),
+            'shortLeverage': self.safe_integer(leverage, 'leverage'),
+        }
+
+    def encode_margin_mode(self, mode):
+        modes = {
+            'cross': 'CROSS',
+            'isolated': 'ISOLATED',
+        }
+        return self.safe_string(modes, mode, mode)
+
+    async def set_leverage(self, leverage: int, symbol: Str = None, params={}):
+        """
+        set the level of leverage for a market
+
+        https://docs.api.testnet.paradex.trade/#set-margin-configuration
+
+        :param float leverage: the rate of leverage
+        :param str [symbol]: unified market symbol(is mandatory for swap markets)
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: 'cross' or 'isolated'
+        :returns dict: response from the exchange
+        """
+        self.check_required_argument('setLeverage', symbol, 'symbol')
+        await self.authenticate_rest()
+        await self.load_markets()
+        market: Market = self.market(symbol)
+        marginMode: Str = None
+        marginMode, params = self.handle_margin_mode_and_params('setLeverage', params, 'cross')
+        request: dict = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': self.encode_margin_mode(marginMode),
+        }
+        return await self.privatePostAccountMarginMarket(self.extend(request, params))
+
+    async def fetch_greeks(self, symbol: str, params={}) -> Greeks:
+        """
+        fetches an option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
+
+        https://docs.api.testnet.paradex.trade/#list-available-markets-summary
+
+        :param str symbol: unified symbol of the market to fetch greeks for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `greeks structure <https://docs.ccxt.com/#/?id=greeks-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.publicGetMarketsSummary(self.extend(request, params))
+        #
+        #     {
+        #         "results": [
+        #             {
+        #                 "symbol": "BTC-USD-114000-P",
+        #                 "mark_price": "10835.66892602",
+        #                 "mark_iv": "0.71781855",
+        #                 "delta": "-0.98726024",
+        #                 "greeks": {
+        #                     "delta": "-0.9872602390817709",
+        #                     "gamma": "0.000004560958862297231",
+        #                     "vega": "227.11344863639806",
+        #                     "rho": "-302.0617972461581",
+        #                     "vanna": "0.06609830491614832",
+        #                     "volga": "925.9501532805552"
+        #                 },
+        #                 "last_traded_price": "10551.5",
+        #                 "bid": "10794.9",
+        #                 "bid_iv": "0.05",
+        #                 "ask": "10887.3",
+        #                 "ask_iv": "0.8783283",
+        #                 "last_iv": "0.05",
+        #                 "volume_24h": "0",
+        #                 "total_volume": "195240.72672261014",
+        #                 "created_at": 1747644009995,
+        #                 "underlying_price": "103164.79162649",
+        #                 "open_interest": "0",
+        #                 "funding_rate": "0.000004464241170536191",
+        #                 "price_change_rate_24h": "0.074915",
+        #                 "future_funding_rate": "0.0001"
+        #             }
+        #         ]
+        #     }
+        #
+        data = self.safe_list(response, 'results', [])
+        greeks = self.safe_dict(data, 0, {})
+        return self.parse_greeks(greeks, market)
+
+    async def fetch_all_greeks(self, symbols: Strings = None, params={}) -> List[Greeks]:
+        """
+        fetches all option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
+
+        https://docs.api.testnet.paradex.trade/#list-available-markets-summary
+
+        :param str[] [symbols]: unified symbols of the markets to fetch greeks for, all markets are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `greeks structure <https://docs.ccxt.com/#/?id=greeks-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True, True)
+        request: dict = {
+            'market': 'ALL',
+        }
+        response = await self.publicGetMarketsSummary(self.extend(request, params))
+        #
+        #     {
+        #         "results": [
+        #             {
+        #                 "symbol": "BTC-USD-114000-P",
+        #                 "mark_price": "10835.66892602",
+        #                 "mark_iv": "0.71781855",
+        #                 "delta": "-0.98726024",
+        #                 "greeks": {
+        #                     "delta": "-0.9872602390817709",
+        #                     "gamma": "0.000004560958862297231",
+        #                     "vega": "227.11344863639806",
+        #                     "rho": "-302.0617972461581",
+        #                     "vanna": "0.06609830491614832",
+        #                     "volga": "925.9501532805552"
+        #                 },
+        #                 "last_traded_price": "10551.5",
+        #                 "bid": "10794.9",
+        #                 "bid_iv": "0.05",
+        #                 "ask": "10887.3",
+        #                 "ask_iv": "0.8783283",
+        #                 "last_iv": "0.05",
+        #                 "volume_24h": "0",
+        #                 "total_volume": "195240.72672261014",
+        #                 "created_at": 1747644009995,
+        #                 "underlying_price": "103164.79162649",
+        #                 "open_interest": "0",
+        #                 "funding_rate": "0.000004464241170536191",
+        #                 "price_change_rate_24h": "0.074915",
+        #                 "future_funding_rate": "0.0001"
+        #             }
+        #         ]
+        #     }
+        #
+        results = self.safe_list(response, 'results', [])
+        return self.parse_all_greeks(results, symbols)
+
+    def parse_greeks(self, greeks: dict, market: Market = None) -> Greeks:
+        #
+        #     {
+        #         "symbol": "BTC-USD-114000-P",
+        #         "mark_price": "10835.66892602",
+        #         "mark_iv": "0.71781855",
+        #         "delta": "-0.98726024",
+        #         "greeks": {
+        #             "delta": "-0.9872602390817709",
+        #             "gamma": "0.000004560958862297231",
+        #             "vega": "227.11344863639806",
+        #             "rho": "-302.0617972461581",
+        #             "vanna": "0.06609830491614832",
+        #             "volga": "925.9501532805552"
+        #         },
+        #         "last_traded_price": "10551.5",
+        #         "bid": "10794.9",
+        #         "bid_iv": "0.05",
+        #         "ask": "10887.3",
+        #         "ask_iv": "0.8783283",
+        #         "last_iv": "0.05",
+        #         "volume_24h": "0",
+        #         "total_volume": "195240.72672261014",
+        #         "created_at": 1747644009995,
+        #         "underlying_price": "103164.79162649",
+        #         "open_interest": "0",
+        #         "funding_rate": "0.000004464241170536191",
+        #         "price_change_rate_24h": "0.074915",
+        #         "future_funding_rate": "0.0001"
+        #     }
+        #
+        marketId = self.safe_string(greeks, 'symbol')
+        market = self.safe_market(marketId, market, None, 'option')
+        symbol = market['symbol']
+        timestamp = self.safe_integer(greeks, 'created_at')
+        greeksData = self.safe_dict(greeks, 'greeks', {})
+        return {
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'delta': self.safe_number(greeksData, 'delta'),
+            'gamma': self.safe_number(greeksData, 'gamma'),
+            'theta': None,
+            'vega': self.safe_number(greeksData, 'vega'),
+            'rho': self.safe_number(greeksData, 'rho'),
+            'vanna': self.safe_number(greeksData, 'vanna'),
+            'volga': self.safe_number(greeksData, 'volga'),
+            'bidSize': None,
+            'askSize': None,
+            'bidImpliedVolatility': self.safe_number(greeks, 'bid_iv'),
+            'askImpliedVolatility': self.safe_number(greeks, 'ask_iv'),
+            'markImpliedVolatility': self.safe_number(greeks, 'mark_iv'),
+            'bidPrice': self.safe_number(greeks, 'bid'),
+            'askPrice': self.safe_number(greeks, 'ask'),
+            'markPrice': self.safe_number(greeks, 'mark_price'),
+            'lastPrice': self.safe_number(greeks, 'last_traded_price'),
+            'underlyingPrice': self.safe_number(greeks, 'underlying_price'),
+            'info': greeks,
+        }
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.implode_hostname(self.urls['api'][self.version]) + '/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))
@@ -1954,7 +2468,6 @@ class paradex(Exchange, ImplicitAPI):
             if query:
                 url += '?' + self.urlencode(query)
         elif api == 'private':
-            self.check_required_credentials()
             headers = {
                 'Accept': 'application/json',
                 'PARADEX-PARTNER': self.safe_string(self.options, 'broker', 'CCXT'),