ccxt 4.2.73 → 4.2.75

package/examples/js/bcc-vs-bch.js

@@ -0,0 +1,115 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ololog from 'ololog'
+import config from '../../keys.json';
+import ansicolor from 'ansicolor';
+
+const log = ololog.configure ({ locate: false })
+
+ansicolor.nice
+
+let sleep = (ms) => new Promise (resolve => setTimeout (resolve, ms))
+
+let proxies = [
+    '', // no proxy by default
+    'https://crossorigin.me/',
+    'https://cors-anywhere.herokuapp.com/',
+]
+
+;(async function main () {
+
+    let ids = ccxt.exchanges
+    let exchanges = {}
+
+    // instantiate all exchanges
+    ccxt.exchanges.forEach (id => {
+        if (id in ccxt)
+            exchanges[id] = new (ccxt)[id] ({
+                verbose: false,
+                substituteCommonCurrencyCodes: true,
+            })
+    })
+
+    // set up api keys appropriately
+    for (let id in config) {
+        if (id in exchanges)
+            for (let key in config[id])
+                exchanges[id][key] = config[id][key]
+    }
+
+    log (ids.join (', ').yellow)
+
+    // load all markets from all exchanges
+
+    await Promise.all (ids.map (async id => {
+
+        let exchange = exchanges[id]
+
+        // basic round-robin proxy scheduler
+        let currentProxy = 0
+        let maxRetries   = proxies.length
+
+        for (let numRetries = 0; numRetries < maxRetries; numRetries++) {
+
+            try { // try to load exchange markets using current proxy
+
+                exchange.proxy = proxies[currentProxy]
+                await exchange.loadMarkets ()
+
+            } catch (e) { // rotate proxies in case of connectivity errors, catch all other exceptions
+
+                // swallow connectivity exceptions only
+                if ((e instanceof ccxt.DDoSProtection) || e.message.includes ('ECONNRESET')) {
+                    log.bright.yellow (exchange.id + ' [DDoS Protection]')
+                } else if (e instanceof ccxt.RequestTimeout) {
+                    log.bright.yellow (exchange.id + ' [Request Timeout] ' + e.message)
+                } else if (e instanceof ccxt.AuthenticationError) {
+                    log.bright.yellow (exchange.id + ' [Authentication Error] ' + e.message)
+                } else if (e instanceof ccxt.ExchangeNotAvailable) {
+                    log.bright.yellow (exchange.id + ' [Exchange Not Available] ' + e.message)
+                } else if (e instanceof ccxt.ExchangeError) {
+                    log.bright.yellow (exchange.id + ' [Exchange Error] ' + e.message)
+                } else {
+                    throw e; // rethrow all other exceptions
+                }
+
+                // retry next proxy in round-robin fashion in case of error
+                currentProxy = ++currentProxy % proxies.length
+            }
+        }
+
+        if (exchange.symbols)
+            log (id.green, 'loaded', exchange.symbols.length.toString ().green, 'markets')
+
+    }))
+
+    log ('Loaded all markets'.green)
+
+    let table = ccxt.exchanges.map (id => {
+        console.log (id)
+        let exchange = exchanges[id]
+        if (exchange.currencies) {
+            let hasBCC = exchange.currencies.includes ('BCC')
+            let hasBCH = exchange.currencies.includes ('BCH')
+            let hasBoth = (hasBCC && hasBCH)
+            return {
+                id,
+                'BCC': hasBoth ? id.green : (hasBCC ? id.yellow : ''),
+                'BCH': hasBCH ? id.green : '',
+            }
+        } else {
+            return {
+                'id': id.red,
+                'BCC': '',
+                'BCH': '',
+            }
+        }
+    })
+
+    log (asTable.configure ({ delimiter: ' | ' }) (table))
+
+    process.exit ()
+
+}) ()

package/examples/js/binance-fetch-all-deposits.js

@@ -0,0 +1,45 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+(async function main () {
+
+    const exchange = new ccxt.binance ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET',
+    })
+
+    await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging
+
+    const ninetyDays = 90 * 24 * 60 * 60 * 1000;
+    let startTime = exchange.parse8601 ('2018-01-01T00:00:00')
+    const now = exchange.milliseconds ()
+    const currencyCode = undefined // any currency
+
+    let allTransactions = []
+
+    while (startTime < now) {
+
+        const endTime = startTime + ninetyDays
+
+        const transactions = await exchange.fetchDeposits (currencyCode, startTime, undefined, {
+            'endTime': endTime,
+        })
+        if (transactions.length) {
+            const lastTransaction = transactions[transactions.length - 1]
+            startTime = lastTransaction['timestamp'] + 1
+            allTransactions = allTransactions.concat (transactions)
+        } else {
+            startTime = endTime;
+        }
+    }
+
+    console.log ('Fetched', allTransactions.length, 'transactions')
+    for (let i = 0; i < allTransactions.length; i++) {
+        const transaction = allTransactions[i]
+        console.log (i, transaction['datetime'], transaction['txid'], transaction['currency'], transaction['amount'])
+    }
+
+}) ()

