ccxt 4.1.1 → 4.1.3

package/dist/cjs/src/okx.js

@@ -2083,15 +2083,32 @@ class okx extends okx$1 {
         defaultType = this.safeString(options, 'type', defaultType); // Candles or HistoryCandles
         const type = this.safeString(params, 'type', defaultType);
         params = this.omit(params, 'type');
-        let method = 'publicGetMarket' + type;
         const isHistoryCandles = (type === 'HistoryCandles');
+        let response = undefined;
         if (price === 'mark') {
-            method = (isHistoryCandles) ? 'publicGetMarketHistoryMarkPriceCandles' : 'publicGetMarketMarkPriceCandles';
+            if (isHistoryCandles) {
+                response = await this.publicGetMarketHistoryMarkPriceCandles(this.extend(request, params));
+            }
+            else {
+                response = await this.publicGetMarketMarkPriceCandles(this.extend(request, params));
+            }
         }
         else if (price === 'index') {
-            method = (isHistoryCandles) ? 'publicGetMarketHistoryIndexCandles' : 'publicGetMarketIndexCandles';
+            if (isHistoryCandles) {
+                response = await this.publicGetMarketHistoryIndexCandles(this.extend(request, params));
+            }
+            else {
+                response = await this.publicGetMarketIndexCandles(this.extend(request, params));
+            }
+        }
+        else {
+            if (isHistoryCandles) {
+                response = await this.publicGetMarketHistoryCandles(this.extend(request, params));
+            }
+            else {
+                response = await this.publicGetMarketCandles(this.extend(request, params));
+            }
         }
-        const response = await this[method](this.extend(request, params));
         //
         //     {
         //         "code": "0",
@@ -2303,17 +2320,16 @@ class okx extends okx$1 {
          */
         await this.loadMarkets();
         const [marketType, query] = this.handleMarketTypeAndParams('fetchBalance', undefined, params);
-        let method = undefined;
+        const request = {
+        // 'ccy': 'BTC,ETH', // comma-separated list of currency ids
+        };
+        let response = undefined;
         if (marketType === 'funding') {
-            method = 'privateGetAssetBalances';
+            response = await this.privateGetAssetBalances(this.extend(request, query));
         }
         else {
-            method = 'privateGetAccountBalance';
+            response = await this.privateGetAccountBalance(this.extend(request, query));
         }
-        const request = {
-        // 'ccy': 'BTC,ETH', // comma-separated list of currency ids
-        };
-        const response = await this[method](this.extend(request, query));
         //
         //     {
         //         "code": "0",

package/dist/cjs/src/pro/binance.js

@@ -140,14 +140,20 @@ class binance extends binance$1 {
         // valid <levels> are 5, 10, or 20
         //
         // default 100, max 1000, valid limits 5, 10, 20, 50, 100, 500, 1000
+        await this.loadMarkets();
+        const market = this.market(symbol);
         if (limit !== undefined) {
-            if ((limit !== 5) && (limit !== 10) && (limit !== 20) && (limit !== 50) && (limit !== 100) && (limit !== 500) && (limit !== 1000)) {
-                throw new errors.ExchangeError(this.id + ' watchOrderBook limit argument must be undefined, 5, 10, 20, 50, 100, 500 or 1000');
+            if (market['contract']) {
+                if ((limit !== 5) && (limit !== 10) && (limit !== 20) && (limit !== 50) && (limit !== 100) && (limit !== 500) && (limit !== 1000)) {
+                    throw new errors.ExchangeError(this.id + ' watchOrderBook limit argument must be undefined, 5, 10, 20, 50, 100, 500 or 1000');
+                }
+            }
+            else {
+                if (limit > 5000) {
+                    throw new errors.ExchangeError(this.id + ' watchOrderBook limit argument must be less than or equal to 5000');
+                }
             }
         }
-        //
-        await this.loadMarkets();
-        const market = this.market(symbol);
         let type = market['type'];
         if (market['contract']) {
             type = market['linear'] ? 'future' : 'delivery';

package/dist/cjs/src/pro/coinbasepro.js

@@ -19,9 +19,11 @@ class coinbasepro extends coinbasepro$1 {
                 'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
+                'watchMyTradesForSymbols': true,
                 'watchBalance': false,
                 'watchStatus': false,
                 'watchOrders': true,
+                'watchOrdersForSymbols': true,
                 'watchMyTrades': true,
             },
             'urls': {
@@ -209,6 +211,54 @@ class coinbasepro extends coinbasepro$1 {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async watchMyTradesForSymbols(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinbasepro#watchMyTradesForSymbols
+         * @description watches information on multiple trades made by the user
+         * @param {string[]} symbols unified symbol of the market to fetch trades for
+         * @param {int} [since] the earliest time in ms to fetch trades for
+         * @param {int} [limit] the maximum number of trade structures to retrieve
+         * @param {object} [params] extra parameters specific to the coinbasepro api endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure
+         */
+        symbols = this.marketSymbols(symbols, undefined, false);
+        await this.loadMarkets();
+        const name = 'user';
+        const messageHash = 'multipleMyTrades::';
+        const authentication = this.authenticate();
+        const trades = await this.subscribeMultiple(name, symbols, messageHash, this.extend(params, authentication));
+        if (this.newUpdates) {
+            const first = this.safeValue(trades, 0);
+            const tradeSymbol = this.safeString(first, 'symbol');
+            limit = trades.getLimit(tradeSymbol, limit);
+        }
+        return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
+    }
+    async watchOrdersForSymbols(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinbasepro#watchOrdersForSymbols
+         * @description watches information on multiple orders made by the user
+         * @param {string[]} symbols unified symbol of the market to fetch orders for
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of trade structures to retrieve
+         * @param {object} [params] extra parameters specific to the coinbasepro api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        symbols = this.marketSymbols(symbols, undefined, false);
+        await this.loadMarkets();
+        const name = 'user';
+        const messageHash = 'multipleOrders::';
+        const authentication = this.authenticate();
+        const orders = await this.subscribeMultiple(name, symbols, messageHash, this.extend(params, authentication));
+        if (this.newUpdates) {
+            const first = this.safeValue(orders, 0);
+            const tradeSymbol = this.safeString(first, 'symbol');
+            limit = orders.getLimit(tradeSymbol, limit);
+        }
+        return this.filterBySinceLimit(orders, since, limit, 'timestamp', true);
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -348,6 +398,7 @@ class coinbasepro extends coinbasepro$1 {
         const marketId = this.safeString(message, 'product_id');
         if (marketId !== undefined) {
             const trade = this.parseWsTrade(message);
+            const symbol = trade['symbol'];
             const type = 'myTrades';
             const messageHash = type + ':' + marketId;
             let tradesArray = this.myTrades;
@@ -358,6 +409,7 @@ class coinbasepro extends coinbasepro$1 {
             }
             tradesArray.append(trade);
             client.resolve(tradesArray, messageHash);
+            this.resolvePromiseIfMessagehashMatches(client, 'multipleMyTrades::', symbol, tradesArray);
         }
         return message;
     }
@@ -414,14 +466,25 @@ class coinbasepro extends coinbasepro$1 {
         // }
         const parsed = super.parseTrade(trade);
         let feeRate = undefined;
+        let isMaker = false;
         if ('maker_fee_rate' in trade) {
+            isMaker = true;
             parsed['takerOrMaker'] = 'maker';
             feeRate = this.safeNumber(trade, 'maker_fee_rate');
         }
         else {
             parsed['takerOrMaker'] = 'taker';
             feeRate = this.safeNumber(trade, 'taker_fee_rate');
-        }
+            // side always represents the maker side of the trade
+            // so if we're taker, we invert it
+            const currentSide = parsed['side'];
+            parsed['side'] = this.safeString({
+                'buy': 'sell',
+                'sell': 'buy',
+            }, currentSide, currentSide);
+        }
+        const idKey = isMaker ? 'maker_order_id' : 'taker_order_id';
+        parsed['order'] = this.safeString(trade, idKey);
         market = this.market(parsed['symbol']);
         const feeCurrency = market['quote'];
         let feeCost = undefined;
@@ -547,6 +610,7 @@ class coinbasepro extends coinbasepro$1 {
                 const parsed = this.parseWsOrder(message);
                 orders.append(parsed);
                 client.resolve(orders, messageHash);
+                this.resolvePromiseIfMessagehashMatches(client, 'multipleOrders::', symbol, orders);
             }
             else {
                 const sequence = this.safeInteger(message, 'sequence');
@@ -590,6 +654,7 @@ class coinbasepro extends coinbasepro$1 {
                         // update the newUpdates count
                         orders.append(previousOrder);
                         client.resolve(orders, messageHash);
+                        this.resolvePromiseIfMessagehashMatches(client, 'multipleOrders::', symbol, orders);
                     }
                     else if ((type === 'received') || (type === 'done')) {
                         const info = this.extend(previousOrder['info'], message);
@@ -605,6 +670,7 @@ class coinbasepro extends coinbasepro$1 {
                         // update the newUpdates count
                         orders.append(previousOrder);
                         client.resolve(orders, messageHash);
+                        this.resolvePromiseIfMessagehashMatches(client, 'multipleOrders::', symbol, orders);
                     }
                 }
             }
@@ -635,11 +701,7 @@ class coinbasepro extends coinbasepro$1 {
                 remaining = amount - filled;
             }
         }
-        let cost = undefined;
-        if ((price !== undefined) && (amount !== undefined)) {
-            cost = price * amount;
-        }
-        return {
+        return this.safeOrder({
             'info': order,
             'symbol': symbol,
             'id': id,
@@ -655,14 +717,14 @@ class coinbasepro extends coinbasepro$1 {
             'stopPrice': undefined,
             'triggerPrice': undefined,
             'amount': amount,
-            'cost': cost,
+            'cost': undefined,
             'average': undefined,
             'filled': filled,
             'remaining': remaining,
             'status': status,
             'fee': undefined,
             'trades': undefined,
-        };
+        });
     }
     handleTicker(client, message) {
         //

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 { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position } 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.0";
+declare const version = "4.1.2";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

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.1';
+const version = '4.1.3';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -11,6 +11,7 @@ interface coinbasepro {
     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>;

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

@@ -11,6 +11,7 @@ interface Exchange {
     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>;

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

@@ -535,6 +535,8 @@ export default class Exchange {
     fetchTradesWs(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchMyTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrdersForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<Dictionary<Dictionary<OHLCV[]>>>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     fetchDepositAddresses(codes?: string[], params?: {}): Promise<any>;

package/js/src/base/Exchange.js

@@ -1304,6 +1304,12 @@ export default class Exchange {
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         throw new NotSupported(this.id + ' watchTradesForSymbols() is not supported yet');
     }
+    async watchMyTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
+        throw new NotSupported(this.id + ' watchMyTradesForSymbols() is not supported yet');
+    }
+    async watchOrdersForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
+        throw new NotSupported(this.id + ' watchOrdersForSymbols() is not supported yet');
+    }
     async watchOHLCVForSymbols(symbolsAndTimeframes, since = undefined, limit = undefined, params = {}) {
         throw new NotSupported(this.id + ' watchOHLCVForSymbols() is not supported yet');
     }