ccxt 4.2.99 → 4.3.1

package/examples/js/fetch-all-balances.js

@@ -1,219 +0,0 @@
-import { PAD_WITH_ZERO } from '../../js/src/base/functions/number.js';
-
-//-----------------------------------------------------------------------------
-
-import ccxt from '../../js/ccxt.js';
-
-import fs from 'fs';
-import path from 'path';
-import ansicolor from 'ansicolor';
-import asTable from 'as-table';
-import ololog from 'ololog';
-
-ansicolor.nice
-//-----------------------------------------------------------------------------
-
-const table = asTable.configure ({
-        delimiter: '|'.lightGray.dim,
-        right: true,
-        title: x => String (x).lightGray,
-        print: x => {
-            if (typeof x === 'object') {
-                const j = JSON.stringify (x).trim ()
-                if (j.length < 100) return j
-            }
-            return String (x)
-        }
-    }),
-    { ROUND, DECIMAL_PLACES, decimalToPrecision, omit, unique, flatten, extend } = ccxt,
-    log = ololog.handleNodeErrors ().noLocate.unlimited;
-
-//-----------------------------------------------------------------------------
-
-// set up keys and settings, if any
-const keysGlobal = path.resolve ('keys.json')
-const keysLocal = path.resolve ('keys.local.json')
-
-const keysGlobalExists = fs.existsSync (keysGlobal)
-const keysLocalExists = fs.existsSync (keysLocal)
-
-if (!(keysGlobalExists || keysLocalExists)) {
-    const lines = [
-        'This script requires a keys.json or a keys.local.json file containing the API keys in JSON format',
-        '{',
-        '    "binance": {',
-        '        "apiKey": "YOUR_API_KEY",',
-        '        "secret": "YOUR_SECRET"',
-        '    }',
-        '    "bitfinex": {',
-        '        "apiKey": "YOUR_API_KEY",',
-        '        "secret": "YOUR_SECRET"',
-        '    }',
-        '}'
-    ]
-    const errorMessage = lines.join ("\n")
-    log.red.bright (errorMessage)
-    process.exit ()
-}
-
-let globalKeysFile = keysGlobalExists ? keysGlobal : false
-let localKeysFile = keysLocalExists ? keysLocal : globalKeysFile
-const dynamicLocalKeysFile = JSON.parse (fs.readFileSync (localKeysFile));
-let settings = localKeysFile ? (dynamicLocalKeysFile || {}) : {}
-
-//-----------------------------------------------------------------------------
-
-const timeout = 30000
-
-const coins = [
-    'BTC',
-    'ETH',
-    'BNB',
-    'EUR',
-    'LTC',
-    'USD',
-    'USDC',
-    'USDT',
-    'BUSD',
-    'XRP',
-    'DOGE',
-    'YFI',
-    'LINK',
-    'XLM',
-    'ADA',
-    'SOL',
-]
-
-function initializeAllExchanges () {
-    let numErrors = 0
-    const ignore = [
-        'bcex',
-        'bitsane',
-        'chbtc',
-        'coinbasepro',
-        'jubi',
-        'hitbtc',
-        'bitstamp1',
-        'bitfinex2',
-        'upbit',
-        'huobipro',
-    ]
-    const result = []
-    ccxt.exchanges.filter (exchangeId => (!ignore.includes (exchangeId))).forEach (exchangeId => {
-        try {
-            const verbose = false
-            const exchange = new ccxt[exchangeId] ({
-                timeout,
-                verbose,
-                ... (settings[exchangeId] || {})
-            })
-            exchange.checkRequiredCredentials ()
-            result.push (exchange)
-        } catch (e) {
-            numErrors++
-            log.red (exchangeId, 'initialization failed', e.constructor.name, e.message.slice (0, 100));
-        }
-    })
-    log ('Initialized', ccxt.exchanges.length - numErrors, 'of', ccxt.exchanges.length, 'exchanges,',
-        numErrors, 'error' + (((numErrors < 1) || (numErrors > 1)) ? 's' : '') + ',',
-        ignore.length, 'skipped')
-    return result
-}
-
-(async () => {
-
-    const exchanges = initializeAllExchanges ()
-    console.log (exchanges.map (exchange => exchange.id))
-    let results = []
-    const priceOracle = new ccxt.gate ()
-    const tickers = await priceOracle.fetchTickers ()
-    await Promise.all (exchanges.map ((exchange) => (async function () {
-
-        try {
-
-            if (exchange.has['signIn']) {
-                await exchange.signIn ()
-            }
-
-            const balance = await exchange.fetchTotalBalance ()
-            if (!balance) {
-                throw new Error (exchange.id + ' erroneous balance')
-            }
-            const keys = Object.keys (balance).sort ()
-            const nonzeroBalance = {}
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i]
-                if (coins.includes (key)) {
-                    const value = balance[key]
-                    const valueToPrecision = decimalToPrecision (value, ROUND, 8, DECIMAL_PLACES)
-                    if (valueToPrecision !== '0') {
-                        nonzeroBalance[key] = valueToPrecision
-                    }
-                }
-            }
-            const numNonzeroKeys = Object.keys (nonzeroBalance).length
-            if (numNonzeroKeys < 1) {
-                log.yellow (exchange.id + ' empty balance')
-            } else {
-                log.green (exchange.id, numNonzeroKeys, 'currencies')
-                results.push ({ exchange: exchange.id, ... nonzeroBalance })
-            }
-
-        } catch (e) {
-            log.red (exchange.id, e.constructor.name, e.message.split ("\n")[0].slice (0, 100))
-        }
-
-    }) ()))
-
-    results = ccxt.sortBy (results, 'exchange')
-
-    const currencies = unique (flatten (results.map (result => Object.keys (omit (result, 'exchange')))))
-    currencies.sort ()
-
-    const total = {}
-    for (let i = 0; i < currencies.length; i++) {
-        const currency = currencies[i]
-        let sum = 0
-        results.forEach (result => {
-            if (currency in result) {
-                sum += parseFloat (result[currency])
-            }
-        })
-        total[currency] = decimalToPrecision (sum, ROUND, 8, DECIMAL_PLACES)
-    }
-
-    results.push (extend ({ 'exchange': 'total' }, total))
-
-    results = results.map (result => {
-        let value = 0;
-        const convertTo = 'USD'
-        currencies.forEach (currency => {
-            if (currency === convertTo) {
-                if (currency in result) {
-                    value += parseFloat (result[currency])
-                }
-            } else {
-                const symbol = currency + '/' + convertTo
-                if (symbol in tickers) {
-                    if (currency in result) {
-                        const ticker = tickers[symbol]
-                        value += parseFloat (result[currency]) * ticker['last']
-                    }
-                }
-            }
-        })
-        return extend ({
-            'exchange': result.exchange,
-            '$': decimalToPrecision (value, ROUND, 2, DECIMAL_PLACES, PAD_WITH_ZERO),
-        }, result);
-    })
-
-    const tableResults = table (results)
-
-    log (tableResults)
-
-    log.green ('Currencies:', currencies)
-
-    console.log (new Date ())
-
-}) ()

