ccxt 4.4.33__py2.py3-none-any.whl → 4.4.35__py2.py3-none-any.whl

ccxt/poloniex.py

@@ -51,6 +51,8 @@ class poloniex(Exchange, ImplicitAPI):
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
                 'createOrder': True,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'editOrder': True,
                 'fetchBalance': True,
                 'fetchClosedOrder': False,
@@ -1256,7 +1258,7 @@ class poloniex(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 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]: *spot only* The price at which a trigger order is triggered at
+        :param float [params.triggerPrice]: the price at which a trigger order is triggered at
         :param float [params.cost]: *spot market buy only* the quote quantity that can be used alternative for the amount
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """

ccxt/poloniexfutures.py

@@ -42,6 +42,8 @@ class poloniexfutures(Exchange, ImplicitAPI):
                 'future': False,
                 'option': None,
                 'createOrder': True,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'fetchBalance': True,
                 'fetchClosedOrders': True,
                 'fetchCurrencies': False,
@@ -827,7 +829,7 @@ class poloniexfutures(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.leverage]: Leverage size of the order
-        :param float [params.stopPrice]: The price at which a trigger order is triggered at
+        :param float [params.triggerPrice]: The price at which a trigger order is triggered at
         :param bool [params.reduceOnly]: A mark to reduce the position size only. Set to False by default. Need to set the position size when reduceOnly is True.
         :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

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.33'
+__version__ = '4.4.35'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitrue.py

@@ -36,15 +36,17 @@ class bitrue(ccxt.async_support.bitrue):
             },
             'api': {
                 'open': {
-                    'private': {
-                        'post': {
-                            'poseidon/api/v1/listenKey': 1,
-                        },
-                        'put': {
-                            'poseidon/api/v1/listenKey/{listenKey}': 1,
-                        },
-                        'delete': {
-                            'poseidon/api/v1/listenKey/{listenKey}': 1,
+                    'v1': {
+                        'private': {
+                            'post': {
+                                'poseidon/api/v1/listenKey': 1,
+                            },
+                            'put': {
+                                'poseidon/api/v1/listenKey/{listenKey}': 1,
+                            },
+                            'delete': {
+                                'poseidon/api/v1/listenKey/{listenKey}': 1,
+                            },
                         },
                     },
                 },
@@ -405,7 +407,7 @@ class bitrue(ccxt.async_support.bitrue):
     async def authenticate(self, params={}):
         listenKey = self.safe_value(self.options, 'listenKey')
         if listenKey is None:
-            response = await self.openPrivatePostPoseidonApiV1ListenKey(params)
+            response = await self.openV1PrivatePostPoseidonApiV1ListenKey(params)
             #
             #     {
             #         "msg": "succ",
@@ -429,7 +431,7 @@ class bitrue(ccxt.async_support.bitrue):
             'listenKey': listenKey,
         }
         try:
-            await self.openPrivatePutPoseidonApiV1ListenKeyListenKey(self.extend(request, params))
+            await self.openV1PrivatePutPoseidonApiV1ListenKeyListenKey(self.extend(request, params))
             #
             # ಠ_ಠ
             #     {

ccxt/pro/idex.py

@@ -72,6 +72,9 @@ class idex(ccxt.async_support.idex):
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+
+        https://api-docs-v4.idex.io/#tickers
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -141,6 +144,9 @@ class idex(ccxt.async_support.idex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+
+        https://api-docs-v4.idex.io/#trades
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -231,6 +237,9 @@ class idex(ccxt.async_support.idex):
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+
+        https://api-docs-v4.idex.io/#candles
+
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -383,6 +392,9 @@ class idex(ccxt.async_support.idex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://api-docs-v4.idex.io/#l2-order-book
+
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -478,6 +490,9 @@ class idex(ccxt.async_support.idex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
+
+        https://api-docs-v4.idex.io/#orders
+
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve

ccxt/pro/probit.py

@@ -41,15 +41,6 @@ class probit(ccxt.async_support.probit):
                     'filter': 'order_books_l2',
                     'interval': 100,  # or 500
                 },
-                'watchTrades': {
-                    'filter': 'recent_trades',
-                },
-                'watchTicker': {
-                    'filter': 'ticker',
-                },
-                'watchOrders': {
-                    'channel': 'open_order',
-                },
             },
             'streaming': {
             },
@@ -66,13 +57,7 @@ class probit(ccxt.async_support.probit):
         """
         await self.authenticate(params)
         messageHash = 'balance'
