ccxt 4.1.87 → 4.1.89

package/dist/cjs/src/woo.js

@@ -37,7 +37,10 @@ class woo extends woo$1 {
                 'closeAllPositions': false,
                 'closePosition': false,
                 'createDepositAddress': false,
+                'createMarketBuyOrderWithCost': true,
                 'createMarketOrder': false,
+                'createMarketOrderWithCost': false,
+                'createMarketSellOrderWithCost': false,
                 'createOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': false,
@@ -739,6 +742,25 @@ class woo extends woo$1 {
         }
         return result;
     }
+    async createMarketBuyOrderWithCost(symbol, cost, params = {}) {
+        /**
+         * @method
+         * @name woo#createMarketBuyOrderWithCost
+         * @description create a market buy order by providing the symbol and cost
+         * @see https://docs.woo.org/#send-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {float} cost how much you want to trade in units of the quote currency
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        if (!market['spot']) {
+            throw new errors.NotSupported(this.id + ' createMarketBuyOrderWithCost() supports spot orders only');
+        }
+        params['createMarketBuyOrderRequiresPrice'] = false;
+        return await this.createOrder(symbol, 'market', 'buy', cost, undefined, params);
+    }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         /**
          * @method
@@ -758,9 +780,11 @@ class woo extends woo$1 {
          * @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered (perpetual swap markets only)
          * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
          * @param {float} [params.algoType] 'STOP'or 'TRAILING_STOP' or 'OCO' or 'CLOSE_POSITION'
+         * @param {float} [params.cost] *spot market buy only* the quote quantity that can be used as an alternative for the amount
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         const reduceOnly = this.safeValue2(params, 'reduceOnly', 'reduce_only');
+        params = this.omit(params, ['reduceOnly', 'reduce_only']);
         const orderType = type.toUpperCase();
         await this.loadMarkets();
         const market = this.market(symbol);
@@ -803,26 +827,29 @@ class woo extends woo$1 {
         if (isMarket && !isStop) {
             // for market buy it requires the amount of quote currency to spend
             if (market['spot'] && orderSide === 'BUY') {
-                const cost = this.safeNumber(params, 'cost');
-                if (this.safeValue(this.options, 'createMarketBuyOrderRequiresPrice', true)) {
-                    if (cost === undefined) {
-                        if (price === undefined) {
-                            throw new errors.InvalidOrder(this.id + " createOrder() requires the price argument for market buy orders to calculate total order cost. Supply a price argument to createOrder() call if you want the cost to be calculated for you from price and amount, or alternatively, supply the total cost value in the 'order_amount' in  exchange-specific parameters");
-                        }
-                        else {
-                            const amountString = this.numberToString(amount);
-                            const priceString = this.numberToString(price);
-                            const orderAmount = Precise["default"].stringMul(amountString, priceString);
-                            request['order_amount'] = this.costToPrecision(symbol, orderAmount);
-                        }
+                let quoteAmount = undefined;
+                let createMarketBuyOrderRequiresPrice = true;
+                [createMarketBuyOrderRequiresPrice, params] = this.handleOptionAndParams(params, 'createOrder', 'createMarketBuyOrderRequiresPrice', true);
+                const cost = this.safeNumber2(params, 'cost', 'order_amount');
+                params = this.omit(params, ['cost', 'order_amount']);
+                if (cost !== undefined) {
+                    quoteAmount = this.costToPrecision(symbol, cost);
+                }
+                else if (createMarketBuyOrderRequiresPrice) {
+                    if (price === undefined) {
+                        throw new errors.InvalidOrder(this.id + ' createOrder() requires the price argument for market buy orders to calculate the total cost to spend (amount * price), alternatively set the createMarketBuyOrderRequiresPrice option or param to false and pass the cost to spend (quote quantity) in the amount argument');
                     }
                     else {
-                        request['order_amount'] = this.costToPrecision(symbol, cost);
+                        const amountString = this.numberToString(amount);
+                        const priceString = this.numberToString(price);
+                        const costRequest = Precise["default"].stringMul(amountString, priceString);
+                        quoteAmount = this.costToPrecision(symbol, costRequest);
                     }
                 }
                 else {
-                    request['order_amount'] = this.costToPrecision(symbol, amount);
+                    quoteAmount = this.costToPrecision(symbol, amount);
                 }
+                request['order_amount'] = quoteAmount;
             }
             else {
                 request['order_quantity'] = this.amountToPrecision(symbol, amount);

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.1.86";
+declare const version = "4.1.88";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';
@@ -43,6 +43,7 @@ import btcturk from './src/btcturk.js';
 import bybit from './src/bybit.js';
 import cex from './src/cex.js';
 import coinbase from './src/coinbase.js';
+import coinbasepro from './src/coinbasepro.js';
 import coincheck from './src/coincheck.js';
 import coinex from './src/coinex.js';
 import coinlist from './src/coinlist.js';
@@ -124,6 +125,7 @@ import blockchaincomPro from './src/pro/blockchaincom.js';
 import bybitPro from './src/pro/bybit.js';
 import cexPro from './src/pro/cex.js';
 import coinbasePro from './src/pro/coinbase.js';
+import coinbaseproPro from './src/pro/coinbasepro.js';
 import coinexPro from './src/pro/coinex.js';
 import cryptocomPro from './src/pro/cryptocom.js';
 import currencycomPro from './src/pro/currencycom.js';
@@ -195,6 +197,7 @@ declare const exchanges: {
     bybit: typeof bybit;
     cex: typeof cex;
     coinbase: typeof coinbase;
+    coinbasepro: typeof coinbasepro;
     coincheck: typeof coincheck;
     coinex: typeof coinex;
     coinlist: typeof coinlist;
@@ -278,6 +281,7 @@ declare const pro: {
     bybit: typeof bybitPro;
     cex: typeof cexPro;
     coinbase: typeof coinbasePro;
+    coinbasepro: typeof coinbaseproPro;
     coinex: typeof coinexPro;
     cryptocom: typeof cryptocomPro;
     currencycom: typeof currencycomPro;
@@ -340,6 +344,7 @@ declare const ccxt: {
         bybit: typeof bybitPro;
         cex: typeof cexPro;
         coinbase: typeof coinbasePro;
+        coinbasepro: typeof coinbaseproPro;
         coinex: typeof coinexPro;
         cryptocom: typeof cryptocomPro;
         currencycom: typeof currencycomPro;
@@ -412,6 +417,7 @@ declare const ccxt: {
     bybit: typeof bybit;
     cex: typeof cex;
     coinbase: typeof coinbase;
+    coinbasepro: typeof coinbasepro;
     coincheck: typeof coincheck;
     coinex: typeof coinex;
     coinlist: typeof coinlist;
@@ -471,5 +477,5 @@ declare const ccxt: {
     zaif: typeof zaif;
     zonda: typeof zonda;
 } & typeof functions & typeof errors;
-export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange, Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitforex, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitvavo, bl3p, blockchaincom, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coincheck, coinex, coinlist, coinmate, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, upbit, wavesexchange, wazirx, whitebit, woo, yobit, zaif, zonda, };
+export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange, Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitforex, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitvavo, bl3p, blockchaincom, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbasepro, coincheck, coinex, coinlist, coinmate, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, upbit, wavesexchange, wazirx, whitebit, woo, yobit, zaif, zonda, };
 export default ccxt;

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.87';
+const version = '4.1.89';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';
@@ -79,6 +79,7 @@ import btcturk from './src/btcturk.js';
 import bybit from './src/bybit.js';
 import cex from './src/cex.js';
 import coinbase from './src/coinbase.js';
+import coinbasepro from './src/coinbasepro.js';
 import coincheck from './src/coincheck.js';
 import coinex from './src/coinex.js';
 import coinlist from './src/coinlist.js';
@@ -161,6 +162,7 @@ import blockchaincomPro from './src/pro/blockchaincom.js';
 import bybitPro from './src/pro/bybit.js';
 import cexPro from './src/pro/cex.js';
 import coinbasePro from './src/pro/coinbase.js';
+import coinbaseproPro from './src/pro/coinbasepro.js';
 import coinexPro from './src/pro/coinex.js';
 import cryptocomPro from './src/pro/cryptocom.js';
 import currencycomPro from './src/pro/currencycom.js';
@@ -232,6 +234,7 @@ const exchanges = {
     'bybit': bybit,
     'cex': cex,
     'coinbase': coinbase,
+    'coinbasepro': coinbasepro,
     'coincheck': coincheck,
     'coinex': coinex,
     'coinlist': coinlist,
@@ -315,6 +318,7 @@ const pro = {
     'bybit': bybitPro,
     'cex': cexPro,
     'coinbase': coinbasePro,
+    'coinbasepro': coinbaseproPro,
     'coinex': coinexPro,
     'cryptocom': cryptocomPro,
     'currencycom': currencycomPro,
@@ -360,6 +364,6 @@ pro.exchanges = Object.keys(pro);
 pro['Exchange'] = Exchange; // now the same for rest and ts
 //-----------------------------------------------------------------------------
 const ccxt = Object.assign({ version, Exchange, Precise, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, functions, errors);
-export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitforex, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitvavo, bl3p, blockchaincom, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coincheck, coinex, coinlist, coinmate, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, upbit, wavesexchange, wazirx, whitebit, woo, yobit, zaif, zonda, };
+export { version, Exchange, exchanges, pro, Precise, functions, errors, BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbay, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitforex, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitvavo, bl3p, blockchaincom, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbasepro, coincheck, coinex, coinlist, coinmate, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hitbtc, hitbtc3, hollaex, htx, huobi, huobijp, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, p2b, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, upbit, wavesexchange, wazirx, whitebit, woo, yobit, zaif, zonda, };
 export default ccxt;
 //-----------------------------------------------------------------------------

package/js/src/abstract/bitget.d.ts

@@ -3,7 +3,6 @@ import { Exchange as _Exchange } from '../base/Exchange.js';
 interface Exchange {
     publicCommonGetV2PublicAnnoucements(params?: {}): Promise<implicitReturnType>;
     publicCommonGetV2PublicTime(params?: {}): Promise<implicitReturnType>;
-    publicCommonGetV2CommonTradeRate(params?: {}): Promise<implicitReturnType>;
     publicSpotGetSpotV1NoticeQueryAllNotices(params?: {}): Promise<implicitReturnType>;
     publicSpotGetSpotV1PublicTime(params?: {}): Promise<implicitReturnType>;
     publicSpotGetSpotV1PublicCurrencies(params?: {}): Promise<implicitReturnType>;
@@ -496,6 +495,7 @@ interface Exchange {
     privateEarnPostV2EarnLoanBorrow(params?: {}): Promise<implicitReturnType>;
     privateEarnPostV2EarnLoanRepay(params?: {}): Promise<implicitReturnType>;
     privateEarnPostV2EarnLoanRevisePledge(params?: {}): Promise<implicitReturnType>;
+    privateCommonGetV2CommonTradeRate(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class Exchange extends _Exchange {
 }

package/js/src/abstract/coinbasepro.d.ts

@@ -0,0 +1,69 @@
+import { implicitReturnType } from '../base/types.js';
+import { Exchange as _Exchange } from '../base/Exchange.js';
+interface Exchange {
+    publicGetCurrencies(params?: {}): Promise<implicitReturnType>;
+    publicGetProducts(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsId(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsIdBook(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsIdCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsIdStats(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsIdTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsIdTrades(params?: {}): Promise<implicitReturnType>;
+    publicGetTime(params?: {}): Promise<implicitReturnType>;
+    publicGetProductsSparkLines(params?: {}): Promise<implicitReturnType>;
+    privateGetAddressBook(params?: {}): Promise<implicitReturnType>;
+    privateGetAccounts(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountsId(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountsIdHolds(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountsIdLedger(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountsIdTransfers(params?: {}): Promise<implicitReturnType>;
+    privateGetCoinbaseAccounts(params?: {}): Promise<implicitReturnType>;
+    privateGetFills(params?: {}): Promise<implicitReturnType>;
+    privateGetFunding(params?: {}): Promise<implicitReturnType>;
+    privateGetFees(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginProfileInformation(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginBuyingPower(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginWithdrawalPower(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginWithdrawalPowerAll(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginExitPlan(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginLiquidationHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginPositionRefreshAmounts(params?: {}): Promise<implicitReturnType>;
+    privateGetMarginStatus(params?: {}): Promise<implicitReturnType>;
+    privateGetOracle(params?: {}): Promise<implicitReturnType>;
+    privateGetOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetOrdersId(params?: {}): Promise<implicitReturnType>;
+    privateGetOrdersClientClientOid(params?: {}): Promise<implicitReturnType>;
+    privateGetOtcOrders(params?: {}): Promise<implicitReturnType>;
+    privateGetPaymentMethods(params?: {}): Promise<implicitReturnType>;
+    privateGetPosition(params?: {}): Promise<implicitReturnType>;
+    privateGetProfiles(params?: {}): Promise<implicitReturnType>;
+    privateGetProfilesId(params?: {}): Promise<implicitReturnType>;
+    privateGetReportsReportId(params?: {}): Promise<implicitReturnType>;
+    privateGetTransfers(params?: {}): Promise<implicitReturnType>;
+    privateGetTransfersTransferId(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersSelfExchangeLimits(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersSelfHoldBalances(params?: {}): Promise<implicitReturnType>;
+    privateGetUsersSelfTrailingVolume(params?: {}): Promise<implicitReturnType>;
+    privateGetWithdrawalsFeeEstimate(params?: {}): Promise<implicitReturnType>;
+    privateGetConversionsConversionId(params?: {}): Promise<implicitReturnType>;
+    privatePostConversions(params?: {}): Promise<implicitReturnType>;
+    privatePostDepositsCoinbaseAccount(params?: {}): Promise<implicitReturnType>;
+    privatePostDepositsPaymentMethod(params?: {}): Promise<implicitReturnType>;
+    privatePostCoinbaseAccountsIdAddresses(params?: {}): Promise<implicitReturnType>;
+    privatePostFundingRepay(params?: {}): Promise<implicitReturnType>;
+    privatePostOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostPositionClose(params?: {}): Promise<implicitReturnType>;
+    privatePostProfilesMarginTransfer(params?: {}): Promise<implicitReturnType>;
+    privatePostProfilesTransfer(params?: {}): Promise<implicitReturnType>;
+    privatePostReports(params?: {}): Promise<implicitReturnType>;
+    privatePostWithdrawalsCoinbase(params?: {}): Promise<implicitReturnType>;
+    privatePostWithdrawalsCoinbaseAccount(params?: {}): Promise<implicitReturnType>;
+    privatePostWithdrawalsCrypto(params?: {}): Promise<implicitReturnType>;
+    privatePostWithdrawalsPaymentMethod(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrders(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrdersClientClientOid(params?: {}): Promise<implicitReturnType>;
+    privateDeleteOrdersId(params?: {}): Promise<implicitReturnType>;
+}
+declare abstract class Exchange extends _Exchange {
+}
+export default Exchange;

package/js/src/abstract/coinbasepro.js

@@ -0,0 +1,11 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// -------------------------------------------------------------------------------
+import { Exchange as _Exchange } from '../base/Exchange.js';
+class Exchange extends _Exchange {
+}
+export default Exchange;

package/js/src/abstract/phemex.d.ts

@@ -22,6 +22,7 @@ interface Exchange {
     v1GetMdSpotTicker24hrAll(params?: {}): Promise<implicitReturnType>;
     v1GetExchangePublicProducts(params?: {}): Promise<implicitReturnType>;
     v1GetApiDataPublicDataFundingRateHistory(params?: {}): Promise<implicitReturnType>;
+    v2GetPublicProducts(params?: {}): Promise<implicitReturnType>;
     v2GetMdV2Orderbook(params?: {}): Promise<implicitReturnType>;
     v2GetMdV2Trade(params?: {}): Promise<implicitReturnType>;
     v2GetMdV2Ticker24hr(params?: {}): Promise<implicitReturnType>;

package/js/src/base/Exchange.d.ts

@@ -532,13 +532,14 @@ export default class Exchange {
     checkOrderArguments(market: any, type: any, side: any, amount: any, price: any, params: any): void;
     handleHttpStatusCode(code: any, reason: any, url: any, method: any, body: any): void;
     remove0xPrefix(hexData: any): any;
-    spawn(method: any, ...args: any[]): Future;
+    spawn(method: any, ...args: any[]): ReturnType<typeof Future>;
     delay(timeout: any, method: any, ...args: any[]): void;
     orderBook(snapshot?: {}, depth?: number): WsOrderBook;
     indexedOrderBook(snapshot?: {}, depth?: number): IndexedOrderBook;
     countedOrderBook(snapshot?: {}, depth?: number): CountedOrderBook;
     handleMessage(client: any, message: any): void;
     client(url: any): WsClient;
+    watchMultiple(url: any, messageHashes: any, message?: any, subscribeHashes?: any, subscription?: any): import("./ws/Future.js").FutureInterface;
     watch(url: any, messageHash: any, message?: any, subscribeHash?: any, subscription?: any): any;
     onConnected(client: any, message?: any): void;
     onError(client: any, error: any): void;
@@ -871,8 +872,6 @@ export default class Exchange {
     fetchTransactions(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     filterByArrayPositions(objects: any, key: IndexType, values?: any, indexed?: boolean): Position[];
     filterByArrayTickers(objects: any, key: IndexType, values?: any, indexed?: boolean): Dictionary<Ticker>;
-    resolvePromiseIfMessagehashMatches(client: any, prefix: string, symbol: string, data: any): void;
-    resolveMultipleOHLCV(client: any, prefix: string, symbol: string, timeframe: string, data: any): void;
     createOHLCVObject(symbol: string, timeframe: string, data: any): Dictionary<Dictionary<OHLCV[]>>;
     handleMaxEntriesPerRequestAndParams(method: string, maxEntriesPerRequest?: Int, params?: {}): [Int, any];
     fetchPaginatedCallDynamic(method: string, symbol?: string, since?: Int, limit?: Int, params?: {}, maxEntriesPerRequest?: Int): Promise<any>;

package/js/src/base/Exchange.js

@@ -15,7 +15,7 @@ ExchangeError, BadSymbol, NullResponse, InvalidAddress, InvalidOrder, NotSupport
 import { Precise } from './Precise.js';
 //-----------------------------------------------------------------------------
 import WsClient from './ws/WsClient.js';
-import { createFuture } from './ws/Future.js';
+import { Future } from './ws/Future.js';
 import { OrderBook as WsOrderBook, IndexedOrderBook, CountedOrderBook } from './ws/OrderBook.js';
 // ----------------------------------------------------------------------------
 //
@@ -970,7 +970,7 @@ export default class Exchange {
         }
     }
     spawn(method, ...args) {
-        const future = createFuture();
+        const future = Future();
         method.apply(this, args).then(future.resolve).catch(future.reject);
         return future;
     }
@@ -1023,6 +1023,99 @@ export default class Exchange {
         }
         return this.clients[url];
     }
+    watchMultiple(url, messageHashes, message = undefined, subscribeHashes = undefined, subscription = undefined) {
+        //
+        // Without comments the code of this method is short and easy:
+        //
+        //     const client = this.client (url)
+        //     const backoffDelay = 0
+        //     const future = client.future (messageHash)
+        //     const connected = client.connect (backoffDelay)
+        //     connected.then (() => {
+        //         if (message && !client.subscriptions[subscribeHash]) {
+        //             client.subscriptions[subscribeHash] = true
+        //             client.send (message)
+        //         }
+        //     }).catch ((error) => {})
+        //     return future
+        //
+        // The following is a longer version of this method with comments
+        //
+        const client = this.client(url);
+        // todo: calculate the backoff using the clients cache
+        const backoffDelay = 0;
+        //
+        //  watchOrderBook ---- future ----+---------------+----→ user
+        //                                 |               |
+        //                                 ↓               ↑
+        //                                 |               |
+        //                              connect ......→ resolve
+        //                                 |               |
+        //                                 ↓               ↑
+        //                                 |               |
+        //                             subscribe -----→ receive
+        //
+        const future = Future.race(messageHashes.map(messageHash => client.future(messageHash)));
+        // read and write subscription, this is done before connecting the client
+        // to avoid race conditions when other parts of the code read or write to the client.subscriptions
+        let missingSubscriptions = [];
+        if (subscribeHashes !== undefined) {
+            for (let i = 0; i < subscribeHashes.length; i++) {
+                const subscribeHash = subscribeHashes[i];
+                if (!client.subscriptions[subscribeHash]) {
+                    missingSubscriptions.push(subscribeHash);
+                    client.subscriptions[subscribeHash] = subscription || true;
+                }
+            }
+        }
+        // we intentionally do not use await here to avoid unhandled exceptions
+        // the policy is to make sure that 100% of promises are resolved or rejected
+        // either with a call to client.resolve or client.reject with
+        //  a proper exception class instance
+        const connected = client.connect(backoffDelay);
+        // the following is executed only if the catch-clause does not
+        // catch any connection-level exceptions from the client
+        // (connection established successfully)
+        if ((subscribeHashes === undefined) || missingSubscriptions.length) {
+            connected.then(() => {
+                const options = this.safeValue(this.options, 'ws');
+                const cost = this.safeValue(options, 'cost', 1);
+                if (message) {
+                    if (this.enableRateLimit && client.throttle) {
+                        // add cost here |
+                        //               |
+                        //               V
+                        client.throttle(cost).then(() => {
+                            client.send(message);
+                        }).catch((e) => {
+                            for (let i = 0; i < missingSubscriptions.length; i++) {
+                                const subscribeHash = missingSubscriptions[i];
+                                delete client.subscriptions[subscribeHash];
+                            }
+                            future.reject(e);
+                        });
+                    }
+                    else {
+                        client.send(message)
+                            .catch((e) => {
+                            for (let i = 0; i < missingSubscriptions.length; i++) {
+                                const subscribeHash = missingSubscriptions[i];
+                                delete client.subscriptions[subscribeHash];
+                            }
+                            future.reject(e);
+                        });
+                    }
+                }
+            }).catch((e) => {
+                for (let i = 0; i < missingSubscriptions.length; i++) {
+                    const subscribeHash = missingSubscriptions[i];
+                    delete client.subscriptions[subscribeHash];
+                }
+                future.reject(e);
+            });
+        }
+        return future;
+    }
     watch(url, messageHash, message = undefined, subscribeHash = undefined, subscription = undefined) {
         //
         // Without comments the code of this method is short and easy:
@@ -1389,7 +1482,7 @@ export default class Exchange {
         const length = usedProxies.length;
         if (length > 1) {
             const joinedProxyNames = usedProxies.join(',');
-            throw new ExchangeError(this.id + ' you have multiple conflicting settings (' + joinedProxyNames + '), please use only one from: wsProxy, wssProxy, socksProxy');
+            throw new ExchangeError(this.id + ' you have multiple conflicting settings (' + joinedProxyNames + '), please use only one from: wsProxy, wssProxy, wsSocksProxy');
         }
         return [wsProxy, wssProxy, wsSocksProxy];
     }
@@ -4514,31 +4607,6 @@ export default class Exchange {
          */
         return this.filterByArray(objects, key, values, indexed);
     }