package/examples/js/fetch-all-tickers-to-files-2.js

@@ -1,53 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-import { writeFileSync } from 'fs';
-import path from 'path';
-
-const enableRateLimit = true, exchanges = {}, tickers = {};
-
-
-ccxt.exchanges.forEach (id => {
-    try {
-        const exchange = new ccxt[id] ()
-        if (exchange.has['fetchTickers']) {
-            exchanges[id] = exchange
-        }
-    } catch (e) {
-        console.log ('Failed to initialize', id, e.constructor.name, e.message)
-    }
-})
-
-async function main () {
-
-    console.log ('Started')
-    const start = Date.now ()
-
-    try {
-        const promises = Object.values (exchanges).map (exchange => (
-            (async () => {
-                console.log (exchange.id)
-                try {
-                    const response = await exchange.fetchTickers ()
-                    tickers[exchange.id] = response
-                } catch (e) {
-                    console.log ('Failed to fetchTickers() from', exchange.id)
-                }
-            }) ()
-        ))
-        await Promise.all (promises)
-    } catch (e) {
-        console.log ('Failed awaiting all exchanges to complete')
-    }
-
-    Object.entries (tickers).forEach (([ id, response ]) => {
-        const folder = 'C:/myproject/tickers'
-        const filename = `${id}-tickers.json`
-        console.log (path.join (folder, filename))
-        writeFileSync (path.join (folder, filename), JSON.stringify (response))
-    })
-
-    const end = Date.now ()
-    console.log (`Fetched tickers in ${(end - start) / 1000} seconds`)
-
-}
-
-main ()

package/examples/js/fetch-all-tickers-to-files.js

