ccxt 4.2.99 → 4.3.1

package/examples/js/search-all-exchanges.js

@@ -1,159 +0,0 @@
-import asTable from 'as-table';
-import ololog from 'ololog';
-import path from 'path';
-import fs from 'fs';
-import ansicolor from 'ansicolor';
-import ccxt from '../../js/ccxt.js';
-
-const { noLocate } = ololog;
-const log = noLocate;
-
-ansicolor.nice
-/*  ------------------------------------------------------------------------ */
-
-const [processPath, , argument = null] = process.argv.filter (x => !x.startsWith ('--'))
-    , verbose = process.argv.includes ('--verbose')
-    , strict  = process.argv.includes ('--strict')
-    , compact = process.argv.includes ('--compact')
-    , debug = process.argv.includes ('--debug')
-    , marketsOnly = process.argv.includes ('--markets')
-    , currenciesOnly = process.argv.includes ('--currencies')
-
-/*  ------------------------------------------------------------------------ */
-
-const warn = log.bright.yellow.error // .error → stderr
-
-/*  ------------------------------------------------------------------------ */
-
-process.on ('uncaughtException',  e => { log.bright.red.error (e); process.exit (1) })
-process.on ('unhandledRejection', e => { log.bright.red.error (e); process.exit (1) })
-
-/*  ------------------------------------------------------------------------ */
-
-let printUsage = function () {
-    log ('     Non-strict search: node', process.argv[1], 'symbol'.green)
-    log ('     Non-strict search: node', process.argv[1], 'currency'.green)
-    log ('         Strict search: node', process.argv[1], '--strict', 'argument'.green)
-    log ('   Search markets only: node', process.argv[1], '--markets', 'argument'.green)
-    log ('Search currencies only: node', process.argv[1], '--currencies', 'argument'.green)
-
-}
-
-if (process.argv.length < 3) {
-    printUsage ()
-    process.exit ()
-}
-
-/*  ------------------------------------------------------------------------ */
-
-const keysGlobal = path.resolve ('keys.json')
-const keysLocal = path.resolve ('keys.local.json')
-let globalKeysFile = fs.existsSync (keysGlobal) ? keysGlobal : false
-let localKeysFile = fs.existsSync (keysLocal) ? keysLocal : globalKeysFile
-
-const keys = JSON.parse (fs.readFileSync (localKeysFile))
-
-/*  ------------------------------------------------------------------------ */
-
-log ('Looking up for:', argument.bright, strict ? '(strict search)' : '(non-strict search)')
-
-const checkAgainst = strict ?
-    (a, b) => (a || '').toUpperCase ().includes ((b || '').toUpperCase ()) :
-    (a, b) => (a || '').toLowerCase ().includes ((b || '').toLowerCase ())
-
-;(async function test () {
-
-    let exchanges = await Promise.all (ccxt.exchanges.map (async id => {
-
-        // instantiate the exchange
-        let exchange = new ccxt[id] (ccxt.extend (localKeysFile ? (keys[id] || {}) : {}, {
-            // agent, // set up keys and settings, if any
-        }))
-
-        if (exchange.has.fetchMarkets) {
-
-            try {
-
-                // load markets
-                await exchange.loadMarkets ()
-                return exchange
-
-            } catch (e) {
-
-                if (debug) {
-                    log.red (exchange.id, e.constructor.name)
-                }
-                return undefined
-            }
-        }
-    }))
-
-    // filter out exchanges that failed to load
-    exchanges = exchanges.filter (exchange => exchange)
-
-    if (!currenciesOnly) {
-
-        log ("---------------------------------------------------------------")
-
-        log ("Markets And Symbols:")
-
-        let markets = ccxt.flatten (exchanges
-            .map (exchange =>
-                Object.values (exchange.markets).map (market =>
-                    exchange.extend (market, {
-                        exchange: exchange.id[(market.active !== false) ? 'green' : 'yellow'],
-                    }))))
-            .filter (market => {
-                try {
-                    return (
-                        checkAgainst (market['base'],  argument) ||
-                        checkAgainst (market['quote'], argument) ||
-                        (market['baseId']  ? checkAgainst (market['baseId'].toString (),  argument) : false) ||
-                        (market['quoteId'] ? checkAgainst (market['quoteId'].toString (), argument) : false) ||
-                        checkAgainst (market['symbol'], argument) ||
-                        checkAgainst (market['id'].toString (), argument) ||
-                        checkAgainst (market['type'], argument)
-                    )
-                } catch (e) {
-                    if (debug) {
-                        log.red (e.constructor.name, e.message)
-                    }
-                    return false
-                }
-            })
-
-        log (asTable (markets.map (market => {
-            market = ccxt.omit (market, [ 'info', 'limits', 'precision', 'tiers' ])
-            return (!compact) ? market : {
-                'symbol': market['symbol'],
-                'exchange': market['exchange'],
-            };
-        })))
-
-        log (markets.length.toString ().yellow, 'markets')
-    }
-
-    if (!marketsOnly) {
-
-        log ("---------------------------------------------------------------")
-
-        log ("Currencies:")
-
-        let currencies = ccxt.flatten (exchanges
-            .map (exchange =>
-                Object.values (exchange.currencies).map (currency =>
-                    exchange.extend (currency, {
-                        exchange: exchange.id[(currency.active !== false) ? 'green' : 'yellow'],
-                    }))))
-            .filter (currency =>
-                checkAgainst (currency['code'], argument) ||
-                checkAgainst (currency['id'], argument))
-
-        log (asTable (currencies.map (currency => ccxt.omit (currency, [ 'info', 'limits', 'precision' ]))))
-
-        log (currencies.length.toString ().yellow, 'currencies')
-    }
-
-    process.exit ()
-
-}) ()

