ccxt 4.1.4 → 4.1.6

package/dist/cjs/src/poloniex.js

@@ -397,11 +397,18 @@ class poloniex extends poloniex$1 {
          * @param {int} [since] timestamp in ms of the earliest candle to fetch
          * @param {int} [limit] the maximum amount of candles to fetch
          * @param {object} [params] extra parameters specific to the poloniex api endpoint
+         * @param {int} [params.until] timestamp in ms
+         * @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]  (ttps://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
         await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'paginate', false);
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 500);
+        }
         const market = this.market(symbol);
-        const request = {
+        let request = {
             'symbol': market['id'],
             'interval': this.safeString(this.timeframes, timeframe, timeframe),
         };
@@ -412,6 +419,7 @@ class poloniex extends poloniex$1 {
             // limit should in between 100 and 500
             request['limit'] = limit;
         }
+        [request, params] = this.handleUntilOption('endTime', request, params);
         const response = await this.publicGetMarketsSymbolCandles(this.extend(request, params));
         //
         //     [
@@ -951,14 +959,21 @@ class poloniex extends poloniex$1 {
          * @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 poloniex api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @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]  (ttps://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure}
          */
         await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchMyTrades', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchMyTrades', symbol, since, limit, params);
+        }
         let market = undefined;
         if (symbol !== undefined) {
             market = this.market(symbol);
         }
