ccxt 4.2.73 → 4.2.74

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

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

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

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

package/examples/js/fetch-ohlcv.js

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

package/examples/js/fetch-okex-futures.js

@@ -0,0 +1,22 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+async function test () {
+
+    const exchange = new ccxt.okex ()
+    await exchange.loadMarkets ()
+
+    for (let symbol in exchange.markets) {
+
+        const market = exchange.markets[symbol]
+
+        if (market['future']) {
+            console.log ('----------------------------------------------------')
+            console.log (symbol, await exchange.fetchTicker (symbol))
+            await ccxt.sleep (exchange.rateLimit)
+        }
+    }
+}
+
+test ()

package/examples/js/fetch-orders.js

@@ -0,0 +1,27 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import log from 'ololog';
+import ansicolor from 'ansicolor';
+
+
+ansicolor.nice
+
+const exchange = new ccxt.bittrex ({
+    apiKey: "YOUR_API_KEY",
+    secret: "YOUR_SECRET",
+})
+
+async function test () {
+
+    const orders = await exchange.fetchOrders ()
+
+    log (asTable (orders.map (order => ccxt.omit (order, [ 'timestamp', 'info' ]))))
+
+    const order = await exchange.fetchOrder (orders[0]['id'])
+
+    log (order)
+}
+
+test ()

package/examples/js/fetch-ticker-from-multiple-exchanges.js

@@ -0,0 +1,35 @@
+
+
+import ccxt from '../../js/ccxt.js';
+(async () => {
+
+    const exchanges = [
+        'bittrex',
+        'poloniex',
+    ]
+
+    const symbol = 'BTC/USDT'
+    const tickers = {}
+
+    await Promise.all (exchanges.map (exchangeId =>
+
+        new Promise (async (resolve, reject) => {
+
+            const exchange = new ccxt[exchangeId] ()
+
+            while (true) {
+
+                const ticker = await exchange.fetchTicker (symbol)
+                tickers[exchangeId] = ticker
+
+                Object.keys (tickers).map (exchangeId => {
+                    const ticker = tickers[exchangeId]
+                    console.log (ticker['datetime'], exchangeId, ticker['bid'], ticker['ask'])
+                })
+            }
+
+        })
+
+    ))
+
+}) ()

package/examples/js/fetch-ticker-where-available.js

@@ -0,0 +1,75 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import log from 'ololog';
+import ansicolor from 'ansicolor';
+
+
+ansicolor.nice
+
+let printUsage = function () {
+    log ('Usage: node', process.argv[1], 'symbol'.green)
+}
+
+;(async function main () {
+
+    if (process.argv.length > 2) {
+
+        let symbol = process.argv[2].toUpperCase ()
+
+        for (let i = 0; i < ccxt.exchanges.length; i++) {
+
+            let id = ccxt.exchanges[i]
+
+            const exchange = new ccxt[id] ()
+            if (exchange.has.fetchTicker) {
+
+                try {
+
+                    await exchange.loadMarkets ()
+
+                    if (exchange.symbols.includes (symbol)) {
+
+                        log (id.green)
+
+                        const ticker = await exchange.fetchTicker (symbol)
+
+                        log.dim (ticker)
+
+                        if (ticker['baseVolume'] && ticker['quoteVolume']) {
+
+                            if (ticker['bid'] > 1) {
+
+                                if (ticker['baseVolume'] > ticker['quoteVolume'])
+                                log (id.bright, 'baseVolume > quoteVolume ← !'.bright)
+
+                            } else {
+
+                                if (ticker['baseVolume'] < ticker['quoteVolume'])
+                                    log (id.bright, 'baseVolume < quoteVolume ← !'.bright)
+
+                            }
+
+                        }
+
+                    } else {
+
+                        log (id.yellow)
+                    }
+
+                } catch (e) {
+
+                    log.error (id.red, e.toString ().red)
+                }
+            }
+        }
+
+    } else {
+
+        printUsage ()
+    }
+
+    process.exit ()
+
+}) ()

package/examples/js/fetch-tickers/build/index.js

@@ -0,0 +1,19 @@
+"use strict";
+// Example code in typescript
+// Based on /examples/js/fetch-from-many-exchanges-simultaneously.js
+Object.defineProperty(exports, "__esModule", { value: true });
+const ccxt = require("ccxt");
+const log = require('ololog');
+const symbol = 'BTC/USD';
+const exchanges = ['coinbasepro', 'gemini', 'kraken'];
+const fetchTickers = async (symbol) => {
+    const result = await Promise.all(exchanges.map(async (id) => {
+        const CCXT = ccxt; // Hack!
+        const exchange = new CCXT[id]({ 'enableRateLimit': true });
+        const ticker = await exchange.fetchTicker(symbol);
+        const exchangeExtended = exchange.extend({ 'exchange': id }, ticker);
+        return exchangeExtended;
+    }));
+    log(result);
+};
+fetchTickers(symbol);

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

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

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

