ccxt 4.2.73 → 4.2.75

package/examples/ts/.eslintrc

@@ -0,0 +1,111 @@
+{
+  "env": {
+    "es2021": true,
+    "node": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "extends": ["eslint:recommended", "airbnb-base", "plugin:import/typescript"],
+  "ignorePatterns": ["*/*", "cli.ts"],
+  "rules": {
+    "no-console": "off",
+    "import/no-unresolved":"off", // tmp until typescript decides to properly resolve names
+    "import/named": "off",
+    "strict": "off",
+    "semi": "error",
+    "indent": ["error", 4],
+    "init-declarations": "error",
+    "no-undef-init": "off",
+    "comma-dangle": ["error", {
+        "arrays": "always-multiline",
+        "objects": "always-multiline",
+        "imports": "always-multiline",
+        "exports": "always-multiline",
+        "functions": "never"
+    }],
+    "import/extensions": "off",
+    "brace-style": ["error", "1tbs"],
+    "multiline-comment-style": ["error", "separate-lines"],
+    "dot-notation": "off",
+    "quote-props": ["error", "always"],
+    "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
+    "no-whitespace-before-property": "error",
+    "space-before-blocks": ["error", "always"],
+    "space-before-function-paren": ["error", "always"],
+    "no-spaced-func": "off",
+    "func-call-spacing": ["error", "always"],
+    "block-spacing": ["error", "always"],
+    "keyword-spacing": ["error", { "before": true, "after": true }],
+    "object-curly-spacing": ["error", "always", { "objectsInObjects": false }],
+    "object-curly-newline": ["error", { "consistent": true }],
+    "space-infix-ops": "error",
+    "space-unary-ops": "error",
+    "space-in-parens": "error",
+    "no-nested-ternary": "error",
+    "eqeqeq": "error",
+    "quotes": ["error", "single", { "avoidEscape": true }],
+    "no-unused-vars": ["warn", { "argsIgnorePattern": "^(headers|body|account|info|symbol|price|tag|side|since|limit|params|market|timeframe|api|path|code|currency|statusCode|statusText|url|method|response|requestHeaders|requestBody|bidsKey|asksKey|context|config|type|priceKey|amountKey|networkCode|marginMode|subscription|message|client)" }],
+    "new-parens": "error",
+    "new-cap": "off",
+    "no-var": "error",
+    "prefer-const": ["error", {
+        "destructuring": "any",
+        "ignoreReadBeforeAssign": false
+    }],
+    "no-warning-comments": ["warn", { "terms": ["fixme"] }],
+    "padded-blocks": ["error", "never"],
+    "lines-between-class-members": "error",
+    "no-multiple-empty-lines": ["error", { "max": 2 }],
+    "padding-line-between-statements": ["warn",
+      // { "blankLine": "never", "prev":"*", "next": "*" }, // comment this to allow blank-lines
+      { "blankLine": "always", "prev":"directive", "next": "*" },
+      { "blankLine": "always", "prev":"*", "next": "cjs-export" },
+      { "blankLine": "always", "prev":"*", "next": "export" },
+      { "blankLine": "always", "prev":"*", "next": "function" }
+    ],
+    "prefer-template": "off",
+    "curly": "error",
+    "no-plusplus": "off",
+    "no-restricted-properties": "off",
+    "prefer-destructuring": "off",
+    "class-methods-use-this": "off",
+    "no-param-reassign": "off",
+    "max-len": "off",
+    "no-return-await": "off",
+    "array-bracket-spacing": ["error", "always"],
+    "radix": "off",
+    "camelcase": "off",
+    "no-lonely-if": "off",
+    "no-mixed-operators": "off",
+    "no-shadow": "off",
+    "no-useless-concat": "off",
+    "no-continue": "off",
+    "no-else-return": "off",
+    "no-unneeded-ternary": "off",
+    "operator-assignment": "off",
+    "no-underscore-dangle": "off",
+    "consistent-return": "off",
+    "no-await-in-loop": "off",
+    "prefer-exponentiation-operator": "off",
+    "no-use-before-define": ["error", {
+        "functions": false,
+        "classes": true,
+        "variables": true,
+        "allowNamedExports": false
+    }]
+  },
+  "settings": {
+    "import/resolver": {
+      "node": {
+        "extensions": [".js", ".ts"]
+      }
+    },
+    "import/parsers": {
+      "@typescript-eslint/parser": [".ts", ".js"]
+    }
+  }
+}

package/examples/ts/build-ohlcv-bars.ts

@@ -0,0 +1,53 @@
+import ccxt from '../../js/ccxt.js';
+
+// AUTO-TRANSPILE //
+
+// Bulding OHLCV array from trades (executions) data is a bit tricky. For example, if you want to build 100 ohlcv bars of 1-minute timeframe, then you have to fetch the 100 minutes of trading data. So, higher timeframe bars require more trading data (i.e. building 100 bars of 1-day timeframe OHLCV would require massive amount of trading data, which might not be desirable for user, because of data-usage rate limits)
+
+async function example_with_fetch_trades () {
+    const exch = new ccxt.binance ({});
+    const timeframe = '1m';
+    const symbol = 'OGN/USDT';
+    const since = exch.milliseconds () - 1000 * 60 * 30; // last 30 mins
+    const limit = 1000;
+    const trades = await exch.fetchTrades (symbol, since, limit);
+    const generatedBars = exch.buildOHLCVC (trades, timeframe, since, limit);
+    // you can ignore 6th index ("count" field) from ohlcv entries, which is not part of OHLCV standard structure and is just added internally by `buildOHLCVC` method
+    console.log ('[REST] Constructed', generatedBars.length, 'bars from trades: ', generatedBars);
+}
+
+async function example_with_watch_trades () {
+    const exch = new ccxt.pro.binance ({});
+    const timeframe = '1m';
+    const symbol = 'DOGE/USDT';
+    const limit = 1000;
+    const since = exch.milliseconds () - 10 * 60 * 1000 * 1000; // last 10 hrs
+    let collectedTrades = [];
+    const collectedBars = [];
+    while (true) {
+        const wsTrades = await exch.watchTrades (symbol, since, limit, {});
+        collectedTrades = collectedTrades.concat (wsTrades);
+        const generatedBars = exch.buildOHLCVC (collectedTrades, timeframe, since, limit);
+        // Note: first bar would be partially constructed bar and its 'open' & 'high' & 'low' prices (except 'close' price) would probably have different values compared to real bar on chart, because the first obtained trade timestamp might be somewhere in the middle of timeframe period, so the pre-period would be missing because we would not have trades data. To fix that, you can get older data with `fetchTrades` to fill up bars till start bar.
+        for (let i = 0; i < generatedBars.length; i++) {
+            const bar = generatedBars[i];
+            const barTimestamp = bar[0];
+            const collectedBarsLength = collectedBars.length;
+            const lastCollectedBarTimestamp = collectedBarsLength > 0 ? collectedBars[collectedBarsLength - 1][0] : 0;
+            if (barTimestamp === lastCollectedBarTimestamp) {
+                // if timestamps are same, just updarte the last bar
+                collectedBars[collectedBarsLength - 1] = bar;
+            } else if (barTimestamp > lastCollectedBarTimestamp) {
+                collectedBars.push (bar);
+                // remove the trades from saved array, which were till last collected bar's open timestamp
+                collectedTrades = exch.filterBySinceLimit (collectedTrades, barTimestamp);
+            }
+        }
+        // Note: first bar would carry incomplete values, please read comment in "buildOHLCVCFromWatchTrades" method definition for further explanation
+        console.log ('[WS] Constructed', collectedBars.length, 'bars from', symbol, 'trades: ', collectedBars);
+    }
+}
+
+
+await example_with_fetch_trades ();
+await example_with_watch_trades ();

package/examples/ts/cli.ts

@@ -0,0 +1,397 @@
+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 '../../ts/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')
+
+//-----------------------------------------------------------------------------
+
+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 as any).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.toString())
+settings = settings[exchangeId] || {}
+
+
+//-----------------------------------------------------------------------------
+
+const timeout = 30000
+let exchange = undefined as any
+
+
+
+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) as any;
+    exchangeId = res[1];
+    methodName = res[2];
+    params = res[3].split(",").map(x => x.trim());
+}
+
+try {
+    if ((ccxt.pro as any).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 (', ') as any).green)
+}
+
+//-----------------------------------------------------------------------------
+
+function printUsage () {
+    log ('This is an example of a basic command-line interface to all exchanges')
+    log ('Usage: node', process.argv[1], ('id' as any).green, ('method' as any).yellow, ('"param1" param2 "param3" param4 ...' as any).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 (!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 as any).configure ({
+                delimiter: (' | ' as any).lightGray.dim,
+                right: true,
+                title: x => (String (x) as any).lightGray,
+                dash: ('-' as any).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)).toString())
+            } 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') {
+
+                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) {
+                            log (exchange.iso8601 (end), 'iteration', i++, 'passed in', end - start, 'ms\n')
+                        }
+                        printHumanReadable (exchange, result)
+                        if (!isWsMethod) {
+                            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] as any;
+                        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/ts/compare-two-exchanges-capabilities.ts

@@ -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 ();