ccxt 4.4.36__py2.py3-none-any.whl → 4.4.38__py2.py3-none-any.whl

ccxt/async_support/kucoin.py

@@ -928,6 +928,7 @@ class kucoin(Exchange, ImplicitAPI):
                     'TRUE': 'true',
                     'CS': 'cs',
                     'ORAI': 'orai',
+                    'BASE': 'base',
                     # below will be uncommented after consensus
                     # 'BITCOINDIAMON': 'bcd',
                     # 'BITCOINGOLD': 'btg',
@@ -1003,6 +1004,74 @@ class kucoin(Exchange, ImplicitAPI):
                     'spot': 'TRADE',
                 },
             },
+            'features': {
+                'spot': {
+                    'sandbox': False,
+                    'createOrder': {
+                        'marginMode': True,
+                        'triggerPrice': True,
+                        'triggerPriceType': None,
+                        'triggerDirection': False,
+                        'stopLossPrice': True,
+                        'takeProfitPrice': True,
+                        'attachedStopLossTakeProfit': None,  # not supported
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': True,
+                            'PO': True,
+                            'GTD': True,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        # exchange-supported features
+                        # 'iceberg': True,
+                        # 'selfTradePrevention': True,
+                        # 'twap': False,
+                        # 'oco': False,
+                    },
+                    'createOrders': {
+                        'max': 5,
+                    },
+                    'fetchMyTrades': {
+                        'marginMode': True,
+                        'limit': None,
+                        'daysBack': None,
+                        'untilDays': 7,  # per  implementation comments
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': True,
+                        'limit': 500,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': {
+                        'marginMode': True,
+                        'limit': 500,
+                        'daysBackClosed': None,
+                        'daysBackCanceled': None,
+                        'untilDays': 7,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 1500,
+                    },
+                },
+                'swap': {
+                    'linear': None,
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
         })
 
     def nonce(self):
@@ -2616,7 +2685,7 @@ class kucoin(Exchange, ImplicitAPI):
         await self.load_markets()
         lowercaseStatus = status.lower()
         until = self.safe_integer(params, 'until')
-        stop = self.safe_bool_2(params, 'stop', 'trigger', False)
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
         hf = None
         hf, params = self.handle_hf_and_params(params)
         if hf and (symbol is None):
@@ -2642,7 +2711,7 @@ class kucoin(Exchange, ImplicitAPI):
             request['endAt'] = until
         request['tradeType'] = self.safe_string(self.options['marginModes'], marginMode, 'TRADE')
         response = None
-        if stop:
+        if trigger:
             response = await self.privateGetStopOrder(self.extend(request, query))
         elif hf:
             if lowercaseStatus == 'active':
@@ -3054,6 +3123,10 @@ class kucoin(Exchange, ImplicitAPI):
         response = None
         request, params = self.handle_until_option('endAt', request, params)
         if hf:
+            # does not return trades earlier than 2019-02-18T00:00:00Z
+            if since is not None:
+                # only returns trades up to one week after the since param
+                request['startAt'] = since
             response = await self.privateGetHfFills(self.extend(request, params))
         elif method == 'private_get_fills':
             # does not return trades earlier than 2019-02-18T00:00:00Z

ccxt/async_support/kucoinfutures.py

@@ -370,6 +370,91 @@ class kucoinfutures(kucoin, ImplicitAPI):
                 #    'code': 'BTC',
                 # },
             },
+            'features': {
+                'spot': None,
+                'forDerivs': {
+                    'sandbox': False,
+                    'createOrder': {
+                        'marginMode': True,
+                        'triggerPrice': True,
+                        'triggerPriceType': {
+                            'last': True,
+                            'mark': True,
+                            'index': True,
+                        },
+                        'triggerDirection': True,
+                        'stopLossPrice': True,
+                        'takeProfitPrice': True,
+                        'attachedStopLossTakeProfit': {
+                            'triggerPrice': None,
+                            'triggerPriceType': None,
+                            'limitPrice': True,
+                        },
+                        'timeInForce': {
+                            'IOC': True,
+                            'FOK': False,
+                            'PO': True,
+                            'GTD': False,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        # exchange-supported features
+                        # 'iceberg': True,
+                        # 'selfTradePrevention': True,
+                        # 'twap': False,
+                        # 'oco': False,
+                    },
+                    'createOrders': {
+                        'max': 20,
+                    },
+                    'fetchMyTrades': {
+                        'marginMode': True,
+                        'limit': 1000,
+                        'daysBack': None,
+                        'untilDays': 7,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,
+                    'fetchClosedOrders': {
+                        'marginMode': False,
+                        'limit': 1000,
+                        'daysBackClosed': None,
+                        'daysBackCanceled': None,
+                        'untilDays': None,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOHLCV': {
+                        'limit': 500,
+                    },
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'forDerivs',
+                    },
+                    'inverse': {
+                        'extends': 'forDerivs',
+                    },
+                },
+                'future': {
+                    'linear': {
+                        'extends': 'forDerivs',
+                    },
+                    'inverse': {
+                        'extends': 'forDerivs',
+                    },
+                },
+            },
         })
 
     async def fetch_status(self, params={}):
