ccxt 4.1.45 → 4.1.46

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

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

@@ -72,7 +72,7 @@ export default class Exchange {
     transactions: {};
     ohlcvs: any;
     myTrades: any;
-    positions: {};
+    positions: any;
     urls: {
         logo?: string;
         api?: string | Dictionary<string>;
@@ -675,6 +675,9 @@ export default class Exchange {
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     fetchPermissions(params?: {}): Promise<void>;
     fetchPosition(symbol: string, params?: {}): Promise<Position>;
+    watchPosition(symbol?: string, params?: {}): Promise<Position>;
+    watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    watchPositionForSymbols(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     fetchPositionsBySymbol(symbol: string, params?: {}): Promise<Position[]>;
     fetchPositions(symbols?: string[], params?: {}): Promise<Position[]>;
     fetchPositionsRisk(symbols?: string[], params?: {}): Promise<Position[]>;

package/js/src/base/Exchange.js

@@ -58,7 +58,6 @@ export default class Exchange {
         this.orders = undefined;
         this.triggerOrders = undefined;
         this.transactions = {};
-        this.positions = {};
         this.requiresWeb3 = false;
         this.requiresEddsa = false;
         this.enableLastJsonResponse = true;
@@ -252,7 +251,7 @@ export default class Exchange {
         this.transactions = {};
         this.ohlcvs = {};
         this.myTrades = undefined;
-        this.positions = {};
+        this.positions = undefined;
         // web3 and cryptography flags
         this.requiresWeb3 = false;
         this.requiresEddsa = false;
@@ -2745,7 +2744,7 @@ export default class Exchange {
         const symbol = this.safeString(position, 'symbol');
         let market = undefined;
         if (symbol !== undefined) {
-            market = this.market(symbol);
+            market = this.safeValue(this.markets, symbol);
         }
         if (contractSize === undefined && market !== undefined) {
             contractSize = this.safeNumber(market, 'contractSize');
@@ -2966,6 +2965,15 @@ export default class Exchange {
     async fetchPosition(symbol, params = {}) {
         throw new NotSupported(this.id + ' fetchPosition() is not supported yet');
     }
+    async watchPosition(symbol = undefined, params = {}) {
+        throw new NotSupported(this.id + ' watchPosition() is not supported yet');
+    }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        throw new NotSupported(this.id + ' watchPositions() is not supported yet');
+    }
+    async watchPositionForSymbols(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        return this.watchPositions(symbols, since, limit, params);
+    }
     async fetchPositionsBySymbol(symbol, params = {}) {
         /**
          * @method

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

@@ -16,4 +16,8 @@ declare class ArrayCacheBySymbolById extends ArrayCache {
     constructor(maxSize?: any);
     append(item: any): void;
 }
-export { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, };
+declare class ArrayCacheBySymbolBySide extends ArrayCache {
+    constructor();
+    append(item: any): void;
+}
+export { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, };

package/js/src/base/ws/Cache.js

@@ -200,4 +200,53 @@ class ArrayCacheBySymbolById extends ArrayCache {
         this.allNewUpdates = (this.allNewUpdates || 0) + (afterLength - beforeLength);
     }
 }
-export { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, };
+class ArrayCacheBySymbolBySide extends ArrayCache {
+    constructor() {
+        super();
+        this.nestedNewUpdatesBySymbol = true;
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+    }
+    append(item) {
+        const bySide = this.hashmap[item.symbol] = this.hashmap[item.symbol] || {};
+        if (item.side in bySide) {
+            const reference = bySide[item.side];
+            if (reference !== item) {
+                for (const prop in item) {
+                    reference[prop] = item[prop];
+                }
+            }
+            item = reference;
+            const index = this.findIndex((x) => x.symbol === item.symbol && x.side === item.side);
+            // move the order to the end of the array
+            this.splice(index, 1);
+        }
+        else {
+            bySide[item.side] = item;
+        }
+        this.push(item);
+        if (this.clearAllUpdates) {
+            this.clearAllUpdates = false;
+            this.clearUpdatesBySymbol = {};
+            this.allNewUpdates = 0;
+            this.newUpdatesBySymbol = {};
+        }
+        if (this.newUpdatesBySymbol[item.symbol] === undefined) {
+            this.newUpdatesBySymbol[item.symbol] = new Set();
+        }
+        if (this.clearUpdatesBySymbol[item.symbol]) {
+            this.clearUpdatesBySymbol[item.symbol] = false;
+            this.newUpdatesBySymbol[item.symbol].clear();
+        }
+        // in case an exchange updates the same order id twice
+        const sideSet = this.newUpdatesBySymbol[item.symbol];
+        const beforeLength = sideSet.size;
+        sideSet.add(item.side);
+        const afterLength = sideSet.size;
+        this.allNewUpdates = (this.allNewUpdates || 0) + (afterLength - beforeLength);
+    }
+}
+export { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, };

package/js/src/bitvavo.js

@@ -315,8 +315,8 @@ export default class bitvavo extends Exchange {
          * @returns {object[]} an array of objects representing market data
          */
         const response = await this.publicGetMarkets(params);
-        const currencies = this.currencies;
-        const currenciesById = this.indexBy(currencies, 'symbol');
+        const currencies = await this.fetchCurrencies();
+        const currenciesById = this.indexBy(currencies, 'id');
         //
         //     [
         //         {
@@ -341,7 +341,8 @@ export default class bitvavo extends Exchange {
             const quote = this.safeCurrencyCode(quoteId);
             const status = this.safeString(market, 'status');
             const baseCurrency = this.safeValue(currenciesById, baseId);
-            result.push({
+            const basePrecision = this.safeInteger(baseCurrency, 'precision');
+            result.push(this.safeMarketStructure({
                 'id': id,
                 'symbol': base + '/' + quote,
                 'base': base,
@@ -366,7 +367,7 @@ export default class bitvavo extends Exchange {
                 'strike': undefined,
                 'optionType': undefined,
                 'precision': {
-                    'amount': this.safeInteger(baseCurrency, 'decimals', 8),
+                    'amount': this.safeInteger(baseCurrency, 'decimals', basePrecision),
                     'price': this.safeInteger(market, 'pricePrecision'),
                 },
                 'limits': {
@@ -389,7 +390,7 @@ export default class bitvavo extends Exchange {
                 },
                 'created': undefined,
                 'info': market,
-            });
+            }));
         }
         return result;
     }

package/js/src/bybit.d.ts

@@ -93,8 +93,6 @@ export default class bybit extends Exchange {
     fetchFundingRates(symbols?: string[], params?: {}): Promise<any>;
     fetchFundingRateHistory(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
     parseTrade(trade: any, market?: any): Trade;
-    parseSpotTrade(trade: any, market?: any): Trade;
-    parseContractTrade(trade: any, market?: any): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseBalance(response: any): Balances;

package/js/src/bybit.js

@@ -2526,88 +2526,8 @@ export default class bybit extends Exchange {
         return this.filterBySymbolSinceLimit(sorted, symbol, since, limit);
     }
     parseTrade(trade, market = undefined) {
-        const isSpotTrade = ('isBuyerMaker' in trade) || ('feeTokenId' in trade);
-        if (isSpotTrade) {
-            return this.parseSpotTrade(trade, market);
-        }
-        else {
-            return this.parseContractTrade(trade, market);
-        }
-    }
-    parseSpotTrade(trade, market = undefined) {
-        //
-        //   public:
-        //     {
-        //        "price": "39548.68",
-        //        "time": "1651748717850",
-        //        "qty": "0.166872",
-        //        "isBuyerMaker": 0
-        //     }
-        //
-        //   private:
-        //     {
-        //         "orderPrice": "82.5",
-        //         "creatTime": "1666702226326",
-        //         "orderQty": "0.016",
-        //         "isBuyer": "0",
-        //         "isMaker": "0",
-        //         "symbol": "AAVEUSDT",
-        //         "id": "1274785101965716992",
-        //         "orderId": "1274784252359089664",
-        //         "tradeId": "2270000000031365639",
-        //         "execFee": "0",
-        //         "feeTokenId": "AAVE",
-        //         "matchOrderId": "1274785101865076224",
-        //         "makerRebate": "0",
-        //         "executionTime": "1666702226335"
-        //     }
-        //
-        const timestamp = this.safeIntegerN(trade, ['time', 'creatTime']);
-        let takerOrMaker = undefined;
-        let side = undefined;
-        const isBuyerMaker = this.safeInteger(trade, 'isBuyerMaker');
-        if (isBuyerMaker !== undefined) {
-            // if public response
-            side = (isBuyerMaker === 1) ? 'buy' : 'sell';
-        }
-        else {
-            // if private response
-            const isBuyer = this.safeInteger(trade, 'isBuyer');
-            const isMaker = this.safeInteger(trade, 'isMaker');
-            takerOrMaker = (isMaker === 0) ? 'maker' : 'taker';
-            side = (isBuyer === 0) ? 'buy' : 'sell';
-        }
-        const marketId = this.safeString(trade, 'symbol');
-        market = this.safeMarket(marketId, market, undefined, 'spot');
-        let fee = undefined;
-        const feeCost = this.safeString(trade, 'execFee');
-        if (feeCost !== undefined) {
-            const feeToken = this.safeString(trade, 'feeTokenId');
-            const feeCurrency = this.safeCurrencyCode(feeToken);
-            fee = {
-                'cost': feeCost,
-                'currency': feeCurrency,
-            };
-        }
-        return this.safeTrade({
-            'id': this.safeString(trade, 'tradeId'),
-            'info': trade,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'symbol': market['symbol'],
-            'order': this.safeString(trade, 'orderId'),
-            'type': undefined,
-            'side': side,
-            'takerOrMaker': takerOrMaker,
-            'price': this.safeString2(trade, 'price', 'orderPrice'),
-            'amount': this.safeString2(trade, 'qty', 'orderQty'),
-            'cost': undefined,
-            'fee': fee,
-        }, market);
-    }
-    parseContractTrade(trade, market = undefined) {
         //
-        // public contract
+        // public https://bybit-exchange.github.io/docs/v5/market/recent-trade
         //
         //     {
         //         "execId": "666042b4-50c6-58f3-bd9c-89b2088663ff",
@@ -2619,59 +2539,66 @@ export default class bybit extends Exchange {
         //         "isBlockTrade": false
         //     }
         //
-        // public unified margin
+        // private trades classic spot https://bybit-exchange.github.io/docs/v5/position/execution
         //
         //     {
-        //         "execId": "da66abbc-f358-5864-8d34-84ef7274d853",
-        //         "symbol": "BTCUSDT",
-        //         "price": "20802.50",
-        //         "size": "0.200",
-        //         "side": "Sell",
-        //         "time": "1657870316630"
-        //     }
-        //
-        // private contract trades
-        //
-        //     {
-        //         "symbol": "ETHUSD",
-        //         "execFee": "0.00005484",
-        //         "execId": "acf78206-d464-589b-b888-51bd130821c1",
-        //         "execPrice": "1367.80",
-        //         "execQty": "100",
-        //         "execType": "Trade",
-        //         "execValue": "0.0731101",
-        //         "feeRate": "0.00075",
-        //         "lastLiquidityInd": "RemovedLiquidity",
-        //         "leavesQty": "0",
-        //         "orderId": "fdc584c3-be5d-41ff-8f54-5be7649b1d1c",
+        //         "symbol": "QNTUSDT",
+        //         "orderId": "1538686353240339712",
         //         "orderLinkId": "",
-        //         "orderPrice": "1299.50",
-        //         "orderQty": "100",
-        //         "orderType": "Market",
-        //         "stopOrderType": "UNKNOWN",
         //         "side": "Sell",
-        //         "execTime": "1611528105547",
-        //         "closedSize": "100"
+        //         "orderPrice": "",
+        //         "orderQty": "",
+        //         "leavesQty": "",
+        //         "orderType": "Limit",
+        //         "stopOrderType": "",
+        //         "execFee": "0.040919",
+        //         "execId": "2210000000097330907",
+        //         "execPrice": "98.6",
+        //         "execQty": "0.415",
+        //         "execType": "",
+        //         "execValue": "",
+        //         "execTime": "1698161716634",
+        //         "isMaker": true,
+        //         "feeRate": "",
+        //         "tradeIv": "",
+        //         "markIv": "",
+        //         "markPrice": "",
+        //         "indexPrice": "",
+        //         "underlyingPrice": "",
+        //         "blockTradeId": ""
         //     }
         //
-        // private unified margin
+        // private trades unified https://bybit-exchange.github.io/docs/v5/position/execution
         //
         //     {
-        //         "symbol": "AAVEUSDT",
-        //         "id": "1274785101965716991",
-        //         "orderId": "1274784252359089664",
-        //         "tradeId": "2270000000031365639",
-        //         "orderPrice": "82.5",
-        //         "orderQty": "0.016",
-        //         "execFee": "0",
-        //         "feeTokenId": "AAVE",
-        //         "creatTime": "1666702226326",
-        //         "isBuyer": "0",
-        //         "isMaker": "0",
-        //         "matchOrderId": "1274785101865076224",
-        //         "makerRebate": "0",
-        //         "executionTime": "1666702226335"
-        //     }
+        //         "symbol": "QNTUSDT",
+        //         "orderType": "Limit",
+        //         "underlyingPrice": "",
+        //         "orderLinkId": "1549452573428424449",
+        //         "orderId": "1549452573428424448",
+        //         "stopOrderType": "",
+        //         "execTime": "1699445151998",
+        //         "feeRate": "0.00025",
+        //         "tradeIv": "",
+        //         "blockTradeId": "",
+        //         "markPrice": "",
+        //         "execPrice": "102.8",
+        //         "markIv": "",
+        //         "orderQty": "3.652",
+        //         "orderPrice": "102.8",
+        //         "execValue": "1.028",
+        //         "closedSize": "",
+        //         "execType": "Trade",
+        //         "seq": "19157444346",
+        //         "side": "Buy",
+        //         "indexPrice": "",
+        //         "leavesQty": "3.642",
+        //         "isMaker": true,
+        //         "execFee": "0.0000025",
+        //         "execId": "2210000000101610464",
+        //         "execQty": "0.01",
+        //         "nextPageCursor": "267951%3A0%2C38567%3A0"
+        //     },
         //
         // private USDC settled trades
         //
@@ -2743,9 +2670,25 @@ export default class bybit extends Exchange {
         const feeCostString = this.safeString(trade, 'execFee');
         let fee = undefined;
         if (feeCostString !== undefined) {
+            const feeRateString = this.safeString(trade, 'feeRate');
             let feeCurrencyCode = undefined;
             if (market['spot']) {
-                feeCurrencyCode = this.safeString(trade, 'commissionAsset');
+                if (Precise.stringGt(feeCostString, '0')) {
+                    if (side === 'buy') {
+                        feeCurrencyCode = market['base'];
+                    }
+                    else {
+                        feeCurrencyCode = market['quote'];
+                    }
+                }
+                else {
+                    if (side === 'buy') {
+                        feeCurrencyCode = market['quote'];
+                    }
+                    else {
+                        feeCurrencyCode = market['base'];
+                    }
+                }
             }
             else {
                 feeCurrencyCode = market['inverse'] ? market['base'] : market['settle'];
@@ -2753,6 +2696,7 @@ export default class bybit extends Exchange {
             fee = {
                 'cost': feeCostString,
                 'currency': feeCurrencyCode,
+                'rate': feeRateString,
             };
         }
         return this.safeTrade({
@@ -5758,11 +5702,19 @@ export default class bybit extends Exchange {
         }
         if (type === 'linear' || type === 'inverse') {
             const baseCoin = this.safeString(params, 'baseCoin');
-            if (symbol === undefined && baseCoin === undefined) {
-                const defaultSettle = this.safeString(this.options, 'defaultSettle', 'USDT');
-                const settleCoin = this.safeString(params, 'settleCoin', defaultSettle);
-                request['settleCoin'] = settleCoin;
-                isUsdcSettled = (settleCoin === 'USDC');
+            if (type === 'linear') {
+                if (symbol === undefined && baseCoin === undefined) {
+                    const defaultSettle = this.safeString(this.options, 'defaultSettle', 'USDT');
+                    const settleCoin = this.safeString(params, 'settleCoin', defaultSettle);
+                    request['settleCoin'] = settleCoin;
+                    isUsdcSettled = (settleCoin === 'USDC');
+                }
+            }
+            else {
+                // inverse
+                if (symbol === undefined && baseCoin === undefined) {
+                    request['category'] = 'inverse';
+                }
             }
         }
         if (((type === 'option') || isUsdcSettled) && !isUnifiedAccount) {

package/js/src/cryptocom.js

@@ -3170,7 +3170,7 @@ export default class cryptocom extends Exchange {
             'datetime': this.iso8601(timestamp),
             'hedged': undefined,
             'side': undefined,
-            'contracts': undefined,
+            'contracts': this.safeNumber(position, 'quantity'),
             'contractSize': market['contractSize'],
             'entryPrice': undefined,
             'markPrice': undefined,

package/js/src/gate.js

@@ -5095,13 +5095,14 @@ export default class gate extends Exchange {
         const takerFee = '0.00075';
         const feePaid = Precise.stringMul(takerFee, notional);
         const initialMarginString = Precise.stringAdd(Precise.stringDiv(notional, leverage), feePaid);
+        const timestamp = this.safeInteger(position, 'time_ms');
         return this.safePosition({
             'info': position,
             'id': undefined,
             'symbol': this.safeString(market, 'symbol'),
             'timestamp': undefined,
             'datetime': undefined,
-            'lastUpdateTimestamp': undefined,
+            'lastUpdateTimestamp': timestamp,
             'initialMargin': this.parseNumber(initialMarginString),
             'initialMarginPercentage': this.parseNumber(Precise.stringDiv(initialMarginString, notional)),
             'maintenanceMargin': this.parseNumber(Precise.stringMul(maintenanceRate, notional)),
@@ -5110,6 +5111,7 @@ export default class gate extends Exchange {
             'notional': this.parseNumber(notional),
             'leverage': this.safeNumber(position, 'leverage'),
             'unrealizedPnl': this.parseNumber(unrealisedPnl),
+            'realizedPnl': this.safeNumber(position, 'realised_pnl'),
             'contracts': this.parseNumber(Precise.stringAbs(size)),
             'contractSize': this.safeValue(market, 'contractSize'),
             // 'realisedPnl': position['realised_pnl'],

package/js/src/huobi.js

@@ -7047,8 +7047,7 @@ export default class huobi extends Exchange {
             market = this.market(first);
         }
         let marginMode = undefined;
-        [marginMode, params] = this.handleMarginModeAndParams('fetchPositions', params);
-        marginMode = (marginMode === undefined) ? 'cross' : marginMode;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchPositions', params, 'cross');
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('fetchPositions', market, params, 'linear');
         let marketType = undefined;

package/js/src/okx.js

@@ -2554,6 +2554,13 @@ export default class okx extends Exchange {
             request['tdMode'] = tradeMode;
         }
         else if (contract) {
+            if (market['swap'] || market['future']) {
+                let positionSide = undefined;
+                [positionSide, params] = this.handleOptionAndParams(params, 'createOrder', 'positionSide');
+                if (positionSide !== undefined) {
+                    request['posSide'] = positionSide;
+                }
+            }
             request['tdMode'] = marginMode;
         }
         const isMarketOrder = type === 'market';
@@ -2750,7 +2757,7 @@ export default class okx 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 fullfilled, in units of the quote currency, ignored in market orders
          * @param {object} [params] extra parameters specific to the okx api endpoint
-         * @param {bool} [params.reduceOnly] MARGIN orders only, or swap/future orders in net mode
+         * @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 {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered (perpetual swap markets only)
          * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
@@ -2760,6 +2767,7 @@ export default class okx extends Exchange {
          * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
          * @param {float} [params.stopLoss.price] used for stop loss limit orders, not used for stop loss market price orders
          * @param {string} [params.stopLoss.type] 'market' or 'limit' used to specify the stop loss price type
+         * @param {string} [params.positionSide] if position mode is one-way: set to 'net', if position mode is hedge-mode: set to 'long' or 'short'
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
@@ -2779,7 +2787,16 @@ export default class okx extends Exchange {
             // because it has a lower ratelimit
             request = [request];
         }
-        const response = await this[method](request);
+        let response = undefined;
+        if (method === 'privatePostTradeOrder') {
+            response = await this.privatePostTradeOrder(request);
+        }
+        else if (method === 'privatePostTradeOrderAlgo') {
+            response = await this.privatePostTradeOrderAlgo(request);
+        }
+        else {
+            response = await this.privatePostTradeBatchOrders(request);
+        }
         const data = this.safeValue(response, 'data', []);
         const first = this.safeValue(data, 0);
         const order = this.parseOrder(first, market);

package/js/src/pro/binance.d.ts

@@ -70,11 +70,17 @@ export default class binance extends binanceRest {
     watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
     handleOrderUpdate(client: Client, message: any): void;
+    watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    setPositionsCache(client: Client, type: any, symbols?: string[]): void;
+    loadPositionsSnapshot(client: any, messageHash: any, type: any): Promise<void>;
+    handlePositions(client: any, message: any): void;
+    parseWsPosition(position: any, market?: any): import("../base/types.js").Position;
     fetchMyTradesWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleTradesWs(client: Client, message: any): void;
     watchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     handleMyTrade(client: Client, message: any): void;
     handleOrder(client: Client, message: any): void;
+    handleAcountUpdate(client: any, message: any): void;
     handleWsError(client: Client, message: any): void;
     handleMessage(client: Client, message: any): any;
 }