package/examples/js/shared-load-markets.js

@@ -1,80 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-
-// ----------------------------------------------------------------------------
-// an example of how to load markets for each exchange just once
-// in order to save memory and time for initializing multiple exchange instances
-// see https://github.com/ccxt/ccxt/issues/7312 for details
-// ----------------------------------------------------------------------------
-
-const globalIds = [ 'binance', 'poloniex', 'bittrex', 'bitstamp' ]
-const globalExchanges = {}
-
-async function loadExchange (id) {
-    try {
-        const exchange = new ccxt[id] ()
-        await exchange.loadMarkets ()
-        globalExchanges[id] = exchange
-    } catch (e) {
-        // throw e // uncomment to break the entire program on any error
-        // console.log (e) // print the exception and ignore this exchange
-    }
-}
-
-async function main () {
-
-    // initialize unique global exchange instances first
-    await Promise.all (globalIds.map (async (id) => loadExchange (id)))
-    console.log ('Loaded global exchanges:', Object.keys (globalExchanges))
-
-    // load user exchanges and keys from a database or configure these via JSON
-    const users = {
-        'user1': {
-            'binance': { 'apiKey': 'USER1_BINANCE_API_KEY', 'secret': 'USER1_BINANCE_SECRET' },
-            'poloniex': { 'apiKey': 'USER1_POLONIEX_API_KEY', 'secret': 'USER1_POLONIEX_SECRET' }
-        },
-        'user2': {
-            'poloniex': { 'apiKey': 'USER2_POLONIEX_API_KEY', 'secret': 'USER2_POLONIEX_SECRET' },
-            'bittrex': { 'apiKey': 'USER2_BITTREX_API_KEY', 'secret': 'USER2_BITTREX_SECRET' }
-        },
-        'user3': {
-            'bittrex': { 'apiKey': 'USER3_BITTREX_API_KEY', 'secret': 'USER3_BITTREX_SECRET' },
-            'bitstamp': { 'apiKey': 'USER3_BITSTAMP_API_KEY', 'secret': 'USER3_BITSTAMP_SECRET' }
-        }
-    }
-
-    // initialize local exchanges per user
-    const localExchanges = {}
-    for (const userId in users) {
-        const userExchanges = {}
-        for (const exchangeId in users[userId]) {
-            if (exchangeId in globalExchanges) {
-                const globalExchange = globalExchanges[exchangeId]
-                const exchange = new ccxt[exchangeId] ({
-                    // 'verbose': true, // uncomment for debug output
-                    ... users[userId][exchangeId],
-                });
-                [
-                    'ids',
-                    'markets',
-                    'markets_by_id',
-                    'currencies',
-                    'currencies_by_id',
-                    'baseCurrencies',
-                    'quoteCurrencies',
-                    'symbols',
-                ].forEach ((propertyName) => {
-                    exchange[propertyName] = globalExchange[propertyName]
-                })
-                userExchanges[exchangeId] = exchange
-            }
-        }
-        localExchanges[userId] = userExchanges
-    }
-
-    // print the loaded exchanges per user
-    for (const userId in localExchanges) {
-        console.log ('Loaded', userId, Object.keys (localExchanges[userId]))
-    }
-}
-
-main ()