@@ -1,77 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import ololog from 'ololog';
-
-const { noLocate } = ololog;
-const log = noLocate;
-
-import fs from 'fs';
-
-// the numWorkers constant defines the number of concurrent workers
-// those aren't really threads in terms of the async environment
-// set this to the number of cores in your CPU * 2
-// or play with this number to find a setting that works best for you
-
-const numWorkers = 8;(async () => {
-
-    // make an array of all exchanges
-    const exchanges = ccxt.exchanges
-
-        // filter coinmarketcap and theocean
-        // coinmarketcap isn't really an exchange
-        // theocean requires web3 dependencies to be installed
-
-        .filter (id => ![ 'coinmarketcap', 'theocean' ].includes (id))
-
-        // instantiate each exchange and save it to the exchanges list
-
-        .map (id => new ccxt[id] ())
-
-    // the worker function for each "async thread"
-    const worker = async function () {
-
-        // while the array of all exchanges is not empty
-        while (exchanges.length > 0) {
-
-            // pop one exchange from the array
-            const exchange = exchanges.pop ()
-
-            // check if it has the necessary method implemented
-            if (exchange.has['fetchTickers']) {
-
-                // try to do "the work" and handle errors if any
-                try {
-
-                    // fetch the response for all tickers from the exchange
-                    const tickers = await exchange.fetchTickers ()
-
-                    // make a filename from exchange id
-                    const filename = exchange.id + '.json'
-
-                    // save the response to a file
-                    fs.writeFileSync (filename, JSON.stringify ({ tickers }));
-
-                    // print out a message on success
-                    log.green (exchange.id, 'tickers saved to', filename)
-
-                } catch (e) {
-
-                    // in case of error - print it out and ignore it further
-                    log.red (e.constructor.name, e.message)
-                }
-
-            } else {
-
-                log.red (exchange.id, "has['fetchTickers'] = false");
-            }
-        }
-    }
-
-    // create numWorkers "threads" (they aren't really threads)
-    const workers = [ ... Array (numWorkers) ].map (_ => worker ())
-
-    // wait for all of them to execute or fail
-    await Promise.all (workers)
-
-}) ()

package/examples/js/fetch-balance.js

@@ -1,28 +0,0 @@
-"use strict";
-
-const ccxt      = require ('../../ccxt.js');
-
-// instantiate the exchange
-let exchange = new ccxt.coinbasepro  ({
-    'apiKey': 'XXXXXXXXXXXXXX',
-    'secret': 'YYYYYYYYYYYYYY',
-    'password': 'ZZZZZZ', // if exchange requires password
-});
-
-
-async function checkMyBalance() {
-    try {
-        // fetch account balance from the exchange
-        let myBalance = await exchange.fetchBalance ();
-
-        // output the result
-        console.log (exchange.id, 'fetched balance', myBalance);
-
-    } catch (e) {
-        // fpr advanced error-handling, see the "advanced-error-handling.js" example file
-        console.log ('[' + e.constructor.name + '] ' + e.message);
-        throw e;
-    }
-}
-
-checkMyBalance();

package/examples/js/fetch-create-deposit-address.js

