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

ccxt/kraken.py

@@ -1616,6 +1616,8 @@ class kraken(Exchange, ImplicitAPI):
             'volume': self.amount_to_precision(symbol, amount),
         }
         orderRequest = self.order_request('createOrder', symbol, type, request, amount, price, params)
+        flags = self.safe_string(orderRequest[0], 'oflags', '')
+        isUsingCost = flags.find('viqc') > -1
         response = self.privatePostAddOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -1627,6 +1629,10 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         result = self.safe_dict(response, 'result')
+        result['usingCost'] = isUsingCost
+        # it's impossible to know if the order was created using cost or base currency
+        # becuase kraken only returns something like self: {order: 'buy 10.00000000 LTCUSD @ market'}
+        # self usingCost flag is used to help the parsing but omited from the order
         return self.parse_order(result)
 
     def find_market_by_altname_or_id(self, id):
@@ -1713,22 +1719,15 @@ class kraken(Exchange, ImplicitAPI):
         #     }
         #
         #  ws - createOrder
-        #    {
-        #        "descr": 'sell 0.00010000 XBTUSDT @ market',
-        #        "event": 'addOrderStatus',
-        #        "reqid": 1,
-        #        "status": 'ok',
-        #        "txid": 'OAVXZH-XIE54-JCYYDG'
-        #    }
+        #     {
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
+        #
         #  ws - editOrder
-        #    {
-        #        "descr": "order edited price = 9000.00000000",
-        #        "event": "editOrderStatus",
-        #        "originaltxid": "O65KZW-J4AW3-VFS74A",
-        #        "reqid": 3,
-        #        "status": "ok",
-        #        "txid": "OTI672-HJFAO-XOIPPK"
-        #    }
+        #     {
+        #         "amend_id": "TJSMEH-AA67V-YUSQ6O",
+        #         "order_id": "OXM2QD-EALR2-YBAVEU"
+        #     }
         #
         #  {
         #      "error": [],
@@ -1796,6 +1795,8 @@ class kraken(Exchange, ImplicitAPI):
         #         "oflags": "fciq"
         #     }
         #
+        isUsingCost = self.safe_bool(order, 'usingCost', False)
+        order = self.omit(order, 'usingCost')
         description = self.safe_dict(order, 'descr', {})
         orderDescriptionObj = self.safe_dict(order, 'descr')  # can be null
         orderDescription = None
@@ -1808,11 +1809,15 @@ class kraken(Exchange, ImplicitAPI):
         marketId = None
         price = None
         amount = None
+        cost = None
         triggerPrice = None
         if orderDescription is not None:
             parts = orderDescription.split(' ')
             side = self.safe_string(parts, 0)
-            amount = self.safe_string(parts, 1)
+            if not isUsingCost:
+                amount = self.safe_string(parts, 1)
+            else:
+                cost = self.safe_string(parts, 1)
             marketId = self.safe_string(parts, 2)
             part4 = self.safe_string(parts, 4)
             part5 = self.safe_string(parts, 5)
@@ -1842,13 +1847,12 @@ class kraken(Exchange, ImplicitAPI):
         # kraken truncates the cost in the api response so we will ignore it and calculate it from average & filled
         # cost = self.safe_string(order, 'cost')
         price = self.safe_string(description, 'price', price)
-        # when type = trailling stop returns price = '+50.0000%'
-        if (price is not None) and price.endswith('%'):
+        # when type = trailing stop returns price = '+50.0000%'
+        if (price is not None) and (price.endswith('%') or Precise.string_equals(price, '0.00000') or Precise.string_equals(price, '0')):
             price = None  # self is not the price we want
-        if (price is None) or Precise.string_equals(price, '0'):
+        if price is None:
             price = self.safe_string(description, 'price2')
-        if (price is None) or Precise.string_equals(price, '0'):
-            price = self.safe_string(order, 'price', price)
+            price = self.safe_string_2(order, 'limitprice', 'price', price)
         flags = self.safe_string(order, 'oflags', '')
         isPostOnly = flags.find('post') > -1
         average = self.safe_number(order, 'price')
