ccxt 4.1.1 → 4.1.2

package/js/src/coinbasepro.js

@@ -114,6 +114,7 @@ export default class coinbasepro extends Exchange {
                 },
                 'private': {
                     'get': [
+                        'address-book',
                         'accounts',
                         'accounts/{id}',
                         'accounts/{id}/holds',

package/js/src/okx.js

@@ -2086,15 +2086,32 @@ export default class okx extends Exchange {
         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",
@@ -2306,17 +2323,16 @@ export default class okx extends Exchange {
          */
         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/js/src/pro/coinbasepro.d.ts

@@ -16,6 +16,8 @@ export default class coinbasepro extends coinbaseproRest {
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTradesForSymbols(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrdersForSymbols(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
@@ -24,30 +26,7 @@ export default class coinbasepro extends coinbaseproRest {
     parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
     parseWsOrderStatus(status: any): string;
     handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): {
-        info: any;
-        symbol: any;
-        id: string;
-        clientOrderId: string;
-        timestamp: number;
-        datetime: string;
-        lastTradeTimestamp: any;
-        type: string;
-        timeInForce: any;
-        postOnly: any;
-        side: string;
-        price: number;
-        stopPrice: any;
-        triggerPrice: any;
-        amount: number;
-        cost: any;
-        average: any;
-        filled: any;
-        remaining: number;
-        status: string;
-        fee: any;
-        trades: any;
-    };
+    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
     handleTicker(client: Client, message: any): any;
     parseTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
     handleDelta(bookside: any, delta: any): void;

package/js/src/pro/coinbasepro.js

@@ -22,9 +22,11 @@ export default class coinbasepro extends coinbaseproRest {
                 'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
+                'watchMyTradesForSymbols': true,
                 'watchBalance': false,
                 'watchStatus': false,
                 'watchOrders': true,
+                'watchOrdersForSymbols': true,
                 'watchMyTrades': true,
             },
             'urls': {
@@ -212,6 +214,54 @@ export default class coinbasepro extends coinbaseproRest {
         }
         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
@@ -351,6 +401,7 @@ export default class coinbasepro extends coinbaseproRest {
         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;
@@ -361,6 +412,7 @@ export default class coinbasepro extends coinbaseproRest {
             }
             tradesArray.append(trade);
             client.resolve(tradesArray, messageHash);
+            this.resolvePromiseIfMessagehashMatches(client, 'multipleMyTrades::', symbol, tradesArray);
         }
         return message;
     }
@@ -417,14 +469,25 @@ export default class coinbasepro extends coinbaseproRest {
         // }
         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;
@@ -550,6 +613,7 @@ export default class coinbasepro extends coinbaseproRest {
                 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');
@@ -593,6 +657,7 @@ export default class coinbasepro extends coinbaseproRest {
                         // 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);
@@ -608,6 +673,7 @@ export default class coinbasepro extends coinbaseproRest {
                         // update the newUpdates count
                         orders.append(previousOrder);
                         client.resolve(orders, messageHash);
+                        this.resolvePromiseIfMessagehashMatches(client, 'multipleOrders::', symbol, orders);
                     }
                 }
             }
@@ -638,11 +704,7 @@ export default class coinbasepro extends coinbaseproRest {
                 remaining = amount - filled;
             }
         }
-        let cost = undefined;
-        if ((price !== undefined) && (amount !== undefined)) {
-            cost = price * amount;
-        }
-        return {
+        return this.safeOrder({
             'info': order,
             'symbol': symbol,
             'id': id,
@@ -658,14 +720,14 @@ export default class coinbasepro extends coinbaseproRest {
             '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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 130+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",