@@ -1,101 +0,0 @@
-// ----------------------------------------------------------------------------
-// setup
-
-import ccxt from '../../js/ccxt.js';
-
-// ----------------------------------------------------------------------------
-// setup
-
-const // change me
-      defaultCurrencyCode = 'BTC',
-      // change me
-      //                                  currency code specified in commandline args ↓
-      // you can call this script like node examples/js/fetch-create-deposit-address ETH
-      exchangeId = 'poloniex',
-      currencyCode = process.argv[3] || defaultCurrencyCode,
-      exchange = new ccxt[exchangeId] ({
-
-              'apiKey': 'YOUR_API_KEY',
-              'secret': 'YOUR_SECRET',
-
-              'enableRateLimit': true, // ←- required! https://github.com/ccxt/ccxt/wiki/Manual#rate-limit
-
-              // 'verbose': true, // ←- uncomment this for verbose output
-
-              // additional credentials might be required in exchange-specific cases:
-              // uid or password for Coinbase Pro, etc...
-          });
-
-// ----------------------------------------------------------------------------
-
-if (!exchange.has['fetchDepositAddress']) {
-
-    console.log ('The exchange does not support fetchDepositAddress() yet')
-    process.exit ()
-}
-
-// ----------------------------------------------------------------------------
-
-;(async () => {
-
-    try {
-
-        console.log ('Trying to fetch deposit address for ' + currencyCode + ' from ' + exchangeId + '...')
-
-        let fetchResult = await exchange.fetchDepositAddress (currencyCode)
-
-        console.log ('Successfully fetched deposit address for ' + currencyCode)
-        console.log (fetchResult)
-
-    } catch (e) {
-
-        // never skip proper error handling, whatever it is you're building
-        // actually, with crypto error handling should be the largest part of your code
-
-        if (e instanceof ccxt.InvalidAddress) {
-
-            console.log ('The address for ' + currencyCode + ' does not exist yet')
-
-            if (exchange.has['createDepositAddress']) {
-
-                console.log ('Attempting to create a deposit address for ' + currencyCode + '...')
-
-                try {
-
-                    const createResult = await exchange.createDepositAddress (currencyCode)
-
-                    // console.log (createResult) // for debugging
-
-                    console.log ('Successfully created a deposit address for ' + currencyCode + ', fetching the deposit address now...')
-
-                    try {
-
-                        let fetchResult = await exchange.fetchDepositAddress (currencyCode)
-
-                        console.log ('Successfully fetched deposit address for ' + currencyCode)
-                        console.log (fetchResult);
-
-
-                    } catch (e) {
-
-                        console.log ('Failed to fetch deposit address for ' + currencyCode, e.constructor.name, e.message)
-                    }
-
-                } catch (e) {
-
-                    console.log ('Failed to create deposit address for ' + currencyCode, e.constructor.name, e.message)
-
-                }
-
-            } else {
-
-                console.log ('The exchange does not support createDepositAddress()')
-            }
-
-        } else {
-
-            console.log ('There was an error while fetching deposit address for ' + currencyCode, e.constructor.name, e.message)
-        }
-    }
-
-}) ()

package/examples/js/fetch-from-many-exchanges-simultaneously.js

@@ -1,21 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import log from 'ololog';
-
-const symbol = 'ETH/BTC'
-const exchanges = [ 'coinbasepro', 'hitbtc2', 'poloniex' ]
-
-;(async () => {
-
-    const result = await Promise.all (exchanges.map (async id => {
-
-        const exchange = new ccxt[id] ()
-        const ticker = await exchange.fetchTicker (symbol)
-        return exchange.extend ({ 'exchange': id }, ticker)
-
-    }))
-
-    log (result);
-
-}) ()

package/examples/js/fetch-funding-rate-history.js

@@ -1,25 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-import asTable from 'as-table';
-
-const table  = asTable.configure ({ delimiter: ' | ' });
-
-console.log ('CCXT Version:', ccxt.version)
-
-async function main () {
-
-    const exchange = new ccxt.binanceusdm()
-        , symbol = 'ETH/USDT'
-        , since = undefined
-        , limit = undefined
-        , params = {}
-
-    // ------------------------------------------------------------------------
-    // fetch the history of the funding rate for a symbol
-
-    const response = await exchange.fetchFundingRateHistory (symbol, since, limit, params)
-
-    console.log (table (response))
-
-}
-
-main ()

package/examples/js/fetch-futures/prettier.config.js

@@ -1,5 +0,0 @@
-"use strict";
-module.exports = {
-    singleQuote: true,
-    trailingComma: 'es5',
-};

package/examples/js/fetch-futures/src/index.js

@@ -1,25 +0,0 @@
-// Example code in typescript
-// Based on /examples/js/fetch-okex-futures.js
-import * as ccxt from 'ccxt';
-const log = require('ololog');
-const fetchFutures = async () => {
-    const exchange = new ccxt.bitmex();
-    exchange.markets = await exchange.loadMarkets(true);
-    for (let symbol in exchange.markets) {
-        log('----------------------------------------------------');
-        log(`symbol = ${symbol}`);
-        try {
-            const market = exchange.markets[symbol];
-            if (market['future']) {
-                const ticker = await exchange.fetchTicker(symbol);
-                log('----------------------------------------------------');
-                log(symbol, ticker);
-                await ccxt.sleep(exchange.rateLimit); // Missing type information.
-            }
-        }
-        catch (error) {
-            log('error =', error);
-        }
-    }
-};
-fetchFutures();

package/examples/js/fetch-ohlcv-from-to-mark-index-premium.js

