ccxt 4.4.82 → 4.4.85

package/js/src/blofin.js

@@ -51,6 +51,7 @@ export default class blofin extends Exchange {
                 'createStopMarketOrder': false,
                 'createStopOrder': false,
                 'createTakeProfitOrder': true,
+                'createTriggerOrder': true,
                 'editOrder': false,
                 'fetchAccounts': false,
                 'fetchBalance': true,
@@ -104,6 +105,7 @@ export default class blofin extends Exchange {
                 'fetchOrders': false,
                 'fetchOrderTrades': true,
                 'fetchPosition': true,
+                'fetchPositionMode': true,
                 'fetchPositions': true,
                 'fetchPositionsForSymbol': false,
                 'fetchPositionsRisk': false,
@@ -131,8 +133,8 @@ export default class blofin extends Exchange {
                 'repayCrossMargin': false,
                 'setLeverage': true,
                 'setMargin': false,
-                'setMarginMode': false,
-                'setPositionMode': false,
+                'setMarginMode': true,
+                'setPositionMode': true,
                 'signIn': false,
                 'transfer': true,
                 'withdraw': false,
@@ -195,10 +197,14 @@ export default class blofin extends Exchange {
                         'account/positions': 1,
                         'account/leverage-info': 1,
                         'account/margin-mode': 1,
+                        'account/position-mode': 1,
                         'account/batch-leverage-info': 1,
                         'trade/orders-tpsl-pending': 1,
+                        'trade/orders-algo-pending': 1,
                         'trade/orders-history': 1,
                         'trade/orders-tpsl-history': 1,
+                        'trade/orders-algo-history': 1,
+                        'trade/order/price-range': 1,
                         'user/query-apikey': 1,
                         'affiliate/basic': 1,
                         'copytrading/instruments': 1,
@@ -215,8 +221,12 @@ export default class blofin extends Exchange {
                         'copytrading/trade/pending-tpsl-by-order': 1,
                     },
                     'post': {
+                        'account/set-margin-mode': 1,
+                        'account/set-position-mode': 1,
                         'trade/order': 1,
+                        'trade/order-algo': 1,
                         'trade/cancel-order': 1,
+                        'trade/cancel-algo': 1,
                         'account/set-leverage': 1,
                         'trade/batch-orders': 1,
                         'trade/order-tpsl': 1,
@@ -1151,7 +1161,12 @@ export default class blofin extends Exchange {
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams('createOrder', params, 'cross');
         request['marginMode'] = marginMode;
+        const triggerPrice = this.safeString(params, 'triggerPrice');
         const timeInForce = this.safeString(params, 'timeInForce', 'GTC');
+        const isHedged = this.safeBool(params, 'hedged', false);
+        if (isHedged) {
+            request['positionSide'] = (side === 'buy') ? 'long' : 'short';
+        }
         const isMarketOrder = type === 'market';
         params = this.omit(params, ['timeInForce']);
         const ioc = (timeInForce === 'IOC') || (type === 'ioc');
@@ -1160,7 +1175,8 @@ export default class blofin extends Exchange {
             request['orderType'] = 'market';
         }
         else {
-            request['price'] = this.priceToPrecision(symbol, price);
+            const key = (triggerPrice !== undefined) ? 'orderPrice' : 'price';
+            request[key] = this.priceToPrecision(symbol, price);
         }
         let postOnly = false;
         [postOnly, params] = this.handlePostOnly(isMarketOrder, type === 'post_only', params);
@@ -1169,7 +1185,7 @@ export default class blofin extends Exchange {
         }
         const stopLoss = this.safeDict(params, 'stopLoss');
         const takeProfit = this.safeDict(params, 'takeProfit');
-        params = this.omit(params, ['stopLoss', 'takeProfit']);
+        params = this.omit(params, ['stopLoss', 'takeProfit', 'hedged']);
         const isStopLoss = stopLoss !== undefined;
         const isTakeProfit = takeProfit !== undefined;
         if (isStopLoss || isTakeProfit) {
@@ -1186,6 +1202,13 @@ export default class blofin extends Exchange {
                 request['tpOrderPrice'] = this.priceToPrecision(symbol, tpPrice);
             }
         }
+        else if (triggerPrice !== undefined) {
+            request['orderType'] = 'trigger';
+            request['triggerPrice'] = this.priceToPrecision(symbol, triggerPrice);
+            if (isMarketOrder) {
+                request['orderPrice'] = '-1';
+            }
+        }
         return this.extend(request, params);
     }
     parseOrderStatus(status) {
@@ -1235,7 +1258,7 @@ export default class blofin extends Exchange {
         //     "instType": "SWAP", // only in WS
         // }
         //
-        const id = this.safeString2(order, 'tpslId', 'orderId');
+        const id = this.safeStringN(order, ['tpslId', 'orderId', 'algoId']);
         const timestamp = this.safeInteger(order, 'createTime');
         const lastUpdateTimestamp = this.safeInteger(order, 'updateTime');
         const lastTradeTimestamp = this.safeInteger(order, 'fillTime');
@@ -1334,12 +1357,14 @@ export default class blofin extends Exchange {
      * @param {float} amount how much of currency you want to trade in units of 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 {string} [params.triggerPrice] the trigger price for a trigger order
      * @param {bool} [params.reduceOnly] a mark to reduce the position size for margin, swap and future orders
      * @param {bool} [params.postOnly] true to place a post only order
      * @param {string} [params.marginMode] 'cross' or 'isolated', default is 'cross'
      * @param {float} [params.stopLossPrice] stop loss trigger price (will use privatePostTradeOrderTpsl)
      * @param {float} [params.takeProfitPrice] take profit trigger price (will use privatePostTradeOrderTpsl)
      * @param {string} [params.positionSide] *stopLossPrice/takeProfitPrice orders only* 'long' or 'short' or 'net' default is 'net'
+     * @param {boolean} [params.hedged] if true, the positionSide will be set to long/short instead of net, default is false
      * @param {string} [params.clientOrderId] a unique id for the order
      * @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered
      * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
@@ -1358,16 +1383,30 @@ export default class blofin extends Exchange {
         [method, params] = this.handleOptionAndParams(params, 'createOrder', 'method', 'privatePostTradeOrder');
         const isStopLossPriceDefined = this.safeString(params, 'stopLossPrice') !== undefined;
         const isTakeProfitPriceDefined = this.safeString(params, 'takeProfitPrice') !== undefined;
+        const isTriggerOrder = this.safeString(params, 'triggerPrice') !== undefined;
         const isType2Order = (isStopLossPriceDefined || isTakeProfitPriceDefined);
         let response = undefined;
+        const reduceOnly = this.safeBool(params, 'reduceOnly');
+        if (reduceOnly !== undefined) {
+            params['reduceOnly'] = reduceOnly ? 'true' : 'false';
+        }
         if (tpsl || (method === 'privatePostTradeOrderTpsl') || isType2Order) {
             const tpslRequest = this.createTpslOrderRequest(symbol, type, side, amount, price, params);
             response = await this.privatePostTradeOrderTpsl(tpslRequest);
         }
+        else if (isTriggerOrder || (method === 'privatePostTradeOrderAlgo')) {
+            const triggerRequest = this.createOrderRequest(symbol, type, side, amount, price, params);
+            response = await this.privatePostTradeOrderAlgo(triggerRequest);
+        }
         else {
             const request = this.createOrderRequest(symbol, type, side, amount, price, params);
             response = await this.privatePostTradeOrder(request);
         }
+        if (isTriggerOrder || (method === 'privatePostTradeOrderAlgo')) {
+            const dataDict = this.safeDict(response, 'data', {});
+            const triggerOrder = this.parseOrder(dataDict, market);
+            return triggerOrder;
+        }
         const data = this.safeList(response, 'data', []);
         const first = this.safeDict(data, 0);
         const order = this.parseOrder(first, market);
@@ -1424,7 +1463,8 @@ export default class blofin extends Exchange {
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market the order was made in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {boolean} [params.trigger] True if cancelling a trigger/conditional order/tp sl orders
+     * @param {boolean} [params.trigger] True if cancelling a trigger/conditional
+     * @param {boolean} [params.tpsl] True if cancelling a tpsl order
      * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
      */
     async cancelOrder(id, symbol = undefined, params = {}) {
@@ -1436,25 +1476,34 @@ export default class blofin extends Exchange {
         const request = {
             'instId': market['id'],
         };
-        const isTrigger = this.safeBoolN(params, ['stop', 'trigger', 'tpsl'], false);
+        const isTrigger = this.safeBoolN(params, ['trigger'], false);
+        const isTpsl = this.safeBool2(params, 'tpsl', 'TPSL', false);
         const clientOrderId = this.safeString(params, 'clientOrderId');
         if (clientOrderId !== undefined) {
             request['clientOrderId'] = clientOrderId;
         }
         else {
-            if (!isTrigger) {
+            if (!isTrigger && !isTpsl) {
                 request['orderId'] = id.toString();
             }
-            else {
+            else if (isTpsl) {
                 request['tpslId'] = id.toString();
             }
+            else if (isTrigger) {
+                request['algoId'] = id.toString();
+            }
         }
         const query = this.omit(params, ['orderId', 'clientOrderId', 'stop', 'trigger', 'tpsl']);
-        if (isTrigger) {
+        if (isTpsl) {
             const tpslResponse = await this.cancelOrders([id], symbol, params);
             const first = this.safeDict(tpslResponse, 0);
             return first;
         }
+        else if (isTrigger) {
+            const triggerResponse = await this.privatePostTradeCancelAlgo(this.extend(request, query));
+            const triggerData = this.safeDict(triggerResponse, 'data');
+            return this.parseOrder(triggerData, market);
+        }
         const response = await this.privatePostTradeCancelOrder(this.extend(request, query));
         const data = this.safeList(response, 'data', []);
         const order = this.safeDict(data, 0);
@@ -1494,6 +1543,7 @@ export default class blofin extends Exchange {
      * @description Fetch orders that are still open
      * @see https://blofin.com/docs#get-active-orders
      * @see https://blofin.com/docs#get-active-tpsl-orders
+     * @see https://docs.blofin.com/index.html#get-active-algo-orders
      * @param {string} symbol unified market symbol
      * @param {int} [since] the earliest time in ms to fetch open orders for
      * @param {int} [limit] the maximum number of  open orders structures to retrieve
@@ -1518,14 +1568,19 @@ export default class blofin extends Exchange {
         if (limit !== undefined) {
             request['limit'] = limit; // default 100, max 100
         }
-        const isTrigger = this.safeBoolN(params, ['stop', 'trigger', 'tpsl', 'TPSL'], false);
+        const isTrigger = this.safeBoolN(params, ['stop', 'trigger'], false);
+        const isTpSl = this.safeBool2(params, 'tpsl', 'TPSL', false);
         let method = undefined;
         [method, params] = this.handleOptionAndParams(params, 'fetchOpenOrders', 'method', 'privateGetTradeOrdersPending');
         const query = this.omit(params, ['method', 'stop', 'trigger', 'tpsl', 'TPSL']);
         let response = undefined;
-        if (isTrigger || (method === 'privateGetTradeOrdersTpslPending')) {
+        if (isTpSl || (method === 'privateGetTradeOrdersTpslPending')) {
             response = await this.privateGetTradeOrdersTpslPending(this.extend(request, query));
         }
+        else if (isTrigger || (method === 'privateGetTradeOrdersAlgoPending')) {
+            request['orderType'] = 'trigger';
+            response = await this.privateGetTradeOrdersAlgoPending(this.extend(request, query));
+        }
         else {
             response = await this.privateGetTradeOrdersPending(this.extend(request, query));
         }
@@ -2213,6 +2268,7 @@ export default class blofin extends Exchange {
      * @param {string} symbol unified market symbol
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.marginMode] 'cross' or 'isolated'
+     * @param {string} [params.positionSide] 'long' or 'short' - required for hedged mode in isolated margin
      * @returns {object} response from the exchange
      */
     async setLeverage(leverage, symbol = undefined, params = {}) {
@@ -2347,10 +2403,95 @@ export default class blofin extends Exchange {
     parseMarginMode(marginMode, market = undefined) {
         return {
             'info': marginMode,
-            'symbol': market['symbol'],
+            'symbol': this.safeString(market, 'symbol'),
             'marginMode': this.safeString(marginMode, 'marginMode'),
         };
     }
+    /**
+     * @method
+     * @name blofin#setMarginMode
+     * @description set margin mode to 'cross' or 'isolated'
+     * @see https://docs.blofin.com/index.html#set-margin-mode
+     * @param {string} marginMode 'cross' or 'isolated'
+     * @param {string} [symbol] unified market symbol (not used in blofin setMarginMode)
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} response from the exchange
+     */
+    async setMarginMode(marginMode, symbol = undefined, params = {}) {
+        this.checkRequiredArgument('setMarginMode', marginMode, 'marginMode', ['cross', 'isolated']);
+        await this.loadMarkets();
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+        }
+        const request = {
+            'marginMode': marginMode,
+        };
+        const response = await this.privatePostAccountSetMarginMode(this.extend(request, params));
+        //
+        //     {
+        //         "code": "0",
+        //         "msg": "success",
+        //         "data": {
+        //             "marginMode": "isolated"
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseMarginMode(data, market);
+    }
+    /**
+     * @method
+     * @name blofin#fetchPositionMode
+     * @description fetchs the position mode, hedged or one way
+     * @see https://docs.blofin.com/index.html#get-position-mode
+     * @param {string} [symbol] unified symbol of the market to fetch the position mode for (not used in blofin fetchPositionMode)
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} an object detailing whether the market is in hedged or one-way mode
+     */
+    async fetchPositionMode(symbol = undefined, params = {}) {
+        const response = await this.privateGetAccountPositionMode(params);
+        const data = this.safeDict(response, 'data', {});
+        const positionMode = this.safeString(data, 'positionMode');
+        //
+        //     {
+        //         "code": "0",
+        //         "msg": "success",
+        //         "data": {
+        //             "positionMode": "long_short_mode"
+        //         }
+        //     }
+        //
+        return {
+            'info': data,
+            'hedged': positionMode === 'long_short_mode',
+        };
+    }
+    /**
+     * @method
+     * @name blofin#setPositionMode
+     * @description set hedged to true or false for a market
+     * @see https://docs.blofin.com/index.html#set-position-mode
+     * @param {bool} hedged set to true to use hedged mode, false for one-way mode
+     * @param {string} [symbol] not used by blofin setPositionMode ()
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} response from the exchange
+     */
+    async setPositionMode(hedged, symbol = undefined, params = {}) {
+        const request = {
+            'positionMode': hedged ? 'long_short_mode' : 'net_mode',
+        };
+        //
+        //     {
+        //         "code": "0",
+        //         "msg": "success",
+        //         "data": {
+        //             "positionMode": "net_mode"
+        //         }
+        //     }
+        //
+        return await this.privatePostAccountSetPositionMode(this.extend(request, params));
+    }
     handleErrors(httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {
         if (response === undefined) {
             return undefined; // fallback to default error handler

package/js/src/btcbox.js

@@ -109,6 +109,18 @@ export default class btcbox extends Exchange {
                         'wallet',
                     ],
                 },
+                'webApi': {
+                    'get': [
+                        'ajax/coin/coinInfo',
+                    ],
+                },
+            },
+            'options': {
+                'fetchMarkets': {
+                    'webApiEnable': true,
+                    'webApiRetries': 3,
+                },
+                'amountPrecision': '0.0001', // exchange has only few pairs and all of them
             },
             'features': {
                 'spot': {
@@ -194,9 +206,12 @@ export default class btcbox extends Exchange {
      * @returns {object[]} an array of objects representing market data
      */
     async fetchMarkets(params = {}) {
-        const response = await this.publicGetTickers();
+        const promise1 = this.publicGetTickers();
+        const promise2 = this.fetchWebEndpoint('fetchMarkets', 'webApiGetAjaxCoinCoinInfo', true);
+        const [response1, response2] = await Promise.all([promise1, promise2]);
         //
-        const marketIds = Object.keys(response);
+        const result2Data = this.safeDict(response2, 'data', {});
+        const marketIds = Object.keys(response1);
         const markets = [];
         for (let i = 0; i < marketIds.length; i++) {
             const marketId = marketIds[i];
@@ -205,9 +220,11 @@ export default class btcbox extends Exchange {
             const quote = this.safeString(symbolParts, 1);
             const quoteId = quote.toLowerCase();
             const id = baseCurr.toLowerCase();
-            const res = response[marketId];
+            const res = response1[marketId];
             const symbol = baseCurr + '/' + quote;
             const fee = (id === 'BTC') ? this.parseNumber('0.0005') : this.parseNumber('0.0010');
+            const details = this.safeDict(result2Data, id, {});
+            const tradeDetails = this.safeDict(details, 'trade', {});
             markets.push(this.safeMarketStructure({
                 'id': id,
                 'uppercaseId': undefined,
@@ -253,10 +270,10 @@ export default class btcbox extends Exchange {
                     },
                 },
                 'precision': {
-                    'price': undefined,
+                    'price': this.parseNumber(this.parsePrecision(this.safeString(tradeDetails, 'pricedecimal'))),
                     'amount': undefined,
                 },
-                'active': undefined,
+                'active': this.safeString(tradeDetails, 'enable') === '1',
                 'created': undefined,
                 'info': res,
             }));
@@ -730,6 +747,9 @@ export default class btcbox extends Exchange {
                 url += '?' + this.urlencode(params);
             }
         }
+        else if (api === 'webApi') {
+            url = this.urls['www'] + '/' + path;
+        }
         else {
             this.checkRequiredCredentials();
             const nonce = this.nonce().toString();

package/js/src/bybit.js

@@ -1643,82 +1643,58 @@ export default class bybit extends Exchange {
             const name = this.safeString(currency, 'name');
             const chains = this.safeList(currency, 'chains', []);
             const networks = {};
-            let minPrecision = undefined;
-            let minWithdrawFeeString = undefined;
-            let minWithdrawString = undefined;
-            let minDepositString = undefined;
-            let deposit = false;
-            let withdraw = false;
             for (let j = 0; j < chains.length; j++) {
                 const chain = chains[j];
                 const networkId = this.safeString(chain, 'chain');
                 const networkCode = this.networkIdToCode(networkId);
-                const precision = this.parseNumber(this.parsePrecision(this.safeString(chain, 'minAccuracy')));
-                minPrecision = (minPrecision === undefined) ? precision : Math.min(minPrecision, precision);
-                const depositAllowed = this.safeInteger(chain, 'chainDeposit') === 1;
-                deposit = (depositAllowed) ? depositAllowed : deposit;
-                const withdrawAllowed = this.safeInteger(chain, 'chainWithdraw') === 1;
-                withdraw = (withdrawAllowed) ? withdrawAllowed : withdraw;
-                const withdrawFeeString = this.safeString(chain, 'withdrawFee');
-                if (withdrawFeeString !== undefined) {
-                    minWithdrawFeeString = (minWithdrawFeeString === undefined) ? withdrawFeeString : Precise.stringMin(withdrawFeeString, minWithdrawFeeString);
-                }
-                const minNetworkWithdrawString = this.safeString(chain, 'withdrawMin');
-                if (minNetworkWithdrawString !== undefined) {
-                    minWithdrawString = (minWithdrawString === undefined) ? minNetworkWithdrawString : Precise.stringMin(minNetworkWithdrawString, minWithdrawString);
-                }
-                const minNetworkDepositString = this.safeString(chain, 'depositMin');
-                if (minNetworkDepositString !== undefined) {
-                    minDepositString = (minDepositString === undefined) ? minNetworkDepositString : Precise.stringMin(minNetworkDepositString, minDepositString);
-                }
                 networks[networkCode] = {
                     'info': chain,
                     'id': networkId,
                     'network': networkCode,
-                    'active': depositAllowed && withdrawAllowed,
-                    'deposit': depositAllowed,
-                    'withdraw': withdrawAllowed,
-                    'fee': this.parseNumber(withdrawFeeString),
-                    'precision': precision,
+                    'active': undefined,
+                    'deposit': this.safeInteger(chain, 'chainDeposit') === 1,
+                    'withdraw': this.safeInteger(chain, 'chainWithdraw') === 1,
+                    'fee': this.safeNumber(chain, 'withdrawFee'),
+                    'precision': this.parseNumber(this.parsePrecision(this.safeString(chain, 'minAccuracy'))),
                     'limits': {
                         'withdraw': {
-                            'min': this.parseNumber(minNetworkWithdrawString),
+                            'min': this.safeNumber(chain, 'withdrawMin'),
                             'max': undefined,
                         },
                         'deposit': {
-                            'min': this.parseNumber(minNetworkDepositString),
+                            'min': this.safeNumber(chain, 'depositMin'),
                             'max': undefined,
                         },
                     },
                 };
             }
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'info': currency,
                 'code': code,
                 'id': currencyId,
                 'name': name,
-                'active': deposit && withdraw,
-                'deposit': deposit,
-                'withdraw': withdraw,
-                'fee': this.parseNumber(minWithdrawFeeString),
-                'precision': minPrecision,
+                'active': undefined,
+                'deposit': undefined,
+                'withdraw': undefined,
+                'fee': undefined,
+                'precision': undefined,
                 'limits': {
                     'amount': {
                         'min': undefined,
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': this.parseNumber(minWithdrawString),
+                        'min': undefined,
                         'max': undefined,
                     },
                     'deposit': {
-                        'min': this.parseNumber(minDepositString),
+                        'min': undefined,
                         'max': undefined,
                     },
                 },
                 'networks': networks,
                 'type': 'crypto', // atm exchange api provides only cryptos
-            };
+            });
         }
         return result;
     }

package/js/src/cex.js

@@ -305,8 +305,6 @@ export default class cex extends Exchange {
         const id = this.safeString(rawCurrency, 'currency');
         const code = this.safeCurrencyCode(id);
         const type = this.safeBool(rawCurrency, 'fiat') ? 'fiat' : 'crypto';
-        const currencyDepositEnabled = this.safeBool(rawCurrency, 'walletDeposit');
-        const currencyWithdrawEnabled = this.safeBool(rawCurrency, 'walletWithdrawal');
         const currencyPrecision = this.parseNumber(this.parsePrecision(this.safeString(rawCurrency, 'precision')));
         const networks = {};
         const rawNetworks = this.safeDict(rawCurrency, 'blockchains', {});
@@ -345,8 +343,8 @@ export default class cex extends Exchange {
             'name': undefined,
             'type': type,
             'active': undefined,
-            'deposit': currencyDepositEnabled,
-            'withdraw': currencyWithdrawEnabled,
+            'deposit': this.safeBool(rawCurrency, 'walletDeposit'),
+            'withdraw': this.safeBool(rawCurrency, 'walletWithdrawal'),
             'fee': undefined,
             'precision': currencyPrecision,
             'limits': {

package/js/src/coinbase.js

@@ -1877,45 +1877,46 @@ export default class coinbase extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     async fetchCurrencies(params = {}) {
-        const response = await this.fetchCurrenciesFromCache(params);
-        const currencies = this.safeList(response, 'currencies', []);
-        //
-        // fiat
-        //
-        //    {
-        //        id: 'IMP',
-        //        name: 'Isle of Man Pound',
-        //        min_size: '0.01'
-        //    },
-        //
-        // crypto
-        //
-        //    {
-        //        asset_id: '9476e3be-b731-47fa-82be-347fabc573d9',
-        //        code: 'AERO',
-        //        name: 'Aerodrome Finance',
-        //        color: '#0433FF',
-        //        sort_index: '340',
-        //        exponent: '8',
-        //        type: 'crypto',
-        //        address_regex: '^(?:0x)?[0-9a-fA-F]{40}$'
-        //    }
+        const promises = [
+            this.v2PublicGetCurrencies(params),
+            this.v2PublicGetCurrenciesCrypto(params),
+            this.v2PublicGetExchangeRates(params),
+        ];
+        const promisesResult = await Promise.all(promises);
+        const fiatResponse = this.safeDict(promisesResult, 0, {});
         //
+        //    [
+        //        "data": [
+        //            {
+        //                id: 'IMP',
+        //                name: 'Isle of Man Pound',
+        //                min_size: '0.01'
+        //            },
+        //        ...
         //
-        //     {
-        //         "data":{
-        //             "currency":"USD",
-        //             "rates":{
-        //                 "AED":"3.67",
-        //                 "AFN":"78.21",
-        //                 "ALL":"110.42",
-        //                 "AMD":"474.18",
-        //                 "ANG":"1.75",
-        //                 ...
-        //             },
-        //         }
-        //     }
+        const cryptoResponse = this.safeDict(promisesResult, 1, {});
         //
+        //     [
+        //        "data": [
+        //           {
+        //              asset_id: '9476e3be-b731-47fa-82be-347fabc573d9',
+        //              code: 'AERO',
+        //              name: 'Aerodrome Finance',
+        //              color: '#0433FF',
+        //              sort_index: '340',
+        //              exponent: '8',
+        //              type: 'crypto',
+        //              address_regex: '^(?:0x)?[0-9a-fA-F]{40}$'
+        //           },
+        //          ...
+        //
+        const ratesResponse = this.safeDict(promisesResult, 2, {});
+        const fiatData = this.safeList(fiatResponse, 'data', []);
+        const cryptoData = this.safeList(cryptoResponse, 'data', []);
+        const ratesData = this.safeDict(ratesResponse, 'data', {});
+        const rates = this.safeDict(ratesData, 'rates', {});
+        const ratesIds = Object.keys(rates);
+        const currencies = this.arrayConcat(fiatData, cryptoData);
         const result = {};
         const networks = {};
         const networksById = {};
@@ -1927,12 +1928,13 @@ export default class coinbase extends Exchange {
             const name = this.safeString(currency, 'name');
             this.options['networks'][code] = name.toLowerCase();
             this.options['networksById'][code] = name.toLowerCase();
-            result[code] = {
+            const type = (assetId !== undefined) ? 'crypto' : 'fiat';
+            result[code] = this.safeCurrencyStructure({
                 'info': currency,
                 'id': id,
                 'code': code,
-                'type': (assetId !== undefined) ? 'crypto' : 'fiat',
-                'name': this.safeString(currency, 'name'),
+                'type': type,
+                'name': name,
                 'active': true,
                 'deposit': undefined,
                 'withdraw': undefined,
@@ -1949,13 +1951,27 @@ export default class coinbase extends Exchange {
                         'max': undefined,
                     },
                 },
-            };
+            });
             if (assetId !== undefined) {
                 const lowerCaseName = name.toLowerCase();
                 networks[code] = lowerCaseName;
                 networksById[lowerCaseName] = code;
             }
         }
+        // we have to add other currencies here ( https://discord.com/channels/1220414409550336183/1220464770239430761/1372215891940479098 )
+        for (let i = 0; i < ratesIds.length; i++) {
+            const currencyId = ratesIds[i];
+            const code = this.safeCurrencyCode(currencyId);
+            if (!(code in result)) {
+                result[code] = this.safeCurrencyStructure({
+                    'info': {},
+                    'id': currencyId,
+                    'code': code,
+                    'type': 'crypto',
+                    'networks': {}, // todo
+                });
+            }
+        }
         this.options['networks'] = this.extend(networks, this.options['networks']);
         this.options['networksById'] = this.extend(networksById, this.options['networksById']);
         return result;