package/examples/js/sort-swap-markets-by-hourly-price-change.js

@@ -1,55 +0,0 @@
-'use strict';
-
-const ccxt = require ('../../ccxt.js');
-
-const exchange = new ccxt.binanceusdm ();
-const timeframe = '1h';
-const type = 'swap';
-
-async function fetchOHLCV (symbol) {
-    /**
-     * @description Wrapper around exchange.fetchOHLCV method
-     * @param {string} symbol CCXT unified symbol
-     * @returns {[float|str]} 1d array with a single ohlcv record with the market symbol appended
-     */
-    try {
-        const ohlcv = await exchange.fetchOHLCV (symbol, timeframe, undefined, 1);
-        ohlcv[0].push (symbol);
-        return ohlcv[0];
-    } catch (err) {
-        console.log (symbol + ' failed fetchOHLCV with error ' + err)
-    }
-}
-
-function getPriceChangePercent (ohlcv) {
-    /**
-     * @description Gets the price change of a market as a percentage
-     * @param {[float]} ohlcv A single ohlcv record with the market symbol appended
-     * @returns {[float, str]} The price change as a percent with the symbol for the market
-     */
-    const open = ohlcv[1];
-    const close = ohlcv[4];
-    const symbol = ohlcv[6];
-    const priceIncrease = close - open;
-    const increaseAsRatio = priceIncrease / open;
-    const increaseAsPercent = increaseAsRatio * 100;
-    return [increaseAsPercent, symbol]
-}
-
-function sort (a, b) {
-    return a[0] - b[0];
-}
-
-async function main () {
-    /**
-     * @description Gets the price change as a percent of every market matching type over the last timeframe matching timeframe and prints a sorted list. The most immediate candle is ignored because it is incomplete
-     */
-    await exchange.loadMarkets ();
-    const allSwapSymbols = exchange.symbols.filter (symbol => exchange.market (symbol)[type] );
-    const ohlcvs = await Promise.all (allSwapSymbols.map (symbol => fetchOHLCV (symbol)));
-    const priceChanges = ohlcvs.map (ohlcv => getPriceChangePercent (ohlcv));
-    const sorted = priceChanges.sort (sort);
-    console.dir(sorted, {'maxArrayLength': null})
-}
-
-main ()

package/examples/js/symbols.js

