ccxt 4.4.34 → 4.4.36

package/dist/cjs/src/hyperliquid.js

@@ -202,9 +202,11 @@ class hyperliquid extends hyperliquid$1 {
                     'User or API Wallet ': errors.InvalidOrder,
                     'Order has invalid size': errors.InvalidOrder,
                     'Order price cannot be more than 80% away from the reference price': errors.InvalidOrder,
+                    'Order has zero size.': errors.InvalidOrder,
+                    'Insufficient spot balance asset': errors.InsufficientFunds,
                 },
             },
-            'precisionMode': number.DECIMAL_PLACES,
+            'precisionMode': number.TICK_SIZE,
             'commonCurrencies': {},
             'options': {
                 'defaultType': 'swap',
@@ -351,6 +353,55 @@ class hyperliquid extends hyperliquid$1 {
         }
         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["default"].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["default"].stringGt(priceStr, '0') && Precise["default"].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
@@ -440,7 +491,11 @@ class hyperliquid extends hyperliquid$1 {
             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({
@@ -471,8 +526,8 @@ class hyperliquid extends hyperliquid$1 {
                 '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': {
@@ -536,7 +591,11 @@ class hyperliquid extends hyperliquid$1 {
         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,
@@ -564,8 +623,8 @@ class hyperliquid extends hyperliquid$1 {
             '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': {
@@ -1042,10 +1101,13 @@ class hyperliquid extends hyperliquid$1 {
     }
     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, number.ROUND, 5, number.SIGNIFICANT_DIGITS, this.paddingMode);
-        const decimalParsedResult = this.decimalToPrecision(result, number.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, number.ROUND, significantDigits, number.SIGNIFICANT_DIGITS, this.paddingMode);
+        const maxDecimals = market['spot'] ? 8 : 6;
+        const subtractedValue = maxDecimals - this.precisionFromString(this.safeString(market['precision'], 'amount'));
+        return this.decimalToPrecision(result, number.ROUND, subtractedValue, number.DECIMAL_PLACES, this.paddingMode);
     }
     hashMessage(message) {
         return '0x' + this.hash(message, sha3.keccak_256, 'hex');

package/dist/cjs/src/idex.js

@@ -195,10 +195,8 @@ class idex extends idex$1 {
         // {"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, number.ROUND, market['precision']['price'], this.precisionMode);
-        return this.decimalToPrecision(price, number.TRUNCATE, quoteAssetPrecision, number.DECIMAL_PLACES, number.PAD_WITH_ZERO);
+        return this.decimalToPrecision(price, number.TRUNCATE, market['precision']['quote'], number.TICK_SIZE, number.PAD_WITH_ZERO);
     }
     /**
      * @method
@@ -306,6 +304,8 @@ class idex extends idex$1 {
                 'precision': {
                     'amount': basePrecision,
                     'price': this.safeNumber(entry, 'tickSize'),
+                    'base': basePrecision,
+                    'quote': quotePrecision,
                 },
                 'limits': {
                     'leverage': {

package/dist/cjs/src/kraken.js

@@ -429,31 +429,43 @@ class kraken extends kraken$1 {
             },
             'precisionMode': number.TICK_SIZE,
             'exceptions': {
-                'EQuery:Invalid asset pair': errors.BadSymbol,
-                'EAPI:Invalid key': errors.AuthenticationError,
-                'EFunding:Unknown withdraw key': errors.InvalidAddress,
-                'EFunding:Invalid amount': errors.InsufficientFunds,
-                'EService:Unavailable': errors.ExchangeNotAvailable,
-                'EDatabase:Internal error': errors.ExchangeNotAvailable,
-                'EService:Busy': errors.ExchangeNotAvailable,
-                'EQuery:Unknown asset': errors.BadSymbol,
-                'EAPI:Rate limit exceeded': errors.DDoSProtection,
-                'EOrder:Rate limit exceeded': errors.DDoSProtection,
-                'EGeneral:Internal error': errors.ExchangeNotAvailable,
-                'EGeneral:Temporary lockout': errors.DDoSProtection,
-                'EGeneral:Permission denied': errors.PermissionDenied,
-                'EGeneral:Invalid arguments:price': errors.InvalidOrder,
-                'EOrder:Unknown order': errors.InvalidOrder,
-                'EOrder:Invalid price:Invalid price argument': errors.InvalidOrder,
-                'EOrder:Order minimum not met': errors.InvalidOrder,
-                'EGeneral:Invalid arguments': errors.BadRequest,
-                'ESession:Invalid session': errors.AuthenticationError,
-                'EAPI:Invalid nonce': errors.InvalidNonce,
-                'EFunding:No funding method': errors.BadRequest,
-                'EFunding:Unknown asset': errors.BadSymbol,
-                'EService:Market in post_only mode': errors.OnMaintenance,
-                'EGeneral:Too many requests': errors.DDoSProtection,
-                'ETrade:User Locked': errors.AccountSuspended, // {"error":["ETrade:User Locked"]}
+                'exact': {
+                    'EQuery:Invalid asset pair': errors.BadSymbol,
+                    'EAPI:Invalid key': errors.AuthenticationError,
+                    'EFunding:Unknown withdraw key': errors.InvalidAddress,
+                    'EFunding:Invalid amount': errors.InsufficientFunds,
+                    'EService:Unavailable': errors.ExchangeNotAvailable,
+                    'EDatabase:Internal error': errors.ExchangeNotAvailable,
+                    'EService:Busy': errors.ExchangeNotAvailable,
+                    'EQuery:Unknown asset': errors.BadSymbol,
+                    'EAPI:Rate limit exceeded': errors.DDoSProtection,
+                    'EOrder:Rate limit exceeded': errors.DDoSProtection,
+                    'EGeneral:Internal error': errors.ExchangeNotAvailable,
+                    'EGeneral:Temporary lockout': errors.DDoSProtection,
+                    'EGeneral:Permission denied': errors.PermissionDenied,
+                    'EGeneral:Invalid arguments:price': errors.InvalidOrder,
+                    'EOrder:Unknown order': errors.InvalidOrder,
+                    'EOrder:Invalid price:Invalid price argument': errors.InvalidOrder,
+                    'EOrder:Order minimum not met': errors.InvalidOrder,
+                    'EOrder:Insufficient funds': errors.InsufficientFunds,
+                    'EGeneral:Invalid arguments': errors.BadRequest,
+                    'ESession:Invalid session': errors.AuthenticationError,
+                    'EAPI:Invalid nonce': errors.InvalidNonce,
+                    'EFunding:No funding method': errors.BadRequest,
+                    'EFunding:Unknown asset': errors.BadSymbol,
+                    'EService:Market in post_only mode': errors.OnMaintenance,
+                    'EGeneral:Too many requests': errors.DDoSProtection,
+                    'ETrade:User Locked': errors.AccountSuspended, // {"error":["ETrade:User Locked"]}
+                },
+                'broad': {
+                    ':Invalid order': errors.InvalidOrder,
+                    ':Invalid arguments:volume': errors.InvalidOrder,
+                    ':Invalid arguments:viqc': errors.InvalidOrder,
+                    ':Invalid nonce': errors.InvalidNonce,
+                    ':IInsufficient funds': errors.InsufficientFunds,
+                    ':Cancel pending': errors.CancelPending,
+                    ':Rate limit exceeded': errors.RateLimitExceeded,
+                },
             },
         });
     }
@@ -1584,18 +1596,9 @@ class kraken extends kraken$1 {
         // 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',
@@ -1715,7 +1718,7 @@ class kraken extends kraken$1 {
             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'];
@@ -1734,12 +1737,12 @@ class kraken extends kraken$1 {
             }
         }
         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++) {
@@ -1757,19 +1760,21 @@ class kraken extends kraken$1 {
         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"
@@ -1778,6 +1783,10 @@ class kraken extends kraken$1 {
         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,
@@ -1807,10 +1816,10 @@ class kraken extends kraken$1 {
         }, 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');
@@ -1940,20 +1949,23 @@ class kraken extends kraken$1 {
      * @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 = {}) {
@@ -1962,33 +1974,50 @@ class kraken extends kraken$1 {
         if (!market['spot']) {
             throw new errors.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
@@ -3204,28 +3233,6 @@ class kraken extends kraken$1 {
         if (code === 520) {
             throw new errors.ExchangeNotAvailable(this.id + ' ' + code.toString() + ' ' + reason);
         }
-        // todo: rewrite this for "broad" exceptions matching
-        if (body.indexOf('Invalid order') >= 0) {
-            throw new errors.InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid nonce') >= 0) {
-            throw new errors.InvalidNonce(this.id + ' ' + body);
-        }
-        if (body.indexOf('Insufficient funds') >= 0) {
-            throw new errors.InsufficientFunds(this.id + ' ' + body);
-        }
-        if (body.indexOf('Cancel pending') >= 0) {
-            throw new errors.CancelPending(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid arguments:volume') >= 0) {
-            throw new errors.InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Invalid arguments:viqc') >= 0) {
-            throw new errors.InvalidOrder(this.id + ' ' + body);
-        }
-        if (body.indexOf('Rate limit exceeded') >= 0) {
-            throw new errors.RateLimitExceeded(this.id + ' ' + body);
-        }
         if (response === undefined) {
             return undefined;
         }
@@ -3237,7 +3244,8 @@ class kraken extends kraken$1 {
                         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 errors.ExchangeError(message);
                     }

package/dist/cjs/src/kucoin.js

@@ -1183,7 +1183,7 @@ class kucoin extends kucoin$1 {
                 'type': 'spot',
                 'spot': true,
                 'margin': isMarginable,
-                'marginMode': {
+                'marginModes': {
                     'cross': hasCrossMargin,
                     'isolated': hasIsolatedMargin,
                 },

package/dist/cjs/src/okx.js

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