ccxt 4.2.40 → 4.2.42

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

@@ -557,14 +557,14 @@ export default class Exchange {
     countedOrderBook(snapshot?: {}, depth?: number): CountedOrderBook;
     handleMessage(client: any, message: any): void;
     ping(client: any): any;
-    client(url: any): WsClient;
-    watchMultiple(url: any, messageHashes: any, message?: any, subscribeHashes?: any, subscription?: any): import("./ws/Future.js").FutureInterface;
-    watch(url: any, messageHash: any, message?: any, subscribeHash?: any, subscription?: any): any;
+    client(url: string): WsClient;
+    watchMultiple(url: string, messageHashes: string[], message?: any, subscribeHashes?: any, subscription?: any): import("./ws/Future.js").FutureInterface;
+    watch(url: string, messageHash: string, message?: any, subscribeHash?: any, subscription?: any): any;
     onConnected(client: any, message?: any): void;
     onError(client: any, error: any): void;
     onClose(client: any, error: any): void;
     close(): Promise<void>;
-    loadOrderBook(client: any, messageHash: any, symbol: any, limit?: any, params?: {}): Promise<void>;
+    loadOrderBook(client: any, messageHash: string, symbol: string, limit?: Int, params?: {}): Promise<void>;
     convertToBigInt(value: string): bigint;
     stringToCharsArray(value: any): any;
     valueIsDefined(value: any): boolean;
@@ -572,7 +572,7 @@ export default class Exchange {
     getProperty(obj: any, property: any, defaultValue?: any): any;
     setProperty(obj: any, property: any, defaultValue?: any): void;
     axolotl(payload: any, hexKey: any, ed25519: any): string;
-    fixStringifiedJsonMembers(content: any): any;
+    fixStringifiedJsonMembers(content: string): any;
     safeBoolN(dictionaryOrList: any, keys: IndexType[], defaultValue?: boolean): boolean | undefined;
     safeBool2(dictionary: any, key1: IndexType, key2: IndexType, defaultValue?: boolean): boolean | undefined;
     safeBool(dictionary: any, key: IndexType, defaultValue?: boolean): boolean | undefined;
@@ -586,8 +586,8 @@ export default class Exchange {
     handleDelta(bookside: any, delta: any): void;
     getCacheIndex(orderbook: any, deltas: any): number;
     findTimeframe(timeframe: any, timeframes?: any): string;
-    checkProxyUrlSettings(url?: any, method?: any, headers?: any, body?: any): any;
-    checkProxySettings(url?: any, method?: any, headers?: any, body?: any): any[];
+    checkProxyUrlSettings(url?: string, method?: string, headers?: any, body?: any): any;
+    checkProxySettings(url?: string, method?: string, headers?: any, body?: any): any[];
     checkWsProxySettings(): any[];
     checkConflictingProxies(proxyAgentSet: any, proxyUrlSet: any): void;
     findMessageHashes(client: any, element: string): string[];
@@ -718,8 +718,8 @@ export default class Exchange {
     fetchL2OrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
     filterBySymbol(objects: any, symbol?: string): any;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
-    networkCodeToId(networkCode: any, currencyCode?: any): string;
-    networkIdToCode(networkId: any, currencyCode?: any): string;
+    networkCodeToId(networkCode: string, currencyCode?: string): string;
+    networkIdToCode(networkId: string, currencyCode?: string): string;
     handleNetworkCodeAndParams(params: any): any[];
     defaultNetworkCode(currencyCode: string): any;
     selectNetworkCodeFromUnifiedNetworks(currencyCode: any, networkCode: any, indexedNetworkEntries: any): any;
@@ -728,14 +728,14 @@ export default class Exchange {
     safeNumber2(dictionary: object, key1: IndexType, key2: IndexType, d?: any): number;
     parseOrderBook(orderbook: object, symbol: string, timestamp?: Int, bidsKey?: string, asksKey?: string, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): OrderBook;
     parseOHLCVs(ohlcvs: object[], market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
-    parseLeverageTiers(response: any, symbols?: string[], marketIdKey?: any): {};
+    parseLeverageTiers(response: object[], symbols?: string[], marketIdKey?: any): {};
     loadTradingLimits(symbols?: string[], reload?: boolean, params?: {}): Promise<Dictionary<any>>;
     safePosition(position: any): Position;
-    parsePositions(positions: any, symbols?: string[], params?: {}): Position[];
-    parseAccounts(accounts: any, params?: {}): any[];
-    parseTrades(trades: any, market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
-    parseTransactions(transactions: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): Transaction[];
-    parseTransfers(transfers: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
+    parsePositions(positions: any[], symbols?: string[], params?: {}): Position[];
+    parseAccounts(accounts: any[], params?: {}): any[];
+    parseTrades(trades: any[], market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
+    parseTransactions(transactions: any[], currency?: Currency, since?: Int, limit?: Int, params?: {}): Transaction[];
+    parseTransfers(transfers: any[], currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
     parseLedger(data: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
     nonce(): number;
     setHeaders(headers: any): any;
@@ -748,9 +748,9 @@ export default class Exchange {
     loadAccounts(reload?: boolean, params?: {}): Promise<any>;
     buildOHLCVC(trades: Trade[], timeframe?: string, since?: number, limit?: number): OHLCVC[];
     parseTradingViewOHLCV(ohlcvs: any, market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
-    editLimitBuyOrder(id: any, symbol: any, amount: number, price?: number, params?: {}): Promise<Order>;
-    editLimitSellOrder(id: any, symbol: any, amount: number, price?: number, params?: {}): Promise<Order>;
-    editLimitOrder(id: any, symbol: any, side: any, amount: number, price?: number, params?: {}): Promise<Order>;
+    editLimitBuyOrder(id: string, symbol: string, amount: number, price?: number, params?: {}): Promise<Order>;
+    editLimitSellOrder(id: string, symbol: string, amount: number, price?: number, params?: {}): Promise<Order>;
+    editLimitOrder(id: string, symbol: string, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     fetchPermissions(params?: {}): Promise<{}>;
@@ -912,7 +912,7 @@ export default class Exchange {
     fetchPremiumIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleTimeInForce(params?: {}): string;
     convertTypeToAccount(account: any): any;
-    checkRequiredArgument(methodName: any, argument: any, argumentName: any, options?: any[]): void;
+    checkRequiredArgument(methodName: string, argument: any, argumentName: any, options?: any[]): void;
     checkRequiredMarginArgument(methodName: string, symbol: Str, marginMode: string): void;
     parseDepositWithdrawFees(response: any, codes?: string[], currencyIdKey?: any): any;
     parseDepositWithdrawFee(fee: any, currency?: Currency): any;
@@ -934,7 +934,7 @@ export default class Exchange {
     fetchPaginatedCallIncremental(method: string, symbol?: string, since?: any, limit?: any, params?: {}, pageKey?: any, maxEntriesPerRequest?: any): Promise<any>;
     sortCursorPaginatedResult(result: any): any;
     removeRepeatedElementsFromArray(input: any): any;
-    handleUntilOption(key: any, request: any, params: any, multiplier?: number): any[];
+    handleUntilOption(key: string, request: any, params: any, multiplier?: number): any[];
     safeOpenInterest(interest: any, market?: Market): OpenInterest;
     parseLiquidation(liquidation: any, market?: Market): Liquidation;
     parseLiquidations(liquidations: any, market?: any, since?: Int, limit?: Int): Liquidation[];

package/js/src/binance.js

@@ -4340,20 +4340,73 @@ export default class binance extends Exchange {
         //         "time": 1676366446072
         //     }
         //
+        // fetchMyTrades: linear portfolio margin
+        //
+        //     {
+        //         "symbol": "BTCUSDT",
+        //         "id": 4575108247,
+        //         "orderId": 261942655610,
+        //         "side": "SELL",
+        //         "price": "47263.40",
+        //         "qty": "0.010",
+        //         "realizedPnl": "27.38400000",
+        //         "marginAsset": "USDT",
+        //         "quoteQty": "472.63",
+        //         "commission": "0.18905360",
+        //         "commissionAsset": "USDT",
+        //         "time": 1707530039409,
+        //         "buyer": false,
+        //         "maker": false,
+        //         "positionSide": "LONG"
+        //     }
+        //
+        // fetchMyTrades: inverse portfolio margin
+        //
+        //     {
+        //         "symbol": "ETHUSD_PERP",
+        //         "id": 701907838,
+        //         "orderId": 71548909034,
+        //         "pair": "ETHUSD",
+        //         "side": "SELL",
+        //         "price": "2498.15",
+        //         "qty": "1",
+        //         "realizedPnl": "0.00012517",
+        //         "marginAsset": "ETH",
+        //         "baseQty": "0.00400296",
+        //         "commission": "0.00000160",
+        //         "commissionAsset": "ETH",
+        //         "time": 1707530317519,
+        //         "positionSide": "LONG",
+        //         "buyer": false,
+        //         "maker": false
+        //     }
+        //
+        // fetchMyTrades: spot margin portfolio margin
+        //
+        //     {
+        //         "symbol": "ADAUSDT",
+        //         "id": 470227543,
+        //         "orderId": 4421170947,
+        //         "price": "0.53880000",
+        //         "qty": "10.00000000",
+        //         "quoteQty": "5.38800000",
+        //         "commission": "0.00538800",
+        //         "commissionAsset": "USDT",
+        //         "time": 1707545780522,
+        //         "isBuyer": false,
+        //         "isMaker": false,
+        //         "isBestMatch": true
+        //     }
+        //
         const timestamp = this.safeInteger2(trade, 'T', 'time');
-        const price = this.safeString2(trade, 'p', 'price');
         let amount = this.safeString2(trade, 'q', 'qty');
         amount = this.safeString(trade, 'quantity', amount);
-        const cost = this.safeString2(trade, 'quoteQty', 'baseQty'); // inverse futures
         const marketId = this.safeString(trade, 'symbol');
-        const isSpotTrade = ('isIsolated' in trade) || ('M' in trade) || ('orderListId' in trade);
+        const isSpotTrade = ('isIsolated' in trade) || ('M' in trade) || ('orderListId' in trade) || ('isMaker' in trade);
         const marketType = isSpotTrade ? 'spot' : 'contract';
         market = this.safeMarket(marketId, market, undefined, marketType);
         const symbol = market['symbol'];
-        let id = this.safeString2(trade, 't', 'a');
-        id = this.safeString2(trade, 'tradeId', 'id', id);
         let side = undefined;
-        const orderId = this.safeString(trade, 'orderId');
         const buyerMaker = this.safeValue2(trade, 'm', 'isBuyerMaker');
         let takerOrMaker = undefined;
         if (buyerMaker !== undefined) {
@@ -4403,14 +4456,14 @@ export default class binance extends Exchange {
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'symbol': symbol,
-            'id': id,
-            'order': orderId,
+            'id': this.safeStringN(trade, ['t', 'a', 'tradeId', 'id']),
+            'order': this.safeString(trade, 'orderId'),
             'type': this.safeStringLower(trade, 'type'),
             'side': side,
             'takerOrMaker': takerOrMaker,
-            'price': price,
+            'price': this.safeString2(trade, 'p', 'price'),
             'amount': amount,
-            'cost': cost,
+            'cost': this.safeString2(trade, 'quoteQty', 'baseQty'),
             'fee': fee,
         }, market);
     }
@@ -6499,12 +6552,16 @@ export default class binance extends Exchange {
          * @see https://binance-docs.github.io/apidocs/futures/en/#account-trade-list-user_data
          * @see https://binance-docs.github.io/apidocs/delivery/en/#account-trade-list-user_data
          * @see https://binance-docs.github.io/apidocs/spot/en/#query-margin-account-39-s-trade-list-user_data
+         * @see https://binance-docs.github.io/apidocs/pm/en/#margin-account-trade-list-user_data
+         * @see https://binance-docs.github.io/apidocs/pm/en/#um-account-trade-list-user_data
+         * @see https://binance-docs.github.io/apidocs/pm/en/#cm-account-trade-list-user_data
          * @param {string} symbol unified market symbol
          * @param {int} [since] the earliest time in ms to fetch trades for
          * @param {int} [limit] the maximum number of trades structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to fetch trades for a portfolio margin account
          * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
          */
         await this.loadMarkets();
@@ -6558,8 +6615,13 @@ export default class binance extends Exchange {
                 throw new ArgumentsRequired(this.id + ' fetchMyTrades() requires a symbol argument');
             }
             [marginMode, params] = this.handleMarginModeAndParams('fetchMyTrades', params);
+            let isPortfolioMargin = undefined;
+            [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'fetchMyTrades', 'papi', 'portfolioMargin', false);
             if (type === 'spot' || type === 'margin') {
-                if ((type === 'margin') || (marginMode !== undefined)) {
+                if (isPortfolioMargin) {
+                    response = await this.papiGetMarginMyTrades(this.extend(request, params));
+                }
+                else if ((type === 'margin') || (marginMode !== undefined)) {
                     if (marginMode === 'isolated') {
                         request['isIsolated'] = true;
                     }
@@ -6570,10 +6632,20 @@ export default class binance extends Exchange {
                 }
             }
             else if (market['linear']) {
-                response = await this.fapiPrivateGetUserTrades(this.extend(request, params));
+                if (isPortfolioMargin) {
+                    response = await this.papiGetUmUserTrades(this.extend(request, params));
+                }
+                else {
+                    response = await this.fapiPrivateGetUserTrades(this.extend(request, params));
+                }
             }
             else if (market['inverse']) {
-                response = await this.dapiPrivateGetUserTrades(this.extend(request, params));
+                if (isPortfolioMargin) {
+                    response = await this.papiGetCmUserTrades(this.extend(request, params));
+                }
+                else {
+                    response = await this.dapiPrivateGetUserTrades(this.extend(request, params));
+                }
             }
         }
         //
@@ -6641,6 +6713,70 @@ export default class binance extends Exchange {
         //         }
         //     ]
         //
+        // linear portfolio margin
+        //
+        //     [
+        //         {
+        //             "symbol": "BTCUSDT",
+        //             "id": 4575108247,
+        //             "orderId": 261942655610,
+        //             "side": "SELL",
+        //             "price": "47263.40",
+        //             "qty": "0.010",
+        //             "realizedPnl": "27.38400000",
+        //             "marginAsset": "USDT",
+        //             "quoteQty": "472.63",
+        //             "commission": "0.18905360",
+        //             "commissionAsset": "USDT",
+        //             "time": 1707530039409,
+        //             "buyer": false,
+        //             "maker": false,
+        //             "positionSide": "LONG"
+        //         }
+        //     ]
+        //
+        // inverse portfolio margin
+        //
+        //     [
+        //         {
+        //             "symbol": "ETHUSD_PERP",
+        //             "id": 701907838,
+        //             "orderId": 71548909034,
+        //             "pair": "ETHUSD",
+        //             "side": "SELL",
+        //             "price": "2498.15",
+        //             "qty": "1",
+        //             "realizedPnl": "0.00012517",
+        //             "marginAsset": "ETH",
+        //             "baseQty": "0.00400296",
+        //             "commission": "0.00000160",
+        //             "commissionAsset": "ETH",
+        //             "time": 1707530317519,
+        //             "positionSide": "LONG",
+        //             "buyer": false,
+        //             "maker": false
+        //         }
+        //     ]
+        //
+        // spot margin portfolio margin
+        //
+        //     [
+        //         {
+        //             "symbol": "ADAUSDT",
+        //             "id": 470227543,
+        //             "orderId": 4421170947,
+        //             "price": "0.53880000",
+        //             "qty": "10.00000000",
+        //             "quoteQty": "5.38800000",
+        //             "commission": "0.00538800",
+        //             "commissionAsset": "USDT",
+        //             "time": 1707545780522,
+        //             "isBuyer": false,
+        //             "isMaker": false,
+        //             "isBestMatch": true
+        //         }
+        //     ]
+        //
         return this.parseTrades(response, market, since, limit);
     }
     async fetchMyDustTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -10527,15 +10663,19 @@ export default class binance extends Exchange {
          * @name binance#fetchBorrowInterest
          * @description fetch the interest owed by the user for borrowing currency for margin trading
          * @see https://binance-docs.github.io/apidocs/spot/en/#get-interest-history-user_data
-         * @param {string} code unified currency code
-         * @param {string} symbol unified market symbol when fetch interest in isolated markets
+         * @see https://binance-docs.github.io/apidocs/pm/en/#get-margin-borrow-loan-interest-history-user_data
+         * @param {string} [code] unified currency code
+         * @param {string} [symbol] unified market symbol when fetch interest in isolated markets
          * @param {int} [since] the earliest time in ms to fetch borrrow interest for
          * @param {int} [limit] the maximum number of structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.portfolioMargin] set to true if you would like to fetch the borrow interest in a portfolio margin account
          * @returns {object[]} a list of [borrow interest structures]{@link https://docs.ccxt.com/#/?id=borrow-interest-structure}
          */
         await this.loadMarkets();
-        const request = {};
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'fetchBorrowInterest', 'papi', 'portfolioMargin', false);
+        let request = {};
         let market = undefined;
         if (code !== undefined) {
             const currency = this.currency(code);
@@ -10547,11 +10687,20 @@ export default class binance extends Exchange {
         if (limit !== undefined) {
             request['size'] = limit;
         }
-        if (symbol !== undefined) { // Isolated
-            market = this.market(symbol);
-            request['isolatedSymbol'] = market['id'];
+        [request, params] = this.handleUntilOption('endTime', request, params);
+        let response = undefined;
+        if (isPortfolioMargin) {
+            response = await this.papiGetMarginMarginInterestHistory(this.extend(request, params));
+        }
+        else {
+            if (symbol !== undefined) {
+                market = this.market(symbol);
+                request['isolatedSymbol'] = market['id'];
+            }
+            response = await this.sapiGetMarginInterestHistory(this.extend(request, params));
         }
-        const response = await this.sapiGetMarginInterestHistory(this.extend(request, params));
+        //
+        // spot margin
         //
         //     {
         //         "rows":[
@@ -10568,13 +10717,31 @@ export default class binance extends Exchange {
         //         "total": 1
         //     }
         //
+        // spot margin portfolio margin
+        //
+        //     {
+        //         "total": 49,
+        //         "rows": [
+        //             {
+        //                 "txId": 1656187724899910076,
+        //                 "interestAccuredTime": 1707541200000,
+        //                 "asset": "USDT",
+        //                 "rawAsset": "USDT",
+        //                 "principal": "0.00011146",
+        //                 "interest": "0.00000001",
+        //                 "interestRate": "0.00089489",
+        //                 "type": "PERIODIC"
+        //             },
+        //         ]
+        //     }
+        //
         const rows = this.safeList(response, 'rows');
         const interest = this.parseBorrowInterests(rows, market);
         return this.filterByCurrencySinceLimit(interest, code, since, limit);
     }
     parseBorrowInterest(info, market = undefined) {
         const symbol = this.safeString(info, 'isolatedSymbol');
-        const timestamp = this.safeNumber(info, 'interestAccuredTime');
+        const timestamp = this.safeInteger(info, 'interestAccuredTime');
         const marginMode = (symbol === undefined) ? 'cross' : 'isolated';
         return {
             'account': (symbol === undefined) ? 'cross' : symbol,

package/js/src/bingx.d.ts

@@ -73,6 +73,7 @@ export default class bingx extends Exchange {
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     parseOrderSide(side: any): string;
+    parseOrderType(type: any): string;
     parseOrder(order: any, market?: Market): Order;
     parseOrderStatus(status: any): string;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;

package/js/src/bingx.js

@@ -1800,6 +1800,7 @@ export default class bingx extends Exchange {
         if (timeInForce === 'IOC') {
             request['timeInForce'] = 'IOC';
         }
+        const triggerPrice = this.safeString2(params, 'stopPrice', 'triggerPrice');
         if (isSpot) {
             [postOnly, params] = this.handlePostOnly(isMarketOrder, timeInForce === 'POC', params);
             if (postOnly || (timeInForce === 'POC')) {
@@ -1811,7 +1812,7 @@ export default class bingx extends Exchange {
                 request['quoteOrderQty'] = this.parseToNumeric(this.costToPrecision(symbol, cost));
             }
             else {
-                if (market['spot'] && isMarketOrder && (price !== undefined)) {
+                if (isMarketOrder && (price !== undefined)) {
                     // keep the legacy behavior, to avoid  breaking the old spot-market-buying code
                     const calculatedCost = Precise.stringMul(this.numberToString(amount), this.numberToString(price));
                     request['quoteOrderQty'] = this.parseToNumeric(calculatedCost);
@@ -1823,6 +1824,18 @@ export default class bingx extends Exchange {
             if (!isMarketOrder) {
                 request['price'] = this.parseToNumeric(this.priceToPrecision(symbol, price));
             }
+            if (triggerPrice !== undefined) {
+                if (isMarketOrder && this.safeString(request, 'quoteOrderQty') === undefined) {
+                    throw new ArgumentsRequired(this.id + ' createOrder() requires the cost parameter (or the amount + price) for placing spot market-buy trigger orders');
+                }
+                request['stopPrice'] = this.priceToPrecision(symbol, triggerPrice);
+                if (type === 'LIMIT') {
+                    request['type'] = 'TRIGGER_LIMIT';
+                }
+                else if (type === 'MARKET') {
+                    request['type'] = 'TRIGGER_MARKET';
+                }
+            }
         }
         else {
             [postOnly, params] = this.handlePostOnly(isMarketOrder, timeInForce === 'PostOnly', params);
@@ -1835,7 +1848,6 @@ export default class bingx extends Exchange {
             else if (timeInForce === 'FOK') {
                 request['timeInForce'] = 'FOK';
             }
-            const triggerPrice = this.safeString2(params, 'stopPrice', 'triggerPrice');
             const stopLossPrice = this.safeString(params, 'stopLossPrice');
             const takeProfitPrice = this.safeString(params, 'takeProfitPrice');
             const trailingAmount = this.safeString(params, 'trailingAmount');
@@ -2135,6 +2147,13 @@ export default class bingx extends Exchange {
         };
         return this.safeString(sides, side, side);
     }
+    parseOrderType(type) {
+        const types = {
+            'trigger_market': 'market',
+            'trigger_limit': 'limit',
+        };
+        return this.safeString(types, type, type);
+    }
     parseOrder(order, market = undefined) {
         //
         // spot
@@ -2399,7 +2418,7 @@ export default class bingx extends Exchange {
             'datetime': this.iso8601(timestamp),
             'lastTradeTimestamp': lastTradeTimestamp,
             'lastUpdateTimestamp': this.safeInteger(order, 'updateTime'),
-            'type': this.safeStringLower2(order, 'type', 'o'),
+            'type': this.parseOrderType(this.safeStringLower2(order, 'type', 'o')),
             'timeInForce': this.safeString(order, 'timeInForce'),
             'postOnly': undefined,
             'side': this.parseOrderSide(side),

package/js/src/bitforex.js

@@ -645,8 +645,8 @@ export default class bitforex extends Exchange {
     }
     parseOrder(order, market = undefined) {
         const id = this.safeString(order, 'orderId');
-        const timestamp = this.safeNumber(order, 'createTime');
-        const lastTradeTimestamp = this.safeNumber(order, 'lastTime');
+        const timestamp = this.safeInteger(order, 'createTime');
+        const lastTradeTimestamp = this.safeInteger(order, 'lastTime');
         const symbol = market['symbol'];
         const sideId = this.safeInteger(order, 'tradeType');
         const side = this.parseSide(sideId);

package/js/src/bitget.d.ts

@@ -25,14 +25,14 @@ export default class bitget extends Exchange {
         currency: string;
         address: string;
         tag: string;
-        network: string;
+        network: any;
         info: any;
     }>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         currency: string;
         address: string;
         tag: string;
-        network: string;
+        network: any;
         info: any;
     };
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;

package/js/src/bitget.js

@@ -2421,7 +2421,10 @@ export default class bitget extends Exchange {
         await this.loadMarkets();
         const networkCode = this.safeString2(params, 'chain', 'network');
         params = this.omit(params, 'network');
-        const networkId = this.networkCodeToId(networkCode, code);
+        let networkId = undefined;
+        if (networkCode !== undefined) {
+            networkId = this.networkCodeToId(networkCode, code);
+        }
         const currency = this.currency(code);
         const request = {
             'coin': currency['code'],
@@ -2460,11 +2463,15 @@ export default class bitget extends Exchange {
         const currencyId = this.safeString(depositAddress, 'coin');
         const networkId = this.safeString(depositAddress, 'chain');
         const parsedCurrency = this.safeCurrencyCode(currencyId, currency);
+        let network = undefined;
+        if (networkId !== undefined) {
+            network = this.networkIdToCode(networkId, parsedCurrency);
+        }
         return {
             'currency': parsedCurrency,
             'address': this.safeString(depositAddress, 'address'),
             'tag': this.safeString(depositAddress, 'tag'),
-            'network': this.networkIdToCode(networkId, parsedCurrency),
+            'network': network,
             'info': depositAddress,
         };
     }

package/js/src/bitrue.js

@@ -2780,28 +2780,20 @@ export default class bitrue extends Exchange {
         this.checkAddress(address);
         await this.loadMarkets();
         const currency = this.currency(code);
-        let chainName = this.safeString2(params, 'network', 'chainName');
-        if (chainName === undefined) {
-            const networks = this.safeValue(currency, 'networks', {});
-            const optionsNetworks = this.safeValue(this.options, 'networks', {});
-            let network = this.safeStringUpper(params, 'network'); // this line allows the user to specify either ERC20 or ETH
-            network = this.safeString(optionsNetworks, network, network);
-            const networkEntry = this.safeValue(networks, network, {});
-            chainName = this.safeString(networkEntry, 'id'); // handle ERC20>ETH alias
-            if (chainName === undefined) {
-                throw new ArgumentsRequired(this.id + ' withdraw() requires a network parameter or a chainName parameter');
-            }
-            params = this.omit(params, 'network');
-        }
         const request = {
-            'coin': currency['id'].toUpperCase(),
+            'coin': currency['id'],
             'amount': amount,
             'addressTo': address,
-            'chainName': chainName, // 'ERC20', 'TRC20', 'SOL'
+            // 'chainName': chainName, // 'ERC20', 'TRC20', 'SOL'
             // 'addressMark': '', // mark of address
             // 'addrType': '', // type of address
             // 'tag': tag,
         };
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        if (networkCode !== undefined) {
+            request['chainName'] = this.networkCodeToId(networkCode);
+        }
         if (tag !== undefined) {
             request['tag'] = tag;
         }

package/js/src/currencycom.js

@@ -1939,7 +1939,7 @@ export default class currencycom extends Exchange {
         //
         market = this.safeMarket(this.safeString(position, 'symbol'), market);
         const symbol = market['symbol'];
-        const timestamp = this.safeNumber(position, 'createdTimestamp');
+        const timestamp = this.safeInteger(position, 'createdTimestamp');
         const quantityRaw = this.safeString(position, 'openQuantity');
         const side = Precise.stringGt(quantityRaw, '0') ? 'long' : 'short';
         const quantity = Precise.stringAbs(quantityRaw);

package/js/src/digifinex.js

@@ -415,7 +415,10 @@ export default class digifinex extends Exchange {
             const minFoundPrecision = Precise.stringMin(feeString, Precise.stringMin(minDepositString, minWithdrawString));
             const precision = this.parseNumber(minFoundPrecision);
             const networkId = this.safeString(currency, 'chain');
-            const networkCode = this.networkIdToCode(networkId);
+            let networkCode = undefined;
+            if (networkId !== undefined) {
+                networkCode = this.networkIdToCode(networkId);
+            }
             const network = {
                 'info': currency,
                 'id': networkId,

package/js/src/gate.js

@@ -1590,7 +1590,10 @@ export default class gate extends Exchange {
             const currency = parts[0];
             const code = this.safeCurrencyCode(currency);
             const networkId = this.safeString(entry, 'chain');
-            const networkCode = this.networkIdToCode(networkId, code);
+            let networkCode = undefined;
+            if (networkId !== undefined) {
+                networkCode = this.networkIdToCode(networkId, code);
+            }
             const delisted = this.safeValue(entry, 'delisted');
             const withdrawDisabled = this.safeBool(entry, 'withdraw_disabled', false);
             const depositDisabled = this.safeBool(entry, 'deposit_disabled', false);

package/js/src/gemini.js

@@ -346,7 +346,10 @@ export default class gemini extends Exchange {
             const precision = this.parseNumber(this.parsePrecision(this.safeString(currency, 5)));
             const networks = {};
             const networkId = this.safeString(currency, 9);
-            const networkCode = this.networkIdToCode(networkId);
+            let networkCode = undefined;
+            if (networkId !== undefined) {
+                networkCode = this.networkIdToCode(networkId);
+            }
             if (networkCode !== undefined) {
                 networks[networkCode] = {
                     'info': currency,

package/js/src/htx.js

@@ -7091,7 +7091,7 @@ export default class htx extends Exchange {
         const marginMode = (marketId === undefined) ? 'cross' : 'isolated';
         market = this.safeMarket(marketId);
         const symbol = this.safeString(market, 'symbol');
-        const timestamp = this.safeNumber(info, 'accrued-at');
+        const timestamp = this.safeInteger(info, 'accrued-at');
         return {
             'account': (marginMode === 'isolated') ? symbol : 'cross',
             'symbol': symbol,