@@ -1,72 +0,0 @@
-"use strict";
-
-const ccxt = require ('../../ccxt')
-
-const exchange = new ccxt.binance ();
-
-const symbols = [ 'BTC/USDT', 'ETH/USDT', 'ADA/USDT'];
-// start from i.e. 01 february 2022
-// you can use milliseconds integer or also parse uniform datetime string, i.e.  exchange.parse8601 ('2020-02-01T00:00:00Z')
-const fromTimestamp = 1643659200000;
-const tillTimestamp = exchange.milliseconds ();
-const timeframe = '1h';
-const itemsLimit = 1000;
-const fetchMethod = 'fetchOHLCV'; // if using swap exchanges, you can also use fetchMarkOHLCV, fetchIndexOHLCV, fetchPremiumIndexOHLCV
-
-async function myDataFetch (symbol) {
-
-    await exchange.loadMarkets ();
- 
-    // get the duration of one timeframe period in milliseconds
-    const duration = exchange.parseTimeframe (timeframe) * 1000;
-    console.log ('Fetching', symbol, timeframe, 'candles', 'from', exchange.iso8601 (fromTimestamp), 'to', exchange.iso8601 (tillTimestamp), '...');
-
-    let result = [];
-    let since = fromTimestamp;
-    do {
-
-        try {
-
-            const candles = await exchange[fetchMethod] (symbol, timeframe, since, itemsLimit);
-
-            const message =  '[' + symbol + '] Fetched ' + candles.length + ' ' + timeframe + ' candles since ' + exchange.iso8601 (since);
-
-            if (candles.length) {
-
-                const first = candles[0];
-                const last = candles[candles.length - 1];
-                console.log ( message, ' | first', exchange.iso8601 (first[0]),  ' | last', exchange.iso8601 (last[0]) );
-
-                // store your candles to a database or to a file here
-                // ...
-                result =  result.concat (candles);
-                since = last[0] + duration // next start from last candle timestamp + duration
-
-            } else {
-                console.log ( message, ' | moving into next period');
-                since = since + duration * itemsLimit; // next start from the current period's end
-            }
-
-        } catch (e) {
-
-            console.log (symbol, e.constructor.name, e.message, ' Taking small pause...');
-            await exchange.sleep (2000);
-            // retry on next iteration
-        }
-
-    } while (since + duration <= tillTimestamp)
-
-    console.log (symbol + ' completed !');
-    return result;
-}
-
-
-
-async function checkAllSymbols() {
-    // download in parallel
-    await Promise.all (symbols.map (symbol => myDataFetch (symbol)));
-    // you can also do one by one (but that is not much optimal)
-    //for (const symbol of symbols) {
-    //    const data = await myDataFetch (symbol);
-}
-checkAllSymbols();

package/examples/js/fetch-ohlcv-many-exchanges-continuosly.js

@@ -1,39 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-// fetch and handle constinuosly
-async function fetchOHLCVContinuously(exchange, symbol) {
-    while (true) {
-        try {
-            const ohlcv = await exchange.fetchOHLCV(symbol);
-            const ohlcvLength = ohlcv.length;
-            console.log('Fetched ', exchange.id, ' - ', symbol, ' candles. last candle: ', ohlcv[ohlcvLength - 1]);
-        }
-        catch (e) {
-            console.log(e);
-            break;
-        }
-    }
-}
-// start exchanges and fetch OHLCV loop
-async function startExchange(exchangeName, symbols) {
-    const ex = new ccxt[exchangeName]({});
-    const promises = [];
-    for (let i = 0; i < symbols.length; i++) {
-        const symbol = symbols[i];
-        promises.push(fetchOHLCVContinuously(ex, symbol));
-    }
-    await Promise.all(promises);
-    await ex.close();
-}
-// main function
-async function example() {
-    const exchanges = ['binance', 'okx', 'kraken'];
-    const symbols = ['BTC/USDT', 'ETH/USDT'];
-    const promises = [];
-    for (let i = 0; i < exchanges.length; i++) {
-        const exchangeName = exchanges[i];
-        promises.push(startExchange(exchangeName, symbols));
-    }
-    await Promise.all(promises);
-}
-await example();

package/examples/js/fetch-ohlcv.js

@@ -1,16 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-async function example() {
-    const myex = new ccxt.okx({});
-    const fromTimestamp = myex.milliseconds() - 86400 * 1000; // last 24 hrs
-    const ohlcv = await myex.fetchOHLCV('BTC/USDT', '1m', fromTimestamp, 3, { 'whatever': 123 });
-    const length = ohlcv.length;
-    if (length > 0) {
-        const lastPrice = ohlcv[length - 1][4];
-        console.log('Fetched ', length, ' candles for ', myex.id, ':  last close ', lastPrice);
-    }
-    else {
-        console.log('No candles have been fetched');
-    }
-}
-await example();