ccxt 4.4.11 → 4.4.13

package/dist/cjs/src/okx.js

@@ -95,6 +95,7 @@ class okx extends okx$1 {
                 'fetchMarketLeverageTiers': true,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': true,
+                'fetchMarkPrices': true,
                 'fetchMySettlementHistory': false,
                 'fetchMyTrades': true,
                 'fetchOHLCV': true,
@@ -1801,6 +1802,13 @@ class okx extends okx$1 {
         return this.parseOrderBook(first, symbol, timestamp);
     }
     parseTicker(ticker, market = undefined) {
+        //
+        //      {
+        //          "instType":"SWAP",
+        //          "instId":"BTC-USDT-SWAP",
+        //          "markPx":"200",
+        //          "ts":"1597026383085"
+        //      }
         //
         //     {
         //         "instType": "SPOT",
@@ -1852,6 +1860,7 @@ class okx extends okx$1 {
             'average': undefined,
             'baseVolume': baseVolume,
             'quoteVolume': quoteVolume,
+            'markPrice': this.safeString(ticker, 'markPx'),
             'info': ticker,
         }, market);
     }
@@ -1959,6 +1968,38 @@ class okx extends okx$1 {
         const tickers = this.safeList(response, 'data', []);
         return this.parseTickers(tickers, symbols);
     }
