ccxt 4.2.73 → 4.2.75

package/examples/js/latoken-example.js

@@ -0,0 +1,108 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog';
+import asTable from 'as-table';
+
+
+const table   = asTable.configure ({ delimiter: ' | ' }),
+      //-----------------------------------------------------------------------------
+      log       = ololog.unlimited.noLocate.handleNodeErrors ();(async function main () {
+
+    const symbol = 'BTC/USDT'
+
+    const exchange = new ccxt.latoken ({
+        'verbose': process.argv.includes ('--verbose'),
+        // uncomment and change for your keys to enable private calls
+        // 'apiKey': 'YOUR_API_KEY',
+        // 'secret': 'YOUR_API_SECRET',
+    })
+
+    await exchange.loadMarkets ()
+
+    log ('-------------------------------------------------------------------')
+
+    log (exchange.id, 'has', exchange.has)
+
+    // public API
+
+    log ('-------------------------------------------------------------------')
+
+    const markets = Object.values (exchange.markets)
+    log ('Loaded', markets.length, exchange.id, 'markets:')
+    log (table (markets.map (x => exchange.omit (x, [ 'info', 'limits', 'precision' ]))))
+
+    log ('-------------------------------------------------------------------')
+
+    const currencies = Object.values (exchange.currencies)
+    log ('Loaded', currencies.length, exchange.id, 'currencies:')
+    log (table (currencies.map (x => exchange.omit (x, [ 'info', 'limits' ]))))
+
+    log ('-------------------------------------------------------------------')
+
+    const time = await exchange.fetchTime ()
+    log ('Exchange time:', exchange.iso8601 (time))
+
+    log ('-------------------------------------------------------------------')
+
+    const ticker = await exchange.fetchTicker (symbol)
+    log (ticker)
+
+    log ('-------------------------------------------------------------------')
+
+    const tickers = await exchange.fetchTickers ()
+    log (table (Object.values (tickers).map (x =>
+        exchange.omit (x, [ 'info', 'bid', 'ask', 'bidVolume', 'askVolume', 'timestamp' ]))))
+
+    log ('-------------------------------------------------------------------')
+
+    const orderbook = await exchange.fetchOrderBook (symbol)
+    log (orderbook)
+
+    log ('-------------------------------------------------------------------')
+
+    const trades = await exchange.fetchTrades (symbol)
+    log (table (trades.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
+
+    log ('-------------------------------------------------------------------')
+
+    // private API
+
+    if (exchange.checkRequiredCredentials (false)) {
+
+        const balance = await exchange.fetchBalance ()
+        log (exchange.omit (balance, [ 'info' ]))
+
+        log ('-------------------------------------------------------------------')
+
+        const order = await exchange.createOrder (symbol, 'limit', 'buy', 0.001, 10000)
+        log (order)
+
+        log ('-------------------------------------------------------------------')
+
+        const openOrders = await exchange.fetchOpenOrders (symbol)
+        log (table (openOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
+
+        log ('-------------------------------------------------------------------')
+
+        const canceled = await exchange.cancelOrder (order['id'], order['symbol'])
+        log (canceled)
+
+        log ('-------------------------------------------------------------------')
+
+        const closedOrders = await exchange.fetchClosedOrders (symbol)
+        log (table (closedOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
+
+        log ('-------------------------------------------------------------------')
+
+        const canceledOrders = await exchange.fetchCanceledOrders (symbol)
+        log (table (canceledOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
+
+        log ('-------------------------------------------------------------------')
+
+        const myTrades = await exchange.fetchMyTrades (symbol)
+        log (table (myTrades.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
+
+    }
+
+}) ()

package/examples/js/live-orderbook.js

@@ -0,0 +1,106 @@
+
+
+import asTable from 'as-table';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+import ccxt from '../../js/ccxt.js';
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+ansicolor.nice
+
+let printSupportedExchanges = function () {
+    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
+}
+
+let printUsage = function () {
+    log ('Usage: node', process.argv[1], 'exchange'.green, 'symbol'.yellow, 'depth'.cyan)
+    printSupportedExchanges ()
+}
+
+let printOrderBook = async (id, symbol, depth) => {
+
+    // check if the exchange is supported by ccxt
+    let exchangeFound = ccxt.exchanges.indexOf (id) > -1
+    if (exchangeFound) {
+
+        log ('Instantiating', id.green, 'exchange')
+
+        // instantiate the exchange by id
+        let exchange = new ccxt[id] ()
+
+        // load all markets from the exchange
+        let markets = await exchange.loadMarkets ()
+
+        // output a list of all market symbols
+        // log (id.green, 'has', exchange.symbols.length, 'symbols:', exchange.symbols.join (', ').yellow)
+
+        if (symbol in exchange.markets) {
+
+            const market = exchange.markets[symbol]
+            const pricePrecision = market.precision ? market.precision.price : 8
+            const amountPrecision = market.precision ? market.precision.amount : 8
+
+            // Object.values (markets).forEach (market => log (market))
+
+            // make a table of all markets
+            // const table = asTable.configure ({ delimiter: ' | ' }) (Object.values (markets))
+            // log (table)
+
+            const priceVolumeHelper = color => ([price, amount]) => ({
+                price: price.toFixed (pricePrecision)[color],
+                amount: amount.toFixed (amountPrecision)[color],
+                '  ': '  ',
+            })
+
+            const cursorUp = '\u001b[1A'
+            const tableHeight = depth * 2 + 4 // bids + asks + headers
+
+            log (' ') // empty line
+
+            while (true) {
+
+                const orderbook = await exchange.fetchOrderBook (symbol)
+
+                log (symbol.green, exchange.iso8601 (exchange.milliseconds ()))
+
+                log (asTable.configure ({ delimiter: ' | '.dim, right: true }) ([
+                    ... orderbook.asks.slice (0, depth).reverse ().map (priceVolumeHelper ('red')),
+                    // { price: '--------'.dim, amount: '--------'.dim },
+                    ... orderbook.bids.slice (0, depth).map (priceVolumeHelper ('green')),
+                ]))
+
+                log (cursorUp.repeat (tableHeight))
+            }
+
+        } else {
+
+            log.error ('Symbol', symbol.bright, 'not found')
+        }
+
+
+    } else {
+
+        log ('Exchange ' + id.red + ' not found')
+        printSupportedExchanges ()
+    }
+}
+
+;(async function main () {
+
+    if (process.argv.length > 4) {
+
+        const id = process.argv[2]
+        const symbol = process.argv[3].toUpperCase ()
+        const depth = parseInt (process.argv[4])
+        await printOrderBook (id, symbol, depth)
+
+    } else {
+
+        printUsage ()
+    }
+
+    process.exit ()
+
+}) ()

package/examples/js/live-ticker.js

@@ -0,0 +1,80 @@
+
+
+import asTable from 'as-table';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+import ccxt from '../../js/ccxt.js';
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+ansicolor.nice
+
+let printSupportedExchanges = function () {
+    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
+}
+
+let printUsage = function () {
+    log ('Usage: node', process.argv[1], 'exchange'.green, 'symbol'.yellow, '[rateLimit]'.magenta)
+    printSupportedExchanges ()
+}
+
+let printTicker = async (id, symbol, rateLimit = undefined) => {
+
+    // check if the exchange is supported by ccxt
+    let exchangeFound = ccxt.exchanges.indexOf (id) > -1
+    if (exchangeFound) {
+
+        log ('Instantiating', id.green, 'exchange')
+
+        // instantiate the exchange by id
+        let exchange = new ccxt[id] ()
+
+        exchange.rateLimit = rateLimit ? rateLimit : exchange.rateLimit
+
+        log.green ('Rate limit:', exchange.rateLimit.toString ().bright)
+
+        // load all markets from the exchange
+        let markets = await exchange.loadMarkets ()
+
+        if (symbol in exchange.markets) {
+
+            while (true) {
+
+                const ticker = await exchange.fetchTicker (symbol)
+
+                log ('--------------------------------------------------------')
+                log (exchange.id.green, symbol.yellow, exchange.iso8601 (exchange.milliseconds ()))
+                log (ccxt.omit (ticker, 'info'))
+            }
+
+        } else {
+
+            log.error ('Symbol', symbol.bright, 'not found')
+        }
+
+
+    } else {
+
+        log ('Exchange ' + id.red + ' not found')
+        printSupportedExchanges ()
+    }
+}
+
+;(async function main () {
+
+    if (process.argv.length > 3) {
+
+        const id = process.argv[2]
+        const symbol = process.argv[3].toUpperCase ()
+        const rateLimit = process.argv[4] ? parseInt (process.argv[4]) : undefined
+        await printTicker (id, symbol, rateLimit)
+
+    } else {
+
+        printUsage ()
+    }
+
+    process.exit ()
+
+}) ()

package/examples/js/live-tickers.js

@@ -0,0 +1,74 @@
+
+
+import asTable from 'as-table';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+import ccxt from '../../js/ccxt.js';
+
+ansicolor.nice
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+let printSupportedExchanges = function () {
+    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
+}
+
+let printUsage = function () {
+    log ('Usage: node', process.argv[1], 'exchange'.green)
+    printSupportedExchanges ()
+}
+
+let printTickers = async (id) => {
+
+    // check if the exchange is supported by ccxt
+    let exchangeFound = ccxt.exchanges.indexOf (id) > -1
+    if (exchangeFound) {
+
+        log ('Instantiating', id.green, 'exchange')
+
+        // instantiate the exchange by id
+        let exchange = new ccxt[id] ()
+
+        // load all markets from the exchange
+        let markets = await exchange.loadMarkets ()
+
+        while (true) {
+
+            const tickers = await exchange.fetchTickers ()
+
+            log ('--------------------------------------------------------')
+            log (exchange.id.green, exchange.iso8601 (exchange.milliseconds ()))
+            log ('Fetched', Object.values (tickers).length.toString ().green, 'tickers:')
+            log (asTable.configure ({ delimiter: ' | '.dim, right: true }) (
+                ccxt.sortBy (Object.values (tickers), 'quoteVolume', true)
+                                   .slice (0,20)
+                                   .map (ticker => ({
+                                        symbol: ticker['symbol'],
+                                        price: ticker['last'].toFixed (8),
+                                        datetime: ticker['datetime'],
+                                   }))))
+        }
+
+    } else {
+
+        log ('Exchange ' + id.red + ' not found')
+        printSupportedExchanges ()
+    }
+}
+
+;(async function main () {
+
+    if (process.argv.length > 2) {
+
+        const id = process.argv[2]
+        await printTickers (id)
+
+    } else {
+
+        printUsage ()
+    }
+
+    process.exit ()
+
+}) ()

package/examples/js/load-all-contracts.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const ccxt = require ('../../ccxt.js')
+
+console.log ('CCXT Version:', ccxt.version)
+
+async function loadExchange (exchange) {
+    try {
+        await exchange.loadMarkets ()
+        exchange.symbols.map (symbol => {
+            const market = exchange.market (symbol)
+            if (market['contract']) {
+                console.log (exchange.id, 'loaded', market['type'], symbol, 'market')
+            }
+        })
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+}
+
+async function loadAllExchanges (exchangeId) {
+    try {
+
+        const exchanges = [];
+        [ 'swap', 'future', 'options' ].forEach (defaultType => {
+            const exchange = new ccxt[exchangeId]()
+            if (exchange.has[defaultType]) {
+                exchanges.push (exchange);
+            }
+        })
+        await Promise.all (exchanges.map (exchange => loadExchange (exchange)))
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+}
+
+async function main () {
+    await Promise.all (ccxt.exchanges.map (exchangeId => loadAllExchanges (exchangeId)))
+}
+
+main ()

package/examples/js/load-all-symbols-at-once.js

@@ -0,0 +1,69 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+const log       = ololog.configure ({ locate: false })
+
+ansicolor.nice
+
+//-----------------------------------------------------------------------------
+
+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 test = async function (exchange) {
+
+    try {
+
+        await exchange.loadMarkets ()
+        log (exchange.id.green, 'loaded', exchange.symbols.length.toString ().bright.green, 'symbols')
+
+    } catch (e) {
+
+        if (e instanceof ccxt.DDoSProtection) {
+            log.bright.yellow (exchange.id, '[DDoS Protection] ' + e.message)
+        } else if (e instanceof ccxt.RequestTimeout) {
+            log.bright.yellow (exchange.id, '[Request Timeout] ' + e.message)
+        } else if (e instanceof ccxt.AuthenticationError) {
+            log.bright.yellow (exchange.id, '[Authentication Error] ' + e.message)
+        } else if (e instanceof ccxt.ExchangeNotAvailable) {
+            log.bright.yellow (exchange.id, '[Exchange Not Available] ' + e.message)
+        } else if (e instanceof ccxt.ExchangeError) {
+            log.bright.yellow (exchange.id, '[Exchange Error] ' + e.message)
+        } else if (e instanceof ccxt.NetworkError) {
+            log.bright.yellow (exchange.id, '[Network Error] ' + e.message)
+        } else {
+            throw e
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+let exchanges = []
+
+async function main () {
+
+    // instantiate all exchanges
+    await Promise.all (ccxt.exchanges.map (async id => {
+        let exchange = new (ccxt)[id] ()
+        exchanges.push (exchange)
+        await test (exchange)
+    }))
+
+    let succeeded = exchanges.filter (exchange => exchange.markets ? true : false).length.toString ().bright.green
+    let failed = exchanges.filter (exchange => exchange.markets ? false : true).length
+    let total = ccxt.exchanges.length.toString ().bright.white
+    let numSymbols = 0;
+    exchanges.map (exchange => {
+        numSymbols += exchange.symbols ? exchange.symbols.length : 0;
+    })
+    log (numSymbols, 'symbols from', succeeded, 'of', total, 'exchanges loaded', ('(' + failed + ' errors)').red)
+
+}
+
+main ()

package/examples/js/load-all-tickers-at-once.js

@@ -0,0 +1,91 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+
+const log = ololog.configure ({ locate: false })
+
+ansicolor.nice
+
+//-----------------------------------------------------------------------------
+
+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 human_value = function (price) {
+    return price === undefined ? 'N/A' : price
+}
+
+//-----------------------------------------------------------------------------
+
+let test = async function (exchange, symbol) {
+
+    try {
+
+        await exchange.loadMarkets ()
+
+        if (symbol in exchange.markets) {
+
+            let ticker = await exchange.fetchTicker (symbol)
+
+            log (exchange.id.green, symbol.green, 'ticker',
+                ticker['datetime'],
+                'high: '    + human_value (ticker['high']),
+                'low: '     + human_value (ticker['low']),
+                'bid: '     + human_value (ticker['bid']),
+                'ask: '     + human_value (ticker['ask']),
+                'volume: '  + human_value (ticker['quoteVolume']))
+        } else {
+
+            // do nothing or throw an error
+            log.bright.yellow (exchange.id + ' does not have ' + symbol)
+        }
+
+    } catch (e) {
+
+        if (e instanceof ccxt.DDoSProtection) {
+            log.bright.yellow (exchange.id, '[DDoS Protection]')
+        } else if (e instanceof ccxt.RequestTimeout) {
+            log.bright.yellow (exchange.id, '[Request Timeout]')
+        } else if (e instanceof ccxt.AuthenticationError) {
+            log.bright.yellow (exchange.id, '[Authentication Error]')
+        } else if (e instanceof ccxt.ExchangeNotAvailable) {
+            log.bright.yellow (exchange.id, '[Exchange Not Available]')
+        } else if (e instanceof ccxt.ExchangeError) {
+            log.bright.yellow (exchange.id, '[Exchange Error]')
+        } else if (e instanceof ccxt.NetworkError) {
+            log.bright.yellow (exchange.id, '[Network Error]')
+        } else {
+            throw e
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+const symbol = 'BTC/USD'
+
+//-----------------------------------------------------------------------------
+
+async function main () {
+
+    let exchanges = []
+
+    // instantiate all exchanges
+    await Promise.all (ccxt.exchanges.map (async id => {
+        let exchange = new (ccxt)[id] ()
+        exchanges.push (exchange)
+        await test (exchange, symbol)
+    }))
+
+    let succeeded = exchanges.filter (exchange => exchange.markets ? true : false).length.toString ().bright.green
+    let failed = exchanges.filter (exchange => exchange.markets ? false : true).length
+    let total = ccxt.exchanges.length.toString ().bright.white
+    console.log (succeeded, 'of', total, 'exchanges loaded', ('(' + failed + ' errors)').red)
+}
+
+main ()

package/examples/js/load-markets-to-files.js

@@ -0,0 +1,57 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import path from 'path';
+import fs from 'fs';
+
+const enableRateLimit = true,
+      // exchange defaults
+      // ------------------------------------------------------------------------
+      // path to your folder, for example '/myproject/markets' or 'C:/myproject/markets'
+      options = { enableRateLimit },
+      // writes to current working directory if left empty
+      // ------------------------------------------------------------------------
+      // use a reasonable value for maxConcurrency to avoid network congestion
+      // a burst of requests in a short period of time will cause
+      // excessive competition for networking resources within the application
+      folder = '',
+      maxConcurrency = 7;
+
+async function main () {
+
+    const allExchanges = ccxt.exchanges.map (id => {
+            try {
+                return new ccxt[id] (options)
+            } catch (e) {
+                console.log ('Failed to initialize', id, e.constructor.name)
+            }
+        }).filter (x => x)
+        , allExchangesByIds = ccxt.indexBy (allExchanges, 'id')
+        , exchangeIds = Object.keys (allExchangesByIds)
+
+    const load = async () => {
+        while (exchangeIds.length > 0) {
+            const id = exchangeIds.pop ()
+            const exchange = allExchangesByIds[id]
+            const file = path.join (folder, `saved-markets-${exchange.id}.json`)
+            try {
+                await exchange.loadMarkets ()
+                const { id, markets } = exchange
+                await writeFile (file, JSON.stringify ({ id, markets }))
+                console.log ('Loaded markets from', id, 'to', file)
+            } catch (e) {
+                console.log ('Failed to load markets from', id, 'to', file, e.constructor.name)
+            }
+        }
+    }
+
+    const started = ccxt.milliseconds ()
+    const loaders = Array (maxConcurrency).fill ().map (x => load ())
+    await Promise.all (loaders)
+    const stopped  = ccxt.milliseconds ()
+    console.log ('Done loading', allExchanges.length, 'exchanges in', ((stopped - started) / 1000).toFixed (2), 'seconds')
+
+    // other code...
+}
+
+main ()

package/examples/js/looping-over-all-symbols-of-specific-exchanges.js

@@ -0,0 +1,61 @@
+
+
+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
+
+//-----------------------------------------------------------------------------
+
+;(async () => {
+
+    const exchanges = [ 'bittrex', 'poloniex', 'hitbtc2' ]
+
+    for (let exchangeId of exchanges) {
+
+        // create the exchange instance
+        const exchange = new ccxt[exchangeId] ()
+
+        // preload all markets first, as explained in the Manual:
+        // https://github.com/ccxt/ccxt/wiki/Manual#loading-markets
+
+        // add error/exception handling as required by the Manual:
+        // https://github.com/ccxt/ccxt/wiki/Manual#error-handling
+
+        try {
+
+            await exchange.loadMarkets ();
+
+        } catch (e) {
+
+            log.red ('Could not load markets from', exchange.id + ':', e.constructor.name, e.message)
+
+            continue; // skip this exchange if markets failed to load
+
+        }
+
+        for (let symbol in exchange.markets) {
+
+            console.log (exchange.id, symbol)
+
+            // add error/exception handling as required by the Manual:
+            // https://github.com/ccxt/ccxt/wiki/Manual#error-handling
+
+            try { // try fetching the ticker for a symbol existing with that exchange
+
+                const ticker = await exchange.fetchTicker (symbol)
+                log.green (ticker)
+
+            } catch (e) { // catch the error (if any) and handle it or ignore it
+
+                log.red ('Could not fetch', symbol, 'ticker from', exchange.id + ':', e.constructor.name, e.message)
+
+            }
+        }
+    }
+
+}) ()