@@ -0,0 +1,17 @@
+// Example code in typescript
+// Based on /examples/js/fetch-from-many-exchanges-simultaneously.js
+import * as ccxt from 'ccxt';
+const log = require('ololog');
+const symbol = 'BTC/USD';
+const exchanges = ['coinbasepro', 'gemini', 'kraken'];
+const fetchTickers = async (symbol) => {
+    const result = await Promise.all(exchanges.map(async (id) => {
+        const CCXT = ccxt; // Hack!
+        const exchange = new CCXT[id]({ 'enableRateLimit': true });
+        const ticker = await exchange.fetchTicker(symbol);
+        const exchangeExtended = exchange.extend({ 'exchange': id }, ticker);
+        return exchangeExtended;
+    }));
+    log(result);
+};
+fetchTickers(symbol);

package/examples/js/gateio-create-batch-order.js

@@ -0,0 +1,43 @@
+const ccxt = require ('../../ccxt');
+
+console.log ('CCXT Version:', ccxt.version);
+
+async function main () {
+
+    const exchange = new ccxt.gateio ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+    });
+    await exchange.loadMarkets ();
+
+    const ada = exchange.market ('ADA/USDT');
+    const xrp = exchange.market ('XRP/USDT');
+
+    const orders = await exchange.privateSpotPostBatchOrders (
+        [
+            {
+                text: "t-123456",
+                currency_pair: ada['id'],
+                type: "limit",
+                account: "spot",
+                side: "buy",
+                amount: "3",
+                price: "0.4",
+            },
+            {
+                text: "t-123456",
+                currency_pair: xrp['id'],
+                type: "limit",
+                account: "spot",
+                side: "buy",
+                amount: "3",
+                price: "0.47",
+            },
+        ]
+    );
+
+    console.log (orders);
+
+};
+
+main ();

package/examples/js/gateio-futures.js