@@ -1865,7 +1869,7 @@ class kraken(Exchange, ImplicitAPI):
                 elif flags.find('fcib') >= 0:
                     fee['currency'] = market['base']
         status = self.parse_order_status(self.safe_string(order, 'status'))
-        id = self.safe_string_n(order, ['id', 'txid', 'amend_id'])
+        id = self.safe_string_n(order, ['id', 'txid', 'order_id', 'amend_id'])
         if (id is None) or (id.startswith('[')):
             txid = self.safe_list(order, 'txid')
             id = self.safe_string(txid, 0)
@@ -1922,7 +1926,7 @@ class kraken(Exchange, ImplicitAPI):
             'triggerPrice': triggerPrice,
             'takeProfitPrice': takeProfitPrice,
             'stopLossPrice': stopLossPrice,
-            'cost': None,
+            'cost': cost,
             'amount': amount,
             'filled': filled,
             'average': average,

ccxt/kucoinfutures.py

@@ -1510,6 +1510,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         :param str [params.timeInForce]: GTC, GTT, IOC, or FOK, default is GTC, limit orders only
         :param str [params.postOnly]: Post only flag, invalid when timeInForce is IOC or FOK
         :param float [params.cost]: the cost of the order in units of USDT
+        :param str [params.marginMode]: 'cross' or 'isolated', default is 'isolated'
  ----------------- Exchange Specific Parameters -----------------
         :param float [params.leverage]: Leverage size of the order(mandatory param in request, default is 1)
         :param str [params.clientOid]: client order id, defaults to uuid if not passed
@@ -1607,6 +1608,10 @@ class kucoinfutures(kucoin, ImplicitAPI):
             'type': type,  # limit or market
             'leverage': 1,
         }
+        marginModeUpper = self.safe_string_upper(params, 'marginMode')
+        if marginModeUpper is not None:
+            params = self.omit(params, 'marginMode')
+            request['marginMode'] = marginModeUpper
         cost = self.safe_string(params, 'cost')
         params = self.omit(params, 'cost')
         if cost is not None:

ccxt/lbank.py

@@ -875,7 +875,7 @@ class lbank(Exchange, ImplicitAPI):
         timestamp = self.milliseconds()
         if market['swap']:
             return self.parse_order_book(orderbook, market['symbol'], timestamp, 'bids', 'asks', 'price', 'volume')
-        return self.parse_order_book(orderbook, market['symbol'], timestamp)
+        return self.parse_order_book(orderbook, market['symbol'], timestamp, 'bids', 'asks', 1, 0)
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #

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/paradex.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.paradex import ImplicitAPI
-from ccxt.base.types import Any, Balances, Currency, Int, Leverage, MarginMode, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, 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
@@ -75,6 +75,7 @@ class paradex(Exchange, ImplicitAPI):
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': True,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
@@ -558,13 +559,14 @@ class paradex(Exchange, ImplicitAPI):
         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
-        takerFee = self.parse_number('0.0003')
-        makerFee = self.parse_number('-0.00005')
         return self.safe_market_structure({
             'id': marketId,
             'symbol': symbol,
@@ -1262,7 +1264,7 @@ 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': reduceOnly,
             'side': side,
@@ -2284,6 +2286,120 @@ class paradex(Exchange, ImplicitAPI):
         }
         return self.privatePostAccountMarginMarket(self.extend(request, params))
 
+    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>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = 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)
+
+    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))

ccxt/pro/__init__.py

@@ -4,13 +4,81 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.85'
 
 # ----------------------------------------------------------------------------
 
 from ccxt.async_support.base.exchange import Exchange  # noqa: F401
 
 # CCXT Pro exchanges (now this is mainly used for importing exchanges in WS tests)