package/examples/js/binance-fetch-ohlcv-many-symbols-async-await.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const ccxt = require ('../../ccxt.js')
+
+console.log('CCXT Version:', ccxt.version)
+
+async function symbolLoop (exchange, symbol, timeframe) {
+    while (true) {
+        try {
+            const ohlcvs = await exchange.fetchOHLCV (symbol, timeframe)
+            console.log (exchange.iso8601 (exchange.milliseconds ()), exchange.id, symbol, ohlcvs.length, 'OHLCV candles received')
+            // await exchange.sleep (60 * 1000) // sleep if necessary, though not required
+        } catch (e) {
+            console.log (exchange.iso8601 (exchange.milliseconds ()), exchange.id, symbol, e.constructor.name, e.message)
+        }
+    }
+}
+
+async function main () {
+    const exchange = new ccxt.binance ()
+    await exchange.loadMarkets ()
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+    const symbols = [
+        'BTC/USDT', // unified symbols used here as opposed to exchange-specific market ids
+        'ETH/USDT', // more about unified symbols vs exchange-specific ids here:
+        'ADA/USDT', // https://github.com/ccxt/ccxt/wiki/Manual#markets
+    ]
+    const timeframe = '1m'
+    const loops = symbols.map (symbol => symbolLoop (exchange, symbol, timeframe))
+    await Promise.all (loops)
+}
+
+
+main ()

package/examples/js/binance-fetch-ohlcv-many-symbols-promise-then-callbacks.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const ccxt = require ('../../ccxt.js')
+
+console.log('CCXT Version:', ccxt.version)
+
+function symbolLoop (exchange, symbol, timeframe) {
+    exchange.fetchOHLCV (symbol, timeframe).then (ohlcvs => {
+        console.log (exchange.iso8601 (exchange.milliseconds ()), exchange.id, symbol, ohlcvs.length, 'OHLCV candles received')
+        setTimeout (() => symbolLoop (exchange, symbol, timeframe), 0)
+    }).catch (e => {
+        console.log (exchange.iso8601 (exchange.milliseconds ()), exchange.id, symbol, e.constructor.name, e.message)
+        setTimeout (() => symbolLoop (exchange, symbol, timeframe), 0)
+    })
+}
+
+function main () {
+    const exchange = new ccxt.binance ()
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+    const symbols = [
+        'BTC/USDT', // unified symbols used here as opposed to exchange-specific market ids
+        'ETH/USDT', // more about unified symbols vs exchange-specific ids here:
+        'ADA/USDT', // https://github.com/ccxt/ccxt/wiki/Manual#markets
+    ]
+    const timeframe = '1m'
+    exchange.loadMarkets ().then (markets => {
+        for (const symbol of symbols) {
+            setTimeout (() => symbolLoop (exchange, symbol, timeframe), 0)
+        }
+    })
+}
+
+main ()

package/examples/js/binance-fetchTicker-delivery-vs-future.js

@@ -0,0 +1,31 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+async function fetchTickers (exchange) {
+    let tickers = undefined
+    try {
+        // await exchange.loadMarkets () // optional
+        tickers = await exchange.fetchTickers ()
+    } catch (e) {
+        console.error (e.constructor.name, e.message)
+    }
+    return tickers
+}
+
+(async () => {
+
+    const future   = new ccxt.binance ({ options: { defaultType: 'future' }})
+    const delivery = new ccxt.binance ({ options: { defaultType: 'delivery' }})
+
+    // ...
+
+    const futureTickers = await fetchTickers (future);
+    console.log (futureTickers)
+
+    console.log ('-------------------------------------------')
+
+    const deliveryTickers = await fetchTickers (delivery);
+    console.log (deliveryTickers)
+
+}) ()

package/examples/js/binance-futures-transfer-from-sub-account-to-master.js