-    resolvePromiseIfMessagehashMatches(client, prefix, symbol, data) {
-        const messageHashes = this.findMessageHashes(client, prefix);
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            if (this.inArray(symbol, symbols)) {
-                client.resolve(data, messageHash);
-            }
-        }
-    }
-    resolveMultipleOHLCV(client, prefix, symbol, timeframe, data) {
-        const messageHashes = this.findMessageHashes(client, 'multipleOHLCV::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsAndTimeframes = parts[1];
-            const splitted = symbolsAndTimeframes.split(',');
-            const id = symbol + '#' + timeframe;
-            if (this.inArray(id, splitted)) {
-                client.resolve([symbol, timeframe, data], messageHash);
-            }
-        }
-    }
     createOHLCVObject(symbol, timeframe, data) {
         const res = {};
         res[symbol] = {};

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

@@ -1,7 +1,7 @@
 import { Future } from './Future.js';
 export default class Client {
     connected: Promise<any>;
-    disconnected: Future;
+    disconnected: ReturnType<typeof Future>;
     futures: {};
     rejections: {};
     keepAlive: number;
@@ -45,7 +45,7 @@ export default class Client {
     onError(error: any): void;
     onClose(event: any): void;
     onUpgrade(message: any): void;
-    send(message: any): Promise<unknown>;
+    send(message: any): Promise<any>;
     close(): void;
     onMessage(messageEvent: any): void;
 }

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

@@ -6,7 +6,7 @@
 
 import { RequestTimeout, NetworkError, NotSupported, BaseError } from '../../base/errors.js';
 import { inflateSync, gunzipSync } from '../../static_dependencies/fflake/browser.js';
-import { createFuture } from './Future.js';
+import { Future } from './Future.js';
 import { isNode, isJsonEncodedObject, deepExtend, milliseconds, } from '../../base/functions.js';
 import { utf8 } from '../../static_dependencies/scure-base/index.js';
 export default class Client {
@@ -43,11 +43,11 @@ export default class Client {
         };
         Object.assign(this, deepExtend(defaults, config));
         // connection-related Future
-        this.connected = createFuture();
+        this.connected = Future();
     }
     future(messageHash) {
         if (!(messageHash in this.futures)) {
-            this.futures[messageHash] = createFuture();
+            this.futures[messageHash] = Future();
         }
         const future = this.futures[messageHash];
         if (messageHash in this.rejections) {
@@ -225,7 +225,7 @@ export default class Client {
             this.log(new Date(), 'sending', message);
         }
         message = (typeof message === 'string') ? message : JSON.stringify(message);
-        const future = createFuture();
+        const future = Future();
         if (isNode) {
             /* eslint-disable no-inner-declarations */
             function onSendComplete(error) {

package/js/src/base/ws/Future.d.ts

@@ -1,5 +1,8 @@
-export interface Future extends Promise<unknown> {
+export interface FutureInterface extends Promise<any> {
     resolve(value: unknown): void;
     reject(reason?: any): void;
 }
-export declare function createFuture(): Future;
+export declare function Future(): FutureInterface;
+export declare namespace Future {
+    var race: (futures: any) => FutureInterface;
+}

package/js/src/base/ws/Future.js

@@ -5,7 +5,7 @@
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
 // @ts-nocheck
-export function createFuture() {
+export function Future() {
     let resolve = undefined, reject = undefined;
     const p = new Promise((resolve_, reject_) => {
         resolve = resolve_;
@@ -25,4 +25,10 @@ export function createFuture() {
     };
     return p;
 }
-;
+function wrapFuture(aggregatePromise) {
+    const p = Future();
+    // wrap the promises as a future
+    aggregatePromise.then(p.resolve, p.reject);
+    return p;
+}
+Future.race = (futures) => wrapFuture(Promise.race(futures));

package/js/src/base/ws/WsClient.d.ts

@@ -7,5 +7,5 @@ export default class WsClient extends Client {
     createConnection(): void;
     connect(backoffDelay?: number): Promise<any>;
     isOpen(): boolean;
-    close(): import("./Future.js").Future;
+    close(): import("./Future.js").FutureInterface;
 }

package/js/src/base/ws/WsClient.js

@@ -7,7 +7,7 @@
 import Client from './Client.js';
 import { sleep, isNode, milliseconds, } from '../../base/functions.js';
 import WebSocket from 'ws';
-import { createFuture } from './Future.js';
+import { Future } from './Future.js';
 const WebSocketPlatform = isNode ? WebSocket : self.WebSocket;
 export default class WsClient extends Client {
     createConnection() {
@@ -54,7 +54,7 @@ export default class WsClient extends Client {
     close() {
         if (this.connection instanceof WebSocketPlatform) {
             if (this.disconnected === undefined) {
-                this.disconnected = createFuture();
+                this.disconnected = Future();
             }
             this.connection.close();
         }