ccxt 4.4.50__tar.gz → 4.4.52__tar.gz

{ccxt-4.4.50/ccxt.egg-info → ccxt-4.4.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.50
+Version: 4.4.52
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -12,7 +12,6 @@ Project-URL: Discord, https://discord.gg/ccxt
 Project-URL: Twitter, https://twitter.com/ccxt_official
 Project-URL: Funding, https://opencollective.com/ccxt
 Keywords: algorithmic,algotrading,altcoin,altcoins,api,arbitrage,real-time,realtime,backtest,backtesting,bitcoin,bot,btc,cny,coin,coins,crypto,cryptocurrency,crypto currency,crypto market,currency,currencies,darkcoin,dash,digital currency,doge,dogecoin,e-commerce,etc,eth,ether,ethereum,exchange,exchanges,eur,framework,invest,investing,investor,library,light,litecoin,ltc,market,market data,markets,merchandise,merchant,minimal,ohlcv,order,orderbook,order book,price,price data,pricefeed,private,public,ripple,strategy,ticker,tickers,toolkit,trade,trader,trading,usd,volume,websocket,websockets,web socket,web sockets,ws,xbt,xrp,zec,zerocoin
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Financial and Insurance Industry
@@ -60,6 +59,9 @@ Current feature list:
 
 ## Sponsored Promotion
 
+[![Gate-3rd-Trading-Carnival](https://github.com/user-attachments/assets/6cbb4055-97a8-4985-8c55-0056b4a8612c)](https://www.gate.io/activities/ccxt-trading-competition)
+
+
 ## See Also
 
 - <sub>[![TabTrader](https://user-images.githubusercontent.com/1294454/66755907-9c3e8880-eea1-11e9-846e-0bff349ceb87.png)](https://tab-trader.com/?utm_source=ccxt)</sub> **[TabTrader](https://tab-trader.com/?utm_source=ccxt)** – trading on all exchanges in one app. Available on **[Android](https://play.google.com/store/apps/details?id=com.tabtrader.android&referrer=utm_source%3Dccxt)** and **[iOS](https://itunes.apple.com/app/apple-store/id1095716562?mt=8)**!
@@ -265,13 +267,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.50/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.50/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.52/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.52/dist/ccxt.browser.min.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.50/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.52/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object:
@@ -631,5 +633,3 @@ Thank you!
 ## Contact Us
 
 For business inquiries: info@ccxt.trade
-
-

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.50'
+__version__ = '4.4.52'
 
 # ----------------------------------------------------------------------------
 

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/alpaca.py

@@ -445,7 +445,7 @@ class alpaca(Exchange, ImplicitAPI):
         #         "status": "active",
         #         "tradable": True,
         #         "marginable": False,
-        #         "maintenance_margin_requirement": 100,
+        #         "maintenance_margin_requirement": 101,
         #         "shortable": False,
         #         "easy_to_borrow": False,
         #         "fractionable": True,

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.50'
+__version__ = '4.4.52'
 
 # -----------------------------------------------------------------------------
 

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/alpaca.py

@@ -445,7 +445,7 @@ class alpaca(Exchange, ImplicitAPI):
         #         "status": "active",
         #         "tradable": True,
         #         "marginable": False,
-        #         "maintenance_margin_requirement": 100,
+        #         "maintenance_margin_requirement": 101,
         #         "shortable": False,
         #         "easy_to_borrow": False,
         #         "fractionable": True,

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.50'
+__version__ = '4.4.52'
 
 # -----------------------------------------------------------------------------
 

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/binance.py

@@ -1600,7 +1600,7 @@ class binance(Exchange, ImplicitAPI):
                         'triggerDirection': False,
                         'stopLossPrice': True,
                         'takeProfitPrice': True,
-                        'attachedStopLossTakeProfit': None,  # not supported
+                        'attachedStopLossTakeProfit': None,
                         'timeInForce': {
                             'IOC': True,
                             'FOK': True,
@@ -1609,12 +1609,16 @@ class binance(Exchange, ImplicitAPI):
                         },
                         'hedged': True,
                         'leverage': False,
-                        'marketBuyRequiresPrice': False,
                         'marketBuyByCost': True,
-                        # exchange-supported features
-                        'selfTradePrevention': True,  # todo
-                        'trailing': True,
-                        'iceberg': True,  # todo implementation
+                        'marketBuyRequiresPrice': False,
+                        'selfTradePrevention': {
+                            'expire_maker': True,
+                            'expire_taker': True,
+                            'expire_both': True,
+                            'none': True,
+                        },
+                        'trailing': False,  # todo: self is different from standard trailing https://github.com/binance/binance-spot-api-docs/blob/master/faqs/trailing-stop-faq.md
+                        'icebergAmount': True,
                     },
                     'createOrders': None,
                     'fetchMyTrades': {
@@ -1655,7 +1659,7 @@ class binance(Exchange, ImplicitAPI):
                         'limit': 1000,
                     },
                 },
-                'default': {
+                'forDerivatives': {
                     'sandbox': True,
                     'createOrder': {
                         'marginMode': False,
@@ -1727,18 +1731,18 @@ class binance(Exchange, ImplicitAPI):
                 },
                 'swap': {
                     'linear': {
-                        'extends': 'default',
+                        'extends': 'forDerivatives',
                     },
                     'inverse': {
-                        'extends': 'default',
+                        'extends': 'forDerivatives',
                     },
                 },
                 'future': {
                     'linear': {
-                        'extends': 'default',
+                        'extends': 'forDerivatives',
                     },
                     'inverse': {
-                        'extends': 'default',
+                        'extends': 'forDerivatives',
                     },
                 },
             },
@@ -4402,12 +4406,11 @@ class binance(Exchange, ImplicitAPI):
         type = 'spot' if (timestamp is None) else 'swap'
         marketId = self.safe_string(entry, 'symbol')
         market = self.safe_market(marketId, market, None, type)
-        price = self.safe_number(entry, 'price')
         return {
             'symbol': market['symbol'],
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
-            'price': price,
+            'price': self.safe_number_omit_zero(entry, 'price'),
             'side': None,
             'info': entry,
         }
@@ -6022,7 +6025,7 @@ class binance(Exchange, ImplicitAPI):
         """
         create a trade order
 
-        https://developers.binance.com/docs/binance-spot-api-docs/rest-api/public-api-endpoints#new-order-trade
+        https://developers.binance.com/docs/binance-spot-api-docs/rest-api/trading-endpoints#new-order-trade
         https://developers.binance.com/docs/binance-spot-api-docs/rest-api/public-api-endpoints#test-new-order-trade
         https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/New-Order
         https://developers.binance.com/docs/derivatives/coin-margined-futures/trade/New-Order
@@ -6051,6 +6054,8 @@ class binance(Exchange, ImplicitAPI):
         :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 boolean [params.portfolioMargin]: set to True if you would like to create an order in a portfolio margin account
+        :param str [params.selfTradePrevention]: set unified value for stp(see .features for available values)
+        :param float [params.icebergAmount]: set iceberg amount for limit orders
         :param str [params.stopLossOrTakeProfit]: 'stopLoss' or 'takeProfit', required for spot trailing orders
         :param str [params.positionSide]: *swap and portfolio margin only* "BOTH" for one-way mode, "LONG" for buy side of hedged mode, "SHORT" for sell side of hedged mode
         :param bool [params.hedged]: *swap and portfolio margin only* True for hedged mode, False for one way mode, default is False
@@ -6344,7 +6349,7 @@ class binance(Exchange, ImplicitAPI):
             if stopPrice is not None:
                 request['stopPrice'] = self.price_to_precision(symbol, stopPrice)
         if timeInForceIsRequired and (self.safe_string(params, 'timeInForce') is None) and (self.safe_string(request, 'timeInForce') is None):
-            request['timeInForce'] = self.options['defaultTimeInForce']  # 'GTC' = Good To Cancel(default), 'IOC' = Immediate Or Cancel
+            request['timeInForce'] = self.safe_string(self.options, 'defaultTimeInForce')  # 'GTC' = Good To Cancel(default), 'IOC' = Immediate Or Cancel
         if not isPortfolioMargin and market['contract'] and postOnly:
             request['timeInForce'] = 'GTX'
         # remove timeInForce from params because PO is only used by self.is_post_only and it's not a valid value for Binance
@@ -6356,7 +6361,17 @@ class binance(Exchange, ImplicitAPI):
                 params = self.omit(params, 'reduceOnly')
                 side = 'sell' if (side == 'buy') else 'buy'
             request['positionSide'] = 'LONG' if (side == 'buy') else 'SHORT'
-        requestParams = self.omit(params, ['type', 'newClientOrderId', 'clientOrderId', 'postOnly', 'stopLossPrice', 'takeProfitPrice', 'stopPrice', 'triggerPrice', 'trailingTriggerPrice', 'trailingPercent', 'quoteOrderQty', 'cost', 'test', 'hedged'])
+        # unified stp
+        selfTradePrevention = self.safe_string(params, 'selfTradePrevention')
+        if selfTradePrevention is not None:
+            if market['spot']:
+                request['selfTradePreventionMode'] = selfTradePrevention.upper()  # binance enums exactly match the unified ccxt enums(but needs uppercase)
+        # unified iceberg
+        icebergAmount = self.safe_number(params, 'icebergAmount')
+        if icebergAmount is not None:
+            if market['spot']:
+                request['icebergQty'] = self.amount_to_precision(symbol, icebergAmount)
+        requestParams = self.omit(params, ['type', 'newClientOrderId', 'clientOrderId', 'postOnly', 'stopLossPrice', 'takeProfitPrice', 'stopPrice', 'triggerPrice', 'trailingTriggerPrice', 'trailingPercent', 'quoteOrderQty', 'cost', 'test', 'hedged', 'selfTradePrevention', 'icebergAmount'])
         return self.extend(request, requestParams)
 
     async def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost: float, params={}):

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/blofin.py

@@ -166,6 +166,9 @@ class blofin(Exchange, ImplicitAPI):
                 'api': {
                     'rest': 'https://openapi.blofin.com',
                 },
+                'test': {
+                    'rest': 'https://demo-trading-openapi.blofin.com',
+                },
                 'referral': {
                     'url': 'https://blofin.com/register?referral_code=f79EsS',
                     'discount': 0.05,
@@ -323,6 +326,7 @@ class blofin(Exchange, ImplicitAPI):
                         'attachedStopLossTakeProfit': {
                             'triggerPriceType': None,
                             'limit': True,
+                            'price': None,
                         },
                         'hedged': True,
                     },

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/coinex.py

@@ -3767,7 +3767,7 @@ class coinex(Exchange, ImplicitAPI):
             'currency': self.safe_currency_code(None, currency),
             'network': None,
             'address': address,
-            'tag': tag,
+            'tag': self.safe_string(depositAddress, 'memo', tag),
         }
 
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/coinmetro.py

@@ -219,7 +219,7 @@ class coinmetro(Exchange, ImplicitAPI):
             # exchange-specific options
             'options': {
                 'currenciesByIdForParseMarket': None,
-                'currencyIdsListForParseMarket': None,
+                'currencyIdsListForParseMarket': ['QRDO'],
             },
             'features': {
                 'spot': {
@@ -407,7 +407,11 @@ class coinmetro(Exchange, ImplicitAPI):
         if self.safe_value(self.options, 'currenciesByIdForParseMarket') is None:
             currenciesById = self.index_by(result, 'id')
             self.options['currenciesByIdForParseMarket'] = currenciesById
-            self.options['currencyIdsListForParseMarket'] = list(currenciesById.keys())
+            currentCurrencyIdsList = self.safe_list(self.options, 'currencyIdsListForParseMarket', [])
+            currencyIdsList = list(currenciesById.keys())
+            for i in range(0, len(currencyIdsList)):
+                currentCurrencyIdsList.append(currencyIdsList[i])
+            self.options['currencyIdsListForParseMarket'] = currentCurrencyIdsList
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:
@@ -506,10 +510,19 @@ class coinmetro(Exchange, ImplicitAPI):
         baseId = None
         quoteId = None
         currencyIds = self.safe_value(self.options, 'currencyIdsListForParseMarket', [])
+        # Bubble sort by length(longest first)
+        currencyIdsLength = len(currencyIds)
+        for i in range(0, currencyIdsLength):
+            for j in range(0, currencyIdsLength - i - 1):
+                a = currencyIds[j]
+                b = currencyIds[j + 1]
+                if len(a) < len(b):
+                    currencyIds[j] = b
+                    currencyIds[j + 1] = a
         for i in range(0, len(currencyIds)):
             currencyId = currencyIds[i]
             entryIndex = marketId.find(currencyId)
-            if entryIndex != -1:
+            if entryIndex == 0:
                 restId = marketId.replace(currencyId, '')
                 if self.in_array(restId, currencyIds):
                     if entryIndex == 0:

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/deribit.py

@@ -3063,7 +3063,7 @@ class deribit(Exchange, ImplicitAPI):
         :param int [since]: the earliest time in ms to fetch funding rate history for
         :param int [limit]: the maximum number of entries to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param int [params.end_timestamp]: fetch funding rate ending at self timestamp
+        :param int [params.until]: fetch funding rate ending at self timestamp
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
         """
@@ -3071,17 +3071,32 @@ class deribit(Exchange, ImplicitAPI):
         market = self.market(symbol)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
+        maxEntriesPerRequest = 744  # seems exchange returns max 744 items per request
+        eachItemDuration = '1h'
         if paginate:
-            return await self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params, 720)
+            # fix for: https://github.com/ccxt/ccxt/issues/25040
+            return await self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, eachItemDuration, self.extend(params, {'isDeribitPaginationCall': True}), maxEntriesPerRequest)
+        duration = self.parse_timeframe(eachItemDuration) * 1000
         time = self.milliseconds()
         month = 30 * 24 * 60 * 60 * 1000
         if since is None:
             since = time - month
+        else:
+            time = since + month
         request: dict = {
             'instrument_name': market['id'],
             'start_timestamp': since - 1,
-            'end_timestamp': time,
         }
+        until = self.safe_integer_2(params, 'until', 'end_timestamp')
+        if until is not None:
+            params = self.omit(params, ['until'])
+            request['end_timestamp'] = until
+        else:
+            request['end_timestamp'] = time
+        if 'isDeribitPaginationCall' in params:
+            params = self.omit(params, 'isDeribitPaginationCall')
+            maxUntil = self.sum(since, limit * duration)
+            request['end_timestamp'] = min(request['end_timestamp'], maxUntil)
         response = await self.publicGetGetFundingRateHistory(self.extend(request, params))
         #
         #    {

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/gate.py

@@ -1792,7 +1792,7 @@ class gate(Exchange, ImplicitAPI):
             active = listed and tradeEnabled and withdrawEnabled and depositEnabled
             if self.safe_value(result, code) is None:
                 result[code] = {
-                    'id': code.lower(),
+                    'id': currency,
                     'code': code,
                     'info': None,
                     'name': None,

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/hollaex.py

@@ -1912,13 +1912,14 @@ class hollaex(Exchange, ImplicitAPI):
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
+        # {"message": "Invalid token"}
         if response is None:
             return None
         if (code >= 400) and (code <= 503):
             #
             #  {"message": "Invalid token"}
             #
-            # different errors return the same code eg:
+            # different errors return the same code eg
             #
             #  {"message":"Error 1001 - Order rejected. Order could not be submitted order was set to a post only order."}
             #

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/htx.py

@@ -6992,10 +6992,12 @@ class htx(Exchange, ImplicitAPI):
                     'AccessKeyId': self.apiKey,
                     'Timestamp': timestamp,
                 }
-                if method != 'POST':
-                    request = self.extend(request, query)
+                # sorting needs such flow exactly, before urlencoding(more at: https://github.com/ccxt/ccxt/issues/24930 )
                 request = self.keysort(request)
-                auth = self.urlencode(request)
+                if method != 'POST':
+                    sortedQuery = self.keysort(query)
+                    request = self.extend(request, sortedQuery)
+                auth = self.urlencode(request).replace('%2c', '%2C')  # in c# it manually needs to be uppercased
                 # unfortunately, PHP demands double quotes for the escaped newline symbol
                 payload = "\n".join([method, hostname, url, auth])  # eslint-disable-line quotes
                 signature = self.hmac(self.encode(payload), self.encode(self.secret), hashlib.sha256, 'base64')

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/kucoin.py

@@ -3101,14 +3101,14 @@ class kucoin(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
-        if limit is not None:
-            request['pageSize'] = limit
         method = self.options['fetchMyTradesMethod']
         parseResponseData = False
         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 limit is not None:
+                request['limit'] = limit
             if since is not None:
                 # only returns trades up to one week after the since param
                 request['startAt'] = since

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/mexc.py

@@ -2235,7 +2235,7 @@ class mexc(Exchange, ImplicitAPI):
         :param bool [params.postOnly]: if True, the order will only be posted if it will be a maker order
         :param bool [params.reduceOnly]: *contract only* indicates if self order is to reduce the size of a position
         :param bool [params.hedged]: *swap only* True for hedged mode, False for one way mode, default is False
-
+        :param str [params.timeInForce]: 'IOC' or 'FOK', default is 'GTC'
  EXCHANGE SPECIFIC PARAMETERS
         :param int [params.leverage]: *contract only* leverage is necessary on isolated margin
         :param long [params.positionId]: *contract only* it is recommended to hasattr(self, fill) parameter when closing a position
@@ -2290,6 +2290,13 @@ class mexc(Exchange, ImplicitAPI):
         postOnly, params = self.handle_post_only(type == 'market', type == 'LIMIT_MAKER', params)
         if postOnly:
             request['type'] = 'LIMIT_MAKER'
+        tif = self.safe_string(params, 'timeInForce')
+        if tif is not None:
+            params = self.omit(params, 'timeInForce')
+            if tif == 'IOC':
+                request['type'] = 'IMMEDIATE_OR_CANCEL'
+            elif tif == 'FOK':
+                request['type'] = 'FILL_OR_KILL'
         return self.extend(request, params)
 
     async def create_spot_order(self, market, type, side, amount, price=None, marginMode=None, params={}):
@@ -5709,12 +5716,20 @@ class mexc(Exchange, ImplicitAPI):
                 url = self.urls['api'][section][access] + '/' + path
             else:
                 url = self.urls['api'][section][access] + '/api/' + self.version + '/' + path
-            paramsEncoded = ''
+            urlParams = params
             if access == 'private':
-                params['timestamp'] = self.nonce()
-                params['recvWindow'] = self.safe_integer(self.options, 'recvWindow', 5000)
-            if params:
-                paramsEncoded = self.urlencode(params)
+                if section == 'broker' and ((method == 'POST') or (method == 'PUT') or (method == 'DELETE')):
+                    urlParams = {
+                        'timestamp': self.nonce(),
+                        'recvWindow': self.safe_integer(self.options, 'recvWindow', 5000),
+                    }
+                    body = self.json(params)
+                else:
+                    urlParams['timestamp'] = self.nonce()
+                    urlParams['recvWindow'] = self.safe_integer(self.options, 'recvWindow', 5000)
+            paramsEncoded = ''
+            if urlParams:
+                paramsEncoded = self.urlencode(urlParams)
                 url += '?' + paramsEncoded
             if access == 'private':
                 self.check_required_credentials()

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/onetrading.py

@@ -1200,7 +1200,7 @@ class onetrading(Exchange, ImplicitAPI):
         https://docs.onetrading.com/#create-order
 
         :param str symbol: unified symbol of the market to create an order in
-        :param str type: 'market' or 'limit'
+        :param str type: 'limit'
         :param str side: 'buy' or 'sell'
         :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 fulfilled, in units of the quote currency, ignored in market orders

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/paradex.py

@@ -943,7 +943,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",

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/probit.py

@@ -990,6 +990,7 @@ class probit(Exchange, ImplicitAPI):
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: the maximum amount of candles to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.until]: timestamp in ms of the earliest candle to fetch
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
@@ -1005,18 +1006,19 @@ class probit(Exchange, ImplicitAPI):
             'limit': requestLimit,  # max 1000
         }
         now = self.milliseconds()
-        duration = self.parse_timeframe(timeframe)
+        until = self.safe_integer(params, 'until')
+        durationMilliseconds = self.parse_timeframe(timeframe) * 1000
         startTime = since
-        endTime = now
+        endTime = until - durationMilliseconds if (until is not None) else now
         if since is None:
             if limit is None:
                 limit = requestLimit
-            startTime = now - limit * duration * 1000
+            startLimit = limit - 1
+            startTime = endTime - startLimit * durationMilliseconds
         else:
-            if limit is None:
-                endTime = now
-            else:
-                endTime = self.sum(since, self.sum(limit, 1) * duration * 1000)
+            if limit is not None:
+                endByLimit = self.sum(since, limit * durationMilliseconds)
+                endTime = min(endTime, endByLimit)
         startTimeNormalized = self.normalize_ohlcv_timestamp(startTime, timeframe)
         endTimeNormalized = self.normalize_ohlcv_timestamp(endTime, timeframe, True)
         request['start_time'] = startTimeNormalized

{ccxt-4.4.50 → ccxt-4.4.52}/ccxt/async_support/vertex.py

@@ -330,6 +330,69 @@ class vertex(Exchange, ImplicitAPI):
                 'timeDifference': 0,  # the difference between system clock and exchange server clock
                 'brokerId': 5930043274845996,
             },