-        const request = {
+        let request = {
         // 'from': 12345678, // A 'trade Id'. The query begins at ‘from'.
         // 'direction': 'PRE', // PRE, NEXT The direction before or after ‘from'.
         };
@@ -968,6 +983,7 @@ class poloniex extends poloniex$1 {
         if (limit !== undefined) {
             request['limit'] = limit;
         }
+        [request, params] = this.handleUntilOption('endTime', request, params);
         const response = await this.privateGetTrades(this.extend(request, params));
         //
         //     [

package/dist/cjs/src/pro/bitget.js

@@ -8,6 +8,11 @@ var sha256 = require('../static_dependencies/noble-hashes/sha256.js');
 
 //  ---------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
+/**
+ * @class bitget
+ * @extends Exchange
+ * @description watching delivery future markets is not yet implemented (perpertual future / swap is implemented)
+ */
 class bitget extends bitget$1 {
     describe() {
         return this.deepExtend(super.describe(), {
@@ -80,10 +85,10 @@ class bitget extends bitget$1 {
         }
         else {
             if (!sandboxMode) {
-                return market['id'].replace('_UMCBL', '');
+                return market['id'].replace('_UMCBL', '').replace('_DMCBL', '').replace('_CMCBL', '');
             }
             else {
-                return market['id'].replace('_SUMCBL', '');
+                return market['id'].replace('_SUMCBL', '').replace('_SDMCBL', '').replace('_SCMCBL', '');
             }
         }
     }
@@ -95,15 +100,24 @@ class bitget extends bitget$1 {
         const sandboxMode = this.safeValue(this.options, 'sandboxMode', false);
         let marketId = this.safeString(arg, 'instId');
         if (instType === 'sp') {
-            marketId += '_SPBL';
+            marketId = marketId + '_SPBL';
         }
         else {
-            if (!sandboxMode) {
-                marketId += '_UMCBL';
+            let extension = sandboxMode ? '_S' : '_';
+            const splitByUSDT = marketId.split('USDT');
+            const splitByPERP = marketId.split('PERP');
+            const splitByUSDTLength = splitByUSDT.length;
+            const splitByPERPLength = splitByPERP.length;
+            if (splitByUSDTLength > 1) {
+                extension += 'UMCBL';
+            }
+            else if (splitByPERPLength > 1) {
+                extension += 'CMCBL';
             }
             else {
-                marketId += '_SUMCBL';
+                extension += 'DMCBL';
             }
+            marketId = marketId + extension;
         }
         return marketId;
     }
@@ -606,6 +620,8 @@ class bitget extends bitget$1 {
          * @method
          * @name bitget#watchTrades
          * @description get the list of most recent trades for a particular symbol
+         * @see https://bitgetlimited.github.io/apidoc/en/spot/#trades-channel
+         * @see https://bitgetlimited.github.io/apidoc/en/mix/#trades-channel
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
          * @param {int} [limit] the maximum amount of trades to fetch

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.1.3";
+declare const version = "4.1.5";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.4';
+const version = '4.1.6';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/kuna.d.ts

@@ -5,6 +5,40 @@ interface Exchange {
     xreserveGetFee(params?: {}): Promise<implicitReturnType>;
     xreserveGetDelegatedTransactions(params?: {}): Promise<implicitReturnType>;
     xreservePostDelegateTransfer(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetMe(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetGetBalance(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetActive(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetOrderHistory(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetOrderPrivateIdTrades(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetOrderDetailsIdWithTradesWithTrades(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetTradeHistory(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetTransactionHash(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetDepositPreRequest(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetDepositCryptoAddress(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetDepositCryptoGetMerchantAddress(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetDepositHistory(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetDepositDetailsDepositId(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetWithdrawPreRequest(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetWithdrawHistory(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetWithdrawDetailsWithdrawId(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetKunaCodeId(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetKunaCodeCodeCheck(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetKunaCodeIssuedByMe(params?: {}): Promise<implicitReturnType>;
+    v4PrivateGetKunaCodeRedeemedByMe(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCreate(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCancel(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostOrderCancelMulti(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostDepositCryptoGenerateAddress(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostDepositCryptoGenerateMerchantAddress(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostWithdrawCreate(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePostKunaCode(params?: {}): Promise<implicitReturnType>;
+    v4PrivatePutKunaCodeRedeem(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetTimestamp(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetFees(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetCurrenciesTypeType(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetMarketsGetAll(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetMarketsTickersPairsPairs(params?: {}): Promise<implicitReturnType>;
+    v4PublicGetOrderBookPairs(params?: {}): Promise<implicitReturnType>;
     v3PublicGetTimestamp(params?: {}): Promise<implicitReturnType>;
     v3PublicGetCurrencies(params?: {}): Promise<implicitReturnType>;
     v3PublicGetMarkets(params?: {}): Promise<implicitReturnType>;

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

@@ -805,5 +805,12 @@ export default class Exchange {
     resolvePromiseIfMessagehashMatches(client: any, prefix: string, symbol: string, data: any): void;
     resolveMultipleOHLCV(client: any, prefix: string, symbol: string, timeframe: string, data: any): void;
     createOHLCVObject(symbol: string, timeframe: string, data: any): Dictionary<Dictionary<OHLCV[]>>;
+    handleMaxEntriesPerRequestAndParams(method: string, maxEntriesPerRequest?: Int, params?: {}): [Int, any];
+    fetchPaginatedCallDynamic(method: string, symbol?: string, since?: Int, limit?: Int, params?: {}, maxEntriesPerRequest?: Int): Promise<any>;
+    safeDeterministicCall(method: string, symbol?: string, since?: Int, limit?: Int, timeframe?: string, params?: {}): Promise<any>;
+    fetchPaginatedCallDeterministic(method: string, symbol?: string, since?: Int, limit?: Int, timeframe?: string, params?: {}, maxEntriesPerRequest?: any): Promise<any>;
+    fetchPaginatedCallCursor(method: string, symbol?: string, since?: any, limit?: any, params?: {}, cursorReceived?: any, cursorSent?: any, cursorIncrement?: any, maxEntriesPerRequest?: any): Promise<any>;
+    removeRepeatedElementsFromArray(input: any): any;
+    handleUntilOption(key: any, request: any, params: any, multiplier?: number): any[];
 }
 export { Exchange, };

package/js/src/base/Exchange.js

@@ -4094,5 +4094,221 @@ export default class Exchange {
         res[symbol][timeframe] = data;
         return res;
     }
+    handleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest = undefined, params = {}) {
+        let newMaxEntriesPerRequest = undefined;
+        [newMaxEntriesPerRequest, params] = this.handleOptionAndParams(params, method, 'maxEntriesPerRequest');
+        if ((newMaxEntriesPerRequest !== undefined) && (newMaxEntriesPerRequest !== maxEntriesPerRequest)) {
+            maxEntriesPerRequest = newMaxEntriesPerRequest;
+        }
+        if (maxEntriesPerRequest === undefined) {
+            maxEntriesPerRequest = 1000; // default to 1000
+        }
+        return [maxEntriesPerRequest, params];
+    }
+    async fetchPaginatedCallDynamic(method, symbol = undefined, since = undefined, limit = undefined, params = {}, maxEntriesPerRequest = undefined) {
+        let maxCalls = undefined;
+        [maxCalls, params] = this.handleOptionAndParams(params, method, 'paginationCalls', 10);
+        let maxRetries = undefined;
+        [maxRetries, params] = this.handleOptionAndParams(params, method, 'maxRetries', 3);
+        let paginationDirection = undefined;
+        [paginationDirection, params] = this.handleOptionAndParams(params, method, 'paginationDirection', 'backward');
+        let paginationTimestamp = undefined;
+        let calls = 0;
+        let result = [];
+        let errors = 0;
+        const until = this.safeInteger2(params, 'untill', 'till'); // do not omit it from params here
+        [maxEntriesPerRequest, params] = this.handleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
+        if ((paginationDirection === 'forward')) {
+            if (since === undefined) {
+                throw new ArgumentsRequired(this.id + ' pagination requires a since argument when paginationDirection set to forward');
+            }
+            paginationTimestamp = since;
+        }
+        while ((calls < maxCalls)) {
+            calls += 1;
+            try {
+                if (paginationDirection === 'backward') {
+                    // do it backwards, starting from the last
+                    // UNTIL filtering is required in order to work
+                    if (paginationTimestamp !== undefined) {
+                        params['until'] = paginationTimestamp - 1;
+                    }
+                    const response = await this[method](symbol, undefined, maxEntriesPerRequest, params);
+                    const responseLength = response.length;
+                    if (this.verbose) {
+                        this.log('Dynamic pagination call', calls, 'method', method, 'response length', responseLength, 'timestamp', paginationTimestamp);
+                    }
+                    if (responseLength === 0) {
+                        break;
+                    }
+                    errors = 0;
+                    result = this.arrayConcat(result, response);
+                    const firstElement = this.safeValue(response, 0);
+                    paginationTimestamp = this.safeInteger2(firstElement, 'timestamp', 0);
+                    if ((since !== undefined) && (paginationTimestamp <= since)) {
+                        break;
+                    }
+                }
+                else {
+                    // do it forwards, starting from the since
+                    const response = await this[method](symbol, paginationTimestamp, maxEntriesPerRequest, params);
+                    const responseLength = response.length;
+                    if (this.verbose) {
+                        this.log('Dynamic pagination call', calls, 'method', method, 'response length', responseLength, 'timestamp', paginationTimestamp);
+                    }
+                    if (responseLength === 0) {
+                        break;
+                    }
+                    errors = 0;
+                    result = this.arrayConcat(result, response);
+                    const last = this.safeValue(response, responseLength - 1);
+                    paginationTimestamp = this.safeInteger(last, 'timestamp') - 1;
+                    if ((until !== undefined) && (paginationTimestamp >= until)) {
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                errors += 1;
+                if (errors > maxRetries) {
+                    throw e;
+                }
+            }
+        }
+        return this.removeRepeatedElementsFromArray(result);
+    }
+    async safeDeterministicCall(method, symbol = undefined, since = undefined, limit = undefined, timeframe = undefined, params = {}) {
+        let maxRetries = undefined;
+        [maxRetries, params] = this.handleOptionAndParams(params, method, 'maxRetries', 3);
+        let errors = 0;
+        try {
+            if (timeframe && method !== 'fetchFundingRateHistory') {
+                return await this[method](symbol, timeframe, since, limit, params);
+            }
+            else {
+                return await this[method](symbol, since, limit, params);
+            }
+        }
+        catch (e) {
+            if (e instanceof RateLimitExceeded) {
+                throw e; // if we are rate limited, we should not retry and fail fast
+            }
+            errors += 1;
+            if (errors > maxRetries) {
+                throw e;
+            }
+        }
+    }
+    async fetchPaginatedCallDeterministic(method, symbol = undefined, since = undefined, limit = undefined, timeframe = undefined, params = {}, maxEntriesPerRequest = undefined) {
+        let maxCalls = undefined;
+        [maxCalls, params] = this.handleOptionAndParams(params, method, 'paginationCalls', 10);
+        [maxEntriesPerRequest, params] = this.handleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
+        const current = this.milliseconds();
+        const tasks = [];
+        const time = this.parseTimeframe(timeframe) * 1000;
+        const step = time * maxEntriesPerRequest;
+        let currentSince = current - (maxCalls * step) - 1;
+        if (since !== undefined) {
+            currentSince = Math.max(currentSince, since);
+        }
+        const until = this.safeInteger2(params, 'until', 'till'); // do not omit it here
+        if (until !== undefined) {
+            const requiredCalls = Math.ceil((until - since) / step);
+            if (requiredCalls > maxCalls) {
+                throw new BadRequest(this.id + ' the number of required calls is greater than the max number of calls allowed, either increase the paginationCalls or decrease the since-until gap. Current paginationCalls limit is ' + maxCalls.toString() + ' required calls is ' + requiredCalls.toString());
+            }
+        }
+        for (let i = 0; i < maxCalls; i++) {
+            if ((until !== undefined) && (currentSince >= until)) {
+                break;
+            }
+            tasks.push(this.safeDeterministicCall(method, symbol, currentSince, maxEntriesPerRequest, timeframe, params));
+            currentSince = this.sum(currentSince, step) - 1;
+        }
+        const results = await Promise.all(tasks);
+        let result = [];
+        for (let i = 0; i < results.length; i++) {
+            result = this.arrayConcat(result, results[i]);
+        }
+        return this.removeRepeatedElementsFromArray(result);
+    }
+    async fetchPaginatedCallCursor(method, symbol = undefined, since = undefined, limit = undefined, params = {}, cursorReceived = undefined, cursorSent = undefined, cursorIncrement = undefined, maxEntriesPerRequest = undefined) {
+        let maxCalls = undefined;
+        [maxCalls, params] = this.handleOptionAndParams(params, method, 'paginationCalls', 10);
+        let maxRetries = undefined;
+        [maxRetries, params] = this.handleOptionAndParams(params, method, 'maxRetries', 3);
+        [maxEntriesPerRequest, params] = this.handleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
+        let cursorValue = undefined;
+        let i = 0;
+        let errors = 0;
+        let result = [];
+        while (i < maxCalls) {
+            try {
+                if (cursorValue !== undefined) {
+                    if (cursorIncrement !== undefined) {
+                        cursorValue = this.parseToInt(cursorValue) + cursorIncrement;
+                    }
+                    params[cursorSent] = cursorValue;
+                }
+                const response = await this[method](symbol, since, maxEntriesPerRequest, params);
+                errors = 0;
+                const responseLength = response.length;
+                if (this.verbose) {
+                    this.log('Cursor pagination call', i + 1, 'method', method, 'response length', responseLength, 'cursor', cursorValue);
+                }
+                if (responseLength === 0) {
+                    break;
+                }
+                result = this.arrayConcat(result, response);
+                const last = this.safeValue(response, responseLength - 1);
+                cursorValue = this.safeValue(last['info'], cursorReceived);
+                if (cursorValue === undefined) {
+                    break;
+                }
+            }
+            catch (e) {
+                errors += 1;
+                if (errors > maxRetries) {
+                    throw e;
+                }
+            }
+            i += 1;
+        }
+        return result;
+    }
+    removeRepeatedElementsFromArray(input) {
+        const uniqueResult = {};
+        for (let i = 0; i < input.length; i++) {
+            const entry = input[i];
+            const id = this.safeString(entry, 'id');
+            if (id !== undefined) {
+                if (this.safeString(uniqueResult, id) === undefined) {
+                    uniqueResult[id] = entry;
+                }
+            }
+            else {
+                const timestamp = this.safeInteger2(entry, 'timestamp', 0);
+                if (timestamp !== undefined) {
+                    if (this.safeString(uniqueResult, timestamp) === undefined) {
+                        uniqueResult[timestamp] = entry;
+                    }
+                }
+            }
+        }
+        const values = Object.values(uniqueResult);
+        const valuesLength = values.length;
+        if (valuesLength > 0) {
+            return values;
+        }
+        return input;
+    }
+    handleUntilOption(key, request, params, multiplier = 1) {
+        const until = this.safeValue2(params, 'until', 'till');
+        if (until !== undefined) {
+            request[key] = this.parseToInt(until * multiplier);
+            params = this.omit(params, ['until', 'till']);
+        }
+        return [request, params];
+    }
 }
 export { Exchange, };

package/js/src/binance.d.ts

@@ -97,7 +97,7 @@ export default class binance extends Exchange {
     };
     fetchTickers(symbols?: string[], params?: {}): Promise<import("./base/types.js").Dictionary<import("./base/types.js").Ticker>>;
     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<any>;
     parseTrade(trade: any, market?: any): import("./base/types.js").Trade | {
         id: any;
         timestamp: number;
@@ -116,7 +116,7 @@ export default class binance extends Exchange {
         };
         info: any;
     };
-    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Trade[]>;
+    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     editSpotOrder(id: string, symbol: any, type: any, side: any, amount: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;
     editSpotOrderRequest(id: string, symbol: any, type: any, side: any, amount: any, price?: any, params?: {}): any;
     editContractOrder(id: string, symbol: any, type: any, side: any, amount: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;
@@ -126,15 +126,15 @@ export default class binance extends Exchange {
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<import("./base/types.js").Order>;
     createOrderRequest(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): any;
     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[]>;
+    fetchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     fetchOpenOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Order[]>;
     fetchClosedOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any[]>;
     fetchCanceledOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     cancelOrder(id: string, symbol?: string, params?: {}): Promise<import("./base/types.js").Order>;
     cancelAllOrders(symbol?: string, params?: {}): Promise<any>;
     cancelOrders(ids: Int[], symbol?: string, params?: {}): Promise<import("./base/types.js").Order[]>;
-    fetchOrderTrades(id: string, 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[]>;
+    fetchOrderTrades(id: string, symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     fetchMyDustTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseDustTrade(trade: any, market?: any): {
         id: any;