@@ -1698,10 +1783,10 @@ class kucoinfutures(kucoin, ImplicitAPI):
         request: dict = {}
         if symbol is not None:
             request['symbol'] = self.market_id(symbol)
-        stop = self.safe_value_2(params, 'stop', 'trigger')
+        trigger = self.safe_value_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         response = None
-        if stop:
+        if trigger:
             response = await self.futuresPrivateDeleteStopOrders(self.extend(request, params))
         else:
             response = await self.futuresPrivateDeleteOrders(self.extend(request, params))
@@ -1882,7 +1967,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchOrdersByStatus', 'paginate')
         if paginate:
             return await self.fetch_paginated_call_dynamic('fetchOrdersByStatus', symbol, since, limit, params)
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         until = self.safe_integer(params, 'until')
         params = self.omit(params, ['stop', 'until', 'trigger'])
         if status == 'closed':
@@ -1890,7 +1975,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         elif status == 'open':
             status = 'active'
         request: dict = {}
-        if not stop:
+        if not trigger:
             request['status'] = status
         elif status != 'active':
             raise BadRequest(self.id + ' fetchOrdersByStatus() can only fetch untriggered stop orders')
@@ -1903,7 +1988,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
         if until is not None:
             request['endAt'] = until
         response = None
-        if stop:
+        if trigger:
             response = await self.futuresPrivateGetStopOrders(self.extend(request, params))
         else:
             response = await self.futuresPrivateGetOrders(self.extend(request, params))
@@ -2510,6 +2595,8 @@ class kucoinfutures(kucoin, ImplicitAPI):
             request['symbol'] = market['id']
         if since is not None:
             request['startAt'] = since
+        if limit is not None:
+            request['pageSize'] = min(1000, limit)
         request, params = self.handle_until_option('endAt', request, params)
         response = await self.futuresPrivateGetFills(self.extend(request, params))
         #

ccxt/async_support/ndax.py

@@ -1069,8 +1069,10 @@ class ndax(Exchange, ImplicitAPI):
         omsId = self.safe_integer(self.options, 'omsId', 1)
         await self.load_markets()
         await self.load_accounts()
-        defaultAccountId = self.safe_integer_2(self.options, 'accountId', 'AccountId', int(self.accounts[0]['id']))
+        defaultAccountId = self.safe_integer_2(self.options, 'accountId', 'AccountId')
         accountId = self.safe_integer_2(params, 'accountId', 'AccountId', defaultAccountId)
+        if accountId is None:
+            accountId = int(self.accounts[0]['id'])
         params = self.omit(params, ['accountId', 'AccountId'])
         request: dict = {
             'omsId': omsId,
@@ -1348,6 +1350,7 @@ class ndax(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.triggerPrice]: the price at which a trigger order would be triggered
+        :param str [params.clientOrderId]: a unique id for the order
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         omsId = self.safe_integer(self.options, 'omsId', 1)
@@ -1578,6 +1581,7 @@ class ndax(Exchange, ImplicitAPI):
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.clientOrderId]: a unique id for the order
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         omsId = self.safe_integer(self.options, 'omsId', 1)

ccxt/async_support/okx.py

@@ -1225,7 +1225,6 @@ class okx(Exchange, ImplicitAPI):
                             'limitPrice': True,
                         },
                         'timeInForce': {
-                            'GTC': True,
                             'IOC': True,
                             'FOK': True,
                             'PO': True,

ccxt/async_support/paradex.py

@@ -276,6 +276,7 @@ class paradex(Exchange, ImplicitAPI):
             'commonCurrencies': {
             },
             'options': {
+                'paradexAccount': None,  # add {"privateKey": A, "publicKey": B, "address": C}
                 'broker': 'CCXT',
             },
         })
