ccxt 4.2.73 → 4.2.74

package/examples/ccxt.pro/js/build-ohlcv-many-symbols.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const ccxt = require ('ccxt');
+const asTable  = require ('as-table').configure ({ delimiter: ' | ' })
+
+console.log ('CCXT Version:', ccxt.version)
+
+
+async function loop (exchange, symbol, timeframe, completeCandlesOnly = false) {
+    const durationInSeconds = exchange.parseTimeframe (timeframe)
+    const durationInMs = durationInSeconds * 1000
+    while (true) {
+        try {
+            const trades = await exchange.watchTrades (symbol)
+            if (trades.length > 0) {
+                const currentMinute = parseInt (exchange.milliseconds () / durationInMs)
+                let ohlcvc = exchange.buildOHLCVC (trades, timeframe)
+                if (completeCandlesOnly) {
+                    ohlcvc = ohlcvc.filter (candle => parseInt (candle[0] / durationInMs) < currentMinute)
+                }
+                if (ohlcvc.length > 0) {
+                    console.log("Symbol:", symbol, "timeframe:", timeframe);
+                    console.log ('-----------------------------------------------------------')
+                    console.log (asTable (ohlcvc))
+                    console.log ('-----------------------------------------------------------')
+                }
+            }
+        } catch (e) {
+            console.log (symbol, e)
+            // do nothing and retry on next loop iteration
+            // throw e // uncomment to break all loops in case of an error in any one of them
+            // break // you can also break just this one loop if it fails
+        }
+    }
+}
+
+async function main () {
+    // select the exchange
+     const exchange = new ccxt.pro.ftx ()
+
+    if (exchange.has['watchTrades']) {
+        await exchange.loadMarkets ()
+        // Change this value accordingly
+        const timeframe = '1m'
+
+        const allSymbols = exchange.symbols;
+
+        // arbitrary n symbols
+        const limit = 5;
+        // const selectedSymbols = allSymbols.slice(0, limit);
+        // you can also specify the symbols manually
+        // example:
+        // const selectedSymbols = ['BTC/USDT', 'LTC/USDT']
+
+        console.log(selectedSymbols);
+
+        // Use this variable to choose if only complete candles 
+        // should be considered
+        const completeCandlesOnly = true
+
+        await Promise.all (selectedSymbols.map (symbol => loop (exchange, symbol, timeframe, completeCandlesOnly)))
+
+    } else {
+        console.log (exchange.id, 'does not support watchTrades yet')
+    }
+}
+
+main ()

