ccxt 4.2.73 → 4.2.74

package/examples/js/proxy-round-robin.js

@@ -0,0 +1,98 @@
+
+
+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
+
+//-----------------------------------------------------------------------------
+
+// this script loads markets from all exchanges
+// if it cannot connect to an exchange, it falls back to an alternative route via proxy
+// it will retry to load a exchange until it either reaches the exchange or runs out of proxies
+
+//-----------------------------------------------------------------------------
+
+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 loadExchange = async exchange => {
+    await exchange.loadMarkets ()
+    log (exchange.id.green, 'loaded', 
+        exchange.symbols.length.toString ().bright.green, 'symbols', 
+        (exchange.proxy ? exchange.proxy : '_').blue)
+}
+
+//-----------------------------------------------------------------------------
+
+let tryAllProxies = async function (exchange, proxies) {
+
+    let currentProxy = 0
+    let maxRetries   = proxies.length
+
+    // a special case for ccex
+    if (exchange.id == 'ccex')
+        currentProxy = 1
+    
+    for (let numRetries = 0; numRetries < maxRetries; numRetries++) {
+
+        try {
+
+            exchange.proxy = proxies[currentProxy]
+            await loadExchange (exchange)
+            break
+
+        } catch (e) {
+
+            currentProxy = ++currentProxy % proxies.length
+            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 proxies = [
+    '',
+    'https://cors-anywhere.herokuapp.com/',
+    'https://crossorigin.me/',
+]
+
+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 tryAllProxies (exchange, proxies)
+    }))
+
+    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/proxy-usage.js

@@ -0,0 +1,32 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+// ABOUT CCXT PROXIES, READ MORE AT: https://docs.ccxt.com/#/README?id=proxy
+async function example_proxyUrl() {
+    const myEx = new ccxt.kucoin();
+    myEx.proxyUrl = 'http://5.75.153.75:8090/proxy_url.php?caller=https://ccxt.com&url=';
+    console.log(await myEx.fetch('https://api.ipify.org/'));
+}
+async function example_httpProxy() {
+    const myEx = new ccxt.kucoin();
+    myEx.httpProxy = 'http://5.75.153.75:8002'; // "httpProxy" or "httpsProxy" (depending on your proxy protocol)
+    console.log(await myEx.fetch('https://api.ipify.org/'));
+}
+async function example_socksProxy() {
+    const myEx = new ccxt.kucoin();
+    myEx.socksProxy = 'socks5://127.0.0.1:1080'; // from protocols: socks, socks5, socks5h
+    console.log(await myEx.fetch('https://api.ipify.org/'));
+}
+async function example_webSockets() {
+    const myEx = new ccxt.pro.kucoin();
+    myEx.httpProxy = 'http://5.75.153.75:8002'; // even though you are using WebSockets, you might also need to set up proxy for the exchange's REST requests
+    myEx.wsProxy = 'http://5.75.153.75:8002'; // "wsProxy" or "wssProxy" or "wsSocksProxy" (depending on your proxy protocol)
+    await myEx.loadMarkets();
+    while (true) {
+        const ticker = await myEx.watchTicker('BTC/USDT');
+        console.log(ticker);
+    }
+}
+await example_proxyUrl();
+// await example_httpProxy ();
+// await example_socksProxy ();
+// await example_webSockets ();

package/examples/js/sample-local-proxy-server-with-cors.js

@@ -0,0 +1,12 @@
+// @ts-nocheck
+// JavaScript sample Proxy with CORS support
+// Save this in a file like cors.js and run with:
+//    node cors [port]
+// It will listen for your requests on the port you pass in command line (or port 8080 by default)
+import cors from 'cors-anywhere'; // npm install cors-anywhere
+const port = (process.argv.length > 2) ? parseInt(process.argv[2]) : 8080; // if not provided from cli, default to 8080
+cors.createServer({
+// you can set origin, if needed by exchange
+// setHeaders: { 'origin': 'https://www.bitmex.com' }
+}).listen(port, 'localhost');
+console.log('Running CORS Anywhere on localhost:' + port);

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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,55 @@
+'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

@@ -0,0 +1,110 @@
+
+
+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

@@ -0,0 +1,41 @@
+
+
+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 ();
+}) ()