ccxt 4.3.69 → 4.3.70

package/js/src/blofin.js

@@ -23,6 +23,7 @@ export default class blofin extends Exchange {
             'countries': ['US'],
             'version': 'v1',
             'rateLimit': 100,
+            'pro': true,
             'has': {
                 'CORS': undefined,
                 'spot': false,
@@ -97,7 +98,7 @@ export default class blofin extends Exchange {
                 'fetchOpenInterestHistory': false,
                 'fetchOpenOrder': undefined,
                 'fetchOpenOrders': true,
-                'fetchOrder': true,
+                'fetchOrder': undefined,
                 'fetchOrderBook': true,
                 'fetchOrderBooks': false,
                 'fetchOrders': false,
@@ -147,11 +148,12 @@ export default class blofin extends Exchange {
                 '2h': '2H',
                 '4h': '4H',
                 '6h': '6H',
+                '8h': '8H',
                 '12h': '12H',
                 '1d': '1D',
+                '3d': '3D',
                 '1w': '1W',
                 '1M': '1M',
-                '3M': '3M',
             },
             'hostname': 'www.blofin.com',
             'urls': {
@@ -492,6 +494,25 @@ export default class blofin extends Exchange {
         return this.parseOrderBook(first, symbol, timestamp);
     }
     parseTicker(ticker, market = undefined) {
+        //
+        // response similar for REST & WS
+        //
+        //     {
+        //         instId: "ADA-USDT",
+        //         ts: "1707736811486",
+        //         last: "0.5315",
+        //         lastSize: "4",
+        //         askPrice: "0.5318",
+        //         askSize: "248",
+        //         bidPrice: "0.5315",
+        //         bidSize: "63",
+        //         open24h: "0.5555",
+        //         high24h: "0.5563",
+        //         low24h: "0.5315",
+        //         volCurrency24h: "198560100",
+        //         vol24h: "1985601",
+        //     }
+        //
         const timestamp = this.safeInteger(ticker, 'ts');
         const marketId = this.safeString(ticker, 'instId');
         market = this.safeMarket(marketId, market, '-');
@@ -564,7 +585,8 @@ export default class blofin extends Exchange {
     }
     parseTrade(trade, market = undefined) {
         //
-        // fetch trades
+        // fetch trades (response similar for REST & WS)
+        //
         //   {
         //       "tradeId": "3263934920",
         //       "instId": "LTC-USDT",
@@ -573,6 +595,7 @@ export default class blofin extends Exchange {
         //       "side": "buy",
         //       "ts": "1707232020854"
         //   }
+        //
         // my trades
         //   {
         //       "instId": "LTC-USDT",
@@ -851,10 +874,12 @@ export default class blofin extends Exchange {
             return this.parseFundingBalance(response);
         }
         else {
-            return this.parseTradingBalance(response);
+            return this.parseBalance(response);
         }
     }
-    parseTradingBalance(response) {
+    parseBalance(response) {
+        //
+        // "data" similar for REST & WS
         //
         // {
         //     "code": "0",
@@ -876,7 +901,8 @@ export default class blofin extends Exchange {
         //                 "orderFrozen": "14920.994472632597427761",
         //                 "equityUsd": "10011254.077985990315787910",
         //                 "isolatedUnrealizedPnl": "-22.151999999999999999952",
-        //                 "bonus": "0"
+        //                 "bonus": "0" // present only in REST
+        //                 "unrealizedPnl": "0" // present only in WS
         //             }
         //         ]
         //     }
@@ -1038,6 +1064,8 @@ export default class blofin extends Exchange {
         return this.safeString(statuses, status, status);
     }
     parseOrder(order, market = undefined) {
+        //
+        // response similar for REST & WS
         //
         // {
         //     "orderId": "2075628533",
@@ -1066,6 +1094,9 @@ export default class blofin extends Exchange {
         //     "cancelSource": "not_canceled",
         //     "cancelSourceReason": null,
         //     "brokerId": "ec6dd3a7dd982d0b"
+        //     "filled_amount": "1.000000000000000000", // filledAmount in "ws" watchOrders
+        //     "cancelSource": "", // only in WS
+        //     "instType": "SWAP", // only in WS
         // }
         //
         const id = this.safeString2(order, 'tpslId', 'orderId');
@@ -1815,6 +1846,32 @@ export default class blofin extends Exchange {
         return this.filterByArrayPositions(result, 'symbol', symbols, false);
     }
     parsePosition(position, market = undefined) {
+        //
+        // response similar for REST & WS
+        //
+        //     {
+        //         instType: 'SWAP',
+        //         instId: 'LTC-USDT',
+        //         marginMode: 'cross',
+        //         positionId: '644159',
+        //         positionSide: 'net',
+        //         positions: '1',
+        //         availablePositions: '1',
+        //         averagePrice: '68.16',
+        //         unrealizedPnl: '0.80631223',
+        //         unrealizedPnlRatio: '0.03548909463028169',
+        //         leverage: '3',
+        //         liquidationPrice: '10.116655172370356435',
+        //         markPrice: '68.96',
+        //         initialMargin: '22.988770743333333333',
+        //         margin: '', // this field might not exist in rest response
+        //         marginRatio: '152.523509620342499273',
+        //         maintenanceMargin: '0.34483156115',
+        //         adl: '4',
+        //         createTime: '1707235776528',
+        //         updateTime: '1707235776528'
+        //     }
+        //
         const marketId = this.safeString(position, 'instId');
         market = this.safeMarket(marketId, market);
         const symbol = market['symbol'];

package/js/src/bybit.js

@@ -8205,7 +8205,7 @@ export default class bybit extends Exchange {
         const quoteValueString = Precise.stringMul(baseValueString, priceString);
         return this.safeLiquidation({
             'info': liquidation,
-            'symbol': this.safeSymbol(marketId, market),
+            'symbol': this.safeSymbol(marketId, market, undefined, 'contract'),
             'contracts': this.parseNumber(contractsString),
             'contractSize': this.parseNumber(contractSizeString),
             'price': this.parseNumber(priceString),

package/js/src/coinbaseinternational.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/coinbaseinternational.js';
-import type { Int, OrderSide, OrderType, Order, Trade, Ticker, Str, Transaction, Balances, Tickers, Strings, Market, Currency, TransferEntry, Position, FundingRateHistory, Currencies, Dict, int } from './base/types.js';
+import type { Int, OrderSide, OrderType, Order, Trade, Ticker, Str, Transaction, Balances, Tickers, Strings, Market, Currency, TransferEntry, Position, FundingRateHistory, Currencies, Dict, int, OHLCV } from './base/types.js';
 /**
  * @class coinbaseinternational
  * @augments Exchange
@@ -15,6 +15,8 @@ export default class coinbaseinternational extends Exchange {
         code: any;
         info: any;
     };
+    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    parseOHLCV(ohlcv: any, market?: Market): OHLCV;
     fetchFundingRateHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
     parseFundingRateHistory(info: any, market?: Market): FundingRateHistory;
     parseFundingRate(contract: any, market?: Market): {
@@ -47,6 +49,9 @@ export default class coinbaseinternational extends Exchange {
         amount: number;
         rate: any;
     };
+    fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<TransferEntry[]>;
+    parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;
+    parseTransferStatus(status: Str): Str;
     createDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
         tag: string;

package/js/src/coinbaseinternational.js

@@ -86,7 +86,7 @@ export default class coinbaseinternational extends Exchange {
                 'fetchMyBuys': true,
                 'fetchMySells': true,
                 'fetchMyTrades': true,
-                'fetchOHLCV': false,
+                'fetchOHLCV': true,
                 'fetchOpenInterestHistory': false,
                 'fetchOpenOrders': true,
                 'fetchOrder': true,
@@ -105,6 +105,7 @@ export default class coinbaseinternational extends Exchange {
                 'fetchTrades': false,
                 'fetchTradingFee': false,
                 'fetchTradingFees': false,
+                'fetchTransfers': true,
                 'fetchWithdrawals': true,
                 'reduceMargin': false,
                 'sandbox': true,
@@ -147,7 +148,7 @@ export default class coinbaseinternational extends Exchange {
                             'instruments/{instrument}',
                             'instruments/{instrument}/quote',
                             'instruments/{instrument}/funding',
-                            '',
+                            'instruments/{instrument}/candles',
                         ],
                     },
                     'private': {
@@ -355,6 +356,81 @@ export default class coinbaseinternational extends Exchange {
             'info': account,
         };
     }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = 100, params = {}) {
+        /**
+         * @method
+         * @name coinbaseinternational#fetchOHLCV
+         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://docs.cdp.coinbase.com/intx/reference/getinstrumentcandles
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {int} [since] timestamp in ms of the earliest candle to fetch
+         * @param {int} [limit] the maximum amount of candles to fetch, default 100 max 10000
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         * @param {int} [params.until] timestamp in ms of the latest candle to fetch
+         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 10000);
+        }
+        const market = this.market(symbol);
+        const request = {
+            'instrument': market['id'],
+            'granularity': this.safeString(this.timeframes, timeframe, timeframe),
+        };
+        if (since !== undefined) {
+            request['start'] = this.iso8601(since);
+        }
+        else {
+            throw new ArgumentsRequired(this.id + ' fetchOHLCV() requires a since argument');
+        }
+        const unitl = this.safeInteger(params, 'until');
+        if (unitl !== undefined) {
+            params = this.omit(params, 'until');
+            request['end'] = this.iso8601(unitl);
+        }
+        const response = await this.v1PublicGetInstrumentsInstrumentCandles(this.extend(request, params));
+        //
+        //   {
+        //       "aggregations": [
+        //         {
+        //           "start": "2024-04-23T00:00:00Z",
+        //           "open": "62884.4",
+        //           "high": "64710.6",
+        //           "low": "62884.4",
+        //           "close": "63508.4",
+        //           "volume": "3253.9983"
+        //         }
+        //       ]
+        //   }
+        //
+        const candles = this.safeList(response, 'aggregations', []);
+        return this.parseOHLCVs(candles, market, timeframe, since, limit);
+    }
+    parseOHLCV(ohlcv, market = undefined) {
+        //
+        //   {
+        //     "start": "2024-04-23T00:00:00Z",
+        //     "open": "62884.4",
+        //     "high": "64710.6",
+        //     "low": "62884.4",
+        //     "close": "63508.4",
+        //     "volume": "3253.9983"
+        //   }
+        //
+        return [
+            this.parse8601(this.safeString2(ohlcv, 'start', 'time')),
+            this.safeNumber(ohlcv, 'open'),
+            this.safeNumber(ohlcv, 'high'),
+            this.safeNumber(ohlcv, 'low'),
+            this.safeNumber(ohlcv, 'close'),
+            this.safeNumber(ohlcv, 'volume'),
+        ];
+    }
     async fetchFundingRateHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -520,6 +596,96 @@ export default class coinbaseinternational extends Exchange {
             'rate': undefined,
         };
     }
+    async fetchTransfers(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinbaseinternational#fetchTransfers
+         * @description fetch a history of internal transfers made on an account
+         * @see https://docs.cdp.coinbase.com/intx/reference/gettransfers
+         * @param {string} code unified currency code of the currency transferred
+         * @param {int} [since] the earliest time in ms to fetch transfers for
+         * @param {int} [limit] the maximum number of  transfers structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'type': 'INTERNAL',
+        };
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+        }
+        let portfolios = undefined;
+        [portfolios, params] = this.handleOptionAndParams(params, 'fetchTransfers', 'portfolios');
+        if (portfolios !== undefined) {
+            request['portfolios'] = portfolios;
+        }
+        if (since !== undefined) {
+            request['time_from'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['result_limit'] = limit;
+        }
+        else {
+            request['result_limit'] = 100;
+        }
+        const response = await this.v1PrivateGetTransfers(this.extend(request, params));
+        const transfers = this.safeList(response, 'results', []);
+        return this.parseTransfers(transfers, currency, since, limit);
+    }
+    parseTransfer(transfer, currency = undefined) {
+        //
+        // {
+        //     "amount":"0.0008",
+        //     "asset":"USDC",
+        //     "created_at":"2024-02-22T16:00:00Z",
+        //     "from_portfolio":{
+        //        "id":"13yuk1fs-1-0",
+        //        "name":"Eng Test Portfolio - 2",
+        //        "uuid":"018712f2-5ff9-7de3-9010-xxxxxxxxx"
+        //     },
+        //     "instrument_id":"149264164756389888",
+        //     "instrument_symbol":"ETH-PERP",
+        //     "position_id":"1xy4v51m-1-2",
+        //     "status":"PROCESSED",
+        //     "to_portfolio":{
+        //        "name":"CB_FUND"
+        //     },
+        //     "transfer_type":"FUNDING",
+        //     "transfer_uuid":"a6b708df-2c44-32c5-bb98-xxxxxxxxxx",
+        //     "updated_at":"2024-02-22T16:00:00Z"
+        // }
+        //
+        const datetime = this.safeInteger(transfer, 'created_at');
+        const timestamp = this.parse8601(datetime);
+        const currencyId = this.safeString(transfer, 'asset');
+        const code = this.safeCurrencyCode(currencyId);
+        const fromPorfolio = this.safeDict(transfer, 'from_portfolio', {});
+        const fromId = this.safeString(fromPorfolio, 'id');
+        const toPorfolio = this.safeDict(transfer, 'to_portfolio', {});
+        const toId = this.safeString(toPorfolio, 'id');
+        return {
+            'info': transfer,
+            'id': this.safeString(transfer, 'transfer_uuid'),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'currency': code,
+            'amount': this.safeNumber(transfer, 'amount'),
+            'fromAccount': fromId,
+            'toAccount': toId,
+            'status': this.parseTransferStatus(this.safeString(transfer, 'status')),
+        };
+    }
+    parseTransferStatus(status) {
+        const statuses = {
+            'FAILED': 'failed',
+            'PROCESSED': 'ok',
+            'NEW': 'pending',
+            'STARTED': 'pending',
+        };
+        return this.safeString(statuses, status, status);
+    }
     async createDepositAddress(code, params = {}) {
         /**
          * @method

package/js/src/cryptocom.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/cryptocom.js';
 import { Precise } from './base/Precise.js';
-import { AuthenticationError, ArgumentsRequired, ExchangeError, InsufficientFunds, DDoSProtection, InvalidNonce, PermissionDenied, BadRequest, BadSymbol, NotSupported, AccountNotEnabled, OnMaintenance, InvalidOrder } from './base/errors.js';
+import { AuthenticationError, ArgumentsRequired, ExchangeError, InsufficientFunds, DDoSProtection, InvalidNonce, PermissionDenied, BadRequest, BadSymbol, NotSupported, AccountNotEnabled, OnMaintenance, InvalidOrder, RequestTimeout, OrderNotFound, RateLimitExceeded } from './base/errors.js';
 import { TICK_SIZE } from './base/functions/number.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
 /**
@@ -389,7 +389,15 @@ export default class cryptocom extends Exchange {
                     '40006': BadRequest,
                     '40007': BadRequest,
                     '40101': AuthenticationError,
-                    '50001': BadRequest,
+                    '40102': InvalidNonce,
+                    '40103': AuthenticationError,
+                    '40104': AuthenticationError,
+                    '40107': BadRequest,
+                    '40401': OrderNotFound,
+                    '40801': RequestTimeout,
+                    '42901': RateLimitExceeded,
+                    '43005': InvalidOrder,
+                    '50001': ExchangeError,
                     '9010001': OnMaintenance, // {"code":9010001,"message":"SYSTEM_MAINTENANCE","details":"Crypto.com Exchange is currently under maintenance. Please refer to https://status.crypto.com for more details."}
                 },
                 'broad': {},

package/js/src/hitbtc.js

@@ -2526,7 +2526,7 @@ export default class hitbtc extends Exchange {
     async fetchMarginModes(symbols = undefined, params = {}) {
         /**
          * @method
-         * @name hitbtc#fetchMarginMode
+         * @name hitbtc#fetchMarginModes
          * @description fetches margin mode of the user
          * @see https://api.hitbtc.com/#get-margin-position-parameters
          * @see https://api.hitbtc.com/#get-futures-position-parameters

package/js/src/poloniex.js

@@ -347,6 +347,7 @@ export default class poloniex extends Exchange {
                     '21350': InvalidOrder,
                     '21355': ExchangeError,
                     '21356': BadRequest,
+                    '21721': InsufficientFunds,
                     '24101': BadSymbol,
                     '24102': InvalidOrder,
                     '24103': InvalidOrder,

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

@@ -0,0 +1,39 @@
+import blofinRest from '../blofin.js';
+import type { Int, Market, Trade, OrderBook, Strings, Ticker, Tickers, OHLCV, Balances, Str, Order, Position } from '../base/types.js';
+import Client from '../base/ws/Client.js';
+export default class blofin extends blofinRest {
+    describe(): any;
+    ping(client: any): string;
+    handlePong(client: Client, message: any): void;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    handleTrades(client: Client, message: any): void;
+    parseWsTrade(trade: any, market?: Market): Trade;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    handleOrderBook(client: Client, message: any): void;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleTicker(client: Client, message: any): void;
+    parseWsTicker(ticker: any, market?: Market): Ticker;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
+    handleOHLCV(client: Client, message: any): void;
+    watchBalance(params?: {}): Promise<Balances>;
+    handleBalance(client: Client, message: any): void;
+    parseWsBalance(message: any): Balances;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchOrdersForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    handleOrders(client: Client, message: any): void;
+    parseWsOrder(order: any, market?: Market): Order;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    handlePositions(client: Client, message: any): void;
+    parseWsPosition(position: any, market?: Market): Position;
+    watchMultipleWrapper(isPublic: boolean, channelName: string, callerMethodName: string, symbolsArray?: any[], params?: {}): Promise<any>;
+    getSubscriptionRequest(args: any): {
+        op: string;
+        args: any;
+    };
+    handleMessage(client: Client, message: any): void;
+    authenticate(params?: {}): Promise<void>;
+}