+
+# DO_NOT_REMOVE__ERROR_IMPORTS_START
+from ccxt.base.errors import BaseError                                # noqa: F401
+from ccxt.base.errors import ExchangeError                            # noqa: F401
+from ccxt.base.errors import AuthenticationError                      # noqa: F401
+from ccxt.base.errors import PermissionDenied                         # noqa: F401
+from ccxt.base.errors import AccountNotEnabled                        # noqa: F401
+from ccxt.base.errors import AccountSuspended                         # noqa: F401
+from ccxt.base.errors import ArgumentsRequired                        # noqa: F401
+from ccxt.base.errors import BadRequest                               # noqa: F401
+from ccxt.base.errors import BadSymbol                                # noqa: F401
+from ccxt.base.errors import OperationRejected                        # noqa: F401
+from ccxt.base.errors import NoChange                                 # noqa: F401
+from ccxt.base.errors import MarginModeAlreadySet                     # noqa: F401
+from ccxt.base.errors import MarketClosed                             # noqa: F401
+from ccxt.base.errors import ManualInteractionNeeded                  # noqa: F401
+from ccxt.base.errors import InsufficientFunds                        # noqa: F401
+from ccxt.base.errors import InvalidAddress                           # noqa: F401
+from ccxt.base.errors import AddressPending                           # noqa: F401
+from ccxt.base.errors import InvalidOrder                             # noqa: F401
+from ccxt.base.errors import OrderNotFound                            # noqa: F401
+from ccxt.base.errors import OrderNotCached                           # noqa: F401
+from ccxt.base.errors import OrderImmediatelyFillable                 # noqa: F401
+from ccxt.base.errors import OrderNotFillable                         # noqa: F401
+from ccxt.base.errors import DuplicateOrderId                         # noqa: F401
+from ccxt.base.errors import ContractUnavailable                      # noqa: F401
+from ccxt.base.errors import NotSupported                             # noqa: F401
+from ccxt.base.errors import InvalidProxySettings                     # noqa: F401
+from ccxt.base.errors import ExchangeClosedByUser                     # noqa: F401
+from ccxt.base.errors import OperationFailed                          # noqa: F401
+from ccxt.base.errors import NetworkError                             # noqa: F401
+from ccxt.base.errors import DDoSProtection                           # noqa: F401
+from ccxt.base.errors import RateLimitExceeded                        # noqa: F401
+from ccxt.base.errors import ExchangeNotAvailable                     # noqa: F401
+from ccxt.base.errors import OnMaintenance                            # noqa: F401
+from ccxt.base.errors import InvalidNonce                             # noqa: F401
+from ccxt.base.errors import ChecksumError                            # noqa: F401
+from ccxt.base.errors import RequestTimeout                           # noqa: F401
+from ccxt.base.errors import BadResponse                              # noqa: F401
+from ccxt.base.errors import NullResponse                             # noqa: F401
+from ccxt.base.errors import CancelPending                            # noqa: F401
+from ccxt.base.errors import UnsubscribeError                         # noqa: F401
+from ccxt.base.errors import error_hierarchy                          # noqa: F401
+# DO_NOT_REMOVE__ERROR_IMPORTS_END
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 from ccxt.pro.alpaca import alpaca                                        # noqa: F401
 from ccxt.pro.apex import apex                                            # noqa: F401
@@ -57,7 +125,6 @@ from ccxt.pro.htx import htx                                              # noqa
 from ccxt.pro.huobi import huobi                                          # noqa: F401
 from ccxt.pro.huobijp import huobijp                                      # noqa: F401
 from ccxt.pro.hyperliquid import hyperliquid                              # noqa: F401
-from ccxt.pro.idex import idex                                            # noqa: F401
 from ccxt.pro.independentreserve import independentreserve                # noqa: F401
 from ccxt.pro.kraken import kraken                                        # noqa: F401
 from ccxt.pro.krakenfutures import krakenfutures                          # noqa: F401
@@ -131,7 +198,6 @@ exchanges = [
     'huobi',
     'huobijp',
     'hyperliquid',
-    'idex',
     'independentreserve',
     'kraken',
     'krakenfutures',