@@ -1,110 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import fs from 'fs';
-import ololog from 'ololog';
-import ansicolor from 'ansicolor';
-import asTable from 'as-table';
-
-const { noLocate } = ololog;
-const log = noLocate;
-
-ansicolor.nice
-const table = asTable.configure ({ delimiter: ' | ' }), verbose   = process.argv.includes ('--verbose'), debug     = process.argv.includes ('--debug');
-
-//-----------------------------------------------------------------------------
-
-let printSupportedExchanges = function () {
-    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
-}
-
-let printUsage = function () {
-    log ('Usage: node', process.argv[1], 'id'.green)
-    printSupportedExchanges ()
-}
-
-let printSymbols = async (id) => {
-
-    // check if the exchange is supported by ccxt
-    let exchangeFound = ccxt.exchanges.indexOf (id) > -1
-    if (exchangeFound) {
-
-        log ('Instantiating', id.green, 'exchange')
-
-        // set up keys and settings, if any
-        const keysGlobal = 'keys.json'
-        const keysLocal = 'keys.local.json'
-
-        let keysFile = fs.existsSync (keysLocal) ? keysLocal : (fs.existsSync (keysGlobal) ? keysGlobal : false)
-        let settings = keysFile ? (require ('../../' + keysFile)[id] || {}) : {}
-
-        // instantiate the exchange by id
-        let exchange = new ccxt[id] (ccxt.extend ({
-            verbose,
-            // 'proxy': 'https://cors-anywhere.herokuapp.com/',
-            // 'proxy': 'https://crossorigin.me/',
-        }, settings))
-
-        // Object.assign (exchange, settings)
-
-        // load all markets from the exchange
-        let markets = await exchange.loadMarkets ()
-
-        // debug log
-        if (debug)
-            Object.values (markets).forEach (market => log (market))
-
-        log ("\nSymbols:\n")
-
-        // make a table of all markets
-
-        const marketsList =
-            ccxt.sortBy (Object.values (markets), 'symbol')
-                .map (market =>
-                    ccxt.omit (market, [ 'info', 'limits', 'precision', 'fees' ]))
-
-        let table = table (marketsList)
-        log (table)
-
-        log ("\n---------------------------------------------------------------")
-
-        log ("\nCurrencies:\n")
-
-        // make a table of all currencies
-
-        const currenciesList =
-            ccxt.sortBy (Object.values (exchange.currencies), 'code')
-                .map (currency =>
-                    ccxt.omit (currency, [ 'info', 'limits' ]))
-
-        const currenciesTable = table (currenciesList)
-        log (currenciesTable)
-
-        log ("\n---------------------------------------------------------------")
-
-        // output a summary
-        log (id.green, 'has', exchange.symbols.length.toString ().yellow, 'symbols and',
-            Object.keys (exchange.currencies).length.toString ().yellow, "currencies\n")
-
-    } else {
-
-        log ('Exchange ' + id.red + ' not found')
-        printSupportedExchanges ()
-    }
-}
-
-;(async function main () {
-
-    if (process.argv.length > 2) {
-
-        let id = process.argv[2]
-        await printSymbols (id)
-
-    } else {
-
-        printUsage ()
-    }
-
-    process.exit ()
-
-}) ()

package/examples/js/theocean.js

@@ -1,41 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-(async function main () {
-    const walletAddress = process.env['WALLET_ADDRESS']
-    const privateKey = process.env['PRIVATE_KEY']
-    const apiKey = process.env['API_KEY']
-    const secret = process.env['SECRET']
-
-    const ocean = new ccxt.theocean({
-        walletAddress,
-        privateKey,
-        apiKey,
-        secret
-    });
-
-    // get balance
-    const balance = await ocean.fetchBalanceByCode('REP');
-    console.log('REP balance: ', balance);
-
-    // get order book
-    const orderBook = await ocean.fetchOrderBook('REP/ZRX');
-    console.log('REP/ZRX orderbook: ', orderBook);
-
-    // placing order
-    const placeResult = await ocean.createOrder('REP/ZRX', 'limit', 'sell', '0.5', '30');
-    const id = placeResult['id'];
-    console.log('result of placing order: ', placeResult);
-
-    // cancel order
-    if (placeResult['remaining'] > 0) {
-        const cancelResult = await ocean.cancelOrder(id);
-        console.log('cancel result: ', cancelResult);
-    }
-
-    // cancel all open user orders
-    const cancelAllOrderssResult = await ocean.cancelAllOrders();
-    console.log('cancel all orders result: ', cancelAllOrderssResult);
-
-    process.exit ();
-}) ()