@@ -0,0 +1,49 @@
+import ccxt from '../../js/ccxt.js';
+
+
+const exchange = new ccxt.gateio ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET_KEY',
+    'options': {
+        'defaultType': 'future',
+    },
+})
+
+;(async () => {
+    // exchange.setSandboxMode (true)
+
+    const markets = await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    // Example 1: Creating a future (market) order
+    try {
+
+        // find a future
+        const futures = []
+        for (const [key, market] of Object.entries(markets)) {
+            if (market['future']) {
+                futures.push(market);
+            }
+        }
+        if (futures.length > 0) {
+            const market = futures[0];
+            const symbol = market['symbol'] // example: BTC/USDT:USDT-220318
+            const type = 'market'
+            const side = 'buy'
+            const amount = 1
+
+            // placing an order
+            const order = await exchange.createOrder (symbol, type, side, amount)
+            console.log (order)
+
+            // fetching open orders
+            const openOrders = await exchange.fetchOpenOrders(symbol)
+            console.log(openOrders)
+        }
+
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+
+}) ()

package/examples/js/gateio-open-close-contract.js

@@ -0,0 +1,49 @@
+const ccxt = require ('../../ccxt');
+
+
+const exchange = new ccxt.gateio ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET',
+    'options': {
+        'defaultType': 'swap',
+        'marginMode': 'cross'
+    },
+})
+
+
+;(async () => {
+
+    // exchange.setSandboxMode (true)
+    
+    const markets = await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    // Example: creating and closing a contract
+    let symbol = 'LTC/USDT:USDT'
+    let type = 'market'
+    let side = 'buy'
+    let amount = 1
+    let price = undefined
+
+    try {
+        // fetching current balance
+        const balance = await exchange.fetchBalance()
+        console.log(balance)
+
+        // placing an order / opening contract position
+        const order = await exchange.createOrder (symbol, type, side, amount, price)
+        console.log (order)
+
+        // closing it by issuing an oposite contract 
+        // and therefore close our previous position
+        side = 'sell'
+        type = 'market'
+        reduce_only = true
+        params = {'reduce_only': reduce_only}
+        const opositeOrder = await exchange.createOrder (symbol, type, side, amount, price, params)
+        console.log (opositeOrder)
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+}) ()

package/examples/js/gateio-swaps.js

@@ -0,0 +1,74 @@
+import ccxt from '../../js/ccxt.js';
+
+const exchange = new ccxt.gateio ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET_KEY',
+    'options': {
+        'defaultType': 'swap',
+    },
+})
+
+;(async () => {
+    // exchange.setSandboxMode (true)
+
+    const markets = await exchange.loadMarkets ()
+
+    exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    // Example 1: Creating and canceling a linear swap (limit) order
+    try {
+        const symbol = 'LTC/USDT:USDT'
+        const type = 'limit'
+        const side = 'buy'
+        const amount = 1
+        const price = 55
+
+        // placing an order
+        const order = await exchange.createOrder (symbol, type, side, amount, price)
+        console.log (order)
+
+        // fetching open orders
+        const openOrders = await exchange.fetchOpenOrders(symbol)
+        console.log(openOrders)
+
+        // canceling an order
+        const cancel = await exchange.cancelOrder (order['id'], symbol)
+        console.log (cancel)
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+
+    // Example 2: Creating and canceling a linear swap (stop-limit) order with leverage
+    try {
+        const symbol = 'LTC/USDT:USDT'
+        const type = 'limit'
+        const side = 'buy'
+        const amount = 1
+        const price = 55
+
+        const stopPrice = 130
+        const params = {
+            'stopPrice': stopPrice,
+        }
+        //set leverage
+        const leverage = await exchange.setLeverage(3, symbol);
+        console.log(leverage)
+
+        // placing an order
+        const order = await exchange.createOrder (symbol, type, side, amount, price, params)
+        console.log (order)
+
+        // canceling an order
+        const cancelParams = {
+            isStop: true,
+        };
+        const cancel = await exchange.cancelOrder (order['id'], symbol, cancelParams)
+        console.log (cancel)
+
+        //reset leverage
+        exchange.setLeverage(1, symbol);
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+
+}) ()

package/examples/js/gdax-fetch-trades-pagination.js

@@ -0,0 +1,29 @@
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog';
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+const exchange = new ccxt.coinbasepro ()
+
+;(async () => {
+
+    const symbol = 'ETH/BTC'
+    const params = {}
+    await exchange.loadMarkets ()
+    while (true) {
+        const trades = await exchange.fetchTrades (symbol, undefined, undefined, params)
+        if (trades.length) {
+            const firstTrade = trades[0]
+            const lastTrade = trades[trades.length - 1]
+            log.yellow ('Fetched', trades.length, symbol, 'trades from', firstTrade['datetime'], 'to', lastTrade['datetime'])
+            if ('Cb-After' in exchange.last_response_headers) {
+                params['after'] = exchange.last_response_headers['Cb-After'];
+            }
+        } else {
+            log.green ('Done.')
+            break;
+        }
+    }
+
+}) ()

package/examples/js/hitbtc2-withdraw.js

@@ -0,0 +1,61 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ololog from 'ololog';
+const log       = ololog.configure ({ locate: false })
+
+require ('ansicolor').nice
+
+const getPositiveAccounts = function (balance) {
+    const result = {}
+    Object.keys (balance)
+        .filter (currency => balance[currency] && (balance[currency] > 0))
+        .forEach (currency => {
+            result[currency] = balance[currency]
+        })
+    return result
+}
+
+;(async () => {
+
+    // instantiate the exchange
+    let exchange = new ccxt.hitbtc2  ({
+        "apiKey": "YOUR_API_KEY",
+        "secret": "YOUR_SECRET",
+    })
+
+    try {
+
+        let tradingBalance = await exchange.fetchBalance ()
+        let accountBalance = await exchange.fetchBalance ({ type: 'account' })
+
+        log.cyan    ('Trading balance:', getPositiveAccounts (tradingBalance.total))
+        log.magenta ('Account balance:', getPositiveAccounts (accountBalance.total))
+
+        // withdraw
+        let withdraw = await exchange.withdraw ('ETH', 0.01, '0x811DCfeb6dC0b9ed825808B6B060Ca469b83fB81')
+
+        // output the result
+        log (exchange.name.green, 'withdraw', withdraw)
+
+    } 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
+        }
+    }
+
+}) ()

package/examples/js/how-to-import-one-exchange-esm.js

@@ -0,0 +1,10 @@
+import { binance } from '../../js/ccxt.js';
+async function example() {
+    const exchange = new binance({});
+    const ob = await exchange.fetchOrderBook('BTC/USDT', 3);
+    const asks = ob['asks'];
+    const bids = ob['bids'];
+    console.log(asks);
+    console.log(bids);
+}
+example();