ccxt 4.2.73 → 4.2.75

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

@@ -0,0 +1,39 @@
+
+import ccxt from '../../js/ccxt.js';
+import log from 'ololog';
+import asTable from 'as-table';
+
+
+const table = asTable.configure ({ delimiter: ' | ' }), id = 'bitstamp', exchange = new ccxt[id] ({ enableRateLimit: true }), symbol = 'BTC/USD';(async function main () {
+
+    // Markets data
+    const markets = await exchange.fetchMarkets ()
+    console.log('Total number of markets: ', Object.keys(markets).length);
+
+    // Currencies
+    const currencies = await exchange.fetchCurrencies ()
+    console.log('Currencies: ', JSON.stringify(currencies));
+
+    // Order book data
+    const orderbook = await exchange.fetchOrderBook (symbol)
+    console.log ('Order book ', symbol, orderbook.asks[0], orderbook.bids[0])
+
+    // Ticker
+    const ticker = await exchange.fetchTicker (symbol)
+    console.log ('Ticker ', symbol, " bid ", ticker.bid, " ask ", ticker.ask)
+
+    // Trades
+    const response = await exchange.fetchTrades (symbol, null, 10)
+    log (table (response))
+
+    // OHLC data
+    const candles = await exchange.fetchOHLCV (symbol, '1m', undefined, 10);
+    const first = candles[0]
+    const last = candles[candles.length - 1]
+    console.log (
+        'Fetched', candles.length, symbol, 'candles',
+        'from', exchange.iso8601 (first[0]),
+        'to', exchange.iso8601 (last[0])
+    )
+
+}) ()

package/examples/js/bittrex-balance.js

