ccxt 4.3.1__py2.py3-none-any.whl → 4.3.2__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.1'
+__version__ = '4.3.2'
 
 # ----------------------------------------------------------------------------
 

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.1'
+__version__ = '4.3.2'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.1'
+__version__ = '4.3.2'
 
 # -----------------------------------------------------------------------------
 
@@ -25,7 +25,7 @@ from ccxt.async_support.base.throttler import Throttler
 # -----------------------------------------------------------------------------
 
 from ccxt.base.errors import BaseError, BadSymbol, BadRequest, BadResponse, ExchangeError, ExchangeNotAvailable, RequestTimeout, NotSupported, NullResponse, InvalidAddress, RateLimitExceeded
-from ccxt.base.types import OrderType, OrderSide, OrderRequest
+from ccxt.base.types import OrderType, OrderSide, OrderRequest, CancellationRequest
 
 # -----------------------------------------------------------------------------
 
@@ -1210,6 +1210,9 @@ class Exchange(BaseExchange):
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' cancelAllOrders() is not supported yet')
 
+    async def cancel_orders_for_symbols(self, orders: List[CancellationRequest], params={}):
+        raise NotSupported(self.id + ' cancelOrdersForSymbols() is not supported yet')
+
     async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' cancelAllOrdersWs() is not supported yet')
 

ccxt/async_support/bingx.py

@@ -21,6 +21,7 @@ from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import DDoSProtection
+from ccxt.base.errors import ExchangeNotAvailable
 from ccxt.base.decimal_to_precision import DECIMAL_PLACES
 from ccxt.base.precise import Precise
 
@@ -398,7 +399,7 @@ class bingx(Exchange, ImplicitAPI):
                     '100400': BadRequest,
                     '100421': BadSymbol,  # {"code":100421,"msg":"This pair is currently restricted from API trading","debugMsg":""}
                     '100440': ExchangeError,
-                    '100500': ExchangeError,
+                    '100500': ExchangeNotAvailable,  # {"code":100500,"msg":"The current system is busy, please try again later","debugMsg":""}
                     '100503': ExchangeError,
                     '80001': BadRequest,
                     '80012': InsufficientFunds,  # bingx {"code":80012,"msg":"{\"Code\":101253,\"Msg\":\"margin is not enough\"}}
@@ -3718,7 +3719,7 @@ class bingx(Exchange, ImplicitAPI):
         market = None
         if symbol is not None:
             market = self.market(symbol)
-            request['symbol'] = symbol
+            request['symbol'] = market['id']
         if since is not None:
             request['startTime'] = since
         if limit is not None:

ccxt/async_support/bitget.py

@@ -8051,6 +8051,8 @@ class bitget(Exchange, ImplicitAPI):
         #
         # spot
         #
+        #     {"code":"00000","msg":"success","requestTime":1713294492511,"data":[...]}"
+        #
         #     {"status":"fail","err_code":"01001","err_msg":"系统异常，请稍后重试"}
         #     {"status":"error","ts":1595594160149,"err_code":"invalid-parameter","err_msg":"invalid size, valid range: [1,2000]"}
         #     {"status":"error","ts":1595684716042,"err_code":"invalid-parameter","err_msg":"illegal sign invalid"}
@@ -8072,13 +8074,13 @@ class bitget(Exchange, ImplicitAPI):
         #     {"code":"40108","msg":"","requestTime":1595885064600,"data":null}
         #     {"order_id":"513468410013679613","client_oid":null,"symbol":"ethusd","result":false,"err_code":"order_no_exist_error","err_msg":"订单不存在！"}
         #
-        message = self.safe_string(response, 'err_msg')
-        errorCode = self.safe_string_2(response, 'code', 'err_code')
+        message = self.safe_string_2(response, 'err_msg', 'msg')
         feedback = self.id + ' ' + body
