ccxt 4.4.21 → 4.4.23

package/js/src/okx.js

@@ -96,6 +96,8 @@ export default class okx extends Exchange {
                 'fetchLedgerEntry': undefined,
                 'fetchLeverage': true,
                 'fetchLeverageTiers': false,
+                'fetchLongShortRatio': false,
+                'fetchLongShortRatioHistory': true,
                 'fetchMarginAdjustmentHistory': true,
                 'fetchMarketLeverageTiers': true,
                 'fetchMarkets': true,
@@ -238,6 +240,7 @@ export default class okx extends Exchange {
                         'rubik/stat/margin/loan-ratio': 4,
                         // long/short
                         'rubik/stat/contracts/long-short-account-ratio': 4,
+                        'rubik/stat/contracts/long-short-account-ratio-contract': 4,
                         'rubik/stat/contracts/open-interest-volume': 4,
                         'rubik/stat/option/open-interest-volume': 4,
                         // put/call
@@ -8500,4 +8503,75 @@ export default class okx extends Exchange {
         const positions = this.parsePositions(data, symbols, params);
         return this.filterBySinceLimit(positions, since, limit);
     }
+    async fetchLongShortRatioHistory(symbol = undefined, timeframe = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#fetchLongShortRatioHistory
+         * @description fetches the long short ratio history for a unified market symbol
+         * @see https://www.okx.com/docs-v5/en/#trading-statistics-rest-api-get-contract-long-short-ratio
+         * @param {string} symbol unified symbol of the market to fetch the long short ratio for
+         * @param {string} [timeframe] the period for the ratio
+         * @param {int} [since] the earliest time in ms to fetch ratios for
+         * @param {int} [limit] the maximum number of long short ratio structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest ratio to fetch
+         * @returns {object[]} an array of [long short ratio structures]{@link https://docs.ccxt.com/#/?id=long-short-ratio-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        const until = this.safeString2(params, 'until', 'end');
+        params = this.omit(params, 'until');
+        if (until !== undefined) {
+            request['end'] = until;
+        }
+        if (timeframe !== undefined) {
+            request['period'] = timeframe;
+        }
+        if (since !== undefined) {
+            request['begin'] = since;
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        const response = await this.publicGetRubikStatContractsLongShortAccountRatioContract(this.extend(request, params));
+        //
+        //     {
+        //         "code": "0",
+        //         "data": [
+        //             ["1729323600000", "0.9398602814619824"],
+        //             ["1729323300000", "0.9398602814619824"],
+        //             ["1729323000000", "0.9398602814619824"],
+        //         ],
+        //         "msg": ""
+        //     }
+        //
+        const data = this.safeList(response, 'data', []);
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const entry = data[i];
+            result.push({
+                'timestamp': this.safeString(entry, 0),
+                'longShortRatio': this.safeString(entry, 1),
+            });
+        }
+        return this.parseLongShortRatioHistory(result, market);
+    }
+    parseLongShortRatio(info, market = undefined) {
+        const timestamp = this.safeInteger(info, 'timestamp');
+        let symbol = undefined;
+        if (market !== undefined) {
+            symbol = market['symbol'];
+        }
+        return {
+            'info': info,
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'timeframe': undefined,
+            'longShortRatio': this.safeNumber(info, 'longShortRatio'),
+        };
+    }
 }

package/js/src/poloniex.js

@@ -50,7 +50,12 @@ export default class poloniex extends Exchange {
                 'fetchDepositsWithdrawals': true,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': true,
+                'fetchFundingHistory': false,
+                'fetchFundingInterval': false,
+                'fetchFundingIntervals': false,
                 'fetchFundingRate': false,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
                 'fetchMarginMode': false,
                 'fetchMarkets': true,
                 'fetchMyTrades': true,

package/js/src/pro/coincatch.d.ts

@@ -0,0 +1,57 @@
+import coincatchRest from '../coincatch.js';
+import type { Balances, Dict, Int, Market, OHLCV, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade } from '../base/types.js';
+import Client from '../base/ws/Client.js';
+export default class coincatch extends coincatchRest {
+    describe(): any;
+    getMarketFromArg(entry: any): import("../base/types.js").MarketInterface;
+    authenticate(params?: {}): Promise<any>;
+    watchPublic(messageHash: any, subscribeHash: any, args: any, params?: {}): Promise<any>;
+    unWatchPublic(messageHash: any, args: any, params?: {}): Promise<any>;
+    watchPrivate(messageHash: any, subscribeHash: any, args: any, params?: {}): Promise<any>;
+    watchPrivateMultiple(messageHashes: any, subscribeHashes: any, args: any, params?: {}): Promise<any>;
+    handleAuthenticate(client: Client, message: any): void;
+    watchPublicMultiple(messageHashes: any, subscribeHashes: any, argsArray: any, params?: {}): Promise<any>;
+    unWatchChannel(symbol: string, channel: string, messageHashTopic: string, params?: {}): Promise<any>;
+    getPublicInstTypeAndId(market: Market): any[];
+    handleDMCBLMarketByMessageHashes(market: Market, hash: string, client: Client, timeframe?: Str): import("../base/types.js").MarketInterface;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    unWatchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleTicker(client: Client, message: any): void;
+    parseWsTicker(ticker: any, market?: any): Ticker;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    unWatchOHLCV(symbol: string, timeframe?: string, params?: {}): Promise<any>;
+    handleOHLCV(client: Client, message: any): void;
+    parseWsOHLCV(ohlcv: any, market?: Market): OHLCV;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    handleOrderBook(client: Client, message: any): void;
+    handleCheckSumError(client: Client, symbol: string, messageHash: string): Promise<void>;
+    handleDelta(bookside: any, delta: any): void;
+    handleDeltas(bookside: any, deltas: any): void;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    unWatchTrades(symbol: string, params?: {}): Promise<any>;
+    handleTrades(client: Client, message: any): void;
+    parseWsTrade(trade: any, market?: any): Trade;
+    watchBalance(params?: {}): Promise<Balances>;
+    handleBalance(client: Client, message: any): void;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    handleOrder(client: Client, message: any): void;
+    parseWsOrder(order: Dict, market?: Market): Order;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    getPrivateInstType(market: Market): "umcbl" | "dmcbl";
+    handlePositions(client: Client, message: any): void;
+    parseWsPosition(position: any, market?: any): Position;
+    handleErrorMessage(client: Client, message: any): boolean;
+    handleMessage(client: Client, message: any): void;
+    ping(client: Client): string;
+    handlePong(client: Client, message: any): any;
+    handleSubscriptionStatus(client: Client, message: any): any;
+    handleUnSubscriptionStatus(client: Client, message: any): any;
+    handleOrderBookUnSubscription(client: Client, message: any): void;
+    handleTradesUnSubscription(client: Client, message: any): void;
+    handleTickerUnSubscription(client: Client, message: any): void;
+    handleOHLCVUnSubscription(client: Client, message: any): void;
+}