ccxt 4.2.73 → 4.2.74

package/examples/js/cli.js

@@ -0,0 +1,405 @@
+#! /usr/bin/env node
+import fs from 'fs'
+import path from 'path'
+import ansi from 'ansicolor'
+import asTable from 'as-table'
+import ololog from 'ololog'
+import util from 'util'
+import { execSync } from 'child_process'
+import ccxt from '../../js/ccxt.js'
+import { Agent } from 'https'
+
+const fsPromises = fs.promises;
+ansi.nice
+const log = ololog.configure ({ locate: false }).unlimited
+const { ExchangeError , NetworkError} = ccxt
+//-----------------------------------------------------------------------------
+
+let [processPath, , exchangeId, methodName, ... params] = process.argv.filter (x => !x.startsWith ('--'))
+    , verbose = process.argv.includes ('--verbose')
+    , debug = process.argv.includes ('--debug')
+    , poll = process.argv.includes ('--poll')
+    , no_send = process.argv.includes ('--no-send')
+    , no_load_markets = process.argv.includes ('--no-load-markets')
+    , details = process.argv.includes ('--details')
+    , no_table = process.argv.includes ('--no-table')
+    , table = process.argv.includes ('--table')
+    , iso8601 = process.argv.includes ('--iso8601')
+    , cors = process.argv.includes ('--cors')
+    , cache_markets = process.argv.includes ('--cache-markets')
+    , testnet =
+        process.argv.includes ('--test') ||
+        process.argv.includes ('--testnet') ||
+        process.argv.includes ('--sandbox')
+    , signIn = process.argv.includes ('--sign-in') || process.argv.includes ('--signIn')
+    , isSpot = process.argv.includes ('--spot')
+    , isSwap = process.argv.includes ('--swap')
+    , isFuture = process.argv.includes ('--future')
+    , isOption = process.argv.includes ('--option')
+    , shouldCreateRequestReport = process.argv.includes ('--report')
+    , shouldCreateResponseReport = process.argv.includes ('--response')
+    , shouldCreateBoth = process.argv.includes ('--static')
+    , raw = process.argv.includes ('--raw')
+
+//-----------------------------------------------------------------------------
+if (!raw) {
+    log ((new Date ()).toISOString())
+    log ('Node.js:', process.version)
+    log ('CCXT v' + ccxt.version)
+}
+
+//-----------------------------------------------------------------------------
+
+process.on ('uncaughtException',  e => { log.bright.red.error (e); log.red.error (e.message); process.exit (1) })
+process.on ('unhandledRejection', e => { log.bright.red.error (e); log.red.error (e.message); process.exit (1) })
+
+//-----------------------------------------------------------------------------
+
+// set up keys and settings, if any
+const keysGlobal = path.resolve ('keys.json')
+const keysLocal = path.resolve ('keys.local.json')
+
+const keysFile = fs.existsSync (keysLocal) ? keysLocal : keysGlobal
+const settingsFile  = fs.readFileSync(keysFile);
+// eslint-disable-next-line import/no-dynamic-require, no-path-concat
+let settings = JSON.parse(settingsFile)
+settings = settings[exchangeId] || {}
+
+
+//-----------------------------------------------------------------------------
+
+const timeout = 30000
+let exchange = undefined
+
+
+
+const httpsAgent = new Agent ({
+    ecdhCurve: 'auto',
+    keepAlive: true,
+})
+
+
+// check here if we have a arg like this: binance.fetchOrders()
+const callRegex = /\s*(\w+)\s*\.\s*(\w+)\s*\(([^()]*)\)/
+if (callRegex.test (exchangeId)) {
+    const res = callRegex.exec (exchangeId);
+    exchangeId = res[1];
+    methodName = res[2];
+    params = res[3].split(",").map(x => x.trim());
+}
+
+try {
+    if (ccxt.pro.exchanges.includes(exchangeId)) {
+        exchange = new (ccxt.pro)[exchangeId] ({ timeout, httpsAgent, ... settings })
+    } else {
+        exchange = new (ccxt)[exchangeId] ({ timeout, httpsAgent, ... settings })
+    }
+
+    if (exchange === undefined) {
+        process.exit ()
+    }
+
+    if (isSpot) {
+        exchange.options['defaultType'] = 'spot';
+    } else if (isSwap) {
+        exchange.options['defaultType'] = 'swap';
+    } else if (isFuture) {
+        exchange.options['defaultType'] = 'future';
+    } else if (isOption) {
+        exchange.options['defaultType'] = 'option';
+    }
+
+    // check auth keys in env var
+    const requiredCredentials = exchange.requiredCredentials;
+    for (const [credential, isRequired] of Object.entries (requiredCredentials)) {
+        if (isRequired && exchange[credential] === undefined) {
+            const credentialEnvName = (exchangeId + '_' + credential).toUpperCase () // example: KRAKEN_APIKEY
+            const credentialValue = process.env[credentialEnvName]
+            if (credentialValue) {
+                exchange[credential] = credentialValue
+            }
+        }
+    }
+
+    if (testnet) {
+        exchange.setSandboxMode (true)
+    }
+
+} catch (e) {
+
+    log.red (e)
+    printUsage ()
+    process.exit ()
+}
+
+//-----------------------------------------------------------------------------
+
+function createRequestTemplate(exchange, methodName, args, result) {
+    const final = {
+        'description': 'Fill this with a description of the method call',
+        'method': methodName,
+        'url': exchange.last_request_url ?? '',
+        'input': args,
+        'output': exchange.last_request_body ?? undefined
+    }
+    log('Report: (paste inside static/request/' + exchange.id + '.json ->' + methodName + ')')
+    log.green('-------------------------------------------')
+    log (JSON.stringify (final, null, 2))
+    log.green('-------------------------------------------')
+}
+
+//-----------------------------------------------------------------------------
+
+function createResponseTemplate(exchange, methodName, args, result) {
+    const final = {
+        'description': 'Fill this with a description of the method call',
+        'method': methodName,
+        'input': args,
+        'httpResponse': exchange.last_json_response ?? exchange.last_http_response,
+        'parsedResponse': result
+    }
+    log('Report: (paste inside static/response/' + exchange.id + '.json ->' + methodName + ')')
+    log.green('-------------------------------------------')
+    log (JSON.stringify (final, function(k, v) { return v === undefined ? null : v; }, 2))
+    log.green('-------------------------------------------')
+}
+
+//-----------------------------------------------------------------------------
+
+function printSupportedExchanges () {
+    log ('Supported exchanges:', ccxt.exchanges.join (', ').green)
+}
+
+//-----------------------------------------------------------------------------
+
+function printUsage () {
+    log ('This is an example of a basic command-line interface to all exchanges')
+    log ('Usage: node', process.argv[1], 'id'.green, 'method'.yellow, '"param1" param2 "param3" param4 ...'.blue)
+    log ('Examples:')
+    log ('node', process.argv[1], 'okcoin fetchOHLCV BTC/USD 15m')
+    log ('node', process.argv[1], 'bitfinex fetchBalance')
+    log ('node', process.argv[1], 'kraken fetchOrderBook ETH/BTC')
+    printSupportedExchanges ()
+    log ('Supported options:')
+    log ('--verbose         Print verbose output')
+    log ('--debug           Print debugging output')
+    log ('--poll            Repeat continuously in rate-limited mode')
+    log ('--no-send         Print the request but do not actually send it to the exchange (sets verbose and load-markets)')
+    log ('--no-load-markets Do not pre-load markets (for debugging)')
+    log ('--details         Print detailed fetch responses')
+    log ('--no-table        Do not print the fetch response as a table')
+    log ('--table           Print the fetch response as a table')
+    log ('--iso8601         Print timestamps as ISO8601 datetimes')
+    log ('--cors            use CORS proxy for debugging')
+    log ('--sign-in         Call signIn() if any')
+    log ('--sandbox         Use the exchange sandbox if available, same as --testnet')
+    log ('--testnet         Use the exchange testnet if available, same as --sandbox')
+    log ('--test            Use the exchange testnet if available, same as --sandbox')
+    log ('--cache-markets   Cache the loaded markets in the .cache folder in the current directory')
+}
+
+//-----------------------------------------------------------------------------
+
+const printHumanReadable = (exchange, result) => {
+    if (raw) {
+        return log (JSON.stringify(result))
+    }
+    if (!no_table && Array.isArray (result) || table) {
+        result = Object.values (result)
+        let arrayOfObjects = (typeof result[0] === 'object')
+
+        if (details)
+            result.forEach (object => {
+                if (arrayOfObjects)
+                    log ('-------------------------------------------')
+                log (object)
+            })
+
+        if (arrayOfObjects || table && Array.isArray (result)) {
+            const configuredAsTable = asTable.configure ({
+                delimiter: ' | '.lightGray.dim,
+                right: true,
+                title: x => String (x).lightGray,
+                dash: '-'.lightGray.dim,
+                print: x => {
+                    if (typeof x === 'object') {
+                        const j = JSON.stringify (x).trim ()
+                        if (j.length < 100) return j
+                    }
+                    return String (x)
+                }
+            })
+            log (result.length > 0 ? configuredAsTable (result.map (element => {
+                let keys = Object.keys (element)
+                delete element['info']
+                keys.forEach (key => {
+                    if (!iso8601)
+                        return element[key]
+                    try {
+                        const iso8601 = exchange.iso8601 (element[key])
+                        if (iso8601.match (/^20[0-9]{2}[-]?/))
+                            element[key] = iso8601
+                        else
+                            throw new Error ('wrong date')
+                    } catch (e) {
+                        return element[key]
+                    }
+                })
+                return element
+            })) : result)
+            log (result.length, 'objects');
+        } else {
+            console.dir (result, { depth: null })
+            log (result.length, 'objects');
+        }
+    } else {
+        console.dir (result, { depth: null, maxArrayLength: null })
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+async function run () {
+
+
+
+    if (!exchangeId) {
+
+        printUsage ()
+
+    } else {
+
+        let args = params
+            .map (s => s.match (/^[0-9]{4}[-][0-9]{2}[-][0-9]{2}[T\s]?[0-9]{2}[:][0-9]{2}[:][0-9]{2}/g) ? exchange.parse8601 (s) : s)
+            .map (s => (() => { 
+                if (s.match ( /^\d+$/g)) return s < Number.MAX_SAFE_INTEGER ? Number (s) : s
+                try {return eval ('(() => (' + s + ')) ()') } catch (e) { return s }
+            }) ())
+
+        const www = Array.isArray (exchange.urls.www) ? exchange.urls.www[0] : exchange.urls.www
+
+        if (cors) {
+            exchange.proxy = 'https://cors-anywhere.herokuapp.com/';
+            exchange.origin = exchange.uuid ()
+        }
+
+        no_load_markets = no_send ? true : no_load_markets
+
+        if (debug) {
+            exchange.verbose = verbose
+        }
+
+        const path = '.cache/' + exchangeId + '-markets.json'
+
+        if (!no_load_markets) {
+            try {
+                await fsPromises.access (path, fs.constants.R_OK)
+                exchange.markets = JSON.parse (await fsPromises.readFile (path))
+            } catch {
+                await exchange.loadMarkets ()
+                if (cache_markets) {
+                    await fsPromises.writeFile (path, JSON.stringify (exchange.markets))
+                }
+            }
+        }
+
+        if (signIn && exchange.has.signIn) {
+            await exchange.signIn ()
+        }
+
+        exchange.verbose = verbose
+
+        if (no_send) {
+
+            exchange.verbose = no_send
+            exchange.fetch = function fetch (url, method = 'GET', headers = undefined, body = undefined) {
+                log.dim.noLocate ('-------------------------------------------')
+                log.dim.noLocate (exchange.iso8601 (exchange.milliseconds ()))
+                log.green.unlimited ({
+                    url,
+                    method,
+                    headers,
+                    body,
+                })
+                process.exit ()
+            }
+        }
+
+        if (methodName) {
+
+            if (typeof exchange[methodName] === 'function') {
+
+                if (!raw) log (exchange.id + '.' + methodName, '(' + args.join (', ') + ')')
+
+                let start = exchange.milliseconds ()
+                let end = exchange.milliseconds ()
+
+                let i = 0;
+
+                let isWsMethod = false
+                if (methodName.startsWith("watch")) { // handle WS methods
+                    isWsMethod = true;
+                }
+
+                while (true) {
+                    try {
+                        const result = await exchange[methodName] (... args)
+                        end = exchange.milliseconds ()
+                        if (!isWsMethod && !raw) {
+                            log (exchange.iso8601 (end), 'iteration', i++, 'passed in', end - start, 'ms\n')
+                        }
+                        printHumanReadable (exchange, JSON.parse(JSON.stringify(result)))
+                        if (!isWsMethod && !raw) {
+                            log (exchange.iso8601 (end), 'iteration', i, 'passed in', end - start, 'ms\n')
+                        }
+                        if (shouldCreateRequestReport || shouldCreateBoth) {
+                            createRequestTemplate(exchange, methodName, args, result)
+                        }
+                        if (shouldCreateResponseReport || shouldCreateBoth) {
+                            createResponseTemplate(exchange, methodName, args, result)
+                        }
+                        start = end
+                    } catch (e) {
+                        if (e instanceof ExchangeError) {
+                            log.red (e.constructor.name, e.message)
+                        } else if (e instanceof NetworkError) {
+                            log.yellow (e.constructor.name, e.message)
+                        }
+
+                        log.dim ('---------------------------------------------------')
+
+                        // rethrow for call-stack // other errors
+                        throw e
+
+                    }
+
+                    if (debug) {
+                        const keys = Object.keys (httpsAgent.freeSockets)
+                        const firstKey = keys[0]
+                        let httpAgent = httpsAgent.freeSockets[firstKey];
+                        log (firstKey, httpAgent.length)
+                    }
+
+                    if (!poll && !isWsMethod){
+                        break
+                    }
+                }
+
+            } else if (exchange[methodName] === undefined) {
+                log.red (exchange.id + '.' + methodName + ': no such property')
+            } else {
+                printHumanReadable (exchange, exchange[methodName])
+            }
+        } else {
+            log (exchange)
+        }
+    }
+
+}
+
+//-----------------------------------------------------------------------------
+
+run ()
+
+export  {
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+
+const ccxt = require ('../../ccxt.js')
+
+console.log ('CCXT Version:', ccxt.version)
+
+async function fetchAllBalances (exchange) {
+    const params = {}
+    let balance = {}
+    while (true) {
+        const response = await exchange.fetchBalance (params)
+        balance = exchange.extend (balance, response)
+        const info = exchange.safeValue (response, 'info', {})
+        const pagination = exchange.safeValue (info, 'pagination', {})
+        const startingAfter = exchange.safeString (pagination, 'next_starting_after')
+        if (startingAfter !== undefined) {
+            params['starting_after'] = startingAfter
+        } else {
+            break
+        }
+    }
+    return balance
+}
+
+async function main () {
+    const exchange = new ccxt.coinbase ({
+        apiKey: 'YOUR_API_KEY',
+        secret: 'YOUR_API_SECRET',
+    })
+    const markets = await exchange.loadMarkets ()
+    // coinbase.verbose = true // uncomment for debugging purposes if necessary
+    const balance = await fetchAllBalances (exchange)
+    console.log (balance)
+}
+
+main ()

package/examples/js/coinex-fetch-all-deposit-addresses-using-fetchDepositAddress.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const ccxt = require ('../../ccxt')
+
+console.log ('CCXT Version:', ccxt.version)
+
+// https://github.com/ccxt/ccxt/issues/15405
+
+async function main () {
+    
+    const exchange = new ccxt.coinex ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+    });
+
+    // exchange.verbose = true // uncomment for debugging purposes
+
+    await exchange.loadMarkets ();
+    const addresses = {};
+    const promises = [];
+
+    async function fetchDepositAddress (currency, network) {
+        try {
+            const response = await exchange.fetchDepositAddress(currency, { 'network': network });
+            addresses[currency][network] = response['address']
+        }
+        catch (err) {
+            console.error(err)
+        }
+    }    
+
+    const currencies = Object.keys (exchange.currencies);
+
+    for (const currency of currencies) {
+        const networks = Object.keys (exchange.currencies[currency]['networks']);
+        for (const network of networks) {
+            addresses[currency] = {};
+            promises.push (fetchDepositAddress (currency, network));
+        }
+    }
+
+    await Promise.all (promises);
+
+    console.log (addresses)
+};
+
+main ();

package/examples/js/coinex-futures.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const ccxt = require ('../../ccxt');
+
+console.log ('CCXT Version:', ccxt.version)
+
+let exchange = new ccxt.coinex({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET_KEY',
+})
+
+// Example 1 :: Swap : fetch balance, create a limit swap order with leverage
+async function example1 () {
+    exchange['options']['defaultType'] = 'swap';
+    exchange.options['defaultMarginMode'] = 'cross' // or isolated
+    await exchange.loadMarkets ();
+
+    const symbol = 'ADA/USDT:USDT';
+
+    // fetchBalance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // set the desired leverage (has to be made before placing the order and for a specific symbol)
+    const leverage = 8;
+    const leverage_response = await exchange.setLeverage(leverage, symbol)
+
+    // create limit order
+    const amount = 50;
+    const price = 0.3 // adjust this accordingly
+    const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', amount, price);
+    console.log ('Created order id:', createOrder['id'])
+}
+
+// Example 2 :: Swap :: open a position and close it
+async function example2 () {
+    exchange['options']['defaultType'] = 'swap';
+    exchange.options['defaultMarginMode'] = 'cross' // or isolated
+    await exchange.loadMarkets ();
+
+    const symbol = 'ADA/USDT:USDT';
+
+    // fetchBalance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // set the desired leverage (has to be made before placing the order and for a specific symbol)
+    const leverage = 8;
+    const leverage_response = await exchange.setLeverage(leverage, symbol)
+
+    // create market order and open position
+    const amount = 50;
+    const createOrder = await exchange.createOrder (symbol, 'market', 'buy', amount);
+    console.log ('Created order id:', createOrder['id'])
+
+    // check if the order was filled and the position opened
+    const position = await exchange.fetchPositions (symbol);
+    console.log (position)
+
+    // close position (assuming it was already opened) by issuing an order in the opposite direction
+    const params = {
+        'reduce_only': true
+    }
+    const closePositionOrder = await exchange.createOrder (symbol, 'market', 'sell', amount, undefined, params);
+    console.log (closePositionOrder);
+}
+
+// -----------------------------------------------------------------------------------------
+
+async function main () {
+    await example1 ();
+    await example2 ();
+}
+
+main ();

package/examples/js/coinone-fetch-tickers.js

@@ -0,0 +1,54 @@
+
+
+import { nice as ansi } from 'ansicolor';
+import ololog from 'ololog';
+import asTable from 'as-table';
+
+import ccxt from '../../js/ccxt.js';
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+const table = asTable.configure ({
+        delimiter: ' | '.dim,
+        right: true,
+    });
+
+const exchange = new ccxt.coinone ({
+    'verbose': process.argv.includes ('--verbose'),
+})
+
+let printTickersAsTable = function (exchange, tickers) {
+    log (exchange.id.green, exchange.iso8601 (exchange.milliseconds ()))
+    log ('Fetched', Object.values (tickers).length.toString ().green, 'tickers:')
+    log (table (ccxt.sortBy (Object.values (tickers), 'symbol', false)))
+}
+
+async function fetchAllAndPrint () {
+    const tickers = await exchange.fetchTickers ()
+    log ('---------------------------------------- fetchTickers ----------------------------------------')
+    printTickersAsTable (exchange, tickers)
+}
+
+async function fetchOneByOneAndPrint () {
+    const markets = await exchange.loadMarkets ()
+    const symbols = Object.keys (markets)
+    const tickers = []
+
+    log ('---------------------------------------- fetchTicker (one by one) ----------------------------------------')
+
+    for (let i = 0; i < symbols.length; i++) {
+        const ticker = await exchange.fetchTicker (symbols[i])
+        tickers.push (ticker)
+        log (`${i+1} / ${symbols.length}`)
+        log ('\u001b[1A'.repeat (2))  // cursor up
+    }
+
+    printTickersAsTable (exchange, tickers)
+}
+
+(async () => {
+    await fetchAllAndPrint ()
+    log ('\n')
+    await fetchOneByOneAndPrint ()
+}) ()

package/examples/js/coinone-markets.js

@@ -0,0 +1,16 @@
+
+
+import log from 'ololog';
+import ccxt from '../../js/ccxt.js';
+
+const exchange = new ccxt.coinone ({
+    'verbose': process.argv.includes ('--verbose'),
+})
+
+;(async function main () {
+
+    const markets = await exchange.loadMarkets ()
+    log (markets)
+    log ('\n' + exchange['name'] + ' supports ' + Object.keys (markets).length + ' pairs')
+
+}) ()

package/examples/js/compare-two-exchanges-capabilities.js

@@ -0,0 +1,36 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+async function example() {
+    const prefix = '-';
+    const exchange_1 = new ccxt.okx();
+    const exchange_2 = new ccxt.htx();
+    const keys_1 = Object.keys(exchange_1.has);
+    const keys_2 = Object.keys(exchange_2.has);
+    // check missing from exchange-1
+    console.log('### checking missing functionalities from exchange-1:', exchange_1.id);
+    for (let i = 0; i < keys_2.length; i++) {
+        const key = keys_2[i];
+        if (exchange_2.has[key]) {
+            if (!keys_1.includes(key)) {
+                console.log(prefix, key, 'does not exist in', exchange_1.id, 'as opposed to', exchange_2.id);
+            }
+            else if (exchange_2.has[key] !== exchange_1.has[key]) {
+                console.log(prefix, key, '> ', exchange_1.id, ':', exchange_1.has[key], ',', exchange_2.id, ':', exchange_2.has[key]);
+            }
+        }
+    }
+    // check missing from exchange-2
+    console.log('### checking missing functionalities from exchange-2:', exchange_2.id);
+    for (let i = 0; i < keys_1.length; i++) {
+        const key = keys_1[i];
+        if (exchange_1.has[key]) {
+            if (!keys_2.includes(key)) {
+                console.log(prefix, key, 'does not exist in', exchange_2.id, 'as opposed to', exchange_1.id);
+            }
+            else if (exchange_1.has[key] !== exchange_2.has[key]) {
+                console.log(prefix, key, '> ', exchange_2.id, ':', exchange_2.has[key], ',', exchange_1.id, ':', exchange_1.has[key]);
+            }
+        }
+    }
+}
+await example();

package/examples/js/cors-proxy.js

@@ -0,0 +1,5 @@
+// JavaScript CORS Proxy
+// 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
+let port = (process.argv.length > 2) ? parseInt (process.argv[2]) : 8080 // default
+require ('cors-anywhere').createServer ().listen (port, '0.0.0.0')