+            'features': {
+                'default': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': True,  # todo
+                        'triggerDirection': False,
+                        'triggerPriceType': None,
+                        'stopLossPrice': True,  # todo
+                        'takeProfitPrice': True,  # todo
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': False,
+                            'FOK': False,
+                            'PO': True,
+                            'GTD': True,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,  # todo
+                        'marketBuyRequiresPrice': True,  # todo fix implementation
+                        'selfTradePrevention': False,
+                        'iceberg': False,
+                    },
+                    'createOrders': None,
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 500,
+                        'daysBack': 100000,  # todo
+                        'untilDays': None,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': 500,
+                        'trigger': True,
+                        'trailing': False,
+                    },
+                    'fetchOrders': None,  # todo, only for trigger
+                    'fetchClosedOrders': None,  # todo through fetchOrders
+                    'fetchOHLCV': {
+                        'limit': 1000,
+                    },
+                },
+                'spot': {
+                    'extends': 'default',
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'default',
+                    },
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
         })
 
     def set_sandbox_mode(self, enabled):
@@ -2104,7 +2167,7 @@ class vertex(Exchange, ImplicitAPI):
             #       "product_id": 1,
             #       "orders": [
             #         {
-            #           "product_id": 1,
+            #           "product_id": 2,
             #           "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000",
             #           "price_x18": "1000000000000000000",
             #           "amount": "1000000000000000000",
@@ -2113,7 +2176,7 @@ class vertex(Exchange, ImplicitAPI):
             #           "order_type": "default",
             #           "unfilled_amount": "1000000000000000000",
             #           "digest": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            #           "placed_at": 1682437739,
+            #           "placed_at": 1682437737,
             #           "order_type": "ioc"
             #         }
             #       ]