@@ -0,0 +1,50 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import ansicolor from 'ansicolor';
+import ololog from 'ololog'
+
+const log = ololog.configure ({ locate: false })
+
+ansicolor.nice
+
+let sleep = (ms) => new Promise (resolve => setTimeout (resolve, ms))
+
+;(async () => {
+
+    // instantiate the exchange
+    let exchange = new ccxt.bittrex  ({
+        "apiKey": "471b47a06c384e81b24072e9a8739064",
+        "secret": "694025686e9445589787e8ca212b4cff",
+    })
+
+
+    try {
+
+        // fetch account balance from the exchange
+        let balance = await exchange.fetchBalance ()
+
+        // output the result
+        log (exchange.name.green, 'balance', balance)
+
+    } 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/bittrex-fetch-closed-orders-history.js

@@ -0,0 +1,69 @@
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog';
+import asTable from 'as-table';
+
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+const exchange = new ccxt.bittrex ({
+        'enableRateLimit': true,
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+    });(async () => {
+
+    await exchange.loadMarkets ()
+
+    const symbol = 'ETH/BTC'
+        , market = exchange.markets[symbol]
+        , startingDate = '2017-01-01T00:00:00'
+        , now = exchange.milliseconds ()
+
+    log.bright.green ('\nFetching history for:', symbol, '\n')
+
+    let allOrders = []
+    let since = exchange.parse8601 (startingDate)
+
+    while (since < now) {
+
+        try {
+
+            log.bright.blue ('Fetching history for', symbol, 'since', exchange.iso8601 (since))
+            const orders = await exchange.fetchClosedOrders (symbol, since)
+            log.green.dim ('Fetched', orders.length, 'orders')
+
+            allOrders = allOrders.concat (orders)
+
+            if (orders.length) {
+
+                const lastOrder = orders[orders.length - 1]
+                since = lastOrder['timestamp'] + 1
+
+            } else {
+
+                break // no more orders left for this symbol, move to next one
+            }
+
+        } catch (e) {
+
+            log.red.unlimited (e)
+
+        }
+    }
+
+    // omit the following keys for a compact table output
+    // otherwise it won't fit into the screen width
+    const omittedKeys = [
+        'info',
+        'timestamp',
+        'lastTradeTimestamp',
+        'fee',
+    ]
+
+    log.yellow (asTable (allOrders.map (order => exchange.omit (order, omittedKeys))))
+    log.green ('Fetched', allOrders.length, symbol, 'orders in total')
+
+    // do whatever you want to do with them, calculate profit loss, etc...
+
+}) ()
+

package/examples/js/blockchaincom-withdrawal.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const ccxt = require('../../ccxt.js')
+const asTable = require('as-table')
+const log = require('ololog').configure({ locate: false })
+
+
+const exchange = new ccxt.blockchaincom({
+    'secret': 'YOUR_API_SECRET',
+})
+
+// blockchaincom specific internal beneficiary id
+const address = 'BENEFICIARY_ID';
+
+
+(async () => {
+
+    const markets = await exchange.loadMarkets ()
+
+    try {
+        const code = 'USDT'
+        const amount = 5
+
+        // fetch withdrawal beneficiary ids
+        const whiteList = await exchange.privateGetWhitelistCurrency({'currency': code})
+        log('Withdrawl Whitelist', whiteList)
+        //
+        //      [
+        //          {
+        //              "whitelistId":"adcd73fb-9ba6-41o7-8c0d-7013482cb88f", // unique id for each beneficiary, to be passed in as address into withdraw ()
+        //              "name":"John Doe",
+        //              "currency":"USDT"
+        //          }
+        //      ]
+        //
+
+        // withdrawal
+        let withdrawal = await exchange.withdraw(code, amount, address, undefined);
+        log('Withdrawal', withdrawal)
+
+    } catch (e) {
+        if (e instanceof ccxt.DDoSProtection || e.message.includes('ECONNRESET')) {
+            log('[DDoS Protection] ' + e.message)
+        } else if (e instanceof ccxt.RequestTimeout) {
+            log('[Request Timeout] ' + e.message)
+        } else if (e instanceof ccxt.AuthenticationError) {
+            log('[Authentication Error] ' + e.message)
+        } else if (e instanceof ccxt.ExchangeNotAvailable) {
+            log('[Exchange Not Available Error] ' + e.message)
+        } else if (e instanceof ccxt.ExchangeError) {
+            log('[Exchange Error] ' + e.message)
+        } else if (e instanceof ccxt.NetworkError) {
+            log('[Network Error] ' + e.message)
+        } else {
+            throw e;
+        }
+    }
+
+})()

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

@@ -0,0 +1,48 @@
+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/js/builtin-rate-limiting-rest-poller.js

@@ -0,0 +1,25 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import log from 'ololog';
+import { nice as ansi } from 'ansicolor';
+import asTable from 'as-table';
+
+const exchange = new ccxt.coinbasepro ()
+const repeat   = 100
+
+async function test (symbol) {
+
+    for (let i = 0; i < repeat; i++) {
+        let ticker = await exchange.fetchTicker (symbol)
+        log (exchange.id.green, exchange.iso8601 (exchange.milliseconds ()), ticker['datetime'], symbol.green, ticker['last'])
+    }
+}
+
+const concurrent = [
+    test ('BTC/USD'),
+    test ('ETH/BTC'),
+    test ('ETH/USD')
+]
+
+Promise.all (concurrent)

package/examples/js/bybit-trailing.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const ccxt = require ('../../ccxt');
+
+console.log ('CCXT Version:', ccxt.version)
+
+const exchange = new ccxt.bybit({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_API_KEY',
+})
+
+// exchange.set_sandbox_mode(true)  // enable sandbox mode
+
+// Example 1 :: Swap : open position and set trailing stop and close it 
+async function example1 () {
+    exchange['options']['defaultType'] = 'swap'; // very important set swap as default type
+    await exchange.loadMarkets ();
+
+    const symbol = 'LTC/USDT:USDT';
+    const market = exchange.market(symbol);
+    
+    // fetch swap balance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // create order and open position
+    const type = 'market';
+    const side = 'buy';
+    const amount = 0.1
+    const price = undefined;
+    const createOrder = await exchange.createOrder (symbol, type, side, amount, price);
+    console.log ('Created order id:', createOrder['id'])
+
+    // set trailing stop
+    const rawSide = 'Buy'; // or 'Sell'
+    const trailing_stop = 30; // YOUR TRAILING STOP HERE
+    const trailingParams = {
+        'symbol': market['id'],
+        'side': rawSide,
+        'trailing_stop': trailing_stop
+    }
+    const trailing_response = await exchange.privatePostPrivateLinearPositionTradingStop (trailingParams);
+    console.log(trailing_response)
+
+    // check opened position
+    const symbols = [ symbol ];
+    const positions = await exchange.fetchPositions (symbols);
+    console.log (positions)
+
+    // Close position by issuing a order in the opposite direction
+    const params = {
+        'reduce_only': true
+    }
+    const closePositionOrder = await exchange.createOrder (symbol, type, side, amount, price, params);
+    console.log (closePositionOrder);
+}
+
+async function main () {
+    await example1 ();
+}
+
+main ();

package/examples/js/bybit-updated.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+const ccxt = require ('../../dist/ccxt.bundle.cjs');
+
+console.log ('CCXT Version:', ccxt.version)
+
+const exchange = new ccxt.bybit ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET_KEY',
+})
+
+// Example 1: Spot : fetch balance, create order, cancel it and check canceled orders
+async function example1 () {
+    exchange['options']['defaultType'] = 'spot'; // very important set spot as default type
+
+    await exchange.loadMarkets ();
+
+    // fetch spot balance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // create order
+    const symbol = 'LTC/USDT';
+    const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', 50, 0.1);
+    console.log ('Created order id:', createOrder['id'])
+
+    // cancel order
+    const cancelOrder = await exchange.cancelOrder (createOrder['id'], symbol);
+
+    // Check canceled orders (bybit does not have a single endpoint to check orders
+    // we have to choose whether to check open or closed orders and call fetchOpenOrders
+    // or fetchClosedOrders respectively
+    const canceledOrders = await exchange.fetchClosedOrders (symbol);
+    console.log (canceledOrders);
+}
+
+// -----------------------------------------------------------------------------------------
+
+// Example 2 :: Swap : fetch balance, open a position and close it
+async function example2 () {
+    exchange['options']['defaultType'] = 'swap'; // very important set swap as default type
+    await exchange.loadMarkets ();
+
+    // fetch swap balance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // create order and open position
+    const symbol = 'LTC/USDT:USDT';
+    const createOrder = await exchange.createOrder (symbol, 'market', 'buy', 0.1);
+    console.log ('Created order id:', createOrder['id'])
+
+    // check opened position
+    const symbols = [ symbol ];
+    const positions = await exchange.fetchPositions (symbols);
+    console.log (positions)
+
+    // Close position by issuing a order in the opposite direction
+    const params = {
+        'reduce_only': true
+    }
+    const closePositionOrder = await exchange.createOrder (symbol, 'market', 'sell', 0.1, undefined, params);
+    console.log (closePositionOrder);
+}
+
+// -----------------------------------------------------------------------------------------
+
+// Example 3 :: USDC Swap : fetch balance, open a position and close it
+async function example3 () {
+    exchange['options']['defaultType'] = 'swap'; // very important set swap as default type
+    await exchange.loadMarkets ();
+
+    // fetch USDC swap balance
+    // when no symbol is available we can show our intent
+    // of using USDC endpoints by either using defaultSettle in options or
+    // settle in params
+    // Using Options: exchange['options']['defaultSettle'] = 'USDC';
+    // Using params:
+    const balanceParams = {
+        'settle': 'USDC'
+    }
+    const balance = await exchange.fetchBalance (balanceParams);
+    console.log (balance)
+
+    // create order and open position
+    // taking into consideration that USDC markets do not support
+    // market orders
+    const symbol = 'BTC/USD:USDC';
+    const amount = 0.1;
+    const price = 29940 // adjust this accordingly
+    const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', amount, price);
+    console.log ('Created order id:', createOrder['id'])
+
+    // check if the order was filled and the position opened
+    const symbols = [ symbol ];
+    const positions = await exchange.fetchPositions (symbols);
+    console.log (positions)
+
+    // 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, 'limit', 'sell', amount, price, params);
+    console.log (closePositionOrder);
+}
+
+// -----------------------------------------------------------------------------------------
+
+// Example 4 :: Future : fetch balance, create stop-order and check open stop-orders
+async function example4 () {
+    exchange['options']['defaultType'] = 'future'; // very important set future as default type
+    await exchange.loadMarkets ();
+
+    // fetch future balance
+    const balance = await exchange.fetchBalance ();
+    console.log (balance)
+
+    // create stop-order
+    const symbol = 'ETH/USD:ETH-220930';
+    const amount = 10; // in USD for inverse futures
+    const price = 1200;
+    const side = 'buy';
+    const type = 'limit';
+    const stopOrderParams = {
+        'position_idx': 0, // 0 One-Way Mode, 1 Buy-side, 2 Sell-side, default = 0
+        'stopPrice': 1000, // mandatory for stop orders
+        'basePrice': 1100  // mandatory for stop orders
+    }
+    const stopOrder = await exchange.createOrder (symbol, type, side, amount, price, stopOrderParams);
+    console.log ('Created order id:', stopOrder['id'])
+
+    // check opened stop-order
+    const openOrderParams = {
+        'stop': true
+    }
+    const openOrders = await exchange.fetchOpenOrders (symbol, undefined, undefined, openOrderParams);
+    console.log (openOrders)
+
+    // Cancell open stop-order
+    const cancelOrder = await exchange.cancelOrder (stopOrder['id'], symbol, openOrderParams);
+    console.log (cancelOrder);
+}
+
+// -----------------------------------------------------------------------------------------
+
+async function main () {
+    await example1 ();
+    await example2 ();
+    await example3 ();
+    await example4 ();
+
+}
+
+main ();