ccxt 4.1.29 → 4.1.31

package/js/src/bitget.js

@@ -28,7 +28,7 @@ export default class bitget extends Exchange {
             'has': {
                 'CORS': undefined,
                 'spot': true,
-                'margin': undefined,
+                'margin': true,
                 'swap': true,
                 'future': true,
                 'option': false,
@@ -1306,11 +1306,16 @@ export default class bitget extends Exchange {
         };
     }
     async fetchMarketsByType(type, params = {}) {
-        const method = this.getSupportedMapping(type, {
-            'spot': 'publicSpotGetPublicProducts',
-            'swap': 'publicMixGetMarketContracts',
-        });
-        const response = await this[method](params);
+        let response = undefined;
+        if (type === 'spot') {
+            response = await this.publicSpotGetPublicProducts(params);
+        }
+        else if (type === 'swap') {
+            response = await this.publicMixGetMarketContracts(params);
+        }
+        else {
+            throw new NotSupported(this.id + ' does not support ' + type + ' market');
+        }
         //
         // spot
         //
@@ -1495,20 +1500,47 @@ export default class bitget extends Exchange {
          * @name bitget#fetchMarketLeverageTiers
          * @description retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes for a single market
          * @see https://bitgetlimited.github.io/apidoc/en/mix/#get-position-tier
+         * @see https://bitgetlimited.github.io/apidoc/en/margin/#get-isolated-tier-data
+         * @see https://bitgetlimited.github.io/apidoc/en/margin/#get-cross-tier-data
          * @param {string} symbol unified market symbol
          * @param {object} [params] extra parameters specific to the bitget api endpoint
+         * @param {string} [params.marginMode] for spot margin 'cross' or 'isolated', default is 'isolated'
+         * @param {string} [params.code] required for cross spot margin
          * @returns {object} a [leverage tiers structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#leverage-tiers-structure}
          */
         await this.loadMarkets();
         const request = {};
-        let market = undefined;
-        market = this.market(symbol);
-        if (market['spot']) {
+        const market = this.market(symbol);
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchMarketLeverageTiers', market, params);
+        let response = undefined;
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchMarketLeverageTiers', params, 'isolated');
+        if ((type === 'swap') || (type === 'future')) {
+            const marketId = market['id'];
+            const parts = marketId.split('_');
+            const productType = this.safeStringUpper(parts, 1);
+            request['symbol'] = marketId;
+            request['productType'] = productType;
+            response = await this.publicMixGetMarketQueryPositionLever(this.extend(request, params));
+        }
+        else if (marginMode === 'isolated') {
+            request['symbol'] = market['info']['symbolName'];
+            response = await this.publicMarginGetIsolatedPublicTierData(this.extend(request, params));
+        }
+        else if (marginMode === 'cross') {
+            const code = this.safeString(params, 'code');
+            this.checkRequiredArgument('fetchMarketLeverageTiers', code, 'code');
+            params = this.omit(params, 'code');
+            const currency = this.currency(code);
+            request['coin'] = currency['code'];
+            response = await this.publicMarginGetCrossPublicTierData(this.extend(request, params));
+        }
+        else {
             throw new BadRequest(this.id + ' fetchMarketLeverageTiers() symbol does not support market ' + symbol);
         }
-        request['symbol'] = market['id'];
-        request['productType'] = 'UMCBL';
-        const response = await this.publicMixGetMarketQueryPositionLever(this.extend(request, params));
+        //
+        // swap and future
         //
         //     {
         //         "code":"00000",
@@ -1525,10 +1557,50 @@ export default class bitget extends Exchange {
         //         "requestTime":1627292076687
         //     }
         //
-        const result = this.safeValue(response, 'data');
+        // isolated
+        //
+        //     {
+        //         "code": "00000",
+        //         "msg": "success",
+        //         "requestTime": 1698352496622,
+        //         "data": [
+        //             {
+        //                 "tier": "1",
+        //                 "symbol": "BTCUSDT",
+        //                 "leverage": "10",
+        //                 "baseCoin": "BTC",
+        //                 "quoteCoin": "USDT",
+        //                 "baseMaxBorrowableAmount": "3",
+        //                 "quoteMaxBorrowableAmount": "30000",
+        //                 "maintainMarginRate": "0.05",
+        //                 "initRate": "0.1111"
+        //             },
+        //         ]
+        //     }
+        //
+        // cross
+        //
+        //     {
+        //         "code": "00000",
+        //         "msg": "success",
+        //         "requestTime": 1698352997077,
+        //         "data": [
+        //             {
+        //                 "tier": "1",
+        //                 "leverage": "3",
+        //                 "coin": "BTC",
+        //                 "maxBorrowableAmount": "26",
+        //                 "maintainMarginRate": "0.1"
+        //             }
+        //         ]
+        //     }
+        //
+        const result = this.safeValue(response, 'data', []);
         return this.parseMarketLeverageTiers(result, market);
     }
     parseMarketLeverageTiers(info, market = undefined) {
+        //
+        // swap and future
         //
         //     [
         //         {
@@ -1538,22 +1610,57 @@ export default class bitget extends Exchange {
         //             "leverage": 125,
         //             "keepMarginRate": "0.004"
         //         }
-        //     ],
+        //     ]
+        //
+        // isolated
+        //
+        //     [
+        //         {
+        //             "tier": "1",
+        //             "symbol": "BTCUSDT",
+        //             "leverage": "10",
+        //             "baseCoin": "BTC",
+        //             "quoteCoin": "USDT",
+        //             "baseMaxBorrowableAmount": "3",
+        //             "quoteMaxBorrowableAmount": "30000",
+        //             "maintainMarginRate": "0.05",
+        //             "initRate": "0.1111"
+        //         }
+        //     ]
+        //
+        // cross
+        //
+        //     [
+        //         {
+        //             "tier": "1",
+        //             "leverage": "3",
+        //             "coin": "BTC",
+        //             "maxBorrowableAmount": "26",
+        //             "maintainMarginRate": "0.1"
+        //         }
+        //     ]
         //
         const tiers = [];
+        let minNotional = 0;
         for (let i = 0; i < info.length; i++) {
             const item = info[i];
-            const minNotional = this.safeNumber(item, 'startUnit');
-            const maxNotional = this.safeNumber(item, 'endUnit');
+            const minimumNotional = this.safeNumber(item, 'startUnit');
+            if (minimumNotional !== undefined) {
+                minNotional = minimumNotional;
+            }
+            const maxNotional = this.safeNumberN(item, ['endUnit', 'maxBorrowableAmount', 'baseMaxBorrowableAmount']);
+            const marginCurrency = this.safeString2(item, 'coin', 'baseCoin');
+            const currencyId = (marginCurrency !== undefined) ? marginCurrency : market['base'];
             tiers.push({
-                'tier': this.sum(i, 1),
-                'currency': market['base'],
+                'tier': this.safeInteger2(item, 'level', 'tier'),
+                'currency': this.safeCurrencyCode(currencyId),
                 'minNotional': minNotional,
                 'maxNotional': maxNotional,
-                'maintenanceMarginRate': this.safeNumber(item, 'keepMarginRate'),
+                'maintenanceMarginRate': this.safeNumber2(item, 'keepMarginRate', 'maintainMarginRate'),
                 'maxLeverage': this.safeNumber(item, 'leverage'),
                 'info': item,
             });
+            minNotional = maxNotional;
         }
         return tiers;
     }
@@ -3335,12 +3442,16 @@ export default class bitget extends Exchange {
          * @description create a list of trade orders (all orders should be of the same symbol)
          * @see https://bitgetlimited.github.io/apidoc/en/spot/#batch-order
          * @see https://bitgetlimited.github.io/apidoc/en/mix/#batch-order
+         * @see https://bitgetlimited.github.io/apidoc/en/margin/#isolated-batch-order
+         * @see https://bitgetlimited.github.io/apidoc/en/margin/#cross-batch-order
          * @param {array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+         * @param {object} [params] extra parameters specific to the api endpoint
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
         const ordersRequests = [];
         let symbol = undefined;
+        let marginMode = undefined;
         for (let i = 0; i < orders.length; i++) {
             const rawOrder = orders[i];
             const marketId = this.safeString(rawOrder, 'symbol');
@@ -3357,23 +3468,44 @@ export default class bitget extends Exchange {
             const amount = this.safeValue(rawOrder, 'amount');
             const price = this.safeValue(rawOrder, 'price');
             const orderParams = this.safeValue(rawOrder, 'params', {});
+            const marginResult = this.handleMarginModeAndParams('createOrders', params);
+            const currentMarginMode = marginResult[0];
+            if (currentMarginMode !== undefined) {
+                if (marginMode === undefined) {
+                    marginMode = currentMarginMode;
+                }
+                else {
+                    if (marginMode !== currentMarginMode) {
+                        throw new BadRequest(this.id + ' createOrders() requires all orders to have the same margin mode (isolated or cross)');
+                    }
+                }
+            }
             const orderRequest = this.createOrderRequest(marketId, type, side, amount, price, orderParams);
             ordersRequests.push(orderRequest);
         }
         const market = this.market(symbol);
+        const symbolRequest = (marginMode !== undefined) ? (market['info']['symbolName']) : (market['id']);
         const request = {
-            'symbol': market['id'],
+            'symbol': symbolRequest,
         };
         let response = undefined;
         if (market['spot']) {
             request['orderList'] = ordersRequests;
-            response = await this.privateSpotPostTradeBatchOrders(request);
         }
-        else {
+        if ((market['swap']) || (market['future'])) {
             request['orderDataList'] = ordersRequests;
             request['marginCoin'] = market['settleId'];
             response = await this.privateMixPostOrderBatchOrders(request);
         }
+        else if (marginMode === 'isolated') {
+            response = await this.privateMarginPostIsolatedOrderBatchPlaceOrder(request);
+        }
+        else if (marginMode === 'cross') {
+            response = await this.privateMarginPostCrossOrderBatchPlaceOrder(request);
+        }
+        else {
+            response = await this.privateSpotPostTradeBatchOrders(request);
+        }
         //
         // {
         //     "code": "00000",
@@ -3441,11 +3573,6 @@ export default class bitget extends Exchange {
         if (!isStopOrder && !isTriggerOrder) {
             throw new InvalidOrder(this.id + ' editOrder() only support plan orders');
         }
-        let method = this.getSupportedMapping(marketType, {
-            'spot': 'privateSpotPostPlanModifyPlan',
-            'swap': 'privateMixPostPlanModifyPlan',
-            'future': 'privateMixPostPlanModifyPlan',
-        });
         if (triggerPrice !== undefined) {
             // default triggerType to market price for unification
             const triggerType = this.safeString(params, 'triggerType', 'market_price');
@@ -3453,6 +3580,8 @@ export default class bitget extends Exchange {
             request['triggerPrice'] = this.priceToPrecision(symbol, triggerPrice);
             request['executePrice'] = this.priceToPrecision(symbol, price);
         }
+        const omitted = this.omit(query, ['stopPrice', 'triggerType', 'stopLossPrice', 'takeProfitPrice']);
+        let response = undefined;
         if (marketType === 'spot') {
             if (isStopOrder) {
                 throw new InvalidOrder(this.id + ' editOrder() does not support stop orders on spot markets, only swap markets');
@@ -3472,10 +3601,15 @@ export default class bitget extends Exchange {
             else {
                 request['size'] = this.amountToPrecision(symbol, amount);
             }
+            response = await this.privateSpotPostPlanModifyPlan(this.extend(request, omitted));
         }
         else {
             request['symbol'] = market['id'];
             request['size'] = this.amountToPrecision(symbol, amount);
+            if ((marketType !== 'swap') && (marketType !== 'future')) {
+                throw new NotSupported(this.id + ' editOrder() does not support ' + marketType + ' market');
+            }
+            request['marginCoin'] = market['settleId'];
             if (isStopOrder) {
                 if (!isMarketOrder) {
                     throw new ExchangeError(this.id + ' editOrder() bitget stopLoss or takeProfit orders must be market orders');
@@ -3488,12 +3622,12 @@ export default class bitget extends Exchange {
                     request['triggerPrice'] = this.priceToPrecision(symbol, takeProfitPrice);
                     request['planType'] = 'profit_plan';
                 }
-                method = 'privateMixPostPlanModifyTPSLPlan';
+                response = await this.privateMixPostPlanModifyTPSLPlan(this.extend(request, omitted));
+            }
+            else {
+                response = await this.privateMixPostPlanModifyPlan(this.extend(request, omitted));
             }
-            request['marginCoin'] = market['settleId'];
         }
-        const omitted = this.omit(query, ['stopPrice', 'triggerType', 'stopLossPrice', 'takeProfitPrice']);
-        const response = await this[method](this.extend(request, omitted));
         //
         // spot
         //     {
@@ -3823,16 +3957,20 @@ export default class bitget extends Exchange {
         await this.loadMarkets();
         const market = this.market(symbol);
         const [marketType, query] = this.handleMarketTypeAndParams('fetchOrder', market, params);
-        const method = this.getSupportedMapping(marketType, {
-            'spot': 'privateSpotPostTradeOrderInfo',
-            'swap': 'privateMixGetOrderDetail',
-            'future': 'privateMixGetOrderDetail',
-        });
         const request = {
             'symbol': market['id'],
             'orderId': id,
         };
-        let response = await this[method](this.extend(request, query));
+        let response = undefined;
+        if (marketType === 'spot') {
+            response = await this.privateSpotPostTradeOrderInfo(this.extend(request, query));
+        }
+        else if ((marketType === 'swap') || (marketType === 'future')) {
+            response = await this.privateMixGetOrderDetail(this.extend(request, query));
+        }
+        else {
+            throw new NotSupported(this.id + ' fetchOrder() does not support ' + marketType + ' market');
+        }
         // spot
         //     {
         //       code: '00000',
@@ -4758,16 +4896,20 @@ export default class bitget extends Exchange {
         await this.loadMarkets();
         const market = this.market(symbol);
         const [marketType, query] = this.handleMarketTypeAndParams('fetchOrderTrades', market, params);
-        const method = this.getSupportedMapping(marketType, {
-            'spot': 'privateSpotPostTradeFills',
-            'swap': 'privateMixGetOrderFills',
-            'future': 'privateMixGetOrderFills',
-        });
         const request = {
             'symbol': market['id'],
             'orderId': id,
         };
-        const response = await this[method](this.extend(request, query));
+        let response = undefined;
+        if (marketType === 'spot') {
+            response = await this.privateSpotPostTradeFills(this.extend(request, query));
+        }
+        else if ((marketType === 'swap') || (marketType === 'future')) {
+            response = await this.privateMixGetOrderFills(this.extend(request, query));
+        }
+        else {
+            throw new NotSupported(this.id + ' fetchOrderTrades() does not support ' + marketType + ' market');
+        }
         // spot
         //
         // swap
@@ -5231,7 +5373,7 @@ export default class bitget extends Exchange {
             'previousFundingDatetime': undefined,
         };
     }
-    async fetchFundingHistory(symbol, since = undefined, limit = undefined, params = {}) {
+    async fetchFundingHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
          * @name bitget#fetchFundingHistory
@@ -5244,6 +5386,7 @@ export default class bitget extends Exchange {
          * @returns {object[]} a list of [funding history structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#funding-history-structure}
          */
         await this.loadMarkets();
+        this.checkRequiredSymbol('fetchFundingHistory', symbol);
         const market = this.market(symbol);
         if (!market['swap']) {
             throw new BadSymbol(this.id + ' fetchFundingHistory() supports swap contracts only');

package/js/src/bitopro.js

@@ -1124,14 +1124,15 @@ export default class bitopro extends Exchange {
         const request = {
         // 'pair': market['id'], // optional
         };
-        // privateDeleteOrdersAll or privateDeleteOrdersPair
-        let method = this.safeString(this.options, 'privateDeleteOrdersPair', 'privateDeleteOrdersAll');
+        let response = undefined;
         if (symbol !== undefined) {
             const market = this.market(symbol);
             request['pair'] = market['id'];
-            method = 'privateDeleteOrdersPair';
+            response = await this.privateDeleteOrdersPair(this.extend(request, params));
+        }
+        else {
+            response = await this.privateDeleteOrdersAll(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         const result = this.safeValue(response, 'data', {});
         //
         //     {

package/js/src/bitrue.js

@@ -799,6 +799,16 @@ export default class bitrue extends Exchange {
         return orderbook;
     }
     parseTicker(ticker, market = undefined) {
+        //
+        // fetchBidsAsks
+        //
+        //     {
+        //         "symbol": "LTCBTC",
+        //         "bidPrice": "4.00000000",
+        //         "bidQty": "431.00000000",
+        //         "askPrice": "4.00000200",
+        //         "askQty": "9.00000000"
+        //     }
         //
         // fetchTicker
         //
@@ -823,10 +833,10 @@ export default class bitrue extends Exchange {
             'datetime': undefined,
             'high': this.safeString(ticker, 'high24hr'),
             'low': this.safeString(ticker, 'low24hr'),
-            'bid': this.safeString(ticker, 'highestBid'),
-            'bidVolume': undefined,
-            'ask': this.safeString(ticker, 'lowestAsk'),
-            'askVolume': undefined,
+            'bid': this.safeString2(ticker, 'highestBid', 'bidPrice'),
+            'bidVolume': this.safeString(ticker, 'bidQty'),
+            'ask': this.safeString2(ticker, 'lowestAsk', 'askPrice'),
+            'askVolume': this.safeString(ticker, 'askQty'),
             'vwap': undefined,
             'open': undefined,
             'close': last,
@@ -954,26 +964,31 @@ export default class bitrue extends Exchange {
          * @method
          * @name bitrue#fetchBidsAsks
          * @description fetches the bid and ask price and volume for multiple markets
+         * @see https://github.com/Bitrue-exchange/Spot-official-api-docs#symbol-order-book-ticker
          * @param {string[]|undefined} symbols unified symbols of the markets to fetch the bids and asks for, all markets are returned if not assigned
          * @param {object} [params] extra parameters specific to the bitrue api endpoint
          * @returns {object} a dictionary of [ticker structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure}
          */
         await this.loadMarkets();
-        const defaultType = this.safeString2(this.options, 'fetchBidsAsks', 'defaultType', 'spot');
-        const type = this.safeString(params, 'type', defaultType);
-        const query = this.omit(params, 'type');
-        let method = undefined;
-        if (type === 'future') {
-            method = 'fapiPublicGetTickerBookTicker';
-        }
-        else if (type === 'delivery') {
-            method = 'dapiPublicGetTickerBookTicker';
-        }
-        else {
-            method = 'publicGetTickerBookTicker';
+        symbols = this.marketSymbols(symbols);
+        let market = undefined;
+        const request = {};
+        if (symbols !== undefined) {
+            const first = this.safeString(symbols, 0);
+            market = this.market(first);
+            request['symbol'] = market['id'];
         }
-        const response = await this[method](query);
-        return this.parseTickers(response, symbols);
+        const response = await this.v1PublicGetTickerBookTicker(this.extend(request, params));
+        //     {
+        //         "symbol": "LTCBTC",
+        //         "bidPrice": "4.00000000",
+        //         "bidQty": "431.00000000",
+        //         "askPrice": "4.00000200",
+        //         "askQty": "9.00000000"
+        //     }
+        const data = {};
+        data[market['id']] = response;
+        return this.parseTickers(data, symbols);
     }
     async fetchTickers(symbols = undefined, params = {}) {
         /**

package/js/src/bitvavo.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bitvavo.js';
-import { Int, OrderSide, OrderType } from './base/types.js';
+import { Int, OHLCV, Order, OrderSide, OrderType, Trade } from './base/types.js';
 /**
  * @class bitvavo
  * @extends Exchange
@@ -15,12 +15,12 @@ export default class bitvavo extends Exchange {
     fetchTicker(symbol: string, params?: {}): Promise<import("./base/types.js").Ticker>;
     parseTicker(ticker: any, market?: any): import("./base/types.js").Ticker;
     fetchTickers(symbols?: string[], params?: {}): Promise<import("./base/types.js").Dictionary<import("./base/types.js").Ticker>>;
-    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Trade[]>;
-    parseTrade(trade: any, market?: any): import("./base/types.js").Trade;
+    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    parseTrade(trade: any, market?: any): Trade;
     fetchTradingFees(params?: {}): Promise<{}>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<import("./base/types.js").OrderBook>;
     parseOHLCV(ohlcv: any, market?: any): number[];
-    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").OHLCV[]>;
+    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     parseBalance(response: any): import("./base/types.js").Balances;
     fetchBalance(params?: {}): Promise<import("./base/types.js").Balances>;
     fetchDepositAddress(code: string, params?: {}): Promise<{
@@ -30,16 +30,16 @@ export default class bitvavo extends Exchange {
         network: any;
         info: any;
     }>;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;
-    editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;
-    cancelOrder(id: string, symbol?: string, params?: {}): Promise<import("./base/types.js").Order>;
-    cancelAllOrders(symbol?: string, params?: {}): Promise<import("./base/types.js").Order[]>;
-    fetchOrder(id: string, symbol?: string, params?: {}): Promise<import("./base/types.js").Order>;
-    fetchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Order[]>;
-    fetchOpenOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Order[]>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    cancelOrder(id: string, symbol?: string, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: string, params?: {}): Promise<Order[]>;
+    fetchOrder(id: string, symbol?: string, params?: {}): Promise<Order>;
+    fetchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOpenOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseOrderStatus(status: any): string;
-    parseOrder(order: any, market?: any): import("./base/types.js").Order;
-    fetchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Trade[]>;
+    parseOrder(order: any, market?: any): Order;
+    fetchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     withdraw(code: string, amount: any, address: any, tag?: any, params?: {}): Promise<{
         info: any;
         id: any;