ccxt 4.3.30 → 4.3.31

package/js/src/bitfinex2.js

@@ -1263,14 +1263,15 @@ export default class bitfinex2 extends Exchange {
         //         ...
         //     ]
         //
-        const tradeLength = trade.length;
+        const tradeList = this.safeList(trade, 'result', []);
+        const tradeLength = tradeList.length;
         const isPrivate = (tradeLength > 5);
-        const id = this.safeString(trade, 0);
+        const id = this.safeString(tradeList, 0);
         const amountIndex = isPrivate ? 4 : 2;
         let side = undefined;
-        let amountString = this.safeString(trade, amountIndex);
+        let amountString = this.safeString(tradeList, amountIndex);
         const priceIndex = isPrivate ? 5 : 3;
-        const priceString = this.safeString(trade, priceIndex);
+        const priceString = this.safeString(tradeList, priceIndex);
         if (amountString[0] === '-') {
             side = 'sell';
             amountString = Precise.stringAbs(amountString);
@@ -1284,22 +1285,22 @@ export default class bitfinex2 extends Exchange {
         let fee = undefined;
         let symbol = this.safeSymbol(undefined, market);
         const timestampIndex = isPrivate ? 2 : 1;
-        const timestamp = this.safeInteger(trade, timestampIndex);
+        const timestamp = this.safeInteger(tradeList, timestampIndex);
         if (isPrivate) {
-            const marketId = trade[1];
+            const marketId = tradeList[1];
             symbol = this.safeSymbol(marketId);
-            orderId = this.safeString(trade, 3);
-            const maker = this.safeInteger(trade, 8);
+            orderId = this.safeString(tradeList, 3);
+            const maker = this.safeInteger(tradeList, 8);
             takerOrMaker = (maker === 1) ? 'maker' : 'taker';
-            let feeCostString = this.safeString(trade, 9);
+            let feeCostString = this.safeString(tradeList, 9);
             feeCostString = Precise.stringNeg(feeCostString);
-            const feeCurrencyId = this.safeString(trade, 10);
+            const feeCurrencyId = this.safeString(tradeList, 10);
             const feeCurrency = this.safeCurrencyCode(feeCurrencyId);
             fee = {
                 'cost': feeCostString,
                 'currency': feeCurrency,
             };
-            const orderType = trade[6];
+            const orderType = tradeList[6];
             type = this.safeString(this.options['exchangeTypes'], orderType);
         }
         return this.safeTrade({
@@ -1315,7 +1316,7 @@ export default class bitfinex2 extends Exchange {
             'amount': amountString,
             'cost': undefined,
             'fee': fee,
-            'info': trade,
+            'info': tradeList,
         }, market);
     }
     async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
@@ -1364,7 +1365,11 @@ export default class bitfinex2 extends Exchange {
         //     ]
         //
         const trades = this.sortBy(response, 1);
-        return this.parseTrades(trades, market, undefined, limit);
+        const tradesList = [];
+        for (let i = 0; i < trades.length; i++) {
+            tradesList.push({ 'result': trades[i] }); // convert to array of dicts to match parseOrder signature
+        }
+        return this.parseTrades(tradesList, market, undefined, limit);
     }
     async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = 100, params = {}) {
         /**
@@ -1477,20 +1482,21 @@ export default class bitfinex2 extends Exchange {
         return this.safeString(orderTypes, orderType, 'GTC');
     }
     parseOrder(order, market = undefined) {
-        const id = this.safeString(order, 0);
-        const marketId = this.safeString(order, 3);
+        const orderList = this.safeList(order, 'result');
+        const id = this.safeString(orderList, 0);
+        const marketId = this.safeString(orderList, 3);
         const symbol = this.safeSymbol(marketId);
         // https://github.com/ccxt/ccxt/issues/6686
-        // const timestamp = this.safeTimestamp (order, 5);
-        const timestamp = this.safeInteger(order, 5);
-        const remaining = Precise.stringAbs(this.safeString(order, 6));
-        const signedAmount = this.safeString(order, 7);
+        // const timestamp = this.safeTimestamp (orderObject, 5);
+        const timestamp = this.safeInteger(orderList, 5);
+        const remaining = Precise.stringAbs(this.safeString(orderList, 6));
+        const signedAmount = this.safeString(orderList, 7);
         const amount = Precise.stringAbs(signedAmount);
         const side = Precise.stringLt(signedAmount, '0') ? 'sell' : 'buy';
-        const orderType = this.safeString(order, 8);
+        const orderType = this.safeString(orderList, 8);
         const type = this.safeString(this.safeValue(this.options, 'exchangeTypes'), orderType);
         const timeInForce = this.parseTimeInForce(orderType);
-        const rawFlags = this.safeString(order, 12);
+        const rawFlags = this.safeString(orderList, 12);
         const flags = this.parseOrderFlags(rawFlags);
         let postOnly = false;
         if (flags !== undefined) {
@@ -1500,25 +1506,25 @@ export default class bitfinex2 extends Exchange {
                 }
             }
         }
-        let price = this.safeString(order, 16);
+        let price = this.safeString(orderList, 16);
         let stopPrice = undefined;
         if ((orderType === 'EXCHANGE STOP') || (orderType === 'EXCHANGE STOP LIMIT')) {
             price = undefined;
-            stopPrice = this.safeString(order, 16);
+            stopPrice = this.safeString(orderList, 16);
             if (orderType === 'EXCHANGE STOP LIMIT') {
-                price = this.safeString(order, 19);
+                price = this.safeString(orderList, 19);
             }
         }
         let status = undefined;
-        const statusString = this.safeString(order, 13);
+        const statusString = this.safeString(orderList, 13);
         if (statusString !== undefined) {
             const parts = statusString.split(' @ ');
             status = this.parseOrderStatus(this.safeString(parts, 0));
         }
-        const average = this.safeString(order, 17);
-        const clientOrderId = this.safeString(order, 2);
+        const average = this.safeString(orderList, 17);
+        const clientOrderId = this.safeString(orderList, 2);
         return this.safeOrder({
-            'info': order,
+            'info': orderList,
             'id': id,
             'clientOrderId': clientOrderId,
             'timestamp': timestamp,
@@ -1777,7 +1783,7 @@ export default class bitfinex2 extends Exchange {
         for (let i = 0; i < data.length; i++) {
             const entry = data[i];
             const individualOrder = entry[4];
-            results.push(individualOrder[0]);
+            results.push({ 'result': individualOrder[0] });
         }
         return this.parseOrders(results);
     }
@@ -1797,7 +1803,11 @@ export default class bitfinex2 extends Exchange {
         };
         const response = await this.privatePostAuthWOrderCancelMulti(this.extend(request, params));
         const orders = this.safeList(response, 4, []);
-        return this.parseOrders(orders);
+        const ordersList = [];
+        for (let i = 0; i < orders.length; i++) {
+            ordersList.push({ 'result': orders[i] });
+        }
+        return this.parseOrders(ordersList);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**
@@ -1831,7 +1841,8 @@ export default class bitfinex2 extends Exchange {
         }
         const response = await this.privatePostAuthWOrderCancel(this.extend(request, params));
         const order = this.safeValue(response, 4);
-        return this.parseOrder(order);
+        const orderObject = { 'result': order };
+        return this.parseOrder(orderObject);
     }
     async cancelOrders(ids, symbol = undefined, params = {}) {
         /**
@@ -1907,7 +1918,11 @@ export default class bitfinex2 extends Exchange {
         //     ]
         //
         const orders = this.safeList(response, 4, []);
-        return this.parseOrders(orders, market);
+        const ordersList = [];
+        for (let i = 0; i < orders.length; i++) {
+            ordersList.push({ 'result': orders[i] });
+        }
+        return this.parseOrders(ordersList, market);
     }
     async fetchOpenOrder(id, symbol = undefined, params = {}) {
         /**
@@ -2016,7 +2031,11 @@ export default class bitfinex2 extends Exchange {
         //          ],
         //      ]
         //
-        return this.parseOrders(response, market, since, limit);
+        const ordersList = [];
+        for (let i = 0; i < response.length; i++) {
+            ordersList.push({ 'result': response[i] });
+        }
+        return this.parseOrders(ordersList, market, since, limit);
     }
     async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -2096,7 +2115,11 @@ export default class bitfinex2 extends Exchange {
         //          ]
         //      ]
         //
-        return this.parseOrders(response, market, since, limit);
+        const ordersList = [];
+        for (let i = 0; i < response.length; i++) {
+            ordersList.push({ 'result': response[i] });
+        }
+        return this.parseOrders(ordersList, market, since, limit);
     }
     async fetchOrderTrades(id, symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -2123,7 +2146,11 @@ export default class bitfinex2 extends Exchange {
         };
         // valid for trades upto 10 days old
         const response = await this.privatePostAuthROrderSymbolIdTrades(this.extend(request, params));
-        return this.parseTrades(response, market, since, limit);
+        const tradesList = [];
+        for (let i = 0; i < response.length; i++) {
+            tradesList.push({ 'result': response[i] }); // convert to array of dicts to match parseOrder signature
+        }
+        return this.parseTrades(tradesList, market, since, limit);
     }
     async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -2158,7 +2185,11 @@ export default class bitfinex2 extends Exchange {
         else {
             response = await this.privatePostAuthRTradesHist(this.extend(request, params));
         }
-        return this.parseTrades(response, market, since, limit);
+        const tradesList = [];
+        for (let i = 0; i < response.length; i++) {
+            tradesList.push({ 'result': response[i] }); // convert to array of dicts to match parseOrder signature
+        }
+        return this.parseTrades(tradesList, market, since, limit);
     }
     async createDepositAddress(code, params = {}) {
         /**
@@ -2704,7 +2735,11 @@ export default class bitfinex2 extends Exchange {
         //         ]
         //     ]
         //
-        return this.parsePositions(response, symbols);
+        const positionsList = [];
+        for (let i = 0; i < response.length; i++) {
+            positionsList.push({ 'result': response[i] });
+        }
+        return this.parsePositions(positionsList, symbols);
     }
     parsePosition(position, market = undefined) {
         //
@@ -2739,22 +2774,23 @@ export default class bitfinex2 extends Exchange {
         //        }
         //    ]
         //
-        const marketId = this.safeString(position, 0);
-        const amount = this.safeString(position, 2);
-        const timestamp = this.safeInteger(position, 12);
-        const meta = this.safeString(position, 19);
+        const positionList = this.safeList(position, 'result');
+        const marketId = this.safeString(positionList, 0);
+        const amount = this.safeString(positionList, 2);
+        const timestamp = this.safeInteger(positionList, 12);
+        const meta = this.safeString(positionList, 19);
         const tradePrice = this.safeString(meta, 'trade_price');
         const tradeAmount = this.safeString(meta, 'trade_amount');
         return this.safePosition({
-            'info': position,
-            'id': this.safeString(position, 11),
+            'info': positionList,
+            'id': this.safeString(positionList, 11),
             'symbol': this.safeSymbol(marketId, market),
             'notional': this.parseNumber(amount),
             'marginMode': 'isolated',
-            'liquidationPrice': this.safeNumber(position, 8),
-            'entryPrice': this.safeNumber(position, 3),
-            'unrealizedPnl': this.safeNumber(position, 6),
-            'percentage': this.safeNumber(position, 7),
+            'liquidationPrice': this.safeNumber(positionList, 8),
+            'entryPrice': this.safeNumber(positionList, 3),
+            'unrealizedPnl': this.safeNumber(positionList, 6),
+            'percentage': this.safeNumber(positionList, 7),
             'contracts': undefined,
             'contractSize': undefined,
             'markPrice': undefined,
@@ -2763,13 +2799,13 @@ export default class bitfinex2 extends Exchange {
             'hedged': undefined,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'lastUpdateTimestamp': this.safeInteger(position, 13),
-            'maintenanceMargin': this.safeNumber(position, 18),
+            'lastUpdateTimestamp': this.safeInteger(positionList, 13),
+            'maintenanceMargin': this.safeNumber(positionList, 18),
             'maintenanceMarginPercentage': undefined,
-            'collateral': this.safeNumber(position, 17),
+            'collateral': this.safeNumber(positionList, 17),
             'initialMargin': this.parseNumber(Precise.stringMul(tradeAmount, tradePrice)),
             'initialMarginPercentage': undefined,
-            'leverage': this.safeNumber(position, 9),
+            'leverage': this.safeNumber(positionList, 9),
             'marginRatio': undefined,
             'stopLossPrice': undefined,
             'takeProfitPrice': undefined,
@@ -2879,14 +2915,15 @@ export default class bitfinex2 extends Exchange {
         //         ]
         //     ]
         //
+        const itemList = this.safeList(item, 'result', []);
         let type = undefined;
-        const id = this.safeString(item, 0);
-        const currencyId = this.safeString(item, 1);
+        const id = this.safeString(itemList, 0);
+        const currencyId = this.safeString(itemList, 1);
         const code = this.safeCurrencyCode(currencyId, currency);
-        const timestamp = this.safeInteger(item, 3);
-        const amount = this.safeNumber(item, 5);
-        const after = this.safeNumber(item, 6);
-        const description = this.safeString(item, 8);
+        const timestamp = this.safeInteger(itemList, 3);
+        const amount = this.safeNumber(itemList, 5);
+        const after = this.safeNumber(itemList, 6);
+        const description = this.safeString(itemList, 8);
         if (description !== undefined) {
             const parts = description.split(' @ ');
             const first = this.safeStringLower(parts, 0);
@@ -2963,7 +3000,12 @@ export default class bitfinex2 extends Exchange {
         //         ]
         //     ]
         //
-        return this.parseLedger(response, currency, since, limit);
+        const ledgerObjects = [];
+        for (let i = 0; i < response.length; i++) {
+            const item = response[i];
+            ledgerObjects.push({ 'result': item });
+        }
+        return this.parseLedger(ledgerObjects, currency, since, limit);
     }
     async fetchFundingRate(symbol, params = {}) {
         /**

package/js/src/bitflyer.d.ts

@@ -14,13 +14,13 @@ export default class bitflyer extends Exchange {
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseTicker(ticker: Dict, market?: Market): Ticker;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    parseTrade(trade: any, market?: Market): Trade;
+    parseTrade(trade: Dict, market?: Market): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchTradingFee(symbol: string, params?: {}): Promise<TradingFeeInterface>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
-    parseOrderStatus(status: any): string;
-    parseOrder(order: any, market?: Market): Order;
+    parseOrderStatus(status: Str): string;
+    parseOrder(order: Dict, market?: Market): Order;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
@@ -32,7 +32,7 @@ export default class bitflyer extends Exchange {
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     parseDepositStatus(status: any): string;
     parseWithdrawalStatus(status: any): string;
-    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: string;
         method: string;

package/js/src/bitget.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bitget.js';
-import type { Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderRequest, FundingHistory, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Market, Strings, Currency, Position, Liquidation, TransferEntry, Leverage, MarginMode, Num, MarginModification, TradingFeeInterface, Currencies, TradingFees, Conversion, CrossBorrowRate, IsolatedBorrowRate, Dict, TransferEntries } from './base/types.js';
+import type { Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderRequest, FundingHistory, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Market, Strings, Currency, Position, Liquidation, TransferEntry, Leverage, MarginMode, Num, MarginModification, TradingFeeInterface, Currencies, TradingFees, Conversion, CrossBorrowRate, IsolatedBorrowRate, Dict, TransferEntries, LeverageTier } from './base/types.js';
 /**
  * @class bitget
  * @augments Exchange
@@ -14,12 +14,12 @@ export default class bitget extends Exchange {
     parseMarket(market: any): Market;
     fetchMarketsByType(type: any, params?: {}): Promise<import("./base/types.js").MarketInterface[]>;
     fetchCurrencies(params?: {}): Promise<Currencies>;
-    fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<any[]>;
-    parseMarketLeverageTiers(info: any, market?: Market): any[];
+    fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<LeverageTier[]>;
+    parseMarketLeverageTiers(info: any, market?: Market): LeverageTier[];
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     parseTransactionStatus(status: any): string;
     fetchDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
@@ -39,7 +39,7 @@ export default class bitget extends Exchange {
     parseTicker(ticker: Dict, market?: Market): Ticker;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    parseTrade(trade: any, market?: Market): Trade;
+    parseTrade(trade: Dict, market?: Market): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchTradingFee(symbol: string, params?: {}): Promise<TradingFeeInterface>;
     fetchTradingFees(params?: {}): Promise<TradingFees>;
@@ -55,8 +55,8 @@ export default class bitget extends Exchange {
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     fetchBalance(params?: {}): Promise<Balances>;
     parseBalance(balance: any): Balances;
-    parseOrderStatus(status: any): string;
-    parseOrder(order: any, market?: Market): Order;
+    parseOrderStatus(status: Str): string;
+    parseOrder(order: Dict, market?: Market): Order;
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     createOrderRequest(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): any;
@@ -71,8 +71,8 @@ export default class bitget extends Exchange {
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchCanceledAndClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseLedgerEntry(item: any, currency?: Currency): {
-        info: any;
+    parseLedgerEntry(item: Dict, currency?: Currency): {
+        info: Dict;
         id: string;
         timestamp: number;
         datetime: string;
@@ -92,7 +92,7 @@ export default class bitget extends Exchange {
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchPosition(symbol: string, params?: {}): Promise<Position>;
     fetchPositions(symbols?: Strings, params?: {}): Promise<Position[]>;
-    parsePosition(position: any, market?: Market): Position;
+    parsePosition(position: Dict, market?: Market): Position;
     fetchFundingRateHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
     fetchFundingRate(symbol: string, params?: {}): Promise<{
         info: any;
@@ -158,18 +158,7 @@ export default class bitget extends Exchange {
     transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;
     parseTransferStatus(status: Str): Str;
-    parseDepositWithdrawFee(fee: any, currency?: Currency): {
-        info: any;
-        withdraw: {
-            fee: any;
-            percentage: any;
-        };
-        deposit: {
-            fee: any;
-            percentage: any;
-        };
-        networks: {};
-    };
+    parseDepositWithdrawFee(fee: any, currency?: Currency): Dict;
     fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<any>;
     borrowCrossMargin(code: string, amount: number, params?: {}): Promise<{
         id: string;
@@ -230,7 +219,7 @@ export default class bitget extends Exchange {
         info: any;
     };
     fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseBorrowInterest(info: any, market?: Market): {
+    parseBorrowInterest(info: Dict, market?: Market): {
         symbol: string;
         marginMode: string;
         currency: string;
@@ -239,12 +228,12 @@ export default class bitget extends Exchange {
         amountBorrowed: any;
         timestamp: number;
         datetime: string;
-        info: any;
+        info: Dict;
     };
     closePosition(symbol: string, side?: OrderSide, params?: {}): Promise<Order>;
     closeAllPositions(params?: {}): Promise<Position[]>;
     fetchMarginMode(symbol: string, params?: {}): Promise<MarginMode>;
-    parseMarginMode(marginMode: any, market?: any): MarginMode;
+    parseMarginMode(marginMode: Dict, market?: any): MarginMode;
     fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     fetchConvertQuote(fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
     createConvertTrade(id: string, fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;

package/js/src/bithumb.d.ts

@@ -17,17 +17,17 @@ export default class bithumb extends Exchange {
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    parseTrade(trade: any, market?: Market): Trade;
+    parseTrade(trade: Dict, market?: Market): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    parseOrderStatus(status: any): string;
-    parseOrder(order: any, market?: Market): Order;
+    parseOrderStatus(status: Str): string;
+    parseOrder(order: Dict, market?: Market): Order;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     cancelUnifiedOrder(order: any, params?: {}): Promise<any>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
-    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     fixCommaNumber(numberStr: any): any;
     nonce(): number;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {

package/js/src/bitmart.d.ts

@@ -20,7 +20,7 @@ export default class bitmart extends Exchange {
     fetchCurrencies(params?: {}): Promise<Currencies>;
     fetchTransactionFee(code: string, params?: {}): Promise<{
         info: any;
-        withdraw: {};
+        withdraw: Dict;
         deposit: {};
     }>;
     parseDepositWithdrawFee(fee: any, currency?: Currency): {
@@ -40,7 +40,7 @@ export default class bitmart extends Exchange {
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    parseTrade(trade: any, market?: Market): Trade;
+    parseTrade(trade: Dict, market?: Market): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
@@ -49,9 +49,9 @@ export default class bitmart extends Exchange {
     customParseBalance(response: any, marketType: any): Balances;
     parseBalanceHelper(entry: any): import("./base/types.js").BalanceAccount;
     fetchBalance(params?: {}): Promise<Balances>;
-    parseTradingFee(fee: any, market?: Market): TradingFeeInterface;
+    parseTradingFee(fee: Dict, market?: Market): TradingFeeInterface;
     fetchTradingFee(symbol: string, params?: {}): Promise<TradingFeeInterface>;
-    parseOrder(order: any, market?: Market): Order;
+    parseOrder(order: Dict, market?: Market): Order;
     parseOrderSide(side: any): string;
     parseOrderStatusByType(type: any, status: any): string;
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
@@ -89,7 +89,7 @@ export default class bitmart extends Exchange {
     fetchWithdrawal(id: string, code?: Str, params?: {}): Promise<Transaction>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     parseTransactionStatus(status: any): string;
-    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     repayIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<any>;
     borrowIsolatedMargin(symbol: string, code: string, amount: number, params?: {}): Promise<any>;
     parseMarginLoan(info: any, currency?: Currency): {
@@ -111,7 +111,7 @@ export default class bitmart extends Exchange {
     parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;
     fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<TransferEntries>;
     fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseBorrowInterest(info: any, market?: Market): {
+    parseBorrowInterest(info: Dict, market?: Market): {
         symbol: string;
         marginMode: string;
         currency: string;
@@ -120,7 +120,7 @@ export default class bitmart extends Exchange {
         amountBorrowed: number;
         timestamp: number;
         datetime: string;
-        info: any;
+        info: Dict;
     };
     fetchOpenInterest(symbol: string, params?: {}): Promise<import("./base/types.js").OpenInterest>;
     parseOpenInterest(interest: any, market?: Market): import("./base/types.js").OpenInterest;
@@ -165,7 +165,7 @@ export default class bitmart extends Exchange {
     };
     fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
     fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
-    parsePosition(position: any, market?: Market): import("./base/types.js").Position;
+    parsePosition(position: Dict, market?: Market): import("./base/types.js").Position;
     fetchMyLiquidations(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Liquidation[]>;
     parseLiquidation(liquidation: any, market?: Market): import("./base/types.js").Liquidation;
     nonce(): number;

package/js/src/bitmart.js

@@ -2730,7 +2730,7 @@ export default class bitmart extends Exchange {
         }
         const data = this.safeValue(response, 'data');
         if (data === true) {
-            return this.parseOrder(id, market);
+            return this.safeOrder({ 'id': id }, market);
         }
         const succeeded = this.safeValue(data, 'succeed');
         if (succeeded !== undefined) {
@@ -2745,8 +2745,8 @@ export default class bitmart extends Exchange {
                 throw new InvalidOrder(this.id + ' cancelOrder() ' + symbol + ' order id ' + id + ' is filled or canceled');
             }
         }
-        const order = this.parseOrder(id, market);
-        return this.extend(order, { 'id': id });
+        const order = this.safeOrder({ 'id': id, 'symbol': market['symbol'], 'info': {} }, market);
+        return order;
     }
     async cancelOrders(ids, symbol = undefined, params = {}) {
         /**

package/js/src/bitmex.d.ts

@@ -23,9 +23,9 @@ export default class bitmex extends Exchange {
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseLedgerEntryType(type: any): string;
-    parseLedgerEntry(item: any, currency?: Currency): {
+    parseLedgerEntry(item: Dict, currency?: Currency): {
         id: string;
-        info: any;
+        info: Dict;
         timestamp: number;
         datetime: string;
         direction: any;
@@ -46,16 +46,16 @@ export default class bitmex extends Exchange {
     fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     fetchDepositsWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     parseTransactionStatus(status: any): string;
-    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     parseTicker(ticker: Dict, market?: Market): Ticker;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    parseTrade(trade: any, market?: Market): Trade;
-    parseOrderStatus(status: any): string;
-    parseTimeInForce(timeInForce: any): string;
-    parseOrder(order: any, market?: Market): Order;
+    parseTrade(trade: Dict, market?: Market): Trade;
+    parseOrderStatus(status: Str): string;
+    parseTimeInForce(timeInForce: Str): string;
+    parseOrder(order: Dict, market?: Market): Order;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
@@ -63,10 +63,10 @@ export default class bitmex extends Exchange {
     cancelOrders(ids: any, symbol?: Str, params?: {}): Promise<Order[]>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     cancelAllOrdersAfter(timeout: Int, params?: {}): Promise<any>;
-    fetchLeverages(symbols?: string[], params?: {}): Promise<Leverages>;
+    fetchLeverages(symbols?: Strings, params?: {}): Promise<Leverages>;
     parseLeverage(leverage: Dict, market?: Market): Leverage;
     fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
-    parsePosition(position: any, market?: Market): import("./base/types.js").Position;
+    parsePosition(position: Dict, market?: Market): import("./base/types.js").Position;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     fetchFundingRates(symbols?: Strings, params?: {}): Promise<any>;
     parseFundingRate(contract: any, market?: Market): {
@@ -105,18 +105,7 @@ export default class bitmex extends Exchange {
         network: any;
         info: any;
     }>;
-    parseDepositWithdrawFee(fee: any, currency?: Currency): {
-        info: any;
-        withdraw: {
-            fee: any;
-            percentage: any;
-        };
-        deposit: {
-            fee: any;
-            percentage: any;
-        };
-        networks: {};
-    };
+    parseDepositWithdrawFee(fee: any, currency?: Currency): Dict;
     fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<any>;
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
     fetchLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;

package/js/src/bitmex.js

@@ -1492,7 +1492,7 @@ export default class bitmex extends Exchange {
         }
         // send JSON key/value pairs, such as {"key": "value"}
         // filter by individual fields and do advanced queries on timestamps
-        // let filter = { 'key': 'value' };
+        // let filter: Dict = { 'key': 'value' };
         // send a bare series (e.g. XBU) to nearest expiring contract in that series
         // you can also send a timeframe, e.g. XBU:monthly
         // timeframes: daily, weekly, monthly, quarterly, and biquarterly