package/examples/js/tickers.js

@@ -1,106 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import asTable from 'as-table';
-import ansicolor from 'ansicolor';
-import ololog from 'ololog';
-
-const log = ololog.configure ({ locate: false }), verbose   = process.argv.includes ('--verbose');
-
-ansicolor.nice
-
-//-----------------------------------------------------------------------------
-
-let printSupportedExchanges = function () {
-    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
-}
-
-let printUsage = function () {
-    log ('Usage: node', process.argv[1], 'id'.green, '[symbol]'.yellow)
-    printSupportedExchanges ()
-}
-
-let printSymbols = function (exchange) {
-    log (id.green, 'has', exchange.symbols.length, 'symbols:', exchange.symbols.join (', ').yellow)
-}
-
-let sleep = (ms) => new Promise (resolve => setTimeout (resolve, ms))
-
-let printTicker = async (exchange, symbol) => {
-    let ticker = await exchange.fetchTicker (symbol)
-    log (exchange.id.green, symbol.yellow, 'ticker',
-        ticker['datetime'],
-        'high: '    + ticker['high'],
-        'low: '     + ticker['low'],
-        'bid: '     + ticker['bid'],
-        'ask: '     + ticker['ask'],
-        'volume: '  + ticker['baseVolume'])
-    return ticker
-}
-
-//-----------------------------------------------------------------------------
-
-let printTickers = async (id) => {
-
-    log ('Instantiating', id.green, 'exchange exchange')
-
-    // instantiate the exchange by id
-    let exchange = new ccxt[id] ({ verbose })
-
-    // load all markets from the exchange
-    let markets = await exchange.loadMarkets ()
-
-    if (process.argv.length > 3) { // if a symbol was supplied, get that symbol only
-
-        let symbol = process.argv[3]
-
-        await printTicker (exchange, symbol)
-
-    } else { // otherwise run through all symbols one by one
-
-        for (let symbol of exchange.symbols)
-            if ((symbol.indexOf ('.d') < 0)) { // skip darkpool symbols
-
-                const market = exchange.markets[symbol];
-
-                if (!market['active']) {
-                    log.red (exchange.id + ' ' + symbol + ' inactive');
-                    continue;
-                }
-
-                await sleep (exchange.rateLimit)
-                await printTicker (exchange, symbol)
-            }
-    }
-}
-
-//-----------------------------------------------------------------------------
-
-;(async function main () {
-
-    if (process.argv.length > 2) {
-
-        let id = process.argv[2]
-
-        // check if the exchange is supported by ccxt
-        let exchangeFound = ccxt.exchanges.indexOf (id) > -1
-
-        if (exchangeFound) {
-
-            await printTickers (id)
-
-        } else {
-
-            log ('Exchange ' + id.red + ' not found')
-            printUsage ()
-        }
-
-    } else {
-
-        printUsage ()
-
-    }
-
-    process.exit ()
-
-}) ()

package/examples/js/validate-paginated-data.js

