ccxt 4.4.22 → 4.4.23

package/js/src/coinex.d.ts

@@ -104,6 +104,7 @@ export default class coinex extends Exchange {
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
     parseLeverage(leverage: Dict, market?: Market): Leverage;
     fetchPositionHistory(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    closePosition(symbol: string, side?: OrderSide, params?: {}): Promise<Order>;
     handleMarginModeAndParams(methodName: any, params?: {}, defaultValue?: any): any[];
     nonce(): number;
     sign(path: any, api?: any[], method?: string, params?: {}, headers?: any, body?: any): {

package/js/src/coinex.js

@@ -48,6 +48,8 @@ export default class coinex extends Exchange {
                 'cancelAllOrders': true,
                 'cancelOrder': true,
                 'cancelOrders': true,
+                'closeAllPositions': false,
+                'closePosition': true,
                 'createDepositAddress': true,
                 'createMarketBuyOrderWithCost': true,
                 'createMarketOrderWithCost': false,
@@ -1775,7 +1777,7 @@ export default class coinex extends Exchange {
         //         "stop_id": 117180138153
         //     }
         //
-        // Swap createOrder, createOrders, editOrder, cancelOrders, cancelOrder, fetchOpenOrders, fetchClosedOrders
+        // Swap createOrder, createOrders, editOrder, cancelOrders, cancelOrder, fetchOpenOrders, fetchClosedOrders, closePosition
         //
         //     {
         //         "amount": "0.0001",
@@ -5698,6 +5700,66 @@ export default class coinex extends Exchange {
         const positions = this.parsePositions(records);
         return this.filterBySymbolSinceLimit(positions, symbol, since, limit);
     }
+    async closePosition(symbol, side = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinex#closePosition
+         * @description closes an open position for a market
+         * @see https://docs.coinex.com/api/v2/futures/position/http/close-position
+         * @param {string} symbol unified CCXT market symbol
+         * @param {string} [side] buy or sell, not used by coinex
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} params.type required by coinex, one of: limit, market, maker_only, ioc or fok, default is *market*
+         * @param {string} [params.price] the price to fulfill the order, ignored in market orders
+         * @param {string} [params.amount] the amount to trade in units of the base currency
+         * @param {string} [params.clientOrderId] the client id of the order
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const type = this.safeString(params, 'type', 'market');
+        const request = {
+            'market': market['id'],
+            'market_type': 'FUTURES',
+            'type': type,
+        };
+        const clientOrderId = this.safeString2(params, 'client_id', 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['client_id'] = clientOrderId;
+        }
+        params = this.omit(params, 'clientOrderId');
+        const response = await this.v2PrivatePostFuturesClosePosition(this.extend(request, params));
+        //
+        //     {
+        //         "code": 0,
+        //         "data": {
+        //             "amount": "0.0001",
+        //             "client_id": "",
+        //             "created_at": 1729666043969,
+        //             "fee": "0.00335858",
+        //             "fee_ccy": "USDT",
+        //             "filled_amount": "0.0001",
+        //             "filled_value": "6.717179",
+        //             "last_filled_amount": "0.0001",
+        //             "last_filled_price": "67171.79",
+        //             "maker_fee_rate": "0",
+        //             "market": "BTCUSDT",
+        //             "market_type": "FUTURES",
+        //             "order_id": 155477479761,
+        //             "price": "0",
+        //             "realized_pnl": "-0.001823",
+        //             "side": "sell",
+        //             "taker_fee_rate": "0.0005",
+        //             "type": "market",
+        //             "unfilled_amount": "0",
+        //             "updated_at": 1729666043969
+        //         },
+        //         "message": "OK"
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseOrder(data, market);
+    }
     handleMarginModeAndParams(methodName, params = {}, defaultValue = undefined) {
         /**
          * @ignore

package/js/src/latoken.js

@@ -49,6 +49,12 @@ export default class latoken extends Exchange {
                 'fetchDepositAddressesByNetwork': false,
                 'fetchDepositsWithdrawals': true,
                 'fetchDepositWithdrawFees': false,
+                'fetchFundingHistory': false,
+                'fetchFundingInterval': false,
+                'fetchFundingIntervals': false,
+                'fetchFundingRate': false,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,
                 'fetchMarginMode': false,

package/js/src/mexc.js

@@ -82,7 +82,7 @@ export default class mexc extends Exchange {
                 'fetchFundingIntervals': false,
                 'fetchFundingRate': true,
                 'fetchFundingRateHistory': true,
-                'fetchFundingRates': undefined,
+                'fetchFundingRates': false,
                 'fetchIndexOHLCV': true,
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,

package/js/src/oceanex.js

@@ -53,6 +53,8 @@ export default class oceanex extends Exchange {
                 'fetchDepositAddress': 'emulated',
                 'fetchDepositAddresses': undefined,
                 'fetchDepositAddressesByNetwork': true,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,
                 'fetchMarkets': true,

package/js/src/okcoin.js

@@ -54,6 +54,7 @@ export default class okcoin extends Exchange {
                 'fetchFundingHistory': false,
                 'fetchFundingRate': false,
                 'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
                 'fetchLedger': true,
                 'fetchMarkets': true,
                 'fetchMyTrades': true,

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;
+}