-        url = self.urls['api']['ws']
-        subscribe: dict = {
-            'type': 'subscribe',
-            'channel': 'balance',
-        }
-        request = self.extend(subscribe, params)
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.subscribe_private(messageHash, 'balance', params)
 
     def handle_balance(self, client: Client, message):
         #
@@ -130,9 +115,8 @@ class probit(ccxt.async_support.probit):
         :param int [params.interval]: Unit time to synchronize market information(ms). Available units: 100, 500
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchTicker', 'filter', 'ticker')
-        return await self.subscribe_order_book(symbol, 'ticker', filter, params)
+        channel = 'ticker'
+        return await self.subscribe_public('watchTicker', symbol, 'ticker', channel, params)
 
     def handle_ticker(self, client: Client, message):
         #
@@ -175,9 +159,8 @@ class probit(ccxt.async_support.probit):
         :param int [params.interval]: Unit time to synchronize market information(ms). Available units: 100, 500
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchTrades', 'filter', 'recent_trades')
-        trades = await self.subscribe_order_book(symbol, 'trades', filter, params)
+        channel = 'recent_trades'
+        trades = await self.subscribe_public('watchTrades', symbol, 'trades', channel, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
@@ -207,10 +190,11 @@ class probit(ccxt.async_support.probit):
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
         trades = self.safe_value(message, 'recent_trades', [])
-        reset = self.safe_bool(message, 'reset', False)
+        if self.safe_bool(message, 'reset', False):
+            return  # see comment in handleMessage
         messageHash = 'trades:' + symbol
         stored = self.safe_value(self.trades, symbol)
-        if stored is None or reset:
+        if stored is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCache(limit)
             self.trades[symbol] = stored
@@ -235,19 +219,11 @@ class probit(ccxt.async_support.probit):
         """
         await self.load_markets()
         await self.authenticate(params)
-        messageHash = 'myTrades'
+        messageHash = 'trades'
         if symbol is not None:
-            market = self.market(symbol)
-            symbol = market['symbol']
+            symbol = self.safe_symbol(symbol)
             messageHash = messageHash + ':' + symbol
-        url = self.urls['api']['ws']
-        channel = 'trade_history'
-        message: dict = {
-            'type': 'subscribe',
-            'channel': channel,
-        }
-        request = self.extend(message, params)
-        trades = await self.watch(url, messageHash, request, channel)
+        trades = await self.subscribe_private(messageHash, 'trade_history', params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
@@ -276,10 +252,11 @@ class probit(ccxt.async_support.probit):
         length = len(rawTrades)
         if length == 0:
             return
-        reset = self.safe_bool(message, 'reset', False)
-        messageHash = 'myTrades'
+        if self.safe_bool(message, 'reset', False):
+            return  # see comment in handleMessage
+        messageHash = 'trades'
         stored = self.myTrades
-        if (stored is None) or reset:
+        if stored is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCacheBySymbolById(limit)
             self.myTrades = stored
@@ -287,9 +264,15 @@ class probit(ccxt.async_support.probit):
         tradeSymbols: dict = {}
         for j in range(0, len(trades)):
             trade = trades[j]
+            # don't include 'executed' state, because it's just blanket state of the trade, emited before actual trade event
+            if self.safe_string(trade['info'], 'status') == 'executed':
+                continue
             tradeSymbols[trade['symbol']] = True
             stored.append(trade)
         unique = list(tradeSymbols.keys())
+        uniqueLength = len(unique)
+        if uniqueLength == 0:
+            return
         for i in range(0, len(unique)):
             symbol = unique[i]
             symbolSpecificMessageHash = messageHash + ':' + symbol
@@ -310,20 +293,11 @@ class probit(ccxt.async_support.probit):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.authenticate(params)
-        url = self.urls['api']['ws']
         messageHash = 'orders'
         if symbol is not None:
-            market = self.market(symbol)
-            symbol = market['symbol']
+            symbol = self.safe_symbol(symbol)
             messageHash = messageHash + ':' + symbol
-        channel = None
-        channel, params = self.handle_option_and_params(params, 'watchOrders', 'channel', 'open_order')
-        subscribe: dict = {
-            'type': 'subscribe',
-            'channel': channel,
-        }
-        request = self.extend(subscribe, params)
-        orders = await self.watch(url, messageHash, request, channel)
+        orders = await self.subscribe_private(messageHash, 'open_order', params)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
@@ -388,39 +362,49 @@ class probit(ccxt.async_support.probit):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
-        filter = None
-        filter, params = self.handle_option_and_params(params, 'watchOrderBook', 'filter', 'order_books')
-        orderbook = await self.subscribe_order_book(symbol, 'orderbook', filter, params)
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchOrderBook', 'filter', 'order_books')
+        orderbook = await self.subscribe_public('watchOrderBook', symbol, 'orderbook', channel, params)
         return orderbook.limit()
 
-    async def subscribe_order_book(self, symbol: str, messageHash, filter, params={}):
+    async def subscribe_private(self, messageHash, channel, params):
+        url = self.urls['api']['ws']
+        subscribe: dict = {
+            'type': 'subscribe',
+            'channel': channel,
+        }
+        request = self.extend(subscribe, params)
+        subscribeHash = messageHash
+        return await self.watch(url, messageHash, request, subscribeHash)
+
+    async def subscribe_public(self, methodName: str, symbol: str, dataType, filter, params={}):
         await self.load_markets()
         market = self.market(symbol)
         symbol = market['symbol']
         url = self.urls['api']['ws']
         client = self.client(url)
-        interval = None
-        interval, params = self.handle_option_and_params(params, 'watchOrderBook', 'interval', 100)
-        subscriptionHash = 'marketdata:' + symbol
-        messageHash = messageHash + ':' + symbol
+        subscribeHash = 'marketdata:' + symbol
+        messageHash = dataType + ':' + symbol
         filters = {}
-        if subscriptionHash in client.subscriptions:
+        if subscribeHash in client.subscriptions:
             # already subscribed
-            filters = client.subscriptions[subscriptionHash]
+            filters = client.subscriptions[subscribeHash]
             if not (filter in filters):
                 # resubscribe
-                del client.subscriptions[subscriptionHash]
+                del client.subscriptions[subscribeHash]
         filters[filter] = True
         keys = list(filters.keys())
-        message: dict = {
+        interval = None
+        interval, params = self.handle_option_and_params(params, methodName, 'interval', 100)
+        request: dict = {
+            'type': 'subscribe',
             'channel': 'marketdata',
-            'interval': interval,
             'market_id': market['id'],
-            'type': 'subscribe',
             'filter': keys,
+            'interval': interval,
         }
-        request = self.extend(message, params)
-        return await self.watch(url, messageHash, request, messageHash, filters)
+        request = self.extend(request, params)
+        return await self.watch(url, messageHash, request, subscribeHash, filters)
 
     def handle_order_book(self, client: Client, message, orderBook):
         #
@@ -493,7 +477,8 @@ class probit(ccxt.async_support.probit):
         result = self.safe_string(message, 'result')
         future = client.subscriptions['authenticated']
         if result == 'ok':
-            future.resolve(True)
+            messageHash = 'authenticated'
+            client.resolve(message, messageHash)
         else:
             future.reject(message)
             del client.subscriptions['authenticated']
@@ -503,10 +488,12 @@ class probit(ccxt.async_support.probit):
         if ticker is not None:
             self.handle_ticker(client, message)
         trades = self.safe_value(message, 'recent_trades', [])
-        if len(trades):
+        tradesLength = len(trades)
+        if tradesLength:
             self.handle_trades(client, message)
         orderBook = self.safe_value_n(message, ['order_books', 'order_books_l1', 'order_books_l2', 'order_books_l3', 'order_books_l4'], [])
-        if len(orderBook):
+        orderBookLength = len(orderBook)
+        if orderBookLength:
             self.handle_order_book(client, message, orderBook)
 
     def handle_message(self, client: Client, message):
@@ -519,6 +506,9 @@ class probit(ccxt.async_support.probit):
         #         }
         #     }
         #
+        # Note about 'reset' field
+        # 'reset': True field - it happens once after initial subscription, which just returns old items by the moment of subscription(like "fetchMyTrades" does)
+        #
         errorCode = self.safe_string(message, 'errorCode')
         if errorCode is not None:
             self.handle_error_message(client, message)

ccxt/pro/woo.py

@@ -35,14 +35,14 @@ class woo(ccxt.async_support.woo):
             'urls': {
                 'api': {
                     'ws': {
-                        'public': 'wss://wss.woo.org/ws/stream',
-                        'private': 'wss://wss.woo.org/v2/ws/private/stream',
+                        'public': 'wss://wss.woox.io/ws/stream',
+                        'private': 'wss://wss.woox.io/v2/ws/private/stream',
                     },
                 },
                 'test': {
                     'ws': {
-                        'public': 'wss://wss.staging.woo.org/ws/stream',
-                        'private': 'wss://wss.staging.woo.org/v2/ws/private/stream',
+                        'public': 'wss://wss.staging.woox.io/ws/stream',
+                        'private': 'wss://wss.staging.woox.io/v2/ws/private/stream',
                     },
                 },
             },
@@ -93,8 +93,8 @@ class woo(ccxt.async_support.woo):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
 
-        https://docs.woo.org/#orderbookupdate
-        https://docs.woo.org/#orderbook
+        https://docs.woox.io/#orderbookupdate
+        https://docs.woox.io/#orderbook
 
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str symbol: unified symbol of the market to fetch the order book for
@@ -327,7 +327,7 @@ class woo(ccxt.async_support.woo):
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
 
-        https://docs.woo.org/#24h-tickers
+        https://docs.woox.io/#24h-tickers
 
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :param str[] symbols: unified symbol of the market to fetch the ticker for
@@ -461,7 +461,7 @@ class woo(ccxt.async_support.woo):
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 
-        https://docs.woo.org/#k-line
+        https://docs.woox.io/#k-line
 
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
@@ -534,7 +534,7 @@ class woo(ccxt.async_support.woo):
         """
         watches information on multiple trades made in a market
 
-        https://docs.woo.org/#trade
+        https://docs.woox.io/#trade
 
         :param str symbol: unified market symbol of the market trades were made in
         :param int [since]: the earliest time in ms to fetch trades for
@@ -716,8 +716,8 @@ class woo(ccxt.async_support.woo):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
 
-        https://docs.woo.org/#executionreport
-        https://docs.woo.org/#algoexecutionreportv2
+        https://docs.woox.io/#executionreport
+        https://docs.woox.io/#algoexecutionreportv2
 
         watches information on multiple orders made by the user
         :param str symbol: unified market symbol of the market orders were made in
@@ -749,8 +749,8 @@ class woo(ccxt.async_support.woo):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
 
-        https://docs.woo.org/#executionreport
-        https://docs.woo.org/#algoexecutionreportv2
+        https://docs.woox.io/#executionreport
+        https://docs.woox.io/#algoexecutionreportv2
 
         watches information on multiple trades made by the user
         :param str symbol: unified market symbol of the market orders were made in
@@ -974,7 +974,7 @@ class woo(ccxt.async_support.woo):
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
 
-        https://docs.woo.org/#position-push
+        https://docs.woox.io/#position-push
 
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
@@ -1080,7 +1080,7 @@ class woo(ccxt.async_support.woo):
     async def watch_balance(self, params={}) -> Balances:
         """
 
-        https://docs.woo.org/#balance
+        https://docs.woox.io/#balance
 
         watch balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint

ccxt/test/tests_async.py

@@ -714,7 +714,7 @@ class testMainClass:
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+    def assert_new_and_stored_output_inner(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
             return True
         if not new_output and not stored_output:
@@ -796,6 +796,25 @@ class testMainClass:
                         self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
         return True   # c# requ
 
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+        try:
+            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+        except Exception as e:
+            if self.info:
+                error_message = self.var_to_string(new_output) + '(calculated)' + ' != ' + self.var_to_string(stored_output) + '(stored)'
+                dump('[TEST_FAILURE_DETAIL]' + error_message)
+            raise e
+
+    def var_to_string(self, obj=None):
+        new_string = None
+        if obj is None:
+            new_string = 'undefined'
+        elif is_null_value(obj):
+            new_string = 'null'
+        else:
+            new_string = json_stringify(obj)
+        return new_string
+
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
             # remove the host part from the url
@@ -1064,7 +1083,15 @@ class testMainClass:
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
             else:
                 promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
-        await asyncio.gather(*promises)
+        try:
+            await asyncio.gather(*promises)
+        except Exception as e:
+            if type == 'request':
+                self.request_tests_failed = True
+            else:
+                self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + str(e)
+            dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:

ccxt/test/tests_helpers.py

@@ -40,7 +40,6 @@ class Argv(object):
     ws_tests = False
     request_tests = False
     response_tests = False
-    token_bucket = False
     sandbox = False
     privateOnly = False
     private = False
@@ -58,7 +57,6 @@ class Argv(object):
 
 argv = Argv()
 parser = argparse.ArgumentParser()
-parser.add_argument('--token_bucket', action='store_true', help='enable token bucket experimental test')
 parser.add_argument('--sandbox', action='store_true', help='enable sandbox mode')
 parser.add_argument('--privateOnly', action='store_true', help='run private tests only')
 parser.add_argument('--private', action='store_true', help='run private tests')

ccxt/test/tests_sync.py

@@ -711,7 +711,7 @@ class testMainClass:
             result[key] = value
         return result
 
-    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+    def assert_new_and_stored_output_inner(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
         if is_null_value(new_output) and is_null_value(stored_output):
             return True
         if not new_output and not stored_output:
@@ -793,6 +793,25 @@ class testMainClass:
                         self.assert_static_error(numeric_new_output == numeric_stored_output, message_error, stored_output, new_output, asserting_key)
         return True   # c# requ
 
+    def assert_new_and_stored_output(self, exchange, skip_keys, new_output, stored_output, strict_type_check=True, asserting_key=None):
+        try:
+            return self.assert_new_and_stored_output_inner(exchange, skip_keys, new_output, stored_output, strict_type_check, asserting_key)
+        except Exception as e:
+            if self.info:
+                error_message = self.var_to_string(new_output) + '(calculated)' + ' != ' + self.var_to_string(stored_output) + '(stored)'
+                dump('[TEST_FAILURE_DETAIL]' + error_message)
+            raise e
+
+    def var_to_string(self, obj=None):
+        new_string = None
+        if obj is None:
+            new_string = 'undefined'
+        elif is_null_value(obj):
+            new_string = 'null'
+        else:
+            new_string = json_stringify(obj)
+        return new_string
+
     def assert_static_request_output(self, exchange, type, skip_keys, stored_url, request_url, stored_output, new_output):
         if stored_url != request_url:
             # remove the host part from the url
@@ -1061,7 +1080,15 @@ class testMainClass:
                 promises.append(self.test_exchange_request_statically(exchange_name, exchange_data, test_name))
             else:
                 promises.append(self.test_exchange_response_statically(exchange_name, exchange_data, test_name))
-        (promises)
+        try:
+            (promises)
+        except Exception as e:
+            if type == 'request':
+                self.request_tests_failed = True
+            else:
+                self.response_tests_failed = True
+            error_message = '[' + self.lang + '][STATIC_REQUEST]' + '[' + exchange.id + ']' + str(e)
+            dump('[TEST_FAILURE]' + error_message)
         if self.request_tests_failed or self.response_tests_failed:
             exit_script(1)
         else:

ccxt/vertex.py

@@ -55,6 +55,8 @@ class vertex(Exchange, ImplicitAPI):
                 'createOrder': True,
                 'createOrders': True,
                 'createReduceOnlyOrder': True,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchAccounts': False,
                 'fetchBalance': True,