-        nonEmptyMessage = ((message is not None) and (message != ''))
+        nonEmptyMessage = ((message is not None) and (message != '') and (message != 'success'))
         if nonEmptyMessage:
             self.throw_exactly_matched_exception(self.exceptions['exact'], message, feedback)
             self.throw_broadly_matched_exception(self.exceptions['broad'], message, feedback)
+        errorCode = self.safe_string_2(response, 'code', 'err_code')
         nonZeroErrorCode = (errorCode is not None) and (errorCode != '00000')
         if nonZeroErrorCode:
             self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)

ccxt/async_support/coinbase.py

@@ -28,9 +28,10 @@ class coinbase(Exchange, ImplicitAPI):
     def describe(self):
         return self.deep_extend(super(coinbase, self).describe(), {
             'id': 'coinbase',
-            'name': 'Coinbase',
+            'name': 'Coinbase Advanced',
             'countries': ['US'],
             'pro': True,
+            'certified': True,
             # rate-limits:
             # ADVANCED API: https://docs.cloud.coinbase.com/advanced-trade-api/docs/rest-api-rate-limits
             # - max 30 req/second for private data, 10 req/s for public data

ccxt/async_support/coinbasepro.py

@@ -27,7 +27,7 @@ class coinbasepro(Exchange, ImplicitAPI):
     def describe(self):
         return self.deep_extend(super(coinbasepro, self).describe(), {
             'id': 'coinbasepro',
-            'name': 'Coinbase Pro',
+            'name': 'Coinbase Pro(Deprecated)',
             'countries': ['US'],
             'rateLimit': 100,
             'userAgent': self.userAgents['chrome'],

ccxt/async_support/coinex.py

@@ -815,65 +815,59 @@ class coinex(Exchange, ImplicitAPI):
         # Spot fetchTicker, fetchTickers
         #
         #     {
-        #         "vol": "293.19415130",
-        #         "low": "38200.00",
-        #         "open": "39514.99",
-        #         "high": "39530.00",
-        #         "last": "38649.57",
-        #         "buy": "38640.20",
-        #         "buy_amount": "0.22800000",
-        #         "sell": "38640.21",
-        #         "sell_amount": "0.02828439"
+        #         "close": "62393.47",
+        #         "high": "64106.41",
+        #         "last": "62393.47",
+        #         "low": "59650.01",
+        #         "market": "BTCUSDT",
+        #         "open": "61616.15",
+        #         "period": 86400,
+        #         "value": "28711273.4065667262",
+        #         "volume": "461.76557205",
+        #         "volume_buy": "11.41506354",
+        #         "volume_sell": "7.3240169"
         #     }
         #
         # Swap fetchTicker, fetchTickers
         #
         #     {
-        #         "vol": "7714.2175",
-        #         "low": "38200.00",
-        #         "open": "39569.23",
-        #         "high": "39569.23",
-        #         "last": "38681.37",
-        #         "buy": "38681.36",
+        #         "close": "62480.08",
+        #         "high": "64100",
+        #         "index_price": "62443.05",
+        #         "last": "62480.08",
+        #         "low": "59600",
+        #         "mark_price": "62443.05",
+        #         "market": "BTCUSDT",
+        #         "open": "61679.98",
         #         "period": 86400,
-        #         "funding_time": 462,
-        #         "position_amount": "296.7552",
-        #         "funding_rate_last": "0.00009395",
-        #         "funding_rate_next": "0.00000649",
-        #         "funding_rate_predict": "-0.00007176",
-        #         "insurance": "16464465.09431942163278132918",
-        #         "sign_price": "38681.93",
-        #         "index_price": "38681.69500000",
-        #         "sell_total": "16.6039",
-        #         "buy_total": "19.8481",
-        #         "buy_amount": "4.6315",
-        #         "sell": "38681.37",
-        #         "sell_amount": "11.4044"
+        #         "value": "180226025.69791713065326633165",
+        #         "volume": "2900.2218",
+        #         "volume_buy": "7.3847",
+        #         "volume_sell": "6.1249"
         #     }
         #
-        timestamp = self.safe_integer(ticker, 'date')
-        symbol = self.safe_symbol(None, market)
-        ticker = self.safe_value(ticker, 'ticker', {})
-        last = self.safe_string(ticker, 'last')
+        marketType = 'swap' if ('mark_price' in ticker) else 'spot'
+        marketId = self.safe_string(ticker, 'market')
+        symbol = self.safe_symbol(marketId, market, None, marketType)
         return self.safe_ticker({
             'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
+            'timestamp': None,
+            'datetime': None,
             'high': self.safe_string(ticker, 'high'),
             'low': self.safe_string(ticker, 'low'),
-            'bid': self.safe_string(ticker, 'buy'),
-            'bidVolume': self.safe_string(ticker, 'buy_amount'),
-            'ask': self.safe_string(ticker, 'sell'),
-            'askVolume': self.safe_string(ticker, 'sell_amount'),
+            'bid': None,
+            'bidVolume': self.safe_string(ticker, 'volume_buy'),
+            'ask': None,
+            'askVolume': self.safe_string(ticker, 'volume_sell'),
             'vwap': None,
             'open': self.safe_string(ticker, 'open'),
-            'close': last,
-            'last': last,
+            'close': self.safe_string(ticker, 'close'),
+            'last': self.safe_string(ticker, 'last'),
             'previousClose': None,
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': self.safe_string_2(ticker, 'vol', 'volume'),
+            'baseVolume': self.safe_string(ticker, 'volume'),
             'quoteVolume': None,
             'info': ticker,
         }, market)
@@ -881,8 +875,8 @@ class coinex(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot001_market007_single_market_ticker
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http008_market_ticker
+        :see: https://docs.coinex.com/api/v2/spot/market/http/list-market-ticker
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-ticker
         :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>`
@@ -894,28 +888,29 @@ class coinex(Exchange, ImplicitAPI):
         }
         response = None
         if market['swap']:
-            response = await self.v1PerpetualPublicGetMarketTicker(self.extend(request, params))
+            response = await self.v2PublicGetFuturesTicker(self.extend(request, params))
         else:
-            response = await self.v1PublicGetMarketTicker(self.extend(request, params))
+            response = await self.v2PublicGetSpotTicker(self.extend(request, params))
         #
         # Spot
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "date": 1651306913414,
-        #             "ticker": {
-        #                 "vol": "293.19415130",
-        #                 "low": "38200.00",
-        #                 "open": "39514.99",
-        #                 "high": "39530.00",
-        #                 "last": "38649.57",
-        #                 "buy": "38640.20",
-        #                 "buy_amount": "0.22800000",
-        #                 "sell": "38640.21",
-        #                 "sell_amount": "0.02828439"
+        #         "data": [
+        #             {
+        #                 "close": "62393.47",
+        #                 "high": "64106.41",
+        #                 "last": "62393.47",
+        #                 "low": "59650.01",
+        #                 "market": "BTCUSDT",
+        #                 "open": "61616.15",
+        #                 "period": 86400,
+        #                 "value": "28711273.4065667262",
+        #                 "volume": "461.76557205",
+        #                 "volume_buy": "11.41506354",
+        #                 "volume_sell": "7.3240169"
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
         #
@@ -923,41 +918,35 @@ class coinex(Exchange, ImplicitAPI):
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "date": 1651306641500,
-        #             "ticker": {
-        #                 "vol": "7714.2175",
-        #                 "low": "38200.00",
-        #                 "open": "39569.23",
-        #                 "high": "39569.23",
-        #                 "last": "38681.37",
-        #                 "buy": "38681.36",
+        #         "data": [
+        #             {
+        #                 "close": "62480.08",
+        #                 "high": "64100",
+        #                 "index_price": "62443.05",
+        #                 "last": "62480.08",
+        #                 "low": "59600",
+        #                 "mark_price": "62443.05",
+        #                 "market": "BTCUSDT",
+        #                 "open": "61679.98",
         #                 "period": 86400,
-        #                 "funding_time": 462,
-        #                 "position_amount": "296.7552",
-        #                 "funding_rate_last": "0.00009395",
-        #                 "funding_rate_next": "0.00000649",
-        #                 "funding_rate_predict": "-0.00007176",
-        #                 "insurance": "16464465.09431942163278132918",
-        #                 "sign_price": "38681.93",
-        #                 "index_price": "38681.69500000",
-        #                 "sell_total": "16.6039",
-        #                 "buy_total": "19.8481",
-        #                 "buy_amount": "4.6315",
-        #                 "sell": "38681.37",
-        #                 "sell_amount": "11.4044"
+        #                 "value": "180226025.69791713065326633165",
+        #                 "volume": "2900.2218",
+        #                 "volume_buy": "7.3847",
+        #                 "volume_sell": "6.1249"
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
         #
-        return self.parse_ticker(response['data'], market)
+        data = self.safe_list(response, 'data', [])
+        result = self.safe_dict(data, 0, {})
+        return self.parse_ticker(result, market)
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot001_market008_all_market_ticker
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http009_market_ticker_all
+        :see: https://docs.coinex.com/api/v2/spot/market/http/list-market-ticker
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-ticker
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -971,83 +960,58 @@ class coinex(Exchange, ImplicitAPI):
         marketType, query = self.handle_market_type_and_params('fetchTickers', market, params)
         response = None
         if marketType == 'swap':
-            response = await self.v1PerpetualPublicGetMarketTickerAll(query)
+            response = await self.v2PublicGetFuturesTicker(query)
         else:
-            response = await self.v1PublicGetMarketTickerAll()
+            response = await self.v2PublicGetSpotTicker(query)
         #
         # Spot
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "date": 1651519857284,
-        #             "ticker": {
-        #                 "PSPUSDT": {
-        #                     "vol": "127131.55227034",
-        #                     "low": "0.0669",
-        #                     "open": "0.0688",
-        #                     "high": "0.0747",
-        #                     "last": "0.0685",
-        #                     "buy": "0.0676",
-        #                     "buy_amount": "702.70117866",
-        #                     "sell": "0.0690",
-        #                     "sell_amount": "686.76861562"
-        #                 },
+        #         "data": [
+        #             {
+        #                 "close": "62393.47",
+        #                 "high": "64106.41",
+        #                 "last": "62393.47",
+        #                 "low": "59650.01",
+        #                 "market": "BTCUSDT",
+        #                 "open": "61616.15",
+        #                 "period": 86400,
+        #                 "value": "28711273.4065667262",
+        #                 "volume": "461.76557205",
+        #                 "volume_buy": "11.41506354",
+        #                 "volume_sell": "7.3240169"
         #             }
-        #         },
-        #         "message": "Ok"
+        #         ],
+        #         "message": "OK"
         #     }
         #
         # Swap
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "date": 1651520268644,
-        #             "ticker": {
-        #                 "KAVAUSDT": {
-        #                     "vol": "834924",
-        #                     "low": "3.9418",
-        #                     "open": "4.1834",
-        #                     "high": "4.4328",
-        #                     "last": "4.0516",
-        #                     "buy": "4.0443",
-        #                     "period": 86400,
-        #                     "funding_time": 262,
-        #                     "position_amount": "16111",
-        #                     "funding_rate_last": "-0.00069514",
-        #                     "funding_rate_next": "-0.00061009",
-        #                     "funding_rate_predict": "-0.00055812",
-        #                     "insurance": "16532425.53026084124483989548",
-        #                     "sign_price": "4.0516",
-        #                     "index_price": "4.0530",
-        #                     "sell_total": "59446",
-        #                     "buy_total": "62423",
-        #                     "buy_amount": "959",
-        #                     "sell": "4.0466",
-        #                     "sell_amount": "141"
-        #                 },
+        #         "data": [
+        #             {
+        #                 "close": "62480.08",
+        #                 "high": "64100",
+        #                 "index_price": "62443.05",
+        #                 "last": "62480.08",
+        #                 "low": "59600",
+        #                 "mark_price": "62443.05",
+        #                 "market": "BTCUSDT",
+        #                 "open": "61679.98",
+        #                 "period": 86400,
+        #                 "value": "180226025.69791713065326633165",
+        #                 "volume": "2900.2218",
+        #                 "volume_buy": "7.3847",
+        #                 "volume_sell": "6.1249"
         #             }
-        #         },
-        #         "message": "Ok"
+        #         ],
+        #         "message": "OK"
         #     }
         #
-        data = self.safe_value(response, 'data')
-        timestamp = self.safe_integer(data, 'date')
-        tickers = self.safe_value(data, 'ticker', {})
-        marketIds = list(tickers.keys())
-        result = {}
-        for i in range(0, len(marketIds)):
-            marketId = marketIds[i]
-            marketInner = self.safe_market(marketId, None, None, marketType)
-            symbol = marketInner['symbol']
-            ticker = self.parse_ticker({
-                'date': timestamp,
-                'ticker': tickers[marketId],
-            }, marketInner)
-            ticker['symbol'] = symbol
-            result[symbol] = ticker
-        return self.filter_by_array_tickers(result, 'symbol', symbols)
+        data = self.safe_list(response, 'data', [])
+        return self.parse_tickers(data, symbols)
 
     async def fetch_time(self, params={}):
         """

ccxt/async_support/cryptocom.py

@@ -1500,7 +1500,7 @@ class cryptocom(Exchange, ImplicitAPI):
         """
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         await self.load_markets()
-        currency = self.currency(code)
+        currency = self.safe_currency(code)  # for instance, USDC is not inferred from markets but it's still available
         request = {
             'currency': currency['id'],
             'amount': amount,
@@ -1542,7 +1542,7 @@ class cryptocom(Exchange, ImplicitAPI):
         :returns dict: a dictionary of `address structures <https://docs.ccxt.com/#/?id=address-structure>` indexed by the network
         """
         await self.load_markets()
-        currency = self.currency(code)
+        currency = self.safe_currency(code)
         request = {
             'currency': currency['id'],
         }
@@ -1633,7 +1633,7 @@ class cryptocom(Exchange, ImplicitAPI):
         currency = None
         request = {}
         if code is not None:
-            currency = self.currency(code)
+            currency = self.safe_currency(code)
             request['currency'] = currency['id']
         if since is not None:
             # 90 days date range
@@ -1686,7 +1686,7 @@ class cryptocom(Exchange, ImplicitAPI):
         currency = None
         request = {}
         if code is not None:
-            currency = self.currency(code)
+            currency = self.safe_currency(code)
             request['currency'] = currency['id']
         if since is not None:
             # 90 days date range
@@ -2179,7 +2179,7 @@ class cryptocom(Exchange, ImplicitAPI):
         request = {}
         currency = None
         if code is not None:
-            currency = self.currency(code)
+            currency = self.safe_currency(code)
         if since is not None:
             request['start_time'] = since
         if limit is not None:

ccxt/async_support/hyperliquid.py

@@ -6,10 +6,11 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.hyperliquid import ImplicitAPI
 import asyncio
-from ccxt.base.types import Balances, Currencies, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Trade, TransferEntry
+from ccxt.base.types import Balances, Currencies, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Trade, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
+from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
@@ -44,6 +45,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'cancelAllOrders': False,
                 'cancelOrder': True,
                 'cancelOrders': True,
+                'cancelOrdersForSymbols': True,
                 'closeAllPositions': False,
                 'closePosition': False,
                 'createMarketBuyOrderWithCost': False,
@@ -1168,6 +1170,72 @@ class hyperliquid(Exchange, ImplicitAPI):
         #
         return response
 
+    async def cancel_orders_for_symbols(self, orders: List[CancellationRequest], params={}):
+        """
+        cancel multiple orders for multiple symbols
+        :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s
+        :see: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid
+        :param CancellationRequest[] orders: each order should contain the parameters required by cancelOrder namely id and symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.vaultAddress]: the vault address
+        :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.check_required_credentials()
+        await self.load_markets()
+        nonce = self.milliseconds()
+        request = {
+            'nonce': nonce,
+            # 'vaultAddress': vaultAddress,
+        }
+        cancelReq = []
+        cancelAction = {
+            'type': '',
+            'cancels': [],
+        }
+        cancelByCloid = False
+        for i in range(0, len(orders)):
+            order = orders[i]
+            clientOrderId = self.safe_string(order, 'clientOrderId')
+            if clientOrderId is not None:
+                cancelByCloid = True
+            id = self.safe_string(order, 'id')
+            symbol = self.safe_string(order, 'symbol')
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' cancelOrdersForSymbols() requires a symbol argument in each order')
+            if id is not None and cancelByCloid:
+                raise BadRequest(self.id + ' cancelOrdersForSymbols() all orders must have either id or clientOrderId')
+            assetKey = 'asset' if cancelByCloid else 'a'
+            idKey = 'cloid' if cancelByCloid else 'o'
+            market = self.market(symbol)
+            cancelObj = {}
+            cancelObj[assetKey] = self.parse_to_numeric(market['baseId'])
+            cancelObj[idKey] = clientOrderId if cancelByCloid else self.parse_to_numeric(id)
+            cancelReq.append(cancelObj)
+        cancelAction['type'] = 'cancelByCloid' if cancelByCloid else 'cancel'
+        cancelAction['cancels'] = cancelReq
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
+        signature = self.sign_l1_action(cancelAction, nonce, vaultAddress)
+        request['action'] = cancelAction
+        request['signature'] = signature
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
+        response = await self.privatePostExchange(self.extend(request, params))
+        #
+        #     {
+        #         "status":"ok",
+        #         "response":{
+        #             "type":"cancel",
+        #             "data":{
+        #                 "statuses":[
+        #                     "success"
+        #                 ]
+        #             }
+        #         }
+        #     }
+        #
+        return response
+
     async def edit_order(self, id: str, symbol: str, type: str, side: str, amount: Num = None, price: Num = None, params={}):
         """
         edit a trade order

ccxt/async_support/kraken.py

@@ -1333,7 +1333,7 @@ class kraken(Exchange, ImplicitAPI):
             'ordertype': type,
             'volume': self.amount_to_precision(symbol, amount),
         }
-        orderRequest = self.order_request('createOrder()', symbol, type, request, price, params)
+        orderRequest = self.order_request('createOrder', symbol, type, request, price, params)
         response = await self.privatePostAddOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {
@@ -1659,7 +1659,10 @@ class kraken(Exchange, ImplicitAPI):
                 request['price'] = trailingAmountString
                 request['ordertype'] = 'trailing-stop'
         if reduceOnly:
-            request['reduce_only'] = 'true'  # not using hasattr(self, boolean) case, because the urlencodedNested transforms it into 'True' string
+            if method == 'createOrderWs':
+                request['reduce_only'] = True  # ws request can't have stringified bool
+            else:
+                request['reduce_only'] = 'true'  # not using hasattr(self, boolean) case, because the urlencodedNested transforms it into 'True' string
         close = self.safe_value(params, 'close')
         if close is not None:
             close = self.extend({}, close)
@@ -1710,7 +1713,7 @@ class kraken(Exchange, ImplicitAPI):
         }
         if amount is not None:
             request['volume'] = self.amount_to_precision(symbol, amount)
-        orderRequest = self.order_request('editOrder()', symbol, type, request, price, params)
+        orderRequest = self.order_request('editOrder', symbol, type, request, price, params)
         response = await self.privatePostEditOrder(self.extend(orderRequest[0], orderRequest[1]))
         #
         #     {