@@ -1,61 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import ololog from 'ololog'
-import ansicolor from 'ansicolor';
-
-const log = ololog.configure ({ locate: false })
-
-ansicolor.nice
-
-//-----------------------------------------------------------------------------
-
-/*
-* Warning: Sometimes the exchanges have gaps in their OHLCV data, so it does not mean
-* that CCXT is broken if you see gaps in the chart.
-*/
-
-async function fetchData(exchange, symbol, timeframe) {
-    await exchange.loadMarkets()
-    // exchange.verbose = true;
-    const duration = exchange.parseTimeframe (timeframe) *1000; // in milliseconds
-    const ohlcv = await exchange.fetchOHLCV (symbol, timeframe, undefined, undefined, {'paginate': true, 'paginationCalls': 5})
-    validateTimeframes(ohlcv, duration, exchange, symbol)
-}
-
-function validateTimeframes(ohlcv, duration, exchange, symbol) {
-    for (let j = 0; j < ohlcv.length; j++) {
-        const [timestamp, open, high, low, close, volume] = ohlcv[j]
-        if (j > 0) {
-            const [prevTimestamp, prevOpen, prevHigh, prevLow, prevClose, prevVolume] = ohlcv[j - 1]
-            if (timestamp - prevTimestamp !== duration) {
-                log.red ('[' + j + ']',exchange.id, symbol, 'OHLCV data is not continuous, at', exchange.iso8601 (timestamp), 'diff:', ((timestamp - prevTimestamp) / 1000), 's expected:', duration/ 1000, 's')
-            }
-        }
-    }
-    log.green(exchange.id, symbol, `All the ${ohlcv.length} candles returned are continuous`)
-}
-
-async function main () {
-
-    const exchanges = {
-        'binance': 'BTC/USDT',
-        'bitget': 'BTC/USDT',
-        'kucoin': 'BTC/USDT',
-        'kucoinfutures': 'BTC/USDT:USDT',
-        'okex': 'BTC/USDT',
-        'bybit': 'BTC/USDT'
-    }
-    const timeframe = '1m';
-    const keys = Object.keys (exchanges)
-    const promises = [];
-    for (let i = 0; i < keys.length; i++) {
-        const name = keys[i]
-        const symbol = exchanges[name]
-        const exchange = new ccxt[name] ({ enableRateLimit: true })
-        promises.push(fetchData(exchange, symbol, timeframe))
-    }
-    await Promise.all(promises)
-}
-
-main()

package/examples/js/watch-OHLCV-For-Symbols.js

@@ -1,15 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const binance = new ccxt.pro.binance({});
-    const subscriptions = [
-        ['BTC/USDT', '5m'],
-        ['ETH/USDT', '5m'],
-        ['BTC/USDT', '1h'],
-    ];
-    while (true) {
-        const ohlcv = await binance.watchOHLCVForSymbols(subscriptions);
-        console.log(ohlcv);
-    }
-}
-await example();

package/examples/js/watch-OHLCV.js

@@ -1,12 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const binance = new ccxt.pro.binance({});
-    const symbol = 'BTC/USDT';
-    const timeframe = '1m';
-    while (true) {
-        const ohlcv = await binance.watchOHLCV(symbol, timeframe);
-        console.log(ohlcv);
-    }
-}
-await example();

package/examples/js/watch-OrderBook-For-Symbols.js

@@ -1,11 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const binance = new ccxt.pro.binance({});
-    const symbols = ['BTC/USDT', 'ETH/USDT', 'DOGE/USDT'];
-    while (true) {
-        const orderbook = await binance.watchOrderBookForSymbols(symbols);
-        console.log(orderbook['symbol'], orderbook['asks'][0], orderbook['bids'][0]);
-    }
-}
-await example();

package/examples/js/watch-Trades-For-Symbols.js

@@ -1,11 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const binance = new ccxt.pro.binance({});
-    const symbols = ['BTC/USDT', 'ETH/USDT', 'DOGE/USDT'];
-    while (true) {
-        const trades = await binance.watchTradesForSymbols(symbols);
-        console.log(trades);
-    }
-}
-await example();

package/examples/js/watch-tickers.js

@@ -1,11 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const binance = new ccxt.pro.binance({});
-    const symbols = ['BTC/USDT', 'ETH/USDT', 'DOGE/USDT'];
-    while (true) {
-        const tickers = await binance.watchTickers(symbols);
-        console.log(tickers['BTC/USDT'], tickers['ETH/USDT'], tickers['DOGE/USDT']);
-    }
-}
-await example();