package/examples/ccxt.pro/js/calculate-ohlcvs-from-trades-warmup.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const ccxt = require ('../../../ccxt');
+
+console.log ('CCXT Version:', ccxt.version)
+
+let ohlcvs = {}
+
+async function log (exchange, symbol, timeframe) {
+    const market = exchange.market (symbol)
+    const duration = exchange.parseTimeframe (timeframe) * 1000
+    console.log (exchange.iso8601 (exchange.milliseconds ()), 'Warming up, waiting for at least one trade...')
+    while (!Object.keys (ohlcvs).length) {
+        await exchange.throttle (1)
+    }
+    let now = exchange.milliseconds ()
+    const start = (parseInt (now / duration) + 1) * duration
+    console.log (exchange.iso8601 (exchange.milliseconds ()), 'Trades started arriving, waiting till', exchange.iso8601 (start))
+    await exchange.sleep (start - now)
+    console.log (exchange.iso8601 (exchange.milliseconds ()), 'Done warming up')
+    for (let i = 0;; i++) {
+        now = exchange.milliseconds ()
+        let candle = Object.values (ohlcvs)[0]
+        console.log ('')
+        console.log (exchange.iso8601 (now), '------------------------------------------------------')
+        console.log ('Datetime                ', 'Timestamp    ', ... [ 'Open', 'High', 'Low', 'Close', market['base'], market['quote'] ].map (x => x.toString ().padEnd (10, ' ')))
+        for (let j = start; j < now; j += duration) {
+            if (!(j in ohlcvs)) {
+                ohlcvs[j] = [ j, candle[4], candle[4], candle[4], candle[4], 0, 0 ]
+            }
+            candle = exchange.safeValue (ohlcvs, j);
+            console.log (exchange.iso8601 (j), ... candle.map (x => x.toString ().padEnd (10, ' ')))
+        }
+        ohlcvs = exchange.indexBy (Object.values (ohlcvs).slice (-1000), 0)
+        await exchange.sleep(1000)
+    }
+}
+
+async function watch (exchange, symbol, timeframe) {
+    console.log ('Starting', exchange.id, symbol)
+    const duration = exchange.parseTimeframe (timeframe) * 1000
+    while (true) {
+        try {
+            const trades = await exchange.watchTrades(symbol)
+            for (const trade of trades) {
+                const timestamp = parseInt(trade['timestamp'] / duration) * duration
+                let candle = exchange.safe_value(ohlcvs, timestamp)
+                if (candle) {
+                    candle[2] = Math.max(trade['price'], candle[2])
+                    candle[3] = Math.min(trade['price'], candle[3])
+                    candle[4] = trade['price']
+                    candle[5] = exchange.parseNumber(exchange.amountToPrecision(symbol, trade['amount'] + candle[5]))
+                    candle[6] = exchange.parseNumber(exchange.costToPrecision(symbol, trade['cost'] + candle[6]))
+                } else {
+                    candle = [
+                        timestamp,
+                        trade['price'],
+                        trade['price'],
+                        trade['price'],
+                        trade['price'],
+                        exchange.parseNumber(exchange.amountToPrecision(symbol, trade['amount'])),
+                        exchange.parseNumber(exchange.costToPrecision(symbol, trade['cost'])),
+                    ]
+                }
+                ohlcvs[timestamp] = candle
+            }
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+}
+
+async function main() {
+    const symbol = 'BTC/USDT'
+     const exchange = new ccxt.pro.binance ({ 'newUpdates': true })
+    await exchange.loadMarkets ()
+    const timeframe = '1m'
+    await Promise.all ([ watch (exchange, symbol, timeframe), log (exchange, symbol, timeframe) ])
+    await exchange.close ()
+}
+
+main()

package/examples/ccxt.pro/js/calculate-ohlcvs-from-trades.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const ccxt = require ('../../../ccxt');
+
+console.log ('CCXT Version:', ccxt.version)
+
+
+async function main() {
+    let ohlcvs = {}
+    const symbol = 'BTC/USDT'
+     const exchange = new ccxt.pro.binance ({ 'newUpdates': true })
+    await exchange.loadMarkets ()
+    const market = exchange.market (symbol)
+    const timeframe = '1m'
+    const duration = exchange.parseTimeframe (timeframe) * 1000
+    console.log ('Starting', exchange.id, symbol)
+    while (true) {
+        try {
+            const trades = await exchange.watchTrades(symbol)
+            for (const trade of trades) {
+                const timestamp = parseInt(trade['timestamp'] / duration) * duration
+                let candle = exchange.safe_value(ohlcvs, timestamp)
+                if (candle) {
+                    candle[2] = Math.max(trade['price'], candle[2])
+                    candle[3] = Math.min(trade['price'], candle[3])
+                    candle[4] = trade['price']
+                    candle[5] = exchange.parseNumber(exchange.amountToPrecision(symbol, trade['amount'] + candle[5]))
+                    candle[6] = exchange.parseNumber(exchange.costToPrecision(symbol, trade['cost'] + candle[6]))
+                } else {
+                    candle = [
+                        timestamp,
+                        trade['price'],
+                        trade['price'],
+                        trade['price'],
+                        trade['price'],
+                        exchange.parseNumber(exchange.amountToPrecision(symbol, trade['amount'])),
+                        exchange.parseNumber(exchange.costToPrecision(symbol, trade['cost'])),
+                    ]
+                }
+                ohlcvs[timestamp] = candle
+            }
+            console.log ('')
+            console.log (exchange.iso8601 (exchange.milliseconds ()), '------------------------------------------------------')
+            const values = Object.values (ohlcvs).slice (-1000)
+            ohlcvs = exchange.indexBy (values, 0)
+            console.log ('Datetime                ', 'Timestamp    ', ... [ 'Open', 'High', 'Low', 'Close', market['base'], market['quote'] ].map (x => x.toString ().padEnd (10, ' ')))
+            for (let i = 0; i < values.length; i++) {
+                const candle = values[i]
+                console.log (exchange.iso8601 (candle[0]), ... candle.map (x => x.toString ().padEnd (10, ' ')))
+            }
+
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+    await exchange.close ()
+}
+
+main()

package/examples/ccxt.pro/js/exchange-capabitities.js

@@ -0,0 +1,72 @@
+"use strict";
+
+/*  ------------------------------------------------------------------------ */
+
+const ccxt        = require ('../../../ccxt.js').pro
+    , asTable     = require ('as-table') // .configure ({ print: require ('string.ify').noPretty })
+    , log         = require ('ololog').noLocate
+    , ansi        = require ('ansicolor').nice
+
+;(async function test () {
+
+    let total = 0
+    let missing = 0
+    let implemented = 0
+    let emulated = 0
+
+    const exchanges = ccxt.exchanges
+        .map (id => new ccxt[id]())
+        .filter (exchange => exchange.has.ws)
+
+    log (
+        asTable (
+            exchanges
+                .map (exchange => {
+
+                    let result = {};
+
+                    [
+                        'ws',
+                        'watchOrderBook',
+                        'watchTicker',
+                        'watchTrades',
+                        'watchOHLCV',
+                        'watchBalance',
+                        'watchOrders',
+                        'watchMyTrades',
+
+                    ].forEach (key => {
+
+                        total += 1
+
+                        let capability = (key in exchange.has) ?
+                            exchange.has[key].toString () :
+                            'undefined'
+
+                        if (!exchange.has[key]) {
+                            capability = exchange.id.red.dim
+                            missing += 1
+                        } else if (exchange.has[key] === 'emulated') {
+                            capability = exchange.id.yellow
+                            emulated += 1
+                        } else {
+                            capability = exchange.id.green
+                            implemented += 1
+                        }
+
+                        result[key] = capability
+                    })
+
+                    return result
+                })
+        )
+    )
+
+    log ('Summary:',
+        exchanges.length.toString ().green, 'exchanges,',
+        implemented.toString ().green, 'methods implemented,',
+        emulated.toString ().yellow, 'emulated,',
+        missing.toString ().red, 'missing,',
+        total.toString (), 'total')
+
+}) ()

package/examples/ccxt.pro/js/exchange-close.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const ccxt = require ('../../../ccxt')
+
+console.log ("CCXT Pro Version:", ccxt.version)
+
+const orderbooks = {}
+
+let run = true
+
+async function watchOrderBook (exchange, symbol) {
+    while (run) {
+        try {
+            const orderbook = await exchange.watchOrderBook (symbol)
+            orderbooks[symbol] = orderbook
+            console.log (exchange.iso8601 (exchange.milliseconds ()), orderbook['datetime'], orderbook['nonce'], symbol, orderbook['asks'][0], orderbook['bids'][0])
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+}
+
+
+async function stop (exchange) {
+    await exchange.sleep (10000)
+    run = false
+    await exchange.close ()
+}
+
+
+async function main () {
+     const exchange = new ccxt.pro.binance ()
+    await exchange.loadMarkets ()
+    exchange.verbose = true
+    const symbols = [
+        'BTC/USDT',
+        'ETH/USDT',
+    ]
+    stop (exchange).then (() => {})
+    await Promise.all (symbols.map (symbol => watchOrderBook (exchange, symbol)))
+    console.log ('Sleeping for a moment...')
+    await exchange.sleep (10000)
+    console.log ('Done')
+}
+
+main ()

package/examples/ccxt.pro/js/gateio-swap-watch-many-orderbooks.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const ccxt = require ('ccxt')
+
+console.log ("CCXT Pro Version:", ccxt.version)
+
+async function loop (exchange, method, symbol) {
+    while (true) {
+        try {
+            const orderbook = await exchange[method] (symbol)
+            console.log (exchange.iso8601 (exchange.milliseconds ()), orderbook['datetime'], orderbook['nonce'], symbol, orderbook['asks'][0], orderbook['bids'][0])
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+}
+
+async function main () {
+     const exchange = new ccxt.pro.gateio ({
+        'options': {'defaultType':'swap'}
+    })
+    await exchange.loadMarkets ()
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+    const symbols = [
+        'ANC/USDT:USDT',
+    ]
+    await Promise.all (symbols.map (symbol => loop (exchange, 'fetchOrderBook', symbol)))
+}
+
+main ()

package/examples/ccxt.pro/js/gateio-watch-balance.js

@@ -0,0 +1,23 @@
+const ccxt = require ('../../../ccxt')
+
+console.log ('CCXT Pro version:', ccxt.version)
+
+async function main () {
+     const exchange = new ccxt.pro.gateio ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET',
+    })
+    await exchange.loadMarkets ()
+    exchange.verbose = true
+    while (true) {
+        try {
+            const response = await exchange.watchBalance ()
+            console.log (new Date (), response)
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+            await exchange.sleep (1000)
+        }
+    }
+}
+
+main ()

package/examples/ccxt.pro/js/gateio-watch-order-book.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const ccxt = require ('ccxt')
+
+console.log ("CCXT Pro Version:", ccxt.version)
+
+const orderbooks = {}
+
+async function watchAllSymbols (exchange, symbols) {
+    while (true) {
+        const keys = Object.keys (orderbooks);
+        if (symbols.length === keys.length) {
+            console.log ('\n\n\n\n\n')
+            console.log ('----------------------------------------------------')
+            console.log ('All orderbooks received at least one update:');
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i]
+                const orderbook = orderbooks[symbol]
+                console.log (exchange.iso8601 (exchange.milliseconds ()), orderbook['datetime'], orderbook['nonce'], symbol, orderbook['asks'][0], orderbook['bids'][0])
+            }
+            console.log ('----------------------------------------------------')
+            console.log ('\n\n\n\n\n')
+            // process.exit () // stop here if you want
+            break
+        } else {
+            await exchange.sleep (1000);
+        }
+    }
+}
+
+async function watchOrderBook (exchange, symbol) {
+    while (true) {
+        try {
+            const orderbook = await exchange.watchOrderBook (symbol)
+            orderbooks[symbol] = orderbook
+            console.log (exchange.iso8601 (exchange.milliseconds ()), orderbook['datetime'], orderbook['nonce'], symbol, orderbook['asks'][0], orderbook['bids'][0])
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+}
+
+async function main () {
+     const exchange = new ccxt.pro.gateio ({
+        'options': {
+            'defaultType': 'swap',
+        },
+    })
+    await exchange.loadMarkets ()
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+    const symbols = [
+        // 'SOS/USDT:USDT',
+        // 'JASMY/USDT:USDT',
+        // 'SLP/USDT:USDT',
+        'ACH/USDT:USDT',
+        'MKISHU/USDT:USDT',
+        // 'GMT/USDT:USDT',
+        // 'ASTR/USDT:USDT',
+        'RAMP/USDT:USDT',
+        'RSR/USDT:USDT',
+        // 'RACA/USDT:USDT',
+        // 'ROOK/USDT:USDT',
+        // 'ROSE/USDT:USDT',
+    ]
+    await Promise.all ([
+        watchAllSymbols (exchange, symbols),
+        ... symbols.map (symbol => watchOrderBook (exchange, symbol))
+    ])
+}
+
+main ()

package/examples/ccxt.pro/js/graceful-shutdown.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const ccxt = require ('../../../ccxt');
+
+let stop = false
+
+async function shutdown (milliseconds) {
+    await ccxt.sleep (10000)
+    stop = true
+}
+
+async function watchOrderBook (exchangeId, symbol) {
+
+     const exchange = new ccxt.pro[exchangeId] ()
+    await exchange.loadMarkets ()
+    // exchange.verbose = true
+    while (!stop) {
+        try {
+            const orderbook = await exchange.watchOrderBook (symbol)
+            console.log (new Date (), exchange.id, symbol, orderbook['asks'][0], orderbook['bids'][0])
+        } catch (e) {
+            console.log (symbol, e)
+            stop = true
+            break
+        }
+    }
+    await exchange.close ()
+}
+
+async function main () {
+    const streams = {
+        'binance': 'BTC/USDT',
+        'ftx': 'BTC/USDT',
+    };
+
+    await Promise.all ([
+        shutdown (10000),
+        ... Object.entries (streams).map (([ exchangeId, symbol ]) => watchOrderBook (exchangeId, symbol))
+    ])
+
+}
+
+main()

package/examples/ccxt.pro/js/many-exchanges-many-streams.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const ccxt = require ('../../../ccxt');
+
+(async () => {
+
+    const streams = {
+        'binance': 'BTC/USDT',
+        'bittrex': 'BTC/USDT',
+        'poloniex': 'BTC/USDT',
+        'bitfinex': 'BTC/USDT',
+        'hitbtc': 'BTC/USDT',
+        'upbit': 'BTC/USDT',
+        'coinbasepro': 'BTC/USD',
+        'ftx': 'BTC/USDT',
+        'okex': 'BTC/USDT',
+        'gateio': 'BTC/USDT',
+    };
+
+    await Promise.all (Object.keys (streams).map (exchangeId =>
+
+        (async () => {
+
+             const exchange = new ccxt.pro[exchangeId] ({ enableRateLimit: true })
+            const symbol = streams[exchangeId]
+            while (true) {
+                try {
+                    const orderbook = await exchange.watchOrderBook (symbol)
+                    console.log (new Date (), exchange.id, symbol, orderbook['asks'][0], orderbook['bids'][0])
+                } catch (e) {
+                    console.log (symbol, e)
+                }
+            }
+
+        }) ())
+    )
+}) ()

package/examples/ccxt.pro/js/okex-create-futures-order.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const ccxt = require ('ccxt')
+    , exchange = new ccxt.okex ({
+        apiKey: 'YOUR_API_KEY',
+        secret: 'YOUR_API_SECRET',
+        password: 'YOUR_API_PASSWORD',
+        enableRateLimit: true,
+        options: { defaultType: 'futures' },
+    })
+    , symbol = 'BTC/USDT:USDT-201225'
+    , amount = 1 // how may contracts
+    , price = undefined // or your limit price
+    , side = 'buy' // or 'sell'
+    , type = '1' // 1 open long, 2 open short, 3 close long, 4 close short for futures
+    , order_type = '4' // 0 = limit order, 4 = market order
+
+console.log ('CCXT Pro Version: ', ccxt.version)
+
+async function main () {
+
+    try {
+
+        await exchange.loadMarkets ()
+
+        // exchange.verbose = true // uncomment for debugging
+        // open long market price order
+        const order = await exchange.createOrder(symbol, 'market', side, amount, price, { type });
+        // --------------------------------------------------------------------
+        // open long market price order
+        // const order = await exchange.createOrder(symbol, type, side, amount, price, { order_type });
+        // --------------------------------------------------------------------
+        // close short market price order
+        // const order = await exchange.createOrder(symbol, 'market', side, amount, price, { type, order_type });
+        // --------------------------------------------------------------------
+        // close short market price order
+        // const order = await exchange.createOrder(symbol, '4', side, amount, price, { order_type });
+        // ...
+
+        console.log (order)
+
+    } catch (e) {
+
+        console.log (e.constructor.name, e.message)
+    }
+}
+
+main ()

package/examples/ccxt.pro/js/okex-watch-balance-and-create-order.js

@@ -0,0 +1,54 @@
+const ccxt = require ('ccxt')
+
+console.log ('Node.js:', process.version)
+console.log ('CCXT Pro v' + ccxt.version)
+
+ const exchange = new ccxt.pro.okex ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_API_SECRET',
+    'password': 'YOUR_API_PASWORD'
+})
+
+async function watchBalance (code) {
+
+    while (true) {
+        const balance = await exchange.watchBalance ({
+            'code': code,
+        })
+        console.log ('New', code, 'balance is: ', balance[code])
+    }
+}
+
+async function createOrder (symbol, type, side, amount, price = undefined, params = {}) {
+
+    console.log ('Creating', symbol, type, 'order')
+    const order = await exchange.createOrder (symbol, type, side, amount, price, params);
+    console.log (symbol, type, side, 'order created')
+    console.log (order)
+}
+
+;(async () => {
+
+    await exchange.loadMarkets ()
+    console.log (exchange.id, 'markets loaded')
+
+    const symbol = 'ETH/USDT'
+    const market = exchange.market (symbol)
+    const quote = market['quote']
+
+    // run in parallel without await
+    console.log ('Watching', quote, 'balance')
+    watchBalance (quote)
+
+    // wait a bit to allow it to subscribe
+    await exchange.sleep (3000)
+
+    const ticker = await exchange.watchTicker (symbol)
+    const type = 'market'
+    const side = 'buy'
+    const amount = 0.1
+    const price = ticker['bid']
+
+    await createOrder (symbol, type, side, amount, price)
+
+}) ()

package/examples/ccxt.pro/js/okx-watch-tickers.js

@@ -0,0 +1,31 @@
+import ccxt from '../../../js/ccxt.js';
+
+async function main() {
+    const exchange = new ccxt.pro.okx()
+    await exchange.loadMarkets()
+    // exchange.verbose = true
+    while (true) {
+        try {
+
+            // don't do this, specify a list of symbols to watch for watchTickers
+            // or a very large subscription message will crash your WS connection
+            // const tickers = await exchange.watchTickers ()
+
+            // do this instead
+            const symbols = [
+                'ETH/BTC',
+                'BTC/USDT',
+                'ETH/USDT',
+                // ...
+            ]
+            const tickers = await exchange.watchTickers (symbols)
+            symbols = Object.keys(tickers)
+            console.log (new Date(), 'received', symbols.length, 'symbols', ... symbols.slice(0,5).join(', '), '...')
+        } catch (e) {
+            console.log (new Date(), e.constructor.name, e.message)
+            break
+        }
+    }
+}
+
+main()