ccxt 4.4.34 → 4.4.36

package/js/src/htx.js

@@ -5432,8 +5432,8 @@ export default class htx extends Exchange {
                 request['price'] = this.priceToPrecision(symbol, price);
             }
         }
+        const reduceOnly = this.safeBool2(params, 'reduceOnly', 'reduce_only', false);
         if (!isStopLossTriggerOrder && !isTakeProfitTriggerOrder) {
-            const reduceOnly = this.safeValue2(params, 'reduceOnly', 'reduce_only', false);
             if (reduceOnly) {
                 request['reduce_only'] = 1;
             }
@@ -5442,10 +5442,19 @@ export default class htx extends Exchange {
                 request['order_price_type'] = type;
             }
         }
+        const hedged = this.safeBool(params, 'hedged', false);
+        if (hedged) {
+            if (reduceOnly) {
+                request['offset'] = 'close';
+            }
+            else {
+                request['offset'] = 'open';
+            }
+        }
         const broker = this.safeValue(this.options, 'broker', {});
         const brokerId = this.safeString(broker, 'id');
         request['channel_code'] = brokerId;
-        params = this.omit(params, ['reduceOnly', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice']);
+        params = this.omit(params, ['reduceOnly', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerType', 'leverRate', 'timeInForce', 'leverage', 'trailingPercent', 'trailingTriggerPrice', 'hedged']);
         return this.extend(request, params);
     }
     /**
@@ -5459,6 +5468,8 @@ export default class htx extends Exchange {
      * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#cross-place-trigger-order      // usdt-m swap cross trigger
      * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-place-an-order        // usdt-m swap isolated
      * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-place-trigger-order   // usdt-m swap isolated trigger
+     * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#isolated-set-a-take-profit-and-stop-loss-order-for-an-existing-position
+     * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#cross-set-a-take-profit-and-stop-loss-order-for-an-existing-position
      * @see https://huobiapi.github.io/docs/dm/v1/en/#place-an-order                        // coin-m futures
      * @see https://huobiapi.github.io/docs/dm/v1/en/#place-trigger-order                   // coin-m futures contract trigger
      * @param {string} symbol unified symbol of the market to create an order in
@@ -5479,6 +5490,7 @@ export default class htx extends Exchange {
      * @param {float} [params.cost] *spot market buy only* the quote quantity that can be used as an alternative for the amount
      * @param {float} [params.trailingPercent] *contract only* the percent to trail away from the current market price
      * @param {float} [params.trailingTriggerPrice] *contract only* the price to trigger a trailing order, default uses the price argument
+     * @param {bool} [params.hedged] *contract only* true for hedged mode, false for one way mode, default is false
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {

package/js/src/hyperliquid.d.ts

@@ -35,6 +35,16 @@ export default class hyperliquid extends Exchange {
      * @returns {object[]} an array of objects representing market data
      */
     fetchSwapMarkets(params?: {}): Promise<Market[]>;
+    /**
+     * @method
+     * @name calculatePricePrecision
+     * @description Helper function to calculate the Hyperliquid DECIMAL_PLACES price precision
+     * @param {float} price the price to use in the calculation
+     * @param {int} amountPrecision the amountPrecision to use in the calculation
+     * @param {int} maxDecimals the maxDecimals to use in the calculation
+     * @returns {int} The calculated price precision
+     */
+    calculatePricePrecision(price: number, amountPrecision: number, maxDecimals: number): number;
     /**
      * @method
      * @name hyperliquid#fetchMarkets

package/js/src/hyperliquid.js

@@ -6,9 +6,9 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/hyperliquid.js';
-import { ExchangeError, ArgumentsRequired, NotSupported, InvalidOrder, OrderNotFound, BadRequest } from './base/errors.js';
+import { ExchangeError, ArgumentsRequired, NotSupported, InvalidOrder, OrderNotFound, BadRequest, InsufficientFunds } from './base/errors.js';
 import { Precise } from './base/Precise.js';
-import { ROUND, SIGNIFICANT_DIGITS, DECIMAL_PLACES } from './base/functions/number.js';
+import { ROUND, SIGNIFICANT_DIGITS, DECIMAL_PLACES, TICK_SIZE } from './base/functions/number.js';
 import { keccak_256 as keccak } from './static_dependencies/noble-hashes/sha3.js';
 import { secp256k1 } from './static_dependencies/noble-curves/secp256k1.js';
 import { ecdsa } from './base/functions/crypto.js';
@@ -205,9 +205,11 @@ export default class hyperliquid extends Exchange {
                     'User or API Wallet ': InvalidOrder,
                     'Order has invalid size': InvalidOrder,
                     'Order price cannot be more than 80% away from the reference price': InvalidOrder,
+                    'Order has zero size.': InvalidOrder,
+                    'Insufficient spot balance asset': InsufficientFunds,
                 },
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             'commonCurrencies': {},
             'options': {
                 'defaultType': 'swap',
@@ -354,6 +356,55 @@ export default class hyperliquid extends Exchange {
         }
         return this.parseMarkets(result);
     }
+    /**
+     * @method
+     * @name calculatePricePrecision
+     * @description Helper function to calculate the Hyperliquid DECIMAL_PLACES price precision
+     * @param {float} price the price to use in the calculation
+     * @param {int} amountPrecision the amountPrecision to use in the calculation
+     * @param {int} maxDecimals the maxDecimals to use in the calculation
+     * @returns {int} The calculated price precision
+     */
+    calculatePricePrecision(price, amountPrecision, maxDecimals) {
+        let pricePrecision = 0;
+        const priceStr = this.numberToString(price);
+        if (priceStr === undefined) {
+            return 0;
+        }
+        const priceSplitted = priceStr.split('.');
+        if (Precise.stringEq(priceStr, '0')) {
+            // Significant digits is always 5 in this case
+            const significantDigits = 5;
+            // Integer digits is always 0 in this case (0 doesn't count)
+            const integerDigits = 0;
+            // Calculate the price precision
+            pricePrecision = Math.min(maxDecimals - amountPrecision, significantDigits - integerDigits);
+        }
+        else if (Precise.stringGt(priceStr, '0') && Precise.stringLt(priceStr, '1')) {
+            // Significant digits, always 5 in this case
+            const significantDigits = 5;
+            // Get the part after the decimal separator
+            const decimalPart = this.safeString(priceSplitted, 1, '');
+            // Count the number of leading zeros in the decimal part
+            let leadingZeros = 0;
+            while ((leadingZeros <= decimalPart.length) && (decimalPart[leadingZeros] === '0')) {
+                leadingZeros = leadingZeros + 1;
+            }
+            // Calculate price precision based on leading zeros and significant digits
+            pricePrecision = leadingZeros + significantDigits;
+            // Calculate the price precision based on maxDecimals - szDecimals and the calculated price precision from the previous step
+            pricePrecision = Math.min(maxDecimals - amountPrecision, pricePrecision);
+        }
+        else {
+            // Count the numbers before the decimal separator
+            const integerPart = this.safeString(priceSplitted, 0, '');
+            // Get significant digits, take the max() of 5 and the integer digits count
+            const significantDigits = Math.max(5, integerPart.length);
+            // Calculate price precision based on maxDecimals - szDecimals and significantDigits - integerPart.length
+            pricePrecision = Math.min(maxDecimals - amountPrecision, significantDigits - integerPart.length);
+        }
+        return this.parseToInt(pricePrecision);
+    }
     /**
      * @method
      * @name hyperliquid#fetchMarkets
@@ -443,7 +494,11 @@ export default class hyperliquid extends Exchange {
             const symbol = base + '/' + quote;
             const innerBaseTokenInfo = this.safeDict(baseTokenInfo, 'spec', baseTokenInfo);
             // const innerQuoteTokenInfo = this.safeDict (quoteTokenInfo, 'spec', quoteTokenInfo);
-            const amountPrecision = this.safeInteger(innerBaseTokenInfo, 'szDecimals');
+            const amountPrecisionStr = this.safeString(innerBaseTokenInfo, 'szDecimals');
+            const amountPrecision = parseInt(amountPrecisionStr);
+            const price = this.safeNumber(extraData, 'midPx');
+            const pricePrecision = this.calculatePricePrecision(price, amountPrecision, 8);
+            const pricePrecisionStr = this.numberToString(pricePrecision);
             // const quotePrecision = this.parseNumber (this.parsePrecision (this.safeString (innerQuoteTokenInfo, 'szDecimals')));
             const baseId = this.numberToString(i + 10000);
             markets.push(this.safeMarketStructure({
@@ -474,8 +529,8 @@ export default class hyperliquid extends Exchange {
                 'strike': undefined,
                 'optionType': undefined,
                 'precision': {
-                    'amount': amountPrecision,
-                    'price': 8 - amountPrecision, // MAX_DECIMALS is 8
+                    'amount': this.parseNumber(this.parsePrecision(amountPrecisionStr)),
+                    'price': this.parseNumber(this.parsePrecision(pricePrecisionStr)),
                 },
                 'limits': {
                     'leverage': {
@@ -539,7 +594,11 @@ export default class hyperliquid extends Exchange {
         const fees = this.safeDict(this.fees, 'swap', {});
         const taker = this.safeNumber(fees, 'taker');
         const maker = this.safeNumber(fees, 'maker');
-        const amountPrecision = this.safeInteger(market, 'szDecimals');
+        const amountPrecisionStr = this.safeString(market, 'szDecimals');
+        const amountPrecision = parseInt(amountPrecisionStr);
+        const price = this.safeNumber(market, 'markPx', 0);
+        const pricePrecision = this.calculatePricePrecision(price, amountPrecision, 6);
+        const pricePrecisionStr = this.numberToString(pricePrecision);
         return this.safeMarketStructure({
             'id': baseId,
             'symbol': symbol,
@@ -567,8 +626,8 @@ export default class hyperliquid extends Exchange {
             'strike': undefined,
             'optionType': undefined,
             'precision': {
-                'amount': amountPrecision,
-                'price': 6 - amountPrecision, // MAX_DECIMALS is 6
+                'amount': this.parseNumber(this.parsePrecision(amountPrecisionStr)),
+                'price': this.parseNumber(this.parsePrecision(pricePrecisionStr)),
             },
             'limits': {
                 'leverage': {
@@ -1045,10 +1104,13 @@ export default class hyperliquid extends Exchange {
     }
     priceToPrecision(symbol, price) {
         const market = this.market(symbol);
-        // https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/tick-and-lot-size
-        const result = this.decimalToPrecision(price, ROUND, 5, SIGNIFICANT_DIGITS, this.paddingMode);
-        const decimalParsedResult = this.decimalToPrecision(result, ROUND, market['precision']['price'], this.precisionMode, this.paddingMode);
-        return decimalParsedResult;
+        const priceStr = this.numberToString(price);
+        const integerPart = priceStr.split('.')[0];
+        const significantDigits = Math.max(5, integerPart.length);
+        const result = this.decimalToPrecision(price, ROUND, significantDigits, SIGNIFICANT_DIGITS, this.paddingMode);
+        const maxDecimals = market['spot'] ? 8 : 6;
+        const subtractedValue = maxDecimals - this.precisionFromString(this.safeString(market['precision'], 'amount'));
+        return this.decimalToPrecision(result, ROUND, subtractedValue, DECIMAL_PLACES, this.paddingMode);
     }
     hashMessage(message) {
         return '0x' + this.hash(message, keccak, 'hex');

package/js/src/idex.js

@@ -6,7 +6,7 @@
 
 // ---------------------------------------------------------------------------
 import Exchange from './abstract/idex.js';
-import { TICK_SIZE, PAD_WITH_ZERO, ROUND, TRUNCATE, DECIMAL_PLACES } from './base/functions/number.js';
+import { TICK_SIZE, PAD_WITH_ZERO, ROUND, TRUNCATE } from './base/functions/number.js';
 import { InvalidOrder, InsufficientFunds, ExchangeError, ExchangeNotAvailable, DDoSProtection, BadRequest, NotSupported, InvalidAddress, AuthenticationError } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
@@ -198,10 +198,8 @@ export default class idex extends Exchange {
         // {"code":"INVALID_PARAMETER","message":"invalid value provided for request parameter \"price\": all quantities and prices must be below 100 billion, above 0, need to be provided as strings, and always require 4 decimals ending with 4 zeroes"}
         //
         const market = this.market(symbol);
-        const info = this.safeValue(market, 'info', {});
-        const quoteAssetPrecision = this.safeInteger(info, 'quoteAssetPrecision');
         price = this.decimalToPrecision(price, ROUND, market['precision']['price'], this.precisionMode);
-        return this.decimalToPrecision(price, TRUNCATE, quoteAssetPrecision, DECIMAL_PLACES, PAD_WITH_ZERO);
+        return this.decimalToPrecision(price, TRUNCATE, market['precision']['quote'], TICK_SIZE, PAD_WITH_ZERO);
     }
     /**
      * @method
@@ -309,6 +307,8 @@ export default class idex extends Exchange {
                 'precision': {
                     'amount': basePrecision,
                     'price': this.safeNumber(entry, 'tickSize'),
+                    'base': basePrecision,
+                    'quote': quotePrecision,
                 },
                 'limits': {
                     'leverage': {

package/js/src/kraken.d.ts

@@ -207,20 +207,23 @@ export default class kraken extends Exchange {
      * @method
      * @name kraken#editOrder
      * @description edit a trade order
-     * @see https://docs.kraken.com/rest/#tag/Spot-Trading/operation/editOrder
+     * @see https://docs.kraken.com/api/docs/rest-api/amend-order
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market to create an order in
      * @param {string} type 'market' or 'limit'
      * @param {string} side 'buy' or 'sell'
-     * @param {float} amount how much of the currency you want to trade in units of the base currency
+     * @param {float} [amount] how much of the currency you want to trade in units of the 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 {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {float} [params.stopLossPrice] *margin only* the price that a stop loss order is triggered at
-     * @param {float} [params.takeProfitPrice] *margin only* the price that a take profit order is triggered at
-     * @param {string} [params.trailingAmount] *margin only* the quote price away from the current market price
-     * @param {string} [params.trailingLimitAmount] *margin only* the quote amount away from the trailingAmount
-     * @param {string} [params.offset] *margin only* '+' or '-' whether you want the trailingLimitAmount value to be positive or negative, default is negative '-'
-     * @param {string} [params.trigger] *margin only* the activation price type, 'last' or 'index', default is 'last'
+     * @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 {string} [params.trailingAmount] the quote amount to trail away from the current market price
+     * @param {string} [params.trailingPercent] the percent to trail away from the current market price
+     * @param {string} [params.trailingLimitAmount] the quote amount away from the trailingAmount
+     * @param {string} [params.trailingLimitPercent] the percent away from the trailingAmount
+     * @param {string} [params.offset] '+' or '-' whether you want the trailingLimitAmount value to be positive or negative
+     * @param {boolean} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately
+     * @param {string} [params.clientOrderId] the orders client order id
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;

package/js/src/kraken.js

@@ -432,31 +432,43 @@ export default class kraken extends Exchange {
             },
             'precisionMode': TICK_SIZE,
             'exceptions': {
-                'EQuery:Invalid asset pair': BadSymbol,
-                'EAPI:Invalid key': AuthenticationError,
-                'EFunding:Unknown withdraw key': InvalidAddress,
-                'EFunding:Invalid amount': InsufficientFunds,
-                'EService:Unavailable': ExchangeNotAvailable,
-                'EDatabase:Internal error': ExchangeNotAvailable,
-                'EService:Busy': ExchangeNotAvailable,
-                'EQuery:Unknown asset': BadSymbol,
-                'EAPI:Rate limit exceeded': DDoSProtection,
-                'EOrder:Rate limit exceeded': DDoSProtection,
-                'EGeneral:Internal error': ExchangeNotAvailable,
-                'EGeneral:Temporary lockout': DDoSProtection,
-                'EGeneral:Permission denied': PermissionDenied,
-                'EGeneral:Invalid arguments:price': InvalidOrder,
-                'EOrder:Unknown order': InvalidOrder,
-                'EOrder:Invalid price:Invalid price argument': InvalidOrder,
-                'EOrder:Order minimum not met': InvalidOrder,
-                'EGeneral:Invalid arguments': BadRequest,
-                'ESession:Invalid session': AuthenticationError,
-                'EAPI:Invalid nonce': InvalidNonce,
-                'EFunding:No funding method': BadRequest,
-                'EFunding:Unknown asset': BadSymbol,
-                'EService:Market in post_only mode': OnMaintenance,
-                'EGeneral:Too many requests': DDoSProtection,
-                'ETrade:User Locked': AccountSuspended, // {"error":["ETrade:User Locked"]}
+                'exact': {
+                    'EQuery:Invalid asset pair': BadSymbol,
+                    'EAPI:Invalid key': AuthenticationError,
+                    'EFunding:Unknown withdraw key': InvalidAddress,
+                    'EFunding:Invalid amount': InsufficientFunds,
+                    'EService:Unavailable': ExchangeNotAvailable,
+                    'EDatabase:Internal error': ExchangeNotAvailable,
+                    'EService:Busy': ExchangeNotAvailable,
+                    'EQuery:Unknown asset': BadSymbol,
+                    'EAPI:Rate limit exceeded': DDoSProtection,
+                    'EOrder:Rate limit exceeded': DDoSProtection,
+                    'EGeneral:Internal error': ExchangeNotAvailable,
+                    'EGeneral:Temporary lockout': DDoSProtection,
+                    'EGeneral:Permission denied': PermissionDenied,
+                    'EGeneral:Invalid arguments:price': InvalidOrder,
+                    'EOrder:Unknown order': InvalidOrder,
+                    'EOrder:Invalid price:Invalid price argument': InvalidOrder,
+                    'EOrder:Order minimum not met': InvalidOrder,
+                    'EOrder:Insufficient funds': InsufficientFunds,
+                    'EGeneral:Invalid arguments': BadRequest,
+                    'ESession:Invalid session': AuthenticationError,
+                    'EAPI:Invalid nonce': InvalidNonce,
+                    'EFunding:No funding method': BadRequest,
+                    'EFunding:Unknown asset': BadSymbol,
+                    'EService:Market in post_only mode': OnMaintenance,
+                    'EGeneral:Too many requests': DDoSProtection,
+                    'ETrade:User Locked': AccountSuspended, // {"error":["ETrade:User Locked"]}
+                },
+                'broad': {
+                    ':Invalid order': InvalidOrder,
+                    ':Invalid arguments:volume': InvalidOrder,
+                    ':Invalid arguments:viqc': InvalidOrder,
+                    ':Invalid nonce': InvalidNonce,
+                    ':IInsufficient funds': InsufficientFunds,
+                    ':Cancel pending': CancelPending,
+                    ':Rate limit exceeded': RateLimitExceeded,
+                },
             },
         });
     }
@@ -1587,18 +1599,9 @@ export default class kraken extends Exchange {
         // editOrder
         //
         //     {
-        //         "status": "ok",
-        //         "txid": "OAW2BO-7RWEK-PZY5UO",
-        //         "originaltxid": "OXL6SS-UPNMC-26WBE7",
-        //         "newuserref": 1234,
-        //         "olduserref": 123,
-        //         "volume": "0.00075000",
-        //         "price": "13500.0",
-        //         "orders_cancelled": 1,
-        //         "descr": {
-        //             "order": "buy 0.00075000 XBTUSDT @ limit 13500.0"
-        //         }
+        //         "amend_id": "TJSMEH-AA67V-YUSQ6O"
         //     }
+        //
         //  ws - createOrder
         //    {
         //        "descr": 'sell 0.00010000 XBTUSDT @ market',
@@ -1718,7 +1721,7 @@ export default class kraken extends Exchange {
             price = this.safeString(order, 'price', price);
         }
         const flags = this.safeString(order, 'oflags', '');
-        const isPostOnly = flags.indexOf('post') > -1;
+        let isPostOnly = flags.indexOf('post') > -1;
         const average = this.safeNumber(order, 'price');
         if (market !== undefined) {
             symbol = market['symbol'];
@@ -1737,12 +1740,12 @@ export default class kraken extends Exchange {
             }
         }
         const status = this.parseOrderStatus(this.safeString(order, 'status'));
-        let id = this.safeString2(order, 'id', 'txid');
+        let id = this.safeStringN(order, ['id', 'txid', 'amend_id']);
         if ((id === undefined) || (id.startsWith('['))) {
             const txid = this.safeList(order, 'txid');
             id = this.safeString(txid, 0);
         }
-        const clientOrderId = this.safeString2(order, 'userref', 'newuserref');
+        const clientOrderId = this.safeString(order, 'userref');
         const rawTrades = this.safeValue(order, 'trades', []);
         const trades = [];
         for (let i = 0; i < rawTrades.length; i++) {
@@ -1760,19 +1763,21 @@ export default class kraken extends Exchange {
         let takeProfitPrice = undefined;
         // the dashed strings are not provided from fields (eg. fetch order)
         // while spaced strings from "order" sentence (when other fields not available)
-        if (rawType.startsWith('take-profit')) {
-            takeProfitPrice = this.safeString(description, 'price');
-            price = this.omitZero(this.safeString(description, 'price2'));
-        }
-        else if (rawType.startsWith('stop-loss')) {
-            stopLossPrice = this.safeString(description, 'price');
-            price = this.omitZero(this.safeString(description, 'price2'));
-        }
-        else if (rawType === 'take profit') {
-            takeProfitPrice = triggerPrice;
-        }
-        else if (rawType === 'stop loss') {
-            stopLossPrice = triggerPrice;
+        if (rawType !== undefined) {
+            if (rawType.startsWith('take-profit')) {
+                takeProfitPrice = this.safeString(description, 'price');
+                price = this.omitZero(this.safeString(description, 'price2'));
+            }
+            else if (rawType.startsWith('stop-loss')) {
+                stopLossPrice = this.safeString(description, 'price');
+                price = this.omitZero(this.safeString(description, 'price2'));
+            }
+            else if (rawType === 'take profit') {
+                takeProfitPrice = triggerPrice;
+            }
+            else if (rawType === 'stop loss') {
+                stopLossPrice = triggerPrice;
+            }
         }
         let finalType = this.parseOrderType(rawType);
         // unlike from endpoints which provide eg: "take-profit-limit"
@@ -1781,6 +1786,10 @@ export default class kraken extends Exchange {
         if (this.inArray(finalType, ['stop loss', 'take profit'])) {
             finalType = (price === undefined) ? 'market' : 'limit';
         }
+        const amendId = this.safeString(order, 'amend_id');
+        if (amendId !== undefined) {
+            isPostOnly = undefined;
+        }
         return this.safeOrder({
             'id': id,
             'clientOrderId': clientOrderId,
@@ -1810,10 +1819,10 @@ export default class kraken extends Exchange {
         }, market);
     }
     orderRequest(method, symbol, type, request, amount, price = undefined, params = {}) {
-        const clientOrderId = this.safeString2(params, 'userref', 'clientOrderId');
-        params = this.omit(params, ['userref', 'clientOrderId']);
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        params = this.omit(params, ['clientOrderId']);
         if (clientOrderId !== undefined) {
-            request['userref'] = clientOrderId;
+            request['cl_ord_id'] = clientOrderId;
         }
         const stopLossTriggerPrice = this.safeString(params, 'stopLossPrice');
         const takeProfitTriggerPrice = this.safeString(params, 'takeProfitPrice');
@@ -1943,20 +1952,23 @@ export default class kraken extends Exchange {
      * @method
      * @name kraken#editOrder
      * @description edit a trade order
-     * @see https://docs.kraken.com/rest/#tag/Spot-Trading/operation/editOrder
+     * @see https://docs.kraken.com/api/docs/rest-api/amend-order
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market to create an order in
      * @param {string} type 'market' or 'limit'
      * @param {string} side 'buy' or 'sell'
-     * @param {float} amount how much of the currency you want to trade in units of the base currency
+     * @param {float} [amount] how much of the currency you want to trade in units of the 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 {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {float} [params.stopLossPrice] *margin only* the price that a stop loss order is triggered at
-     * @param {float} [params.takeProfitPrice] *margin only* the price that a take profit order is triggered at
-     * @param {string} [params.trailingAmount] *margin only* the quote price away from the current market price
-     * @param {string} [params.trailingLimitAmount] *margin only* the quote amount away from the trailingAmount
-     * @param {string} [params.offset] *margin only* '+' or '-' whether you want the trailingLimitAmount value to be positive or negative, default is negative '-'
-     * @param {string} [params.trigger] *margin only* the activation price type, 'last' or 'index', default is 'last'
+     * @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 {string} [params.trailingAmount] the quote amount to trail away from the current market price
+     * @param {string} [params.trailingPercent] the percent to trail away from the current market price
+     * @param {string} [params.trailingLimitAmount] the quote amount away from the trailingAmount
+     * @param {string} [params.trailingLimitPercent] the percent away from the trailingAmount
+     * @param {string} [params.offset] '+' or '-' whether you want the trailingLimitAmount value to be positive or negative
+     * @param {boolean} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately
+     * @param {string} [params.clientOrderId] the orders client order id
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
@@ -1965,33 +1977,50 @@ export default class kraken extends Exchange {
         if (!market['spot']) {
             throw new NotSupported(this.id + ' editOrder() does not support ' + market['type'] + ' orders, only spot orders are accepted');
         }
-        const request = {
+        let request = {
             'txid': id,
-            'pair': market['id'],
         };
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['cl_ord_id'] = clientOrderId;
+            params = this.omit(params, 'clientOrderId');
+            request = this.omit(request, 'txid');
+        }
+        const isMarket = (type === 'market');
+        let postOnly = undefined;
+        [postOnly, params] = this.handlePostOnly(isMarket, false, params);
+        if (postOnly) {
+            request['post_only'] = 'true'; // not using boolean in this case, because the urlencodedNested transforms it into 'True' string
+        }
         if (amount !== undefined) {
-            request['volume'] = this.amountToPrecision(symbol, amount);
+            request['order_qty'] = this.amountToPrecision(symbol, amount);
+        }
+        if (price !== undefined) {
+            request['limit_price'] = this.priceToPrecision(symbol, price);
+        }
+        let allTriggerPrices = this.safeStringN(params, ['stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingLimitAmount', 'trailingLimitPercent']);
+        if (allTriggerPrices !== undefined) {
+            const offset = this.safeString(params, 'offset');
+            params = this.omit(params, ['stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingPercent', 'trailingLimitAmount', 'trailingLimitPercent', 'offset']);
+            if (offset !== undefined) {
+                allTriggerPrices = offset + allTriggerPrices;
+                request['trigger_price'] = allTriggerPrices;
+            }
+            else {
+                request['trigger_price'] = this.priceToPrecision(symbol, allTriggerPrices);
+            }
         }
-        const orderRequest = this.orderRequest('editOrder', symbol, type, request, amount, price, params);
-        const response = await this.privatePostEditOrder(this.extend(orderRequest[0], orderRequest[1]));
+        const response = await this.privatePostAmendOrder(this.extend(request, params));
         //
         //     {
         //         "error": [],
         //         "result": {
-        //             "status": "ok",
-        //             "txid": "OAW2BO-7RWEK-PZY5UO",
-        //             "originaltxid": "OXL6SS-UPNMC-26WBE7",
-        //             "volume": "0.00075000",
-        //             "price": "13500.0",
-        //             "orders_cancelled": 1,
-        //             "descr": {
-        //                 "order": "buy 0.00075000 XBTUSDT @ limit 13500.0"
-        //             }
+        //             "amend_id": "TJSMEH-AA67V-YUSQ6O"
         //         }
         //     }
         //
-        const data = this.safeDict(response, 'result', {});
-        return this.parseOrder(data, market);
+        const result = this.safeDict(response, 'result', {});
+        return this.parseOrder(result, market);
     }
     /**
      * @method
@@ -3207,28 +3236,6 @@ export default class kraken extends Exchange {
         if (code === 520) {
             throw new ExchangeNotAvailable(this.id + ' ' + code.toString() + ' ' + reason);
         }
-        // todo: rewrite this for "broad" exceptions matching
-        if (body.indexOf('Invalid order') >= 0) {
-            throw new InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid nonce') >= 0) {
-            throw new InvalidNonce(this.id + ' ' + body);
-        }
-        if (body.indexOf('Insufficient funds') >= 0) {
-            throw new InsufficientFunds(this.id + ' ' + body);
-        }
-        if (body.indexOf('Cancel pending') >= 0) {
-            throw new CancelPending(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid arguments:volume') >= 0) {
-            throw new InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid arguments:viqc') >= 0) {
-            throw new InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Rate limit exceeded') >= 0) {
-            throw new RateLimitExceeded(this.id + ' ' + body);
-        }
         if (response === undefined) {
             return undefined;
         }
@@ -3240,7 +3247,8 @@ export default class kraken extends Exchange {
                         const message = this.id + ' ' + body;
                         for (let i = 0; i < response['error'].length; i++) {
                             const error = response['error'][i];
-                            this.throwExactlyMatchedException(this.exceptions, error, message);
+                            this.throwExactlyMatchedException(this.exceptions['exact'], error, message);
+                            this.throwExactlyMatchedException(this.exceptions['broad'], error, message);
                         }
                         throw new ExchangeError(message);
                     }

package/js/src/kucoin.js

@@ -1186,7 +1186,7 @@ export default class kucoin extends Exchange {
                 'type': 'spot',
                 'spot': true,
                 'margin': isMarginable,
-                'marginMode': {
+                'marginModes': {
                     'cross': hasCrossMargin,
                     'isolated': hasIsolatedMargin,
                 },

package/js/src/okx.js

@@ -328,6 +328,7 @@ export default class okx extends Exchange {
                         'asset/convert/history': 5 / 3,
                         'asset/monthly-statement': 2,
                         // account
+                        'account/instruments': 1,
                         'account/balance': 2,
                         'account/positions': 2,
                         'account/positions-history': 100,