ccxt 4.4.57 → 4.4.59

package/js/src/bitmart.js

@@ -512,7 +512,10 @@ export default class bitmart extends Exchange {
                     '40049': InvalidOrder,
                     '40050': InvalidOrder, // 403, Client OrderId duplicated with existing orders
                 },
-                'broad': {},
+                'broad': {
+                    'You contract account available balance not enough': InsufficientFunds,
+                    'you contract account available balance not enough': InsufficientFunds,
+                },
             },
             'commonCurrencies': {
                 '$GM': 'GOLDMINER',
@@ -525,9 +528,10 @@ export default class bitmart extends Exchange {
                 'TRU': 'Truebit', // conflict with TrueFi
             },
             'options': {
-                'defaultNetwork': 'ERC20',
                 'defaultNetworks': {
-                    'USDT': 'ERC20',
+                    'USDT': 'TRC20',
+                    'BTC': 'BTC',
+                    'ETH': 'ERC20',
                 },
                 'timeDifference': 0,
                 'adjustForTimeDifference': false,
@@ -569,7 +573,7 @@ export default class bitmart extends Exchange {
                     'KSM': 'KSM',
                     'ZEC': 'ZEC',
                     'NAS': 'NAS',
-                    // 'POLYGON': [ 'MATIC', 'Polygon', 'POLYGON' ], // todo: after unification
+                    'POLYGON': 'MATIC',
                     'HRC20': 'HECO',
                     'XDC': 'XDC',
                     'ONE': 'ONE',
@@ -578,7 +582,7 @@ export default class bitmart extends Exchange {
                     'ICP': 'Computer',
                     'XTZ': 'XTZ',
                     'MINA': 'MINA',
-                    // 'BEP20': [ 'BEP20', 'BSC_BNB', 'bep20' ], // todo: after unification
+                    'BEP20': 'BSC_BNB',
                     'THETA': 'THETA',
                     'AKT': 'AKT',
                     'AR': 'AR',
@@ -682,6 +686,12 @@ export default class bitmart extends Exchange {
                     // undetermined chains:
                     // LEX (for LexThum), TAYCAN (for TRICE), SFL (probably TAYCAN), OMNIA (for APEX), NAC (for NAC), KAG (Kinesis), CEM (crypto emergency), XVM (for Venidium), NEVM (for NEVM), IGT20 (for IGNITE), FILM (FILMCredits), CC (CloudCoin), MERGE (MERGE), LTNM (Bitcoin latinum), PLUGCN ( PlugChain), DINGO (dingo), LED (LEDGIS), AVAT (AVAT), VSOL (Vsolidus), EPIC (EPIC cash), NFC (netflowcoin), mrx (Metrix Coin), Idena (idena network), PKT (PKT Cash), BondDex (BondDex), XBN (XBN), KALAM (Kalamint), REV (RChain), KRC20 (MyDeFiPet), ARC20 (Hurricane Token), GMD (Coop network), BERS (Berith), ZEBI (Zebi), BRC (Baer Chain), DAPS (DAPS Coin), APL (Gold Secured Currency), NDAU (NDAU), WICC (WICC), UPG (Unipay God), TSL (TreasureSL), MXW (Maxonrow), CLC (Cifculation), SMH (SMH Coin), XIN (CPCoin), RDD (ReddCoin), OK (Okcash), KAR (KAR), CCX (ConcealNetwork),
                 },
+                'networksById': {
+                    'ETH': 'ERC20',
+                    'Ethereum': 'ERC20',
+                    'USDT': 'OMNI',
+                    'Bitcoin': 'BTC',
+                },
                 'defaultType': 'spot',
                 'fetchBalance': {
                     'type': 'spot', // 'spot', 'swap', 'account'
@@ -960,6 +970,7 @@ export default class bitmart extends Exchange {
         const data = this.safeDict(response, 'data', {});
         const symbols = this.safeList(data, 'symbols', []);
         const result = [];
+        const fees = this.fees['trading'];
         for (let i = 0; i < symbols.length; i++) {
             const market = symbols[i];
             const id = this.safeString(market, 'symbol');
@@ -998,6 +1009,8 @@ export default class bitmart extends Exchange {
                 'expiryDatetime': undefined,
                 'strike': undefined,
                 'optionType': undefined,
+                'maker': fees['maker'],
+                'taker': fees['taker'],
                 'precision': {
                     'amount': baseMinSize,
                     'price': this.parseNumber(this.parsePrecision(this.safeString(market, 'price_max_precision'))),
@@ -1070,6 +1083,7 @@ export default class bitmart extends Exchange {
         const data = this.safeDict(response, 'data', {});
         const symbols = this.safeList(data, 'symbols', []);
         const result = [];
+        const fees = this.fees['trading'];
         for (let i = 0; i < symbols.length; i++) {
             const market = symbols[i];
             const id = this.safeString(market, 'symbol');
@@ -1112,6 +1126,8 @@ export default class bitmart extends Exchange {
                 'expiryDatetime': this.iso8601(expiry),
                 'strike': undefined,
                 'optionType': undefined,
+                'maker': fees['maker'],
+                'taker': fees['taker'],
                 'precision': {
                     'amount': this.safeNumber(market, 'vol_precision'),
                     'price': this.safeNumber(market, 'price_precision'),
@@ -1164,17 +1180,24 @@ export default class bitmart extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     async fetchCurrencies(params = {}) {
-        const response = await this.publicGetSpotV1Currencies(params);
+        const response = await this.publicGetAccountV1Currencies(params);
         //
         //     {
-        //         "message":"OK",
+        //         "message": "OK",
         //         "code":1000,
-        //         "trace":"8c768b3c-025f-413f-bec5-6d6411d46883",
-        //         "data":{
-        //             "currencies":[
-        //                 {"currency":"MATIC","name":"Matic Network","withdraw_enabled":true,"deposit_enabled":true},
-        //                 {"currency":"KTN","name":"Kasoutuuka News","withdraw_enabled":true,"deposit_enabled":false},
-        //                 {"currency":"BRT","name":"Berith","withdraw_enabled":true,"deposit_enabled":true},
+        //         "trace": "9eaec51cd80d46d48a1c6b447206c4d6.71.17392193317851454",
+        //         "data": {
+        //             "currencies": [
+        //                 {
+        //                     "currency": "BTC",
+        //                     "name": "Bitcoin",
+        //                     "contract_address": null,
+        //                     "network": "BTC",
+        //                     "withdraw_enabled": true,
+        //                     "deposit_enabled": true,
+        //                     "withdraw_minsize": "0.0003",
+        //                     "withdraw_minfee": "9.74"
+        //                 }
         //             ]
         //         }
         //     }
@@ -1184,30 +1207,99 @@ export default class bitmart extends Exchange {
         const result = {};
         for (let i = 0; i < currencies.length; i++) {
             const currency = currencies[i];
-            const id = this.safeString(currency, 'id');
-            const code = this.safeCurrencyCode(id);
-            const name = this.safeString(currency, 'name');
-            const withdrawEnabled = this.safeBool(currency, 'withdraw_enabled');
-            const depositEnabled = this.safeBool(currency, 'deposit_enabled');
-            const active = withdrawEnabled && depositEnabled;
-            result[code] = {
-                'id': id,
-                'code': code,
-                'name': name,
+            const fullId = this.safeString(currency, 'currency');
+            let currencyId = fullId;
+            let networkId = this.safeString(currency, 'network');
+            if (fullId.indexOf('NFT') < 0) {
+                const parts = fullId.split('-');
+                currencyId = this.safeString(parts, 0);
+                const second = this.safeString(parts, 1);
+                if (second !== undefined) {
+                    networkId = second.toUpperCase();
+                }
+            }
+            const currencyCode = this.safeCurrencyCode(currencyId);
+            let entry = this.safeDict(result, currencyCode);
+            if (entry === undefined) {
+                entry = {
+                    'info': currency,
+                    'id': currencyId,
+                    'code': currencyCode,
+                    'precision': undefined,
+                    'name': this.safeString(currency, 'name'),
+                    'deposit': undefined,
+                    'withdraw': undefined,
+                    'active': undefined,
+                    'networks': {},
+                };
+            }
+            const networkCode = this.networkIdToCode(networkId);
+            const withdraw = this.safeBool(currency, 'withdraw_enabled');
+            const deposit = this.safeBool(currency, 'deposit_enabled');
+            entry['networks'][networkCode] = {
                 'info': currency,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': undefined,
-                'precision': undefined,
+                'id': networkId,
+                'code': networkCode,
+                'withdraw': withdraw,
+                'deposit': deposit,
+                'active': withdraw && deposit,
+                'fee': this.safeNumber(currency, 'withdraw_minfee'),
                 'limits': {
-                    'amount': { 'min': undefined, 'max': undefined },
-                    'withdraw': { 'min': undefined, 'max': undefined },
+                    'withdraw': {
+                        'min': this.safeNumber(currency, 'withdraw_minsize'),
+                        'max': undefined,
+                    },
+                    'deposit': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
                 },
             };
+            result[currencyCode] = entry;
+        }
+        const keys = Object.keys(result);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const currency = result[key];
+            result[key] = this.safeCurrencyStructure(currency);
         }
         return result;
     }
+    getCurrencyIdFromCodeAndNetwork(currencyCode, networkCode) {
+        if (networkCode === undefined) {
+            networkCode = this.defaultNetworkCode(currencyCode); // use default network code if not provided
+        }
+        const currency = this.currency(currencyCode);
+        let id = currency['id'];
+        let idFromNetwork = undefined;
+        const networks = this.safeDict(currency, 'networks', {});
+        let networkInfo = {};
+        if (networkCode === undefined) {
+            // network code is not provided and there is no default network code
+            let network = this.safeDict(networks, currencyCode); // trying to find network that has the same code as currency
+            if (network === undefined) {
+                // use the first network in the networks list if there is no network code with the same code as currency
+                const keys = Object.keys(networks);
+                const length = keys.length;
+                if (length > 0) {
+                    network = this.safeValue(networks, keys[0]);
+                }
+            }
+            networkInfo = this.safeDict(network, 'info', {});
+            idFromNetwork = this.safeString(networkInfo, 'currency'); // use currency name from network
+        }
+        else {
+            const providedOrDefaultNetwork = this.safeDict(networks, networkCode);
+            if (providedOrDefaultNetwork !== undefined) {
+                networkInfo = this.safeDict(providedOrDefaultNetwork, 'info', {});
+                idFromNetwork = this.safeString(networkInfo, 'currency'); // use currency name from network
+            }
+            else {
+                id += '-' + this.networkCodeToId(networkCode, currencyCode); // use concatenated currency id and network code if network is not found
+            }
+        }
+        return (idFromNetwork !== undefined) ? idFromNetwork : id;
+    }
     /**
      * @method
      * @name bitmart#fetchTransactionFee
@@ -1215,13 +1307,16 @@ export default class bitmart extends Exchange {
      * @description please use fetchDepositWithdrawFee instead
      * @param {string} code unified currency code
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.network] the network code of the currency
      * @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
      */
     async fetchTransactionFee(code, params = {}) {
         await this.loadMarkets();
         const currency = this.currency(code);
+        let network = undefined;
+        [network, params] = this.handleNetworkCodeAndParams(params);
         const request = {
-            'currency': currency['id'],
+            'currency': this.getCurrencyIdFromCodeAndNetwork(currency['code'], network),
         };
         const response = await this.privateGetAccountV1WithdrawCharge(this.extend(request, params));
         //
@@ -1274,13 +1369,15 @@ export default class bitmart extends Exchange {
      * @description fetch the fee for deposits and withdrawals
      * @param {string} code unified currency code
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.network] the network code of the currency
      * @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
      */
     async fetchDepositWithdrawFee(code, params = {}) {
         await this.loadMarkets();
-        const currency = this.currency(code);
+        let network = undefined;
+        [network, params] = this.handleNetworkCodeAndParams(params);
         const request = {
-            'currency': currency['id'],
+            'currency': this.getCurrencyIdFromCodeAndNetwork(code, network),
         };
         const response = await this.privateGetAccountV1WithdrawCharge(this.extend(request, params));
         //
@@ -3607,28 +3704,11 @@ export default class bitmart extends Exchange {
     async fetchDepositAddress(code, params = {}) {
         await this.loadMarkets();
         const currency = this.currency(code);
-        const currencyId = currency['id'];
+        let network = undefined;
+        [network, params] = this.handleNetworkCodeAndParams(params);
         const request = {
-            'currency': currencyId,
+            'currency': this.getCurrencyIdFromCodeAndNetwork(code, network),
         };
-        if (code === 'USDT') {
-            const defaultNetworks = this.safeValue(this.options, 'defaultNetworks');
-            const defaultNetwork = this.safeStringUpper(defaultNetworks, code);
-            const networks = this.safeDict(this.options, 'networks', {});
-            let networkInner = this.safeStringUpper(params, 'network', defaultNetwork); // this line allows the user to specify either ERC20 or ETH
-            networkInner = this.safeString(networks, networkInner, networkInner); // handle ERC20>ETH alias
-            if (networkInner !== undefined) {
-                request['currency'] = currencyId + '-' + networkInner; // when network the currency need to be changed to currency + '-' + network https://developer-pro.bitmart.com/en/account/withdraw_apply.html on the end of page
-                params = this.omit(params, 'network');
-            }
-        }
-        else {
-            let networkCode = undefined;
-            [networkCode, params] = this.handleNetworkCodeAndParams(params);
-            if (networkCode !== undefined) {
-                request['currency'] = currencyId + '-' + this.networkCodeToId(networkCode);
-            }
-        }
         const response = await this.privateGetAccountV1DepositAddress(this.extend(request, params));
         //
         //    {
@@ -3655,27 +3735,23 @@ export default class bitmart extends Exchange {
         //        address_memo: ''
         //    }
         //
-        const currencyId = this.safeString(depositAddress, 'currency');
-        const address = this.safeString(depositAddress, 'address');
-        const chain = this.safeString(depositAddress, 'chain');
-        let network = undefined;
-        currency = this.safeCurrency(currencyId, currency);
-        if (chain !== undefined) {
-            const parts = chain.split('-');
-            const partsLength = parts.length;
-            const networkId = this.safeString(parts, partsLength - 1);
-            if (networkId === this.safeString(currency, 'name')) {
-                network = this.safeString(currency, 'code');
-            }
-            else {
-                network = this.networkIdToCode(networkId);
+        let currencyId = this.safeString(depositAddress, 'currency');
+        let network = this.safeString(depositAddress, 'chain');
+        if (currencyId.indexOf('NFT') < 0) {
+            const parts = currencyId.split('-');
+            currencyId = this.safeString(parts, 0);
+            const secondPart = this.safeString(parts, 1);
+            if (secondPart !== undefined) {
+                network = secondPart;
             }
         }
+        const address = this.safeString(depositAddress, 'address');
+        currency = this.safeCurrency(currencyId, currency);
         this.checkAddress(address);
         return {
             'info': depositAddress,
             'currency': this.safeString(currency, 'code'),
-            'network': network,
+            'network': this.networkIdToCode(network),
             'address': address,
             'tag': this.safeString(depositAddress, 'address_memo'),
         };
@@ -3689,6 +3765,7 @@ export default class bitmart extends Exchange {
      * @param {string} address the address to withdraw to
      * @param {string} tag
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.network] the network name for this withdrawal
      * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
      */
     async withdraw(code, amount, address, tag = undefined, params = {}) {
@@ -3696,8 +3773,10 @@ export default class bitmart extends Exchange {
         this.checkAddress(address);
         await this.loadMarkets();
         const currency = this.currency(code);
+        let network = undefined;
+        [network, params] = this.handleNetworkCodeAndParams(params);
         const request = {
-            'currency': currency['id'],
+            'currency': this.getCurrencyIdFromCodeAndNetwork(code, network),
             'amount': amount,
             'destination': 'To Digital Address',
             'address': address,
@@ -3705,17 +3784,6 @@ export default class bitmart extends Exchange {
         if (tag !== undefined) {
             request['address_memo'] = tag;
         }
-        if (code === 'USDT') {
-            const defaultNetworks = this.safeValue(this.options, 'defaultNetworks');
-            const defaultNetwork = this.safeStringUpper(defaultNetworks, code);
-            const networks = this.safeDict(this.options, 'networks', {});
-            let network = this.safeStringUpper(params, 'network', defaultNetwork); // this line allows the user to specify either ERC20 or ETH
-            network = this.safeString(networks, network, network); // handle ERC20>ETH alias
-            if (network !== undefined) {
-                request['currency'] = request['currency'] + '-' + network; // when network the currency need to be changed to currency + '-' + network https://developer-pro.bitmart.com/en/account/withdraw_apply.html on the end of page
-                params = this.omit(params, 'network');
-            }
-        }
         const response = await this.privatePostAccountV1WithdrawApply(this.extend(request, params));
         //
         //     {
@@ -3750,18 +3818,6 @@ export default class bitmart extends Exchange {
             currency = this.currency(code);
             request['currency'] = currency['id'];
         }
-        if (code === 'USDT') {
-            const defaultNetworks = this.safeValue(this.options, 'defaultNetworks');
-            const defaultNetwork = this.safeStringUpper(defaultNetworks, code);
-            const networks = this.safeDict(this.options, 'networks', {});
-            let network = this.safeStringUpper(params, 'network', defaultNetwork); // this line allows the user to specify either ERC20 or ETH
-            network = this.safeString(networks, network, network); // handle ERC20>ETH alias
-            if (network !== undefined) {
-                request['currency'] = request['currency'] + '-' + network; // when network the currency need to be changed to currency + '-' + network https://developer-pro.bitmart.com/en/account/withdraw_apply.html on the end of page
-                currency['code'] = request['currency']; // update currency code to filter
-                params = this.omit(params, 'network');
-            }
-        }
         const response = await this.privateGetAccountV2DepositWithdrawHistory(this.extend(request, params));
         //
         //     {
@@ -3948,7 +4004,13 @@ export default class bitmart extends Exchange {
         }
         const amount = this.safeNumber(transaction, 'arrival_amount');
         const timestamp = this.safeInteger(transaction, 'apply_time');
-        const currencyId = this.safeString(transaction, 'currency');
+        let currencyId = this.safeString(transaction, 'currency');
+        let networkId = undefined;
+        if (currencyId.indexOf('NFT') < 0) {
+            const parts = currencyId.split('-');
+            currencyId = this.safeString(parts, 0);
+            networkId = this.safeString(parts, 1);
+        }
         const code = this.safeCurrencyCode(currencyId, currency);
         const status = this.parseTransactionStatus(this.safeString(transaction, 'status'));
         const feeCost = this.safeNumber(transaction, 'fee');
@@ -3967,7 +4029,7 @@ export default class bitmart extends Exchange {
             'id': id,
             'currency': code,
             'amount': amount,
-            'network': undefined,
+            'network': this.networkIdToCode(networkId),
             'address': address,
             'addressFrom': undefined,
             'addressTo': undefined,
@@ -5193,6 +5255,7 @@ export default class bitmart extends Exchange {
             direction = 'in';
         }
         const currencyId = this.safeString(item, 'asset');
+        currency = this.safeCurrency(currencyId, currency);
         const timestamp = this.safeInteger(item, 'time');
         const type = this.safeString(item, 'type');
         return this.safeLedgerEntry({
@@ -5203,7 +5266,7 @@ export default class bitmart extends Exchange {
             'referenceAccount': undefined,
             'referenceId': this.safeString(item, 'tradeId'),
             'type': this.parseLedgerEntryType(type),
-            'currency': this.safeCurrencyCode(currencyId, currency),
+            'currency': currency['code'],
             'amount': this.parseNumber(amount),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
@@ -5369,6 +5432,7 @@ export default class bitmart extends Exchange {
         //     {"message":"Bad Request [from is empty]","code":50000,"trace":"579986f7-c93a-4559-926b-06ba9fa79d76","data":{}}
         //     {"message":"Kline size over 500","code":50004,"trace":"d625caa8-e8ca-4bd2-b77c-958776965819","data":{}}
         //     {"message":"Balance not enough","code":50020,"trace":"7c709d6a-3292-462c-98c5-32362540aeef","data":{}}
+        //     {"code":40012,"message":"You contract account available balance not enough.","trace":"..."}
         //
         // contract
         //
@@ -5380,10 +5444,10 @@ export default class bitmart extends Exchange {
         const isErrorCode = (errorCode !== undefined) && (errorCode !== '1000');
         if (isErrorCode || isErrorMessage) {
             const feedback = this.id + ' ' + body;
-            this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
-            this.throwBroadlyMatchedException(this.exceptions['broad'], errorCode, feedback);
             this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
             this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
+            this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], errorCode, feedback);
             throw new ExchangeError(feedback); // unknown message
         }
         return undefined;

package/js/src/bitrue.d.ts

@@ -30,7 +30,7 @@ export default class bitrue extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name bitrue#fetchCurrencies

package/js/src/bitvavo.d.ts

@@ -15,7 +15,7 @@ export default class bitvavo extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name bitvavo#fetchMarkets

package/js/src/blofin.js

@@ -322,8 +322,7 @@ export default class blofin extends Exchange {
                         'takeProfitPrice': true,
                         'attachedStopLossTakeProfit': {
                             'triggerPriceType': undefined,
-                            'limit': true,
-                            'price': undefined,
+                            'price': true,
                         },
                         'hedged': true,
                     },

package/js/src/btcmarkets.d.ts

@@ -64,7 +64,7 @@ export default class btcmarkets extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     parseBalance(response: any): Balances;
     /**
      * @method

package/js/src/bybit.d.ts

@@ -42,7 +42,7 @@ export default class bybit extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name bybit#fetchCurrencies

package/js/src/bybit.js

@@ -1414,8 +1414,8 @@ export default class bybit extends Exchange {
     }
     createExpiredOptionMarket(symbol) {
         // support expired option contracts
-        const quote = 'USD';
-        const settle = 'USDC';
+        let quote = undefined;
+        let settle = undefined;
         const optionParts = symbol.split('-');
         const symbolBase = symbol.split('/');
         let base = undefined;
@@ -1423,10 +1423,23 @@ export default class bybit extends Exchange {
         if (symbol.indexOf('/') > -1) {
             base = this.safeString(symbolBase, 0);
             expiry = this.safeString(optionParts, 1);
+            const symbolQuoteAndSettle = this.safeString(symbolBase, 1);
+            const splitQuote = symbolQuoteAndSettle.split(':');
+            const quoteAndSettle = this.safeString(splitQuote, 0);
+            quote = quoteAndSettle;
+            settle = quoteAndSettle;
         }
         else {
             base = this.safeString(optionParts, 0);
             expiry = this.convertMarketIdExpireDate(this.safeString(optionParts, 1));
+            if (symbol.endsWith('-USDT')) {
+                quote = 'USDT';
+                settle = 'USDT';
+            }
+            else {
+                quote = 'USDC';
+                settle = 'USDC';
+            }
         }
         const strike = this.safeString(optionParts, 2);
         const optionType = this.safeString(optionParts, 3);
@@ -4097,7 +4110,7 @@ export default class bybit extends Exchange {
                     request['qty'] = this.getCost(symbol, Precise.stringMul(amountString, priceString));
                 }
                 else {
-                    request['qty'] = this.getCost(symbol, this.numberToString(amount));
+                    request['qty'] = amountString;
                 }
             }
         }

package/js/src/cex.d.ts

@@ -33,7 +33,7 @@ export default class cex extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name cex#fetchTicker

package/js/src/coinbase.d.ts

@@ -15,7 +15,7 @@ export default class coinbase extends Exchange {
      * @param {string} [params.method] 'v2PublicGetTime' or 'v3PublicGetBrokerageTime' default is 'v2PublicGetTime'
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name coinbase#fetchAccounts

package/js/src/coinbase.js

@@ -23,7 +23,7 @@ export default class coinbase extends Exchange {
             'name': 'Coinbase Advanced',
             'countries': ['US'],
             'pro': true,
-            'certified': true,
+            'certified': false,
             // rate-limits:
             // ADVANCED API: https://docs.cloud.coinbase.com/advanced-trade/docs/rest-api-rate-limits
             // - max 30 req/second for private data, 10 req/s for public data
@@ -5017,10 +5017,17 @@ export default class coinbase extends Exchange {
         //        }
         //      ]
         //    }
+        // or
+        //   {
+        //       "error": "UNKNOWN_FAILURE_REASON",
+        //       "message": "",
+        //       "error_details": "",
+        //       "preview_failure_reason": "PREVIEW_STOP_PRICE_BELOW_LAST_TRADE_PRICE"
+        //   }
         //
         let errorCode = this.safeString(response, 'error');
         if (errorCode !== undefined) {
-            const errorMessage = this.safeString(response, 'error_description');
+            const errorMessage = this.safeString2(response, 'error_description', 'preview_failure_reason');
             this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
             this.throwBroadlyMatchedException(this.exceptions['broad'], errorMessage, feedback);
             throw new ExchangeError(feedback);

package/js/src/coinbaseexchange.d.ts

@@ -140,7 +140,7 @@ export default class coinbaseexchange extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     parseOrderStatus(status: Str): string;
     parseOrder(order: Dict, market?: Market): Order;
     /**
@@ -311,7 +311,7 @@ export default class coinbaseexchange extends Exchange {
      * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
      */
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    parseTransactionStatus(transaction: any): "ok" | "canceled" | "pending" | "failed";
+    parseTransactionStatus(transaction: any): "canceled" | "pending" | "ok" | "failed";
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     /**
      * @method

package/js/src/coinbaseinternational.js

@@ -21,7 +21,7 @@ export default class coinbaseinternational extends Exchange {
             'id': 'coinbaseinternational',
             'name': 'Coinbase International',
             'countries': ['US'],
-            'certified': true,
+            'certified': false,
             'pro': true,
             'rateLimit': 100,
             'version': 'v1',

package/js/src/coincatch.d.ts

@@ -15,7 +15,7 @@ export default class coincatch extends Exchange {
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {int} the current integer timestamp in milliseconds from the exchange server
      */
-    fetchTime(params?: {}): Promise<number>;
+    fetchTime(params?: {}): Promise<Int>;
     /**
      * @method
      * @name coincatch#fetchCurrencies