@@ -0,0 +1,41 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+console.log ('CCXT Version:', ccxt.version)
+
+// https://github.com/ccxt/ccxt/issues/10181
+
+async function main () {
+
+    const exchange = new ccxt.binance ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET',
+    })
+
+    const markets = await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging purposes
+
+    const fromEmail = 'sender@example.com' // edit for your values
+        , toEmail = 'receiver@example.com' // edit for your values
+        , code = 'USDT' // edit for your values
+        , amount = 100 // edit for your values
+        , futuresType = 1 // 1 for USDT-margined futures，2 for coin-margined futures
+
+    const currency = exchange.currency (code);
+
+    const response = await exchange.sapiPostSubAccountFuturesInternalTransfer ({
+        'fromEmail': fromEmail, // sender email
+        'toEmail': toEmail, // recipient email
+        'futuresType': futuresType, // 1 for USDT-margined futures，2 for coin-margined futures
+        'asset': currency['id'],
+        'amount': exchange.currencyToPrecision (code, amount),
+    })
+
+    console.log (response)
+
+}
+
+main ()
+

package/examples/js/binance-margin-stop-order.js

@@ -0,0 +1,39 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+console.log ('CCXT Version:', ccxt.version)
+
+async function main () {
+
+    const exchange = new ccxt.binance({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+        'options': {
+            'defaultType': 'margin',
+        },
+    })
+
+    const markets = await exchange.loadMarkets ()
+
+    exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    const symbol = 'BTC/USDT'
+    const type = 'STOP_LOSS_LIMIT'
+    const side = 'buy'
+    const amount = YOUR_AMOUNT_HERE
+    const price = YOUR_PRICE_HERE
+    const params = {
+        'stopPrice': YOUR_STOP_PRICE_HERE,
+        'timeInForce': 'GTC',
+    }
+
+    try {
+        const order = await exchange.createOrder (symbol, type, side, amount, price, params)
+        console.log (order)
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+}
+
+main ()

package/examples/js/binance-server-time.js

@@ -0,0 +1,34 @@
+
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog'
+
+const log  = ololog.configure ({ locate: false })
+
+const binance = new ccxt['binance'] ()
+const recvWindow = binance.options.recvWindow
+const aheadWindow = 1000
+
+async function test () {
+    const localStartTime = Date.now ()
+    const { serverTime } = await binance.publicGetTime ()
+    const localFinishTime = Date.now ()
+    const estimatedLandingTime = (localFinishTime + localStartTime) / 2
+
+    const diff = serverTime - estimatedLandingTime
+
+    log (`request departure time:     ${binance.iso8601 (localStartTime)}`)
+    log (`response arrival time:      ${binance.iso8601 (localFinishTime)}`)
+    log (`server time:                ${binance.iso8601 (serverTime)}`)
+    log (`request landing time (est): ${binance.iso8601 (estimatedLandingTime)}, ${Math.abs (diff)} ms ${Math.sign (diff) > 0 ? 'behind' : 'ahead of'} server`)
+    log ('\n')
+
+    if (diff < -aheadWindow) {
+        log.error.red (`your request will likely be rejected if local time is ahead of the server's time for more than ${aheadWindow} ms \n`)
+    }
+
+    if (diff > recvWindow) {
+        log.error.red (`your request will likely be rejected if local time is behind server time for more than ${recvWindow} ms\n`)
+    }
+}
+
+test ();

package/examples/js/binance-universal-transfer.js

@@ -0,0 +1,16 @@
+import ccxt from '../../js/ccxt.js';
+
+(async () => {
+
+    // apiKey must have universal transfer permissions
+    const binance = new ccxt.binance ({
+        "apiKey": "",
+        "secret": "",
+    })
+
+    console.log (await binance.transfer ('USDT', 1, 'spot', 'future'))
+    const transfers = await binance.fetchTransfers ();
+    console.log ('got ', transfers.length, ' transfers')
+    console.log (await binance.transfer ('USDT', 1, 'spot', 'cross')) // For transfer to cross margin wallet
+    console.log (await binance.transfer ('USDT', 1, 'spot', 'ADA/USDT')) // For transfer to an isolated margin wallet
+}) ()

package/examples/js/bitfinex-fetch-trades.js

@@ -0,0 +1,35 @@
+
+
+// ----------------------------------------------------------------------------
+
+import ccxt from '../../js/ccxt.js';
+import log from 'ololog';
+import asTable from 'as-table';
+
+// ----------------------------------------------------------------------------
+
+const // ----------------------------------------------------------------------------
+table = asTable.configure ({ delimiter: ' | ' });(async () => {
+
+    const exchange = new ccxt.bitfinex ({
+        'verbose': process.argv.includes ('--verbose'),
+        'timeout': 60000,
+    })
+
+    try {
+
+        const response = await exchange.fetchTrades ('ETH/BTC', 1518983548636 - 2 * 24 * 60 * 60 * 1000)
+        log (table (response))
+        log (response.length.toString (), 'trades')
+        log.green ('Succeeded.')
+
+    } catch (e) {
+
+        log.dim ('--------------------------------------------------------')
+        log (e.constructor.name, e.message)
+        log.dim ('--------------------------------------------------------')
+        log.dim (exchange.last_http_response)
+        log.error ('Failed.')
+    }
+
+}) ()

package/examples/js/bitfinex2-fetch-trades.js

@@ -0,0 +1,35 @@
+
+
+// ----------------------------------------------------------------------------
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import log from 'ololog';
+
+// ----------------------------------------------------------------------------
+
+const // ----------------------------------------------------------------------------
+table = asTable.configure ({ delimiter: ' | ' });(async () => {
+
+    const exchange = new ccxt.bitfinex2 ({
+        'verbose': process.argv.includes ('--verbose'),
+        'timeout': 60000,
+    })
+
+    try {
+
+        const response = await exchange.fetchTrades ('ETH/BTC', 1518983548636 - 2 * 24 * 60 * 60 * 1000)
+        log (table (response))
+        log (response.length.toString (), 'trades')
+        log.green ('Succeeded.')
+
+    } catch (e) {
+
+        log.dim ('--------------------------------------------------------')
+        log (e.constructor.name, e.message)
+        log.dim ('--------------------------------------------------------')
+        log.dim (exchange.last_http_response)
+        log.error ('Failed.')
+    }
+
+}) ()

package/examples/js/bitmex-browser-cors-proxy.js

@@ -0,0 +1,7 @@
+// 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 ({
+    setHeaders: { 'origin': 'https://www.bitmex.com' }
+}).listen (port, '0.0.0.0')

