ccxt 4.3.56 → 4.3.58

package/js/src/base/ws/Client.js

@@ -11,6 +11,7 @@ import { isNode, isJsonEncodedObject, deepExtend, milliseconds, } from '../../ba
 import { utf8 } from '../../static_dependencies/scure-base/index.js';
 export default class Client {
     constructor(url, onMessageCallback, onErrorCallback, onCloseCallback, onConnectedCallback, config = {}) {
+        this.useMessageQueue = true;
         this.verbose = false;
         const defaults = {
             url,
@@ -24,6 +25,8 @@ export default class Client {
             futures: {},
             subscriptions: {},
             rejections: {},
+            messageQueue: {},
+            useMessageQueue: true,
             connected: undefined,
             error: undefined,
             connectionStarted: undefined,
@@ -54,6 +57,15 @@ export default class Client {
         if (messageHash in this.rejections) {
             future.reject(this.rejections[messageHash]);
             delete this.rejections[messageHash];
+            delete this.messageQueue[messageHash];
+            return future;
+        }
+        if (this.useMessageQueue) {
+            const queue = this.messageQueue[messageHash];
+            if (queue && queue.length) {
+                future.resolve(queue.shift());
+                delete this.futures[messageHash];
+            }
         }
         return future;
     }
@@ -61,10 +73,27 @@ export default class Client {
         if (this.verbose && (messageHash === undefined)) {
             this.log(new Date(), 'resolve received undefined messageHash');
         }
-        if ((messageHash !== undefined) && (messageHash in this.futures)) {
-            const promise = this.futures[messageHash];
-            promise.resolve(result);
-            delete this.futures[messageHash];
+        if (this.useMessageQueue === true) {
+            if (!(messageHash in this.messageQueue)) {
+                this.messageQueue[messageHash] = [];
+            }
+            const queue = this.messageQueue[messageHash];
+            queue.push(result);
+            while (queue.length > 10) { // limit size to 10 messages in the queue
+                queue.shift();
+            }
+            if ((messageHash !== undefined) && (messageHash in this.futures)) {
+                const promise = this.futures[messageHash];
+                promise.resolve(queue.shift());
+                delete this.futures[messageHash];
+            }
+        }
+        else {
+            if (messageHash in this.futures) {
+                const promise = this.futures[messageHash];
+                promise.resolve(result);
+                delete this.futures[messageHash];
+            }
         }
         return result;
     }
@@ -105,6 +134,7 @@ export default class Client {
     reset(error) {
         this.clearConnectionTimeout();
         this.clearPingInterval();
+        this.messageQueue = {};
         this.reject(error);
     }
     onConnectionTimeout() {

package/js/src/bigone.d.ts

@@ -26,7 +26,7 @@ export default class bigone extends Exchange {
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<any[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/bigone.js

@@ -1624,7 +1624,27 @@ export default class bigone extends Exchange {
         //         }
         //     }
         //
-        return response;
+        const data = this.safeDict(response, 'data', {});
+        const cancelled = this.safeList(data, 'cancelled', []);
+        const failed = this.safeList(data, 'failed', []);
+        const result = [];
+        for (let i = 0; i < cancelled.length; i++) {
+            const orderId = cancelled[i];
+            result.push(this.safeOrder({
+                'info': orderId,
+                'id': orderId,
+                'status': 'canceled',
+            }));
+        }
+        for (let i = 0; i < failed.length; i++) {
+            const orderId = failed[i];
+            result.push(this.safeOrder({
+                'info': orderId,
+                'id': orderId,
+                'status': 'failed',
+            }));
+        }
+        return result;
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**

package/js/src/bingx.d.ts

@@ -10,6 +10,7 @@ export default class bingx extends Exchange {
     fetchCurrencies(params?: {}): Promise<Currencies>;
     fetchSpotMarkets(params: any): Promise<import("./base/types.js").MarketInterface[]>;
     fetchSwapMarkets(params: any): Promise<import("./base/types.js").MarketInterface[]>;
+    fetchInverseSwapMarkets(params: any): Promise<import("./base/types.js").MarketInterface[]>;
     parseMarket(market: Dict): Market;
     fetchMarkets(params?: {}): Promise<Market[]>;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;

package/js/src/bingx.js

@@ -672,6 +672,29 @@ export default class bingx extends Exchange {
         const markets = this.safeList(response, 'data', []);
         return this.parseMarkets(markets);
     }
+    async fetchInverseSwapMarkets(params) {
+        const response = await this.cswapV1PublicGetMarketContracts(params);
+        //
+        //     {
+        //         "code": 0,
+        //         "msg": "",
+        //         "timestamp": 1720074487610,
+        //         "data": [
+        //             {
+        //                 "symbol": "BNB-USD",
+        //                 "pricePrecision": 2,
+        //                 "minTickSize": "10",
+        //                 "minTradeValue": "10",
+        //                 "minQty": "1.00000000",
+        //                 "status": 1,
+        //                 "timeOnline": 1713175200000
+        //             },
+        //         ]
+        //     }
+        //
+        const markets = this.safeList(response, 'data', []);
+        return this.parseMarkets(markets);
+    }
     parseMarket(market) {
         const id = this.safeString(market, 'symbol');
         const symbolParts = id.split('-');
@@ -679,7 +702,16 @@ export default class bingx extends Exchange {
         const quoteId = symbolParts[1];
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
-        const currency = this.safeString(market, 'currency');
+        let currency = this.safeString(market, 'currency');
+        let checkIsInverse = false;
+        let checkIsLinear = true;
+        const minTickSize = this.safeNumber(market, 'minTickSize');
+        if (minTickSize !== undefined) {
+            // inverse swap market
+            currency = baseId;
+            checkIsInverse = true;
+            checkIsLinear = false;
+        }
         const settle = this.safeCurrencyCode(currency);
         let pricePrecision = this.safeNumber(market, 'tickSize');
         if (pricePrecision === undefined) {
@@ -699,8 +731,12 @@ export default class bingx extends Exchange {
         const fees = this.safeDict(this.fees, type, {});
         const contractSize = (swap) ? this.parseNumber('1') : undefined;
         const isActive = this.safeString(market, 'status') === '1';
-        const isInverse = (spot) ? undefined : false;
-        const isLinear = (spot) ? undefined : swap;
+        const isInverse = (spot) ? undefined : checkIsInverse;
+        const isLinear = (spot) ? undefined : checkIsLinear;
+        let timeOnline = this.safeInteger(market, 'timeOnline');
+        if (timeOnline === 0) {
+            timeOnline = undefined;
+        }
         return this.safeMarketStructure({
             'id': id,
             'symbol': symbol,
@@ -742,15 +778,15 @@ export default class bingx extends Exchange {
                     'max': this.safeNumber(market, 'maxQty'),
                 },
                 'price': {
-                    'min': undefined,
+                    'min': minTickSize,
                     'max': undefined,
                 },
                 'cost': {
-                    'min': this.safeNumber2(market, 'minNotional', 'tradeMinUSDT'),
+                    'min': this.safeNumberN(market, ['minNotional', 'tradeMinUSDT', 'minTradeValue']),
                     'max': this.safeNumber(market, 'maxNotional'),
                 },
             },
-            'created': undefined,
+            'created': timeOnline,
             'info': market,
         });
     }
@@ -761,17 +797,21 @@ export default class bingx extends Exchange {
          * @description retrieves data on all markets for bingx
          * @see https://bingx-api.github.io/docs/#/spot/market-api.html#Query%20Symbols
          * @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Contract%20Information
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Contract%20Information
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} an array of objects representing market data
          */
         const requests = [this.fetchSwapMarkets(params)];
         const isSandbox = this.safeBool(this.options, 'sandboxMode', false);
         if (!isSandbox) {
+            requests.push(this.fetchInverseSwapMarkets(params));
             requests.push(this.fetchSpotMarkets(params)); // sandbox is swap only
         }
         const promises = await Promise.all(requests);
-        const spotMarkets = this.safeList(promises, 0, []);
-        const swapMarkets = this.safeList(promises, 1, []);
+        const linearSwapMarkets = this.safeList(promises, 0, []);
+        const inverseSwapMarkets = this.safeList(promises, 1, []);
+        const spotMarkets = this.safeList(promises, 2, []);
+        const swapMarkets = this.arrayConcat(linearSwapMarkets, inverseSwapMarkets);
         return this.arrayConcat(spotMarkets, swapMarkets);
     }
     async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
@@ -783,13 +823,14 @@ export default class bingx extends Exchange {
          * @see https://bingx-api.github.io/docs/#/spot/market-api.html#Candlestick%20chart%20data
          * @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#%20K-Line%20Data
          * @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#K-Line%20Data%20-%20Mark%20Price
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Get%20K-line%20Data
          * @param {string} symbol unified symbol of the market to fetch OHLCV data for
          * @param {string} timeframe the length of time each candle represents
          * @param {int} [since] timestamp in ms of the earliest candle to fetch
          * @param {int} [limit] the maximum amount of candles to fetch
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {int} [params.until] timestamp in ms of the latest candle to fetch
-         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
         await this.loadMarkets();
@@ -819,13 +860,18 @@ export default class bingx extends Exchange {
             response = await this.spotV1PublicGetMarketKline(this.extend(request, params));
         }
         else {
-            const price = this.safeString(params, 'price');
-            params = this.omit(params, 'price');
-            if (price === 'mark') {
-                response = await this.swapV1PrivateGetMarketMarkPriceKlines(this.extend(request, params));
+            if (market['inverse']) {
+                response = await this.cswapV1PublicGetMarketKlines(this.extend(request, params));
             }
             else {
-                response = await this.swapV3PublicGetQuoteKlines(this.extend(request, params));
+                const price = this.safeString(params, 'price');
+                params = this.omit(params, 'price');
+                if (price === 'mark') {
+                    response = await this.swapV1PrivateGetMarketMarkPriceKlines(this.extend(request, params));
+                }
+                else {
+                    response = await this.swapV3PublicGetQuoteKlines(this.extend(request, params));
+                }
             }
         }
         //
@@ -1137,6 +1183,7 @@ export default class bingx extends Exchange {
          * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @see https://bingx-api.github.io/docs/#/spot/market-api.html#Query%20depth%20information
          * @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Get%20Market%20Depth
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Query%20Depth%20Data
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -1157,7 +1204,12 @@ export default class bingx extends Exchange {
             response = await this.spotV1PublicGetMarketDepth(this.extend(request, params));
         }
         else {
-            response = await this.swapV2PublicGetQuoteDepth(this.extend(request, params));
+            if (market['inverse']) {
+                response = await this.cswapV1PublicGetMarketDepth(this.extend(request, params));
+            }
+            else {
+                response = await this.swapV2PublicGetQuoteDepth(this.extend(request, params));
+            }
         }
         //
         // spot
@@ -1226,6 +1278,7 @@ export default class bingx extends Exchange {
          * @name bingx#fetchFundingRate
          * @description fetch the current funding rate
          * @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Current%20Funding%20Rate
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Price%20&%20Current%20Funding%20Rate
          * @param {string} symbol unified market symbol
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
@@ -1235,7 +1288,13 @@ export default class bingx extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.swapV2PublicGetQuotePremiumIndex(this.extend(request, params));
+        let response = undefined;
+        if (market['inverse']) {
+            response = await this.cswapV1PublicGetMarketPremiumIndex(this.extend(request, params));
+        }
+        else {
+            response = await this.swapV2PublicGetQuotePremiumIndex(this.extend(request, params));
+        }
         //
         //    {
         //        "code":0,
@@ -1387,9 +1446,10 @@ export default class bingx extends Exchange {
         /**
          * @method
          * @name bingx#fetchOpenInterest
-         * @description Retrieves the open interest of a currency
+         * @description retrieves the open interest of a trading pair
          * @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Get%20Swap%20Open%20Positions
-         * @param {string} symbol Unified CCXT market symbol
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Get%20Swap%20Open%20Positions
+         * @param {string} symbol unified CCXT market symbol
          * @param {object} [params] exchange specific parameters
          * @returns {object} an open interest structure{@link https://docs.ccxt.com/#/?id=open-interest-structure}
          */
@@ -1398,7 +1458,15 @@ export default class bingx extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.swapV2PublicGetQuoteOpenInterest(this.extend(request, params));
+        let response = undefined;
+        if (market['inverse']) {
+            response = await this.cswapV1PublicGetMarketOpenInterest(this.extend(request, params));
+        }
+        else {
+            response = await this.swapV2PublicGetQuoteOpenInterest(this.extend(request, params));
+        }
+        //
+        // linear swap
         //
         //     {
         //         "code": 0,
@@ -1410,18 +1478,50 @@ export default class bingx extends Exchange {
         //         }
         //     }
         //
-        const data = this.safeDict(response, 'data', {});
-        return this.parseOpenInterest(data, market);
+        // inverse swap
+        //
+        //     {
+        //         "code": 0,
+        //         "msg": "",
+        //         "timestamp": 1720328247986,
+        //         "data": [
+        //             {
+        //                 "symbol": "BTC-USD",
+        //                 "openInterest": "749.1160",
+        //                 "timestamp": 1720310400000
+        //             }
+        //         ]
+        //     }
+        //
+        let result = {};
+        if (market['inverse']) {
+            const data = this.safeList(response, 'data', []);
+            result = this.safeDict(data, 0, {});
+        }
+        else {
+            result = this.safeDict(response, 'data', {});
+        }
+        return this.parseOpenInterest(result, market);
     }
     parseOpenInterest(interest, market = undefined) {
         //
-        //    {
-        //        "openInterest": "3289641547.10",
-        //        "symbol": "BTC-USDT",
-        //        "time": 1672026617364
-        //    }
+        // linear swap
+        //
+        //     {
+        //         "openInterest": "3289641547.10",
+        //         "symbol": "BTC-USDT",
+        //         "time": 1672026617364
+        //     }
+        //
+        // inverse swap
+        //
+        //     {
+        //         "symbol": "BTC-USD",
+        //         "openInterest": "749.1160",
+        //         "timestamp": 1720310400000
+        //     }
         //
-        const timestamp = this.safeInteger(interest, 'time');
+        const timestamp = this.safeInteger2(interest, 'time', 'timestamp');
         const id = this.safeString(interest, 'symbol');
         const symbol = this.safeSymbol(id, market, '-', 'swap');
         const openInterest = this.safeNumber(interest, 'openInterest');

package/js/src/bitget.d.ts

@@ -64,7 +64,7 @@ export default class bitget extends Exchange {
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     cancelOrders(ids: any, symbol?: Str, params?: {}): Promise<Order[]>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/bitget.js

@@ -5015,6 +5015,22 @@ export default class bitget extends Exchange {
                 else {
                     response = await this.privateMarginPostMarginV1IsolatedOrderBatchCancelOrder(this.extend(request, params));
                 }
+                //
+                //     {
+                //         "code": "00000",
+                //         "msg": "success",
+                //         "requestTime": 1700717155622,
+                //         "data": {
+                //             "resultList": [
+                //                 {
+                //                     "orderId": "1111453253721796609",
+                //                     "clientOid": "2ae7fc8a4ff949b6b60d770ca3950e2d"
+                //                 },
+                //             ],
+                //             "failure": []
+                //         }
+                //     }
+                //
             }
             else {
                 if (stop) {
@@ -5026,6 +5042,27 @@ export default class bitget extends Exchange {
                 else {
                     response = await this.privateSpotPostV2SpotTradeCancelSymbolOrder(this.extend(request, params));
                 }
+                //
+                //     {
+                //         "code": "00000",
+                //         "msg": "success",
+                //         "requestTime": 1700716953996,
+                //         "data": {
+                //             "symbol": "BTCUSDT"
+                //         }
+                //     }
+                //
+                const timestamp = this.safeInteger(response, 'requestTime');
+                const responseData = this.safeDict(response, 'data');
+                const marketId = this.safeString(responseData, 'symbol');
+                return [
+                    this.safeOrder({
+                        'info': response,
+                        'symbol': this.safeSymbol(marketId, undefined, undefined, 'spot'),
+                        'timestamp': timestamp,
+                        'datetime': this.iso8601(timestamp),
+                    }),
+                ];
             }
         }
         else {
@@ -5038,54 +5075,26 @@ export default class bitget extends Exchange {
             else {
                 response = await this.privateMixPostV2MixOrderBatchCancelOrders(this.extend(request, params));
             }
+            //     {
+            //         "code": "00000",
+            //         "msg": "success",
+            //         "requestTime": "1680008815965",
+            //         "data": {
+            //             "successList": [
+            //                 {
+            //                     "orderId": "1024598257429823488",
+            //                     "clientOid": "876493ce-c287-4bfc-9f4a-8b1905881313"
+            //                 },
+            //             ],
+            //             "failureList": []
+            //         }
+            //     }
         }
-        //
-        // spot
-        //
-        //     {
-        //         "code": "00000",
-        //         "msg": "success",
-        //         "requestTime": 1700716953996,
-        //         "data": {
-        //             "symbol": "BTCUSDT"
-        //         }
-        //     }
-        //
-        // swap
-        //
-        //     {
-        //         "code": "00000",
-        //         "msg": "success",
-        //         "requestTime": "1680008815965",
-        //         "data": {
-        //             "successList": [
-        //                 {
-        //                     "orderId": "1024598257429823488",
-        //                     "clientOid": "876493ce-c287-4bfc-9f4a-8b1905881313"
-        //                 },
-        //             ],
-        //             "failureList": []
-        //         }
-        //     }
-        //
-        // spot margin
-        //
-        //     {
-        //         "code": "00000",
-        //         "msg": "success",
-        //         "requestTime": 1700717155622,
-        //         "data": {
-        //             "resultList": [
-        //                 {
-        //                     "orderId": "1111453253721796609",
-        //                     "clientOid": "2ae7fc8a4ff949b6b60d770ca3950e2d"
-        //                 },
-        //             ],
-        //             "failure": []
-        //         }
-        //     }
-        //
-        return response;
+        const data = this.safeDict(response, 'data');
+        const resultList = this.safeList2(data, 'resultList', 'successList');
+        const failureList = this.safeList2(data, 'failure', 'failureList');
+        const responseList = this.arrayConcat(resultList, failureList);
+        return this.parseOrders(responseList);
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**

package/js/src/coinmate.js

@@ -21,7 +21,7 @@ export default class coinmate extends Exchange {
             'id': 'coinmate',
             'name': 'CoinMate',
             'countries': ['GB', 'CZ', 'EU'],
-            'rateLimit': 1000,
+            'rateLimit': 600,
             'has': {
                 'CORS': true,
                 'spot': true,
@@ -170,28 +170,28 @@ export default class coinmate extends Exchange {
                 'trading': {
                     'tierBased': true,
                     'percentage': true,
-                    'maker': this.parseNumber('0.0012'),
-                    'taker': this.parseNumber('0.0025'),
+                    'taker': this.parseNumber('0.006'),
+                    'maker': this.parseNumber('0.004'),
                     'tiers': {
                         'taker': [
-                            [this.parseNumber('0'), this.parseNumber('0.0035')],
-                            [this.parseNumber('10000'), this.parseNumber('0.0023')],
-                            [this.parseNumber('100000'), this.parseNumber('0.0021')],
-                            [this.parseNumber('250000'), this.parseNumber('0.0020')],
-                            [this.parseNumber('500000'), this.parseNumber('0.0015')],
-                            [this.parseNumber('1000000'), this.parseNumber('0.0013')],
-                            [this.parseNumber('3000000'), this.parseNumber('0.0010')],
-                            [this.parseNumber('15000000'), this.parseNumber('0.0005')],
+                            [this.parseNumber('0'), this.parseNumber('0.006')],
+                            [this.parseNumber('10000'), this.parseNumber('0.003')],
+                            [this.parseNumber('100000'), this.parseNumber('0.0023')],
+                            [this.parseNumber('250000'), this.parseNumber('0.0021')],
+                            [this.parseNumber('500000'), this.parseNumber('0.0018')],
+                            [this.parseNumber('1000000'), this.parseNumber('0.0015')],
+                            [this.parseNumber('3000000'), this.parseNumber('0.0012')],
+                            [this.parseNumber('15000000'), this.parseNumber('0.001')],
                         ],
                         'maker': [
-                            [this.parseNumber('0'), this.parseNumber('0.003')],
-                            [this.parseNumber('10000'), this.parseNumber('0.0011')],
-                            [this.parseNumber('100000'), this.parseNumber('0.0010')],
-                            [this.parseNumber('250000'), this.parseNumber('0.0008')],
+                            [this.parseNumber('0'), this.parseNumber('0.004')],
+                            [this.parseNumber('10000'), this.parseNumber('0.002')],
+                            [this.parseNumber('100000'), this.parseNumber('0.0012')],
+                            [this.parseNumber('250000'), this.parseNumber('0.0009')],
                             [this.parseNumber('500000'), this.parseNumber('0.0005')],
                             [this.parseNumber('1000000'), this.parseNumber('0.0003')],
                             [this.parseNumber('3000000'), this.parseNumber('0.0002')],
-                            [this.parseNumber('15000000'), this.parseNumber('0')],
+                            [this.parseNumber('15000000'), this.parseNumber('-0.0004')],
                         ],
                     },
                 },
@@ -1096,26 +1096,19 @@ export default class coinmate extends Exchange {
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };
     }
     handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
-        if (response !== undefined) {
-            if ('error' in response) {
-                // {"error":true,"errorMessage":"Minimum Order Size 0.01 ETH","data":null}
-                if (response['error']) {
-                    const message = this.safeString(response, 'errorMessage');
-                    const feedback = this.id + ' ' + message;
-                    this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
-                    this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
-                    throw new ExchangeError(this.id + ' ' + this.json(response));
-                }
-            }
+        if (response === undefined) {
+            return undefined; // fallback to default error handler
         }
-        if (code > 400) {
-            if (body) {
-                const feedback = this.id + ' ' + body;
-                this.throwExactlyMatchedException(this.exceptions['exact'], body, feedback);
-                this.throwBroadlyMatchedException(this.exceptions['broad'], body, feedback);
-                throw new ExchangeError(feedback); // unknown message
-            }
-            throw new ExchangeError(this.id + ' ' + body);
+        //
+        //     {"error":true,"errorMessage":"Api internal error","data":null}
+        //     {"error":true,"errorMessage":"Access denied.","data":null}
+        //
+        const errorMessage = this.safeString(response, 'errorMessage');
+        if (errorMessage !== undefined) {
+            const feedback = this.id + ' ' + body;
+            this.throwExactlyMatchedException(this.exceptions['exact'], errorMessage, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], errorMessage, feedback);
+            throw new ExchangeError(feedback); // unknown message
         }
         return undefined;
     }