ccxt 4.3.42 → 4.3.44

package/js/src/wazirx.d.ts

@@ -28,7 +28,7 @@ export default class wazirx extends Exchange {
     fetchBalance(params?: {}): Promise<Balances>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
     parseOrder(order: Dict, market?: Market): Order;

package/js/src/wazirx.js

@@ -795,7 +795,26 @@ export default class wazirx extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        return await this.privateDeleteOpenOrders(this.extend(request, params));
+        const response = await this.privateDeleteOpenOrders(this.extend(request, params));
+        //
+        //    [
+        //        {
+        //            id: "4565421197",
+        //            symbol: "adausdt",
+        //            type: "limit",
+        //            side: "buy",
+        //            status: "wait",
+        //            price: "0.41",
+        //            origQty: "11.00",
+        //            executedQty: "0.00",
+        //            avgPrice: "0.00",
+        //            createdTime: "1718089507000",
+        //            updatedTime: "1718089507000",
+        //            clientOrderId: "93d2a838-e272-405d-91e7-3a7bc6d3a003"
+        //        }
+        //    ]
+        //
+        return this.parseOrders(response);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**
@@ -871,18 +890,22 @@ export default class wazirx extends Exchange {
         return this.parseOrder(response, market);
     }
     parseOrder(order, market = undefined) {
-        // {
-        //     "id":1949417813,
-        //     "symbol":"ltcusdt",
-        //     "type":"limit",
-        //     "side":"sell",
-        //     "status":"done",
-        //     "price":"146.2",
-        //     "origQty":"0.05",
-        //     "executedQty":"0.05",
-        //     "createdTime":1641252564000,
-        //     "updatedTime":1641252564000
-        // },
+        //
+        //    {
+        //        "id": 1949417813,
+        //        "symbol": "ltcusdt",
+        //        "type": "limit",
+        //        "side": "sell",
+        //        "status": "done",
+        //        "price": "146.2",
+        //        "origQty": "0.05",
+        //        "executedQty": "0.05",
+        //        "avgPrice":  "0.00",
+        //        "createdTime": 1641252564000,
+        //        "updatedTime": 1641252564000
+        //        "clientOrderId": "93d2a838-e272-405d-91e7-3a7bc6d3a003"
+        //    }
+        //
         const created = this.safeInteger(order, 'createdTime');
         const updated = this.safeInteger(order, 'updatedTime');
         const marketId = this.safeString(order, 'symbol');
@@ -897,7 +920,7 @@ export default class wazirx extends Exchange {
         return this.safeOrder({
             'info': order,
             'id': id,
-            'clientOrderId': undefined,
+            'clientOrderId': this.safeString(order, 'clientOrderId'),
             'timestamp': created,
             'datetime': this.iso8601(created),
             'lastTradeTimestamp': updated,
@@ -913,7 +936,7 @@ export default class wazirx extends Exchange {
             'remaining': undefined,
             'cost': undefined,
             'fee': undefined,
-            'average': undefined,
+            'average': this.safeString(order, 'avgPrice'),
             'trades': [],
         }, market);
     }

package/js/src/xt.d.ts

@@ -0,0 +1,161 @@
+import Exchange from './abstract/xt.js';
+import { Currencies, Currency, Dict, FundingHistory, FundingRateHistory, Int, LeverageTier, MarginModification, Market, Num, OHLCV, Order, OrderSide, OrderType, Str, Tickers, Transaction, TransferEntry } from './base/types.js';
+export default class xt extends Exchange {
+    describe(): any;
+    nonce(): number;
+    fetchTime(params?: {}): Promise<number>;
+    fetchCurrencies(params?: {}): Promise<Currencies>;
+    fetchMarkets(params?: {}): Promise<Market[]>;
+    fetchSpotMarkets(params?: {}): Promise<any[]>;
+    fetchSwapAndFutureMarkets(params?: {}): Promise<any[]>;
+    parseMarkets(markets: any): any[];
+    parseMarket(market: Dict): Market;
+    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    parseOHLCV(ohlcv: any, market?: Market): OHLCV;
+    fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<import("./base/types.js").OrderBook>;
+    fetchTicker(symbol: string, params?: {}): Promise<import("./base/types.js").Ticker>;
+    fetchTickers(symbols?: string[], params?: {}): Promise<Tickers>;
+    fetchBidsAsks(symbols?: string[], params?: {}): Promise<Tickers>;
+    parseTicker(ticker: any, market?: any): import("./base/types.js").Ticker;
+    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Trade[]>;
+    fetchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Trade[]>;
+    parseTrade(trade: any, market?: any): import("./base/types.js").Trade;
+    fetchBalance(params?: {}): Promise<import("./base/types.js").Balances>;
+    parseBalance(response: any): import("./base/types.js").Balances;
+    createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createSpotOrder(symbol: string, type: any, side: any, amount: any, price?: any, params?: {}): Promise<Order>;
+    createContractOrder(symbol: string, type: any, side: any, amount: any, price?: any, params?: {}): Promise<Order>;
+    fetchOrder(id: string, symbol?: string, params?: {}): Promise<Order>;
+    fetchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrdersByStatus(status: any, symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOpenOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchClosedOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchCanceledOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    cancelOrder(id: string, symbol?: string, params?: {}): Promise<Order>;
+    cancelAllOrders(symbol?: string, params?: {}): Promise<Order[]>;
+    cancelOrders(ids: string[], symbol?: string, params?: {}): Promise<Order[]>;
+    parseOrder(order: any, market?: any): Order;
+    parseOrderStatus(status: any): string;
+    fetchLedger(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    parseLedgerEntry(item: any, currency?: any): {
+        id: string;
+        direction: string;
+        account: any;
+        referenceId: any;
+        referenceAccount: any;
+        type: string;
+        currency: string;
+        amount: number;
+        timestamp: number;
+        datetime: string;
+        before: any;
+        after: number;
+        status: any;
+        fee: {
+            currency: any;
+            cost: any;
+        };
+        info: any;
+    };
+    parseLedgerEntryType(type: any): string;
+    fetchDepositAddress(code: string, params?: {}): Promise<{
+        currency: string;
+        address: string;
+        tag: string;
+        network: any;
+        info: any;
+    }>;
+    parseDepositAddress(depositAddress: any, currency?: any): {
+        currency: string;
+        address: string;
+        tag: string;
+        network: any;
+        info: any;
+    };
+    fetchDeposits(code?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    fetchWithdrawals(code?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
+    parseTransaction(transaction: Dict, currency?: Currency): Transaction;
+    parseTransactionStatus(status: any): string;
+    setLeverage(leverage: Int, symbol?: string, params?: {}): Promise<any>;
+    addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    modifyMarginHelper(symbol: string, amount: any, addOrReduce: any, params?: {}): Promise<MarginModification>;
+    parseMarginModification(data: any, market?: any): MarginModification;
+    fetchLeverageTiers(symbols?: string[], params?: {}): Promise<{}>;
+    parseLeverageTiers(response: any, symbols?: any, marketIdKey?: any): {};
+    fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<LeverageTier[]>;
+    parseMarketLeverageTiers(info: any, market?: any): any[];
+    fetchFundingRateHistory(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
+    fetchFundingRate(symbol: string, params?: {}): Promise<{
+        info: any;
+        symbol: string;
+        markPrice: any;
+        indexPrice: any;
+        interestRate: any;
+        estimatedSettlePrice: any;
+        timestamp: any;
+        datetime: any;
+        fundingRate: number;
+        fundingTimestamp: number;
+        fundingDatetime: string;
+        nextFundingRate: any;
+        nextFundingTimestamp: any;
+        nextFundingDatetime: any;
+        previousFundingRate: any;
+        previousFundingTimestamp: any;
+        previousFundingDatetime: any;
+    }>;
+    parseFundingRate(contract: any, market?: any): {
+        info: any;
+        symbol: string;
+        markPrice: any;
+        indexPrice: any;
+        interestRate: any;
+        estimatedSettlePrice: any;
+        timestamp: any;
+        datetime: any;
+        fundingRate: number;
+        fundingTimestamp: number;
+        fundingDatetime: string;
+        nextFundingRate: any;
+        nextFundingTimestamp: any;
+        nextFundingDatetime: any;
+        previousFundingRate: any;
+        previousFundingTimestamp: any;
+        previousFundingDatetime: any;
+    };
+    fetchFundingHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingHistory[]>;
+    parseFundingHistory(contract: any, market?: any): {
+        info: any;
+        symbol: string;
+        code: string;
+        timestamp: number;
+        datetime: string;
+        id: string;
+        amount: number;
+    };
+    fetchPosition(symbol: string, params?: {}): Promise<import("./base/types.js").Position>;
+    fetchPositions(symbols?: string[], params?: {}): Promise<import("./base/types.js").Position[]>;
+    parsePosition(position: any, market?: any): import("./base/types.js").Position;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
+    parseTransfer(transfer: any, currency?: any): {
+        info: any;
+        id: string;
+        timestamp: any;
+        datetime: any;
+        currency: any;
+        amount: any;
+        fromAccount: any;
+        toAccount: any;
+        status: any;
+    };
+    handleErrors(code: any, reason: any, url: any, method: any, headers: any, body: any, response: any, requestHeaders: any, requestBody: any): any;
+    sign(path: any, api?: any[], method?: string, params?: {}, headers?: any, body?: any): {
+        url: any;
+        method: string;
+        body: any;
+        headers: any;
+    };
+}