package/examples/js/bitpanda-fetchMyTrades-reduce.js

@@ -0,0 +1,36 @@
+import ccxt from '../../js/ccxt.js';
+
+const bitpanda = new ccxt.bitpanda ({
+    "apiKey": "INSERTYOURAPIKEY"
+})
+
+
+// output
+`
+fetching USDT/EUR trades on bitpanda
+---------------------------------------------
+maker volume 6621.81 USDT maker fee 5.62 USDT
+taker volume 2544.82 USDT taker fee 3.27 USDT
+
+sold 9166.63 USDT for 7802.38 EUR
+bought 0.00 USDT for 0.00 EUR
+`
+
+;(async () => {
+    const market = {
+        symbol: 'USDT/EUR',
+        base: 'USDT',
+        quote: 'EUR',
+    }
+    console.log ('fetching', market.symbol, 'trades on bitpanda')
+    console.log ('---------------------------------------------')
+    const trades = await bitpanda.fetchMyTrades ('USDT/EUR')
+    const makers = trades.filter (x => x.takerOrMaker === 'maker')
+    const takers = trades.filter (x => x.takerOrMaker === 'taker')
+    console.log ('maker volume', makers.reduce ((a, b) => a + b.amount, 0).toFixed (2), market.base, 'maker fee', makers.reduce ((a, b) => a + b.fee['cost'], 0).toFixed (2), market.base)
+    console.log ('taker volume', takers.reduce ((a, b) => a + b.amount, 0).toFixed (2), market.base, 'taker fee', takers.reduce ((a, b) => a + b.fee['cost'], 0).toFixed (2), market.base)
+    const sells = trades.filter (x => x.side === 'sell')
+    const buys = trades.filter (x => x.side === 'buy')
+    console.log ('\nsold', sells.reduce ((a, b) => a + b.amount, 0).toFixed (2), market.base, 'for', sells.reduce ((a, b) => a + b.cost, 0).toFixed (2), market.quote)
+    console.log ('bought', buys.reduce ((a, b) => a + b.amount, 0).toFixed (2), market.base, 'for', buys.reduce ((a, b) => a + b.cost, 0).toFixed (2), market.quote)
+}) ()

package/examples/js/bitrue-fetch-balance.js

@@ -0,0 +1,28 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+async function main () {
+
+    console.log ('CCXT Version:', ccxt.version)
+
+    const exchange = new ccxt.bitrue ({
+        "apiKey": "YOUR_API_KEY",
+        "secret": "YOUR_SECRET",
+    })
+
+    await exchange.loadMarkets ()
+
+    exchange.verbose = true
+
+    try {
+
+        const balance = await exchange.fetchBalance ()
+        console.log (balance)
+
+    } catch (e) {
+        console.log (e.constructor.name, e.message);
+    }
+}
+
+main ()

