ccxt 4.4.78 → 4.4.82

package/js/src/kraken.js

@@ -861,12 +861,14 @@ export default class kraken extends Exchange {
             const precision = this.parseNumber(this.parsePrecision(this.safeString(currency, 'decimals')));
             // assumes all currencies are active except those listed above
             const active = this.safeString(currency, 'status') === 'enabled';
+            const isFiat = code.indexOf('.HOLD') >= 0;
             result[code] = {
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': this.safeString(currency, 'altname'),
                 'active': active,
+                'type': isFiat ? 'fiat' : 'crypto',
                 'deposit': undefined,
                 'withdraw': undefined,
                 'fee': undefined,

package/js/src/okx.js

@@ -1646,7 +1646,6 @@ export default class okx extends Exchange {
                 }
             }
         }
-        const tickSize = this.safeString(market, 'tickSz');
         const fees = this.safeDict2(this.fees, type, 'trading', {});
         let maxLeverage = this.safeString(market, 'lever', '1');
         maxLeverage = Precise.stringMax(maxLeverage, '1');
@@ -1678,7 +1677,7 @@ export default class okx extends Exchange {
             'created': this.safeInteger(market, 'listTime'),
             'precision': {
                 'amount': this.safeNumber(market, 'lotSz'),
-                'price': this.parseNumber(tickSize),
+                'price': this.safeNumber(market, 'tickSz'),
             },
             'limits': {
                 'leverage': {
@@ -5078,7 +5077,7 @@ export default class okx extends Exchange {
      */
     async fetchDepositAddress(code, params = {}) {
         await this.loadMarkets();
-        const rawNetwork = this.safeStringUpper(params, 'network');
+        const rawNetwork = this.safeString(params, 'network'); // some networks are like "Dora Vota Mainnet"
         params = this.omit(params, 'network');
         code = this.safeCurrencyCode(code);
         const network = this.networkIdToCode(rawNetwork, code);

package/js/src/oxfun.d.ts

@@ -83,6 +83,16 @@ export default class oxfun extends Exchange {
      * @returns {Order[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
      */
     fetchFundingRates(symbols?: Strings, params?: {}): Promise<FundingRates>;
+    /**
+     * @method
+     * @name oxfun#fetchFundingRate
+     * @description fetch the current funding rates for a symbol
+     * @see https://docs.ox.fun/?json#get-v3-funding-estimates
+     * @param {string} symbol unified market symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {Order[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
+     */
+    fetchFundingRate(symbol: string, params?: {}): Promise<FundingRate>;
     parseFundingRate(fundingRate: any, market?: Market): FundingRate;
     /**
      * @method

package/js/src/oxfun.js

@@ -70,7 +70,7 @@ export default class oxfun extends Exchange {
                 'fetchDepositWithdrawFee': false,
                 'fetchDepositWithdrawFees': false,
                 'fetchFundingHistory': true,
-                'fetchFundingRate': 'emulated',
+                'fetchFundingRate': true,
                 'fetchFundingRateHistory': true,
                 'fetchFundingRates': true,
                 'fetchIndexOHLCV': false,
@@ -1104,6 +1104,26 @@ export default class oxfun extends Exchange {
         const data = this.safeList(response, 'data', []);
         return this.parseFundingRates(data, symbols);
     }
+    /**
+     * @method
+     * @name oxfun#fetchFundingRate
+     * @description fetch the current funding rates for a symbol
+     * @see https://docs.ox.fun/?json#get-v3-funding-estimates
+     * @param {string} symbol unified market symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {Order[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
+     */
+    async fetchFundingRate(symbol, params = {}) {
+        await this.loadMarkets();
+        const request = {
+            'marketCode': this.marketId(symbol),
+        };
+        const response = await this.publicGetV3FundingEstimates(this.extend(request, params));
+        //
+        const data = this.safeList(response, 'data', []);
+        const first = this.safeDict(data, 0, {});
+        return this.parseFundingRate(first, this.market(symbol));
+    }
     parseFundingRate(fundingRate, market = undefined) {
         //
         //     {

package/js/src/poloniex.js

@@ -1207,6 +1207,7 @@ export default class poloniex extends Exchange {
                     'withdraw': withdrawEnabled,
                     'fee': this.parseNumber(feeString),
                     'precision': undefined,
+                    'type': 'crypto',
                     'limits': {
                         'amount': {
                             'min': undefined,

package/js/src/pro/binance.js

@@ -68,12 +68,12 @@ export default class binance extends binanceRest {
             'urls': {
                 'test': {
                     'ws': {
-                        'spot': 'wss://testnet.binance.vision/ws',
-                        'margin': 'wss://testnet.binance.vision/ws',
+                        'spot': 'wss://stream.testnet.binance.vision/ws',
+                        'margin': 'wss://stream.testnet.binance.vision/ws',
                         'future': 'wss://fstream.binancefuture.com/ws',
                         'delivery': 'wss://dstream.binancefuture.com/ws',
                         'ws-api': {
-                            'spot': 'wss://testnet.binance.vision/ws-api/v3',
+                            'spot': 'wss://ws-api.testnet.binance.vision/ws-api/v3',
                             'future': 'wss://testnet.binancefuture.com/ws-fapi/v1',
                             'delivery': 'wss://testnet.binancefuture.com/ws-dapi/v1',
                         },

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

@@ -47,7 +47,7 @@ export default class coinbase extends coinbaseRest {
      * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
      */
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    handleTickers(client: any, message: any): any;
+    handleTickers(client: any, message: any): void;
     parseWsTicker(ticker: any, market?: any): Ticker;
     /**
      * @method
@@ -107,11 +107,12 @@ export default class coinbase extends coinbaseRest {
      * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
      */
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
-    handleTrade(client: any, message: any): any;
-    handleOrder(client: any, message: any): any;
+    handleTrade(client: any, message: any): void;
+    handleOrder(client: any, message: any): void;
     parseWsOrder(order: any, market?: any): Order;
     handleOrderBookHelper(orderbook: any, updates: any): void;
     handleOrderBook(client: any, message: any): void;
+    tryResolveUsdc(client: any, messageHash: any, result: any): void;
     handleSubscriptionStatus(client: any, message: any): any;
     handleHeartbeats(client: any, message: any): any;
     handleMessage(client: any, message: any): void;

package/js/src/pro/coinbase.js

@@ -75,7 +75,7 @@ export default class coinbase extends coinbaseRest {
         }
         else if (symbol !== undefined) {
             market = this.market(symbol);
-            messageHash = name + '::' + market['id'];
+            messageHash = name + '::' + symbol;
             productIds = [market['id']];
         }
         const url = this.urls['api']['ws'];
@@ -113,7 +113,7 @@ export default class coinbase extends coinbaseRest {
             const market = this.market(symbol);
             const marketId = market['id'];
             productIds.push(marketId);
-            messageHashes.push(name + '::' + marketId);
+            messageHashes.push(name + '::' + symbol);
         }
         const url = this.urls['api']['ws'];
         let subscribe = {
@@ -181,8 +181,11 @@ export default class coinbase extends coinbaseRest {
             symbols = this.symbols;
         }
         const name = 'ticker_batch';
-        const tickers = await this.subscribe(name, false, symbols, params);
+        const ticker = await this.subscribeMultiple(name, false, symbols, params);
         if (this.newUpdates) {
+            const tickers = {};
+            const symbol = ticker['symbol'];
+            tickers[symbol] = ticker;
             return tickers;
         }
         return this.tickers;
@@ -278,7 +281,7 @@ export default class coinbase extends coinbaseRest {
         //
         //
         const channel = this.safeString(message, 'channel');
-        const events = this.safeValue(message, 'events', []);
+        const events = this.safeList(message, 'events', []);
         const datetime = this.safeString(message, 'timestamp');
         const timestamp = this.parse8601(datetime);
         const newTickers = [];
@@ -287,38 +290,21 @@ export default class coinbase extends coinbaseRest {
             const tickers = this.safeList(tickersObj, 'tickers', []);
             for (let j = 0; j < tickers.length; j++) {
                 const ticker = tickers[j];
+                const wsMarketId = this.safeString(ticker, 'product_id');
+                if (wsMarketId === undefined) {
+                    continue;
+                }
                 const result = this.parseWsTicker(ticker);
                 result['timestamp'] = timestamp;
                 result['datetime'] = datetime;
                 const symbol = result['symbol'];
                 this.tickers[symbol] = result;
-                const wsMarketId = this.safeString(ticker, 'product_id');
-                if (wsMarketId === undefined) {
-                    continue;
-                }
-                const messageHash = channel + '::' + wsMarketId;
                 newTickers.push(result);
+                const messageHash = channel + '::' + symbol;
                 client.resolve(result, messageHash);
-                if (messageHash.endsWith('USD')) {
-                    client.resolve(result, messageHash + 'C'); // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-                }
+                this.tryResolveUsdc(client, messageHash, result);
             }
         }
-        const messageHashes = this.findMessageHashes(client, 'ticker_batch::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const tickers = this.filterByArray(newTickers, 'symbol', symbols);
-            if (!this.isEmpty(tickers)) {
-                client.resolve(tickers, messageHash);
-                if (messageHash.endsWith('USD')) {
-                    client.resolve(tickers, messageHash + 'C'); // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-                }
-            }
-        }
-        return message;
     }
     parseWsTicker(ticker, market = undefined) {
         //
@@ -486,13 +472,13 @@ export default class coinbase extends coinbaseRest {
         //        ]
         //    }
         //
-        const events = this.safeValue(message, 'events');
+        const events = this.safeList(message, 'events');
         const event = this.safeValue(events, 0);
-        const trades = this.safeValue(event, 'trades');
-        const trade = this.safeValue(trades, 0);
+        const trades = this.safeList(event, 'trades');
+        const trade = this.safeDict(trades, 0);
         const marketId = this.safeString(trade, 'product_id');
-        const messageHash = 'market_trades::' + marketId;
         const symbol = this.safeSymbol(marketId);
+        const messageHash = 'market_trades::' + symbol;
         let tradesArray = this.safeValue(this.trades, symbol);
         if (tradesArray === undefined) {
             const tradesLimit = this.safeInteger(this.options, 'tradesLimit', 1000);
@@ -501,17 +487,14 @@ export default class coinbase extends coinbaseRest {
         }
         for (let i = 0; i < events.length; i++) {
             const currentEvent = events[i];
-            const currentTrades = this.safeValue(currentEvent, 'trades');
+            const currentTrades = this.safeList(currentEvent, 'trades');
             for (let j = 0; j < currentTrades.length; j++) {
                 const item = currentTrades[i];
                 tradesArray.append(this.parseTrade(item));
             }
         }
         client.resolve(tradesArray, messageHash);
-        if (marketId.endsWith('USD')) {
-            client.resolve(tradesArray, messageHash + 'C'); // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        }
-        return message;
+        this.tryResolveUsdc(client, messageHash, tradesArray);
     }
     handleOrder(client, message) {
         //
@@ -542,7 +525,7 @@ export default class coinbase extends coinbaseRest {
         //        ]
         //    }
         //
-        const events = this.safeValue(message, 'events');
+        const events = this.safeList(message, 'events');
         const marketIds = [];
         if (this.orders === undefined) {
             const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
@@ -550,7 +533,7 @@ export default class coinbase extends coinbaseRest {
         }
         for (let i = 0; i < events.length; i++) {
             const event = events[i];
-            const responseOrders = this.safeValue(event, 'orders');
+            const responseOrders = this.safeList(event, 'orders');
             for (let j = 0; j < responseOrders.length; j++) {
                 const responseOrder = responseOrders[j];
                 const parsed = this.parseWsOrder(responseOrder);
@@ -564,14 +547,12 @@ export default class coinbase extends coinbaseRest {
         }
         for (let i = 0; i < marketIds.length; i++) {
             const marketId = marketIds[i];
-            const messageHash = 'user::' + marketId;
+            const symbol = this.safeSymbol(marketId);
+            const messageHash = 'user::' + symbol;
             client.resolve(this.orders, messageHash);
-            if (messageHash.endsWith('USD')) {
-                client.resolve(this.orders, messageHash + 'C'); // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-            }
+            this.tryResolveUsdc(client, messageHash, this.orders);
         }
         client.resolve(this.orders, 'user');
-        return message;
     }
     parseWsOrder(order, market = undefined) {
         //
@@ -648,7 +629,7 @@ export default class coinbase extends coinbaseRest {
         //                    {
         //                        "side": "bid",
         //                        "event_time": "1970-01-01T00:00:00Z",
-        //                        "price_level": "21921.73",
+        //                        "price_level": "21921.74",
         //                        "new_quantity": "0.06317902"
         //                    },
         //                    {
@@ -662,36 +643,38 @@ export default class coinbase extends coinbaseRest {
         //        ]
         //    }
         //
-        const events = this.safeValue(message, 'events');
+        const events = this.safeList(message, 'events');
         const datetime = this.safeString(message, 'timestamp');
         for (let i = 0; i < events.length; i++) {
             const event = events[i];
-            const updates = this.safeValue(event, 'updates', []);
+            const updates = this.safeList(event, 'updates', []);
             const marketId = this.safeString(event, 'product_id');
             // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, as they are aliases
             const market = this.safeMarket(marketId);
-            const messageHash = 'level2::' + market['id'];
             const symbol = market['symbol'];
+            const messageHash = 'level2::' + symbol;
             const subscription = this.safeValue(client.subscriptions, messageHash, {});
             const limit = this.safeInteger(subscription, 'limit');
             const type = this.safeString(event, 'type');
             if (type === 'snapshot') {
                 this.orderbooks[symbol] = this.orderBook({}, limit);
-                const orderbook = this.orderbooks[symbol];
-                this.handleOrderBookHelper(orderbook, updates);
-                orderbook['timestamp'] = this.parse8601(datetime);
-                orderbook['datetime'] = datetime;
-                orderbook['symbol'] = symbol;
-                client.resolve(orderbook, messageHash);
             }
-            else if (type === 'update') {
-                const orderbook = this.orderbooks[symbol];
-                this.handleOrderBookHelper(orderbook, updates);
-                orderbook['datetime'] = datetime;
-                orderbook['timestamp'] = this.parse8601(datetime);
-                orderbook['symbol'] = symbol;
-                client.resolve(orderbook, messageHash);
+            // unknown bug, can't reproduce, but sometimes orderbook is undefined
+            if (!(symbol in this.orderbooks) && this.orderbooks[symbol] === undefined) {
+                continue;
             }
+            const orderbook = this.orderbooks[symbol];
+            this.handleOrderBookHelper(orderbook, updates);
+            orderbook['timestamp'] = this.parse8601(datetime);
+            orderbook['datetime'] = datetime;
+            orderbook['symbol'] = symbol;
+            client.resolve(orderbook, messageHash);
+            this.tryResolveUsdc(client, messageHash, orderbook);
+        }
+    }
+    tryResolveUsdc(client, messageHash, result) {
+        if (messageHash.endsWith('/USD') || messageHash.endsWith('-USD')) {
+            client.resolve(result, messageHash + 'C'); // when subscribing to BTC/USDC and coinbase returns BTC/USD, so resolve USDC too
         }
     }
     handleSubscriptionStatus(client, message) {

package/js/src/pro/hyperliquid.js

@@ -98,7 +98,11 @@ export default class hyperliquid extends hyperliquidRest {
         await this.loadMarkets();
         const [order, globalParams] = this.parseCreateEditOrderArgs(undefined, symbol, type, side, amount, price, params);
         const orders = await this.createOrdersWs([order], globalParams);
-        return orders[0];
+        const parsedOrder = orders[0];
+        const orderInfo = this.safeDict(parsedOrder, 'info');
+        // handle potential error here
+        this.handleErrors(undefined, undefined, undefined, undefined, undefined, this.json(orderInfo), orderInfo, undefined, undefined);
+        return parsedOrder;
     }
     /**
      * @method
@@ -135,7 +139,11 @@ export default class hyperliquid extends hyperliquidRest {
         const dataObject = this.safeDict(responseObject, 'data', {});
         const statuses = this.safeList(dataObject, 'statuses', []);
         const first = this.safeDict(statuses, 0, {});
-        return this.parseOrder(first, market);
+        const parsedOrder = this.parseOrder(first, market);
+        const orderInfo = this.safeDict(parsedOrder, 'info');
+        // handle potential error here
+        this.handleErrors(undefined, undefined, undefined, undefined, undefined, this.json(orderInfo), orderInfo, undefined, undefined);
+        return parsedOrder;
     }
     /**
      * @method

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

@@ -1,5 +1,5 @@
 import upbitRest from '../upbit.js';
-import type { Int, Str, Order, OrderBook, Trade, Ticker, Balances, Tickers, Strings } from '../base/types.js';
+import type { Int, Str, Order, OrderBook, Trade, Ticker, Balances, Tickers, Strings, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class upbit extends upbitRest {
     describe(): any;
@@ -60,9 +60,24 @@ export default class upbit extends upbitRest {
      * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
      */
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    /**
+     * @method
+     * @name upbit#watchOHLCV
+     * @description watches information an OHLCV with timestamp, openingPrice, highPrice, lowPrice, tradePrice, baseVolume in 1s.
+     * @see https://docs.upbit.com/kr/reference/websocket-candle for Upbit KR
+     * @see https://global-docs.upbit.com/reference/websocket-candle for Upbit Global
+     * @param {string} symbol unified market symbol of the market orders were made in
+     * @param {string} timeframe specifies the OHLCV candle interval to watch. As of now, Upbit only supports 1s candles.
+     * @param {int} [since] the earliest time in ms to fetch orders for
+     * @param {int} [limit] the maximum number of order structures to retrieve
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {OHLCV[]} a list of [OHLCV structures]{@link https://docs.ccxt.com/#/?id=ohlcv-structure}
+     */
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleTicker(client: Client, message: any): void;
     handleOrderBook(client: Client, message: any): void;
     handleTrades(client: Client, message: any): void;
+    handleOHLCV(client: Client, message: any): void;
     authenticate(params?: {}): Promise<import("../base/ws/WsClient.js").default>;
     watchPrivate(symbol: any, channel: any, messageHash: any, params?: {}): Promise<any>;
     /**

package/js/src/pro/upbit.js

@@ -9,6 +9,7 @@ import upbitRest from '../upbit.js';
 import { ArrayCache, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 import { jwt } from '../base/functions/rsa.js';
+import { NotSupported } from '../base/errors.js';
 //  ---------------------------------------------------------------------------
 export default class upbit extends upbitRest {
     describe() {
@@ -20,6 +21,7 @@ export default class upbit extends upbitRest {
                 'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
+                'watchOHLCV': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
                 'watchBalance': true,
@@ -195,6 +197,26 @@ export default class upbit extends upbitRest {
         const orderbook = await this.watchPublic(symbol, 'orderbook');
         return orderbook.limit();
     }
+    /**
+     * @method
+     * @name upbit#watchOHLCV
+     * @description watches information an OHLCV with timestamp, openingPrice, highPrice, lowPrice, tradePrice, baseVolume in 1s.
+     * @see https://docs.upbit.com/kr/reference/websocket-candle for Upbit KR
+     * @see https://global-docs.upbit.com/reference/websocket-candle for Upbit Global
+     * @param {string} symbol unified market symbol of the market orders were made in
+     * @param {string} timeframe specifies the OHLCV candle interval to watch. As of now, Upbit only supports 1s candles.
+     * @param {int} [since] the earliest time in ms to fetch orders for
+     * @param {int} [limit] the maximum number of order structures to retrieve
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {OHLCV[]} a list of [OHLCV structures]{@link https://docs.ccxt.com/#/?id=ohlcv-structure}
+     */
+    async watchOHLCV(symbol, timeframe = '1s', since = undefined, limit = undefined, params = {}) {
+        if (timeframe !== '1s') {
+            throw new NotSupported(this.id + ' watchOHLCV does not support' + timeframe + ' candle.');
+        }
+        const timeFrameOHLCV = 'candle.' + timeframe;
+        return await this.watchPublic(symbol, timeFrameOHLCV);
+    }
     handleTicker(client, message) {
         // 2020-03-17T23:07:36.511Z "onMessage" <Buffer 7b 22 74 79 70 65 22 3a 22 74 69 63 6b 65 72 22 2c 22 63 6f 64 65 22 3a 22 42 54 43 2d 45 54 48 22 2c 22 6f 70 65 6e 69 6e 67 5f 70 72 69 63 65 22 3a ... >
         // { type: "ticker",
@@ -321,6 +343,26 @@ export default class upbit extends upbitRest {
         const messageHash = 'trade:' + marketId;
         client.resolve(stored, messageHash);
     }
+    handleOHLCV(client, message) {
+        // {
+        //     type: 'candle.1s',
+        //     code: 'KRW-USDT',
+        //     candle_date_time_utc: '2025-04-22T09:50:34',
+        //     candle_date_time_kst: '2025-04-22T18:50:34',
+        //     opening_price: 1438,
+        //     high_price: 1438,
+        //     low_price: 1438,
+        //     trade_price: 1438,
+        //     candle_acc_trade_volume: 1145.8935,
+        //     candle_acc_trade_price: 1647794.853,
+        //     timestamp: 1745315434125,
+        //     stream_type: 'REALTIME'
+        //   }
+        const marketId = this.safeString(message, 'code');
+        const messageHash = 'candle.1s:' + marketId;
+        const ohlcv = this.parseOHLCV(message);
+        client.resolve(ohlcv, messageHash);
+    }
     async authenticate(params = {}) {
         this.checkRequiredCredentials();
         const wsOptions = this.safeDict(this.options, 'ws', {});
@@ -636,6 +678,7 @@ export default class upbit extends upbitRest {
             'trade': this.handleTrades,
             'myOrder': this.handleMyOrder,
             'myAsset': this.handleBalance,
+            'candle.1s': this.handleOHLCV,
         };
         const methodName = this.safeString(message, 'type');
         const method = this.safeValue(methods, methodName);

package/js/src/timex.js

@@ -1556,7 +1556,7 @@ export default class timex extends Exchange {
                 'currency': feeCurrency,
             };
         }
-        return {
+        return this.safeTrade({
             'info': trade,
             'id': id,
             'timestamp': timestamp,
@@ -1570,7 +1570,7 @@ export default class timex extends Exchange {
             'cost': cost,
             'takerOrMaker': takerOrMaker,
             'fee': fee,
-        };
+        });
     }
     parseOHLCV(ohlcv, market = undefined) {
         //