@@ -964,10 +965,10 @@ class paradex(Exchange, ImplicitAPI):
         }
 
     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 = {
@@ -1956,7 +1957,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'),

ccxt/async_support/probit.py

@@ -287,6 +287,8 @@ class probit(Exchange, ImplicitAPI):
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
         closed = self.safe_bool(market, 'closed', False)
+        showInUI = self.safe_bool(market, 'show_in_ui', True)
+        active = not closed and showInUI
         takerFeeRate = self.safe_string(market, 'taker_fee_rate')
         taker = Precise.string_div(takerFeeRate, '100')
         makerFeeRate = self.safe_string(market, 'maker_fee_rate')
@@ -306,7 +308,7 @@ class probit(Exchange, ImplicitAPI):
             'swap': False,
             'future': False,
             'option': False,
-            'active': not closed,
+            'active': active,
             'contract': False,
             'linear': None,
             'inverse': None,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.36'
+__version__ = '4.4.38'
 
 # -----------------------------------------------------------------------------
 
@@ -2791,6 +2791,9 @@ class Exchange(object):
 
     def features_mapper(self, initialFeatures: Any, marketType: Str, subType: Str = None):
         featuresObj = initialFeatures[marketType][subType] if (subType is not None) else initialFeatures[marketType]
+        # if exchange does not have that market-type(eg. future>inverse)
+        if featuresObj is None:
+            return None
         extendsStr: Str = self.safe_string(featuresObj, 'extends')
         if extendsStr is not None:
             featuresObj = self.omit(featuresObj, 'extends')
@@ -2804,9 +2807,13 @@ class Exchange(object):
             if value is not None:
                 featuresObj['createOrder']['stopLoss'] = value
                 featuresObj['createOrder']['takeProfit'] = value
-            # False 'hedged' for spot
+            # for spot, default 'hedged' to False
             if marketType == 'spot':
                 featuresObj['createOrder']['hedged'] = False
+            # default 'GTC' to True
+            gtcValue = self.safe_bool(featuresObj['createOrder']['timeInForce'], 'gtc')
+            if gtcValue is None:
+                featuresObj['createOrder']['timeInForce']['GTC'] = True
         return featuresObj
 
     def orderbook_checksum_message(self, symbol: Str):

ccxt/binance.py

@@ -1591,7 +1591,6 @@ class binance(Exchange, ImplicitAPI):
                         'takeProfitPrice': True,
                         'attachedStopLossTakeProfit': None,  # not supported
                         'timeInForce': {
-                            'GTC': True,
                             'IOC': True,
                             'FOK': True,
                             'PO': True,
@@ -1658,7 +1657,6 @@ class binance(Exchange, ImplicitAPI):
                         'takeProfitPrice': True,
                         'attachedStopLossTakeProfit': None,  # not supported
                         'timeInForce': {
-                            'GTC': True,
                             'IOC': True,
                             'FOK': True,
                             'PO': True,

ccxt/bingx.py

@@ -95,7 +95,7 @@ class bingx(Exchange, ImplicitAPI):
                 'fetchPositionHistory': False,
                 'fetchPositionMode': True,
                 'fetchPositions': True,
-                'fetchPositionsHistory': False,
+                'fetchPositionsHistory': True,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': True,
@@ -219,7 +219,6 @@ class bingx(Exchange, ImplicitAPI):
                         'private': {
                             'get': {
                                 'positionSide/dual': 5,
-                                'market/markPriceKlines': 1,
                                 'trade/batchCancelReplace': 5,
                                 'trade/fullOrder': 2,
                                 'maintMarginRatio': 2,
@@ -553,7 +552,6 @@ class bingx(Exchange, ImplicitAPI):
                             'limitPrice': True,
                         },
                         'timeInForce': {
-                            'GTC': True,
                             'IOC': True,
                             'FOK': True,
                             'PO': True,
@@ -1015,7 +1013,7 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/swapV2/market-api.html#K-Line%20Data
         https://bingx-api.github.io/docs/#/spot/market-api.html#Candlestick%20chart%20data
         https://bingx-api.github.io/docs/#/swapV2/market-api.html#%20K-Line%20Data
-        https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#K-Line%20Data%20-%20Mark%20Price
+        https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Mark%20Price%20Kline/Candlestick%20Data
         https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Get%20K-line%20Data
 
         :param str symbol: unified symbol of the market to fetch OHLCV data for
@@ -1055,7 +1053,7 @@ class bingx(Exchange, ImplicitAPI):
                 price = self.safe_string(params, 'price')
                 params = self.omit(params, 'price')
                 if price == 'mark':
-                    response = self.swapV1PrivateGetMarketMarkPriceKlines(self.extend(request, params))
+                    response = self.swapV1PublicGetMarketMarkPriceKlines(self.extend(request, params))
                 else:
                     response = self.swapV3PublicGetQuoteKlines(self.extend(request, params))
         #
@@ -2264,6 +2262,67 @@ class bingx(Exchange, ImplicitAPI):
             result[code] = account
         return self.safe_balance(result)
 
+    def fetch_position_history(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Position]:
+        """
+        fetches historical positions
+
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Position%20History
+
+        :param str symbol: unified contract symbol
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum amount of records to fetch
+        :param dict [params]: extra parameters specific to the exchange api endpoint
+        :param int [params.until]: the latest time in ms to fetch positions for
+        :returns dict[]: a list of `position structures <https://docs.ccxt.com/#/?id=position-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'symbol': market['id'],
+        }
+        if limit is not None:
+            request['pageSize'] = limit
+        if since is not None:
+            request['startTs'] = since
+        request, params = self.handle_until_option('endTs', request, params)
+        response = None
+        if market['linear']:
+            response = self.swapV1PrivateGetTradePositionHistory(self.extend(request, params))
+        else:
+            raise NotSupported(self.id + ' fetchPositionHistory() is not supported for inverse swap positions')
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "positionHistory": [
+        #                 {
+        #                     "positionId": "1861675561156571136",
+        #                     "symbol": "LTC-USDT",
+        #                     "isolated": False,
+        #                     "positionSide": "LONG",
+        #                     "openTime": 1732693017000,
+        #                     "updateTime": 1733310292000,
+        #                     "avgPrice": "95.18",
+        #                     "avgClosePrice": "129.48",
+        #                     "realisedProfit": "102.89",
+        #                     "netProfit": "99.63",
+        #                     "positionAmt": "30.0",
+        #                     "closePositionAmt": "30.0",
+        #                     "leverage": 6,
+        #                     "closeAllPositions": True,
+        #                     "positionCommission": "-0.33699650000000003",
+        #                     "totalFunding": "-2.921461693902908"
+        #                 },
+        #             ]
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        records = self.safe_list(data, 'positionHistory', [])
+        positions = self.parse_positions(records)
+        return self.filter_by_symbol_since_limit(positions, symbol, since, limit)
+
     def fetch_positions(self, symbols: Strings = None, params={}):
         """
         fetch all open positions
@@ -2503,12 +2562,34 @@ class bingx(Exchange, ImplicitAPI):
         #         "positionAmt": "1.20365912",
         #     }
         #
+        # linear swap fetchPositionHistory
+        #
+        #     {
+        #         "positionId": "1861675561156571136",
+        #         "symbol": "LTC-USDT",
+        #         "isolated": False,
+        #         "positionSide": "LONG",
+        #         "openTime": 1732693017000,
+        #         "updateTime": 1733310292000,
+        #         "avgPrice": "95.18",
+        #         "avgClosePrice": "129.48",
+        #         "realisedProfit": "102.89",
+        #         "netProfit": "99.63",
+        #         "positionAmt": "30.0",
+        #         "closePositionAmt": "30.0",
+        #         "leverage": 6,
+        #         "closeAllPositions": True,
+        #         "positionCommission": "-0.33699650000000003",
+        #         "totalFunding": "-2.921461693902908"
+        #     }
+        #
         marketId = self.safe_string(position, 'symbol', '')
         marketId = marketId.replace('/', '-')  # standard return different format
         isolated = self.safe_bool(position, 'isolated')
         marginMode = None
         if isolated is not None:
             marginMode = 'isolated' if isolated else 'cross'
+        timestamp = self.safe_integer(position, 'openTime')
         return self.safe_position({
             'info': position,
             'id': self.safe_string(position, 'positionId'),
@@ -2526,8 +2607,8 @@ class bingx(Exchange, ImplicitAPI):
             'lastPrice': None,
             'side': self.safe_string_lower(position, 'positionSide'),
             'hedged': None,
-            'timestamp': None,
-            'datetime': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'lastUpdateTimestamp': self.safe_integer(position, 'updateTime'),
             'maintenanceMargin': None,
             'maintenanceMarginPercentage': None,
@@ -6088,7 +6169,7 @@ class bingx(Exchange, ImplicitAPI):
                 body = self.json(parsedParams)
             else:
                 query = self.urlencode(parsedParams)
-                url += '?' + query + '&signature=' + signature
+                url += '?' + query + '&' + 'signature=' + signature
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def nonce(self):