package/examples/js/bitstamp-private-api.js

@@ -0,0 +1,115 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ololog from 'ololog'
+import ansicolor from 'ansicolor';
+
+const log = ololog.configure({ locate: false })
+
+ansicolor.nice
+
+    ;(async () => {
+        let apiUrl = 'https://www.bitstamp.net/api';
+
+        // instantiate the exchange
+        let exchange = new ccxt.bitstamp({
+            'apiKey': 'APIKEY',
+            'secret': 'APISECRET',
+            'uid': 'ACCOUNTID',
+            'urls': {
+                'api': {
+                    'public': apiUrl,
+                    'private': apiUrl,
+                    'v1': apiUrl
+                }
+            }
+        })
+
+        try {
+            // fetch account balance from the exchange
+            let balance = await exchange.fetchBalance()
+            log('balance'.green, balance.total)
+
+            // fetch fees
+            let singleFee = await exchange.fetchTradingFee('BTC/USD')
+            log('fee'.green, 'BTC/USD', singleFee)
+            let tradingFees = await exchange.fetchTradingFees()
+            log('tradingFees'.green, tradingFees)
+            let fundingFees = await exchange.fetchFundingFees()
+            log('fundingFees'.green, fundingFees)
+            let fees = await exchange.fetchFees()
+            log('fees'.green, fees)
+
+            // my trades
+            let myTrades = await exchange.fetchMyTrades('BTC/USD', undefined, 5)
+            log('myTrades'.green, asTable(myTrades))
+
+            // user transactions
+            let transactions = await exchange.fetchTransactions()
+            log('Transactions'.green, asTable(transactions))
+
+            // ledger
+            let ledger = await exchange.fetchLedger()
+            log('Ledger'.green, asTable(ledger))
+
+            // deposits
+            let deposits = await exchange.fetchDeposits()
+            log('Deposits'.green, asTable(deposits))
+
+            // create new limit order
+            let newOrder = await exchange.createOrder('BTC/USD', 'limit', 'buy', 0.01, 8000)
+            console.log('New limit order'.green, newOrder);
+
+            // open orders
+            let openOrders = await exchange.fetchOpenOrders()
+            log('Open orders'.green, asTable(openOrders))
+
+            // order data
+            let orderData = await exchange.fetchOrder(newOrder.id)
+            console.log('Order data'.green, orderData);
+
+            // cancel order
+            let canceledOrder = await exchange.cancelOrder(newOrder.id)
+            console.log('Canceled order'.green, canceledOrder);
+
+            // create market order
+            let marketOrder = await exchange.createOrder('BTC/USD', 'market', 'buy', 0.01)
+            console.log('New market order'.green, marketOrder);
+
+            // open orders
+            let secondOpenOrders = await exchange.fetchOpenOrders()
+            log('Open orders'.green, asTable(secondOpenOrders))
+
+            // deposit address
+            let paxDeposit = await exchange.fetchDepositAddress("XLM")
+            log('Pax deposit address'.green, paxDeposit)
+
+            // withdrawal
+            let ethWithdraw = await exchange.withdraw("ETH", 0.01, "0x6c28cb9dd2f4e3bb6f56c822bc306f3b8a3e7c08")
+            log('ETH withdrawal'.green, ethWithdraw)
+
+            // withdrawals
+            let withdrawals = await exchange.fetchWithdrawals()
+            log('Withdrawals'.green, asTable(withdrawals))
+
+        } catch (e) {
+
+            if (e instanceof ccxt.DDoSProtection || e.message.includes('ECONNRESET')) {
+                log.bright.yellow('[DDoS Protection] ' + e.message)
+            } else if (e instanceof ccxt.RequestTimeout) {
+                log.bright.yellow('[Request Timeout] ' + e.message)
+            } else if (e instanceof ccxt.AuthenticationError) {
+                log.bright.yellow('[Authentication Error] ' + e.message)
+            } else if (e instanceof ccxt.ExchangeNotAvailable) {
+                log.bright.yellow('[Exchange Not Available Error] ' + e.message)
+            } else if (e instanceof ccxt.ExchangeError) {
+                log.bright.yellow('[Exchange Error] ' + e.message)
+            } else if (e instanceof ccxt.NetworkError) {
+                log.bright.yellow('[Network Error] ' + e.message)
+            } else {
+                throw e;
+            }
+        }
+
+    })()