+    async fetchMarkPrices(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#fetchMarkPrices
+         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+         * @see https://www.okx.com/docs-v5/en/#public-data-rest-api-get-mark-price
+         * @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const market = this.getMarketFromSymbols(symbols);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('fetchTickers', market, params, 'swap');
+        const request = {
+            'instType': this.convertToInstrumentType(marketType),
+        };
+        if (marketType === 'option') {
+            const defaultUnderlying = this.safeString(this.options, 'defaultUnderlying', 'BTC-USD');
+            const currencyId = this.safeString2(params, 'uly', 'marketId', defaultUnderlying);
+            if (currencyId === undefined) {
+                throw new errors.ArgumentsRequired(this.id + ' fetchTickers() requires an underlying uly or marketId parameter for options markets');
+            }
+            else {
+                request['uly'] = currencyId;
+            }
+        }
+        const response = await this.publicGetPublicMarkPrice(this.extend(request, params));
+        const tickers = this.safeList(response, 'data', []);
+        return this.parseTickers(tickers, symbols);
+    }
     parseTrade(trade, market = undefined) {
         //
         // public fetchTrades
@@ -2937,7 +2978,7 @@ class okx extends okx$1 {
          * @param {string} [params.positionSide] if position mode is one-way: set to 'net', if position mode is hedge-mode: set to 'long' or 'short'
          * @param {string} [params.trailingPercent] the percent to trail away from the current market price
          * @param {string} [params.tpOrdKind] 'condition' or 'limit', the default is 'condition'
-         * @param {string} [params.hedged] true/false, to automatically set exchange-specific params needed when trading in hedge mode
+         * @param {bool} [params.hedged] *swap and future only* true for hedged mode, false for one way mode
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -4825,38 +4866,30 @@ class okx extends okx$1 {
          * @see https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-deposit-address
          * @param {string} code unified currency code
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.network] the network name for the deposit address
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
+        await this.loadMarkets();
         const rawNetwork = this.safeStringUpper(params, 'network');
-        const networks = this.safeValue(this.options, 'networks', {});
-        const network = this.safeString(networks, rawNetwork, rawNetwork);
         params = this.omit(params, 'network');
+        code = this.safeCurrencyCode(code);
+        const network = this.networkIdToCode(rawNetwork, code);
         const response = await this.fetchDepositAddressesByNetwork(code, params);
-        let result = undefined;
-        if (network === undefined) {
-            result = this.safeValue(response, code);
+        if (network !== undefined) {
+            const result = this.safeDict(response, network);
             if (result === undefined) {
-                const alias = this.safeString(networks, code, code);
-                result = this.safeValue(response, alias);
-                if (result === undefined) {
-                    const defaultNetwork = this.safeString(this.options, 'defaultNetwork', 'ERC20');
-                    result = this.safeValue(response, defaultNetwork);
-                    if (result === undefined) {
-                        const values = Object.values(response);
-                        result = this.safeValue(values, 0);
-                        if (result === undefined) {
-                            throw new errors.InvalidAddress(this.id + ' fetchDepositAddress() cannot find deposit address for ' + code);
-                        }
-                    }
-                }
+                throw new errors.InvalidAddress(this.id + ' fetchDepositAddress() cannot find ' + network + ' deposit address for ' + code);
             }
             return result;
         }
-        result = this.safeValue(response, network);
-        if (result === undefined) {
-            throw new errors.InvalidAddress(this.id + ' fetchDepositAddress() cannot find ' + network + ' deposit address for ' + code);
+        const codeNetwork = this.networkIdToCode(code, code);
+        if (codeNetwork in response) {
+            return response[codeNetwork];
         }
-        return result;
+        // if the network is not specified, return the first address
+        const keys = Object.keys(response);
+        const first = this.safeString(keys, 0);
+        return this.safeDict(response, first);
     }
     async withdraw(code, amount, address, tag = undefined, params = {}) {
         /**

package/dist/cjs/src/oxfun.js

@@ -859,6 +859,7 @@ class oxfun extends oxfun$1 {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'currencyVolume24h'),
             'quoteVolume': undefined,
+            'markPrice': this.safeString(ticker, 'markPrice'),
             'info': ticker,
         }, market);
     }

package/dist/cjs/src/paradex.js

@@ -669,6 +669,7 @@ class paradex extends paradex$1 {
             'average': undefined,
             'baseVolume': undefined,
             'quoteVolume': this.safeString(ticker, 'volume_24h'),
+            'markPrice': this.safeString(ticker, 'mark_price'),
             'info': ticker,
         }, market);
     }

package/dist/cjs/src/phemex.js

@@ -2495,6 +2495,8 @@ class phemex extends phemex$1 {
          * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
          * @param {object} [params.stopLoss] *swap only* *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered (perpetual swap markets only)
          * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
+         * @param {string} [params.posSide] *swap only* "Merged" for one way mode, "Long" for buy side of hedged mode, "Short" for sell side of hedged mode
+         * @param {bool} [params.hedged] *swap only* true for hedged mode, false for one way mode, default is false
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
@@ -2596,15 +2598,22 @@ class phemex extends phemex$1 {
             }
         }
         else if (market['swap']) {
+            const hedged = this.safeBool(params, 'hedged', false);
+            params = this.omit(params, 'hedged');
             let posSide = this.safeStringLower(params, 'posSide');
             if (posSide === undefined) {
-                posSide = 'Merged';
+                if (hedged) {
+                    if (reduceOnly) {
+                        side = (side === 'buy') ? 'sell' : 'buy';
+                    }
+                    posSide = (side === 'buy') ? 'Long' : 'Short';
+                }
+                else {
+                    posSide = 'Merged';
+                }
             }
             posSide = this.capitalize(posSide);
             request['posSide'] = posSide;
-            if (reduceOnly !== undefined) {
-                request['reduceOnly'] = reduceOnly;
-            }
             if (market['settle'] === 'USDT') {
                 request['orderQtyRq'] = amount;
             }

package/dist/cjs/src/poloniex.js

@@ -627,6 +627,7 @@ class poloniex extends poloniex$1 {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'quantity'),
             'quoteVolume': this.safeString(ticker, 'amount'),
+            'markPrice': this.safeString(ticker, 'markPrice'),
             'info': ticker,
         }, market);
     }

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

@@ -36,6 +36,8 @@ class binance extends binance$1 {
                 'watchPositions': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchMarkPrices': true,
+                'watchMarkPrice': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
                 'createOrderWs': true,
@@ -152,6 +154,7 @@ class binance extends binance$1 {
                 'tickerChannelsMap': {
                     '24hrTicker': 'ticker',
                     '24hrMiniTicker': 'miniTicker',
+                    'markPriceUpdate': 'markPrice',
                     // rolling window tickers
                     '1hTicker': 'ticker_1h',
                     '4hTicker': 'ticker_4h',
@@ -1767,6 +1770,44 @@ class binance extends binance$1 {
         const tickers = await this.watchTickers([symbol], this.extend(params, { 'callerMethodName': 'watchTicker' }));
         return tickers[symbol];
     }
+    async watchMarkPrice(symbol, params = {}) {
+        /**
+         * @method
+         * @name binance#watchMarkPrice
+         * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/Mark-Price-Stream
+         * @description watches a mark price for a specific market
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.use1sFreq] *default is true* if set to true, the mark price will be updated every second, otherwise every 3 seconds
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbol = this.symbol(symbol);
+        const tickers = await this.watchMarkPrices([symbol], this.extend(params, { 'callerMethodName': 'watchMarkPrice' }));
+        return tickers[symbol];
+    }
+    async watchMarkPrices(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#watchMarkPrices
+         * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/Mark-Price-Stream-for-All-market
+         * @description watches the mark price for all markets
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.use1sFreq] *default is true* if set to true, the mark price will be updated every second, otherwise every 3 seconds
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        let channelName = undefined;
+        // for now watchmarkPrice uses the same messageHash as watchTicker
+        // so it's impossible to watch both at the same time
+        // refactor this to use different messageHashes
+        [channelName, params] = this.handleOptionAndParams(params, 'watchMarkPrices', 'name', 'markPrice');
+        const newTickers = await this.watchMultiTickerHelper('watchMarkPrices', channelName, symbols, params);
+        if (this.newUpdates) {
+            return newTickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTickers(symbols = undefined, params = {}) {
         /**
          * @method
@@ -1922,13 +1963,17 @@ class binance extends binance$1 {
     async watchMultiTickerHelper(methodName, channelName, symbols = undefined, params = {}) {
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols, undefined, true, false, true);
+        const isBidAsk = (channelName === 'bookTicker');
+        const isMarkPrice = (channelName === 'markPrice');
+        const use1sFreq = this.safeBool(params, 'use1sFreq', true);
         let firstMarket = undefined;
         let marketType = undefined;
         const symbolsDefined = (symbols !== undefined);
         if (symbolsDefined) {
             firstMarket = this.market(symbols[0]);
         }
-        [marketType, params] = this.handleMarketTypeAndParams(methodName, firstMarket, params);
+        const defaultMarket = (isMarkPrice) ? 'swap' : 'spot';
+        [marketType, params] = this.handleMarketTypeAndParams(methodName, firstMarket, params, defaultMarket);
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams(methodName, firstMarket, params);
         let rawMarketType = undefined;
@@ -1944,14 +1989,17 @@ class binance extends binance$1 {
         else {
             throw new errors.NotSupported(this.id + ' ' + methodName + '() does not support options markets');
         }
-        const isBidAsk = (channelName === 'bookTicker');
         const subscriptionArgs = [];
         const messageHashes = [];
+        let suffix = '';
+        if (isMarkPrice) {
+            suffix = (use1sFreq) ? '@1s' : '';
+        }
         if (symbolsDefined) {
             for (let i = 0; i < symbols.length; i++) {
                 const symbol = symbols[i];
                 const market = this.market(symbol);
-                subscriptionArgs.push(market['lowercaseId'] + '@' + channelName);
+                subscriptionArgs.push(market['lowercaseId'] + '@' + channelName + suffix);
                 messageHashes.push(this.getMessageHash(channelName, market['symbol'], isBidAsk));
             }
         }
@@ -1962,6 +2010,9 @@ class binance extends binance$1 {
                 }
                 subscriptionArgs.push('!' + channelName);
             }
+            else if (isMarkPrice) {
+                subscriptionArgs.push('!' + channelName + '@arr' + suffix);
+            }
             else {
                 subscriptionArgs.push('!' + channelName + '@arr');
             }
@@ -1994,6 +2045,17 @@ class binance extends binance$1 {
         }
     }
     parseWsTicker(message, marketType) {
+        // markPrice
+        //   {
+        //       "e": "markPriceUpdate",   // Event type
+        //       "E": 1562305380000,       // Event time
+        //       "s": "BTCUSDT",           // Symbol
+        //       "p": "11794.15000000",    // Mark price
+        //       "i": "11784.62659091",    // Index price
+        //       "P": "11784.25641265",    // Estimated Settle Price, only useful in the last hour before the settlement starts
+        //       "r": "0.00038167",        // Funding rate
+        //       "T": 1562306400000        // Next funding time
+        //   }
         //
         // ticker
         //     {
@@ -2051,10 +2113,23 @@ class binance extends binance$1 {
         //         "time":1589437530011,
         //      }
         //
+        const marketId = this.safeString2(message, 's', 'symbol');
+        const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);
         let event = this.safeString(message, 'e', 'bookTicker');
         if (event === '24hrTicker') {
             event = 'ticker';
         }
+        if (event === 'markPriceUpdate') {
+            // handle this separately because some fields clash with the ticker fields
+            return this.safeTicker({
+                'symbol': symbol,
+                'timestamp': this.safeInteger(message, 'E'),
+                'datetime': this.iso8601(this.safeInteger(message, 'E')),
+                'info': message,
+                'markPrice': this.safeString(message, 'p'),
+                'indexPrice': this.safeString(message, 'i'),
+            });
+        }
         let timestamp = undefined;
         if (event === 'bookTicker') {
             // take the event timestamp, if available, for spot tickers it is not
@@ -2064,8 +2139,6 @@ class binance extends binance$1 {
             // take the timestamp of the closing price for candlestick streams
             timestamp = this.safeIntegerN(message, ['C', 'E', 'time']);
         }
-        const marketId = this.safeString2(message, 's', 'symbol');
-        const symbol = this.safeSymbol(marketId, undefined, undefined, marketType);
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const last = this.safeString2(message, 'c', 'price');
         return this.safeTicker({
@@ -4234,6 +4307,8 @@ class binance extends binance$1 {
             '1dTicker': this.handleTickers,
             '24hrTicker': this.handleTickers,
             '24hrMiniTicker': this.handleTickers,
+            'markPriceUpdate': this.handleTickers,
+            'markPriceUpdate@arr': this.handleTickers,
             'bookTicker': this.handleBidsAsks,
             'outboundAccountPosition': this.handleBalance,
             'balanceUpdate': this.handleBalance,

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

@@ -221,15 +221,15 @@ class bitfinex extends bitfinex$1 {
         if ((last !== undefined) && (change !== undefined)) {
             open = Precise["default"].stringSub(last, change);
         }
-        const result = {
+        const result = this.safeTicker({
             'symbol': symbol,
             'timestamp': undefined,
             'datetime': undefined,
-            'high': this.safeFloat(message, 9),
-            'low': this.safeFloat(message, 10),
-            'bid': this.safeFloat(message, 1),
+            'high': this.safeString(message, 9),
+            'low': this.safeString(message, 10),
+            'bid': this.safeString(message, 1),
             'bidVolume': undefined,
-            'ask': this.safeFloat(message, 3),
+            'ask': this.safeString(message, 3),
             'askVolume': undefined,
             'vwap': undefined,
             'open': this.parseNumber(open),
@@ -237,12 +237,12 @@ class bitfinex extends bitfinex$1 {
             'last': this.parseNumber(last),
             'previousClose': undefined,
             'change': this.parseNumber(change),
-            'percentage': this.safeFloat(message, 6),
+            'percentage': this.safeString(message, 6),
             'average': undefined,
-            'baseVolume': this.safeFloat(message, 8),
+            'baseVolume': this.safeString(message, 8),
             'quoteVolume': undefined,
             'info': message,
-        };
+        });
         this.tickers[symbol] = result;
         client.resolve(result, messageHash);
     }

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

@@ -1062,6 +1062,8 @@ class krakenfutures extends krakenfutures$1 {
             'average': undefined,
             'baseVolume': this.safeString(ticker, 'volume'),
             'quoteVolume': this.safeString(ticker, 'volumeQuote'),
+            'markPrice': this.safeString(ticker, 'markPrice'),
+            'indexPrice': this.safeString(ticker, 'index'),
         });
     }
     handleOrderBookSnapshot(client, message) {

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

@@ -131,6 +131,8 @@ class phemex extends phemex$1 {
             'average': average,
             'baseVolume': baseVolume,
             'quoteVolume': quoteVolume,
+            'markPrice': this.parseNumber(this.fromEp(this.safeString(ticker, 'markPrice'), market)),
+            'indexPrice': this.parseNumber(this.fromEp(this.safeString(ticker, 'indexPrice'), market)),
             'info': ticker,
         };
         return result;

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

@@ -20,6 +20,7 @@ class woo extends woo$1 {
                 'watchOrders': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
                 'watchPositions': true,
@@ -401,6 +402,77 @@ class woo extends woo$1 {
         }
         client.resolve(result, topic);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name woo#watchBidsAsks
+         * @see https://docs.woox.io/#bbos
+         * @description watches best bid & ask for symbols
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const name = 'bbos';
+        const topic = name;
+        const request = {
+            'event': 'subscribe',
+            'topic': topic,
+        };
+        const message = this.extend(request, params);
+        const tickers = await this.watchPublic(topic, message);
+        if (this.newUpdates) {
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //         "topic": "bbos",
+        //         "ts": 1618822376000,
+        //         "data": [
+        //             {
+        //                 "symbol": "SPOT_FIL_USDT",
+        //                 "ask": 159.0318,
+        //                 "askSize": 370.43,
+        //                 "bid": 158.9158,
+        //                 "bidSize": 16
+        //             }
+        //         ]
+        //     }
+        //
+        const topic = this.safeString(message, 'topic');
+        const data = this.safeList(message, 'data', []);
+        const timestamp = this.safeInteger(message, 'ts');
+        const result = {};
+        for (let i = 0; i < data.length; i++) {
+            const ticker = this.safeDict(data, i);
+            ticker['ts'] = timestamp;
+            const parsedTicker = this.parseWsBidAsk(ticker);
+            const symbol = parsedTicker['symbol'];
+            this.bidsasks[symbol] = parsedTicker;
+            result[symbol] = parsedTicker;
+        }
+        client.resolve(result, topic);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'ts');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString(ticker, 'ask'),
+            'askVolume': this.safeString(ticker, 'askSize'),
+            'bid': this.safeString(ticker, 'bid'),
+            'bidVolume': this.safeString(ticker, 'bidSize'),
+            'info': ticker,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1181,6 +1253,7 @@ class woo extends woo$1 {
             'trade': this.handleTrade,
             'balance': this.handleBalance,
             'position': this.handlePositions,
+            'bbos': this.handleBidAsk,
         };
         const event = this.safeString(message, 'event');
         let method = this.safeValue(methods, event);

package/examples/README.md

@@ -145,6 +145,8 @@ python path/to/example.py # substitute for actual filename here
 
 [How to make your own trading bot](https://codeburst.io/how-to-make-your-own-trading-bot-83b5c6e35036) – A tutorial on algortrading in Python.
 
+[Comprehensive Cryptocurrency Trading Utility with ccxt: Real-time and Historical Data Analysis](https://medium.com/@deepml1818/comprehensive-cryptocurrency-trading-utility-with-ccxt-real-time-and-historical-data-analysis-6b9cbba57375) – A tutorial on technical analysis with CCXT.
+
 [Writing crypto trading bot in Python with Telegram and ccxt](https://medium.com/@maxAvdyushkin/writing-crypto-trading-bot-in-python-with-telegram-and-ccxt-80632a00c637) – A tutorial on programming a Telegram bot in Python with CCXT
 
 [Data science is eating the world — Here’s how you can start exploring it](https://medium.com/covee-network/data-science-is-eating-the-world-heres-how-you-can-start-exploring-it-37501414af15) – An article on collecting and analyzing financial big data.
@@ -197,6 +199,8 @@ python path/to/example.py # substitute for actual filename here
 
 [CryptoCurrency eXchange Trading library - CCXT](https://barbotine.medium.com/crypto-currency-exchange-trading-library-ccxt-34ed66ebede8) – An overview of CCXT.
 
+[Simplifying Trading Automation with CCXT](https://j4nt4ncrypto.medium.com/simplifying-trading-automation-with-ccxt-creating-orders-and-fetching-positions-on-kucoin-futures-d42c329577de) – Creating Orders and Fetching Positions on Kucoin Futures.
+
 [https://python.plainenglish.io/cryptocurrency-trading-with-python-5f655d06a4bd](Cryptocurrency Trading with Python) – How to trade cryptocurrencies with CCXT in Python.
 
 [비트코인 해외 거래소 API - 바이낸스 CCXT설치](https://www.youtube.com/watch?v=7dMGbjwZwlU) – Using CCXT to trade with Binance API, a video overview of CCXT in Korean.

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 type { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarketMarginModes, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
-declare const version = "4.4.10";
+declare const version = "4.4.12";
 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, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.4.11';
+const version = '4.4.13';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -555,6 +555,7 @@ export default class Exchange {
             fetchTicker: boolean;
             fetchTickerWs: any;
             fetchTickers: any;
+            fetchMarkPrices: any;
             fetchTickersWs: any;
             fetchTime: any;
             fetchTrades: boolean;
@@ -967,6 +968,7 @@ export default class Exchange {
     fetchTickerWs(symbol: string, params?: {}): Promise<Ticker>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    fetchMarkPrices(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchTickersWs(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchOrderBooks(symbols?: Strings, limit?: Int, params?: {}): Promise<Dictionary<OrderBook>>;
     watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;

package/js/src/base/Exchange.js

@@ -1443,6 +1443,7 @@ export default class Exchange {
                 'fetchTicker': true,
                 'fetchTickerWs': undefined,
                 'fetchTickers': undefined,
+                'fetchMarkPrices': undefined,
                 'fetchTickersWs': undefined,
                 'fetchTime': undefined,
                 'fetchTrades': true,
@@ -3197,6 +3198,8 @@ export default class Exchange {
             'baseVolume': this.parseNumber(baseVolume),
             'quoteVolume': this.parseNumber(quoteVolume),
             'previousClose': this.safeNumber(ticker, 'previousClose'),
+            'indexPrice': this.safeNumber(ticker, 'indexPrice'),
+            'markPrice': this.safeNumber(ticker, 'markPrice'),
         });
     }
     async fetchBorrowRate(code, amount, params = {}) {
@@ -4421,6 +4424,9 @@ export default class Exchange {
     async fetchTickers(symbols = undefined, params = {}) {
         throw new NotSupported(this.id + ' fetchTickers() is not supported yet');
     }
+    async fetchMarkPrices(symbols = undefined, params = {}) {
+        throw new NotSupported(this.id + ' fetchMarkPrices() is not supported yet');
+    }
     async fetchTickersWs(symbols = undefined, params = {}) {
         throw new NotSupported(this.id + ' fetchTickers() is not supported yet');
     }

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

@@ -144,22 +144,24 @@ export interface Ticker {
     info: any;
     timestamp: Int;
     datetime: Str;
-    high: Int;
-    low: Int;
-    bid: Int;
-    bidVolume: Int;
-    ask: Int;
-    askVolume: Int;
-    vwap: Int;
-    open: Int;
-    close: Int;
-    last: Int;
-    previousClose: Int;
-    change: Int;
-    percentage: Int;
-    average: Int;
-    quoteVolume: Int;
-    baseVolume: Int;
+    high: Num;
+    low: Num;
+    bid: Num;
+    bidVolume: Num;
+    ask: Num;
+    askVolume: Num;
+    vwap: Num;
+    open: Num;
+    close: Num;
+    last: Num;
+    previousClose: Num;
+    change: Num;
+    percentage: Num;
+    average: Num;
+    quoteVolume: Num;
+    baseVolume: Num;
+    indexPrice: Num;
+    markPrice: Num;
 }
 export interface Transaction {
     info: any;