ccxt 4.2.73 → 4.2.74

package/examples/js/looping-over-specific-symbols-of-all-exchanges.js

@@ -0,0 +1,91 @@
+
+
+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 }), verbose   = process.argv.includes ('--verbose');
+
+ansicolor.nice
+
+//-----------------------------------------------------------------------------
+
+;(async () => {
+
+    const exchanges = {};
+    const symbols = [ 'ETH/BTC', 'XRP/BTC', 'BTC/USDT' ]
+
+    for (let symbol of symbols) {
+
+        for (let exchangeId of ccxt.exchanges) {
+
+            let exchange = undefined
+
+            try { // try creating the exchange instance first and handle errors if any
+
+                // check if we have created an instance of this exchange already
+
+                exchange = exchanges[exchangeId]
+
+                if (exchange === undefined) {
+
+                    // create the exchange instance
+                    exchange = new ccxt[exchangeId] ()
+                }
+
+                exchanges[exchangeId] = exchange // save it for later use
+
+            } catch (e) {
+
+                log.red ('Could not create exchange', exchangeId + ':', e.constructor.name, e.message)
+
+                // uncomment the following line to interrupt program execution on error
+                // or leave it commented out to do nothing
+
+                // process.exit ()
+
+            }
+
+            if (exchange !== undefined) {
+
+                // preload all markets first, as explained in the Manual:
+                // https://github.com/ccxt/ccxt/wiki/Manual#loading-markets
+
+                // add error/exception handling as required by the Manual:
+                // https://github.com/ccxt/ccxt/wiki/Manual#error-handling
+
+                try {
+
+                    await exchange.loadMarkets ();
+
+                } catch (e) {
+
+                    log.red ('Could not load markets from', exchange.id + ':', e.constructor.name, e.message)
+                    continue; // skip this exchange if markets failed to load
+
+                }
+
+                for (let symbol of symbols) {
+
+                    console.log (exchange.id, symbol)
+
+                    // add error/exception handling as required by the Manual:
+                    // https://github.com/ccxt/ccxt/wiki/Manual#error-handling
+
+                    try { // try fetching the ticker for a symbol existing with that exchange
+
+                        const ticker = await exchange.fetchTicker (symbol)
+                        log.green (ticker)
+
+                    } catch (e) { // catch the error (if any) and handle it or ignore it
+
+                        log.red ('Could not fetch', symbol, 'ticker from', exchange.id + ':', e.constructor.name, e.message)
+
+                    }
+                }
+            }
+        }
+    }
+
+}) ()

package/examples/js/margin-loan-borrow-buy-sell-repay.js

@@ -0,0 +1,70 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+// Note, this is just an example and might not yet work on other exchanges, which are being still unified.
+async function example() {
+    // ########## user inputs ##########
+    const exchange = new ccxt['binance']({ 'apiKey': 'xxx', 'secret': 'xxx' });
+    const symbol = 'BUSD/USDT'; // set target symbol
+    const marginMode = 'isolated'; // margin mode (cross or isolated)
+    const collateral_coin = 'USDT'; // which asset you want to use for margin-borrow collateral
+    const borrow_coin = 'BUSD'; // which coin to borrow
+    const order_side = 'sell'; // which side to trade
+    const amount_to_trade = 14; // how many coins to sell
+    const order_type = 'limit'; // order type (can be market, limit or etc)
+    const limit_price = 0.99; // price to sell at (set undefined/null/None if market-order)
+    const margin_magnitude = 5; // target margin (aka 'leverage'). This might also be obtainable using other unified methods, but for example purposes, we set here manually
+    // ########## end of user-inputs ##########
+    //
+    // for example purposes, let's also check available balance at first
+    const balance_margin = await exchange.fetchBalance({ 'defaultType': 'margin', 'marginMode': marginMode }); // use `defaultType` because of temporary bug, otherwise, after several days, you can use `type` too.
+    // if we don't have enought coins, then we have to borrow at first
+    let needed_amount_to_borrow = undefined; // will be auto-set below
+    if (amount_to_trade > balance_margin[symbol][borrow_coin]['free']) {
+        needed_amount_to_borrow = amount_to_trade - balance_margin[symbol][borrow_coin]['free'];
+        console.log('hmm, I have only ', balance_margin[symbol][borrow_coin]['free'], ' ', borrow_coin, ' in margin balance, and still need additional ', needed_amount_to_borrow, ' to make an order. Lets borrow it.');
+        // To initate a borrow, at first, check if we have enough collateral (for this example, as we make a sell-short, we need '-1' to keep for collateral currency)
+        const needed_collateral_amount = needed_amount_to_borrow / (margin_magnitude - 1);
+        // Check if we have any collateral to get permission for borrow
+        if (balance_margin[symbol][collateral_coin]['free'] < needed_collateral_amount) {
+            // If we don't have enough collateral, then let's try to transfer collateral-asset from spot-balance to margin-balance
+            console.log('hmm, I have only ', balance_margin[symbol][collateral_coin]['free'], ' in balance, but ', needed_collateral_amount, ' collateral is needed. I should transfer ', needed_collateral_amount, ' from spot');
+            // let's check if we have spot balance at all
+            const balance_spot = await exchange.fetchBalance({ 'type': 'spot' });
+            if (exchange.parseNumber(balance_spot[collateral_coin]['free']) < needed_collateral_amount) {
+                console.log('hmm, I neither do have enough balance on spot - only ', balance_spot[collateral_coin]['free'], '. Script can not continue...');
+                return;
+            }
+            else {
+                console.log('Transferring  ', needed_collateral_amount, ' to margin account');
+                await exchange.transfer(collateral_coin, needed_collateral_amount, 'spot', marginMode, { 'symbol': symbol });
+            }
+        }
+        // now, as we have enough margin collateral, initiate borrow
+        console.log('Initiating margin borrow of ', needed_amount_to_borrow, ' ', borrow_coin);
+        const borrowResult = await exchange.borrowMargin(borrow_coin, needed_amount_to_borrow, symbol, { 'marginMode': marginMode });
+    }
+    console.log('Submitting order.');
+    const order = await exchange.createOrder(symbol, order_type, order_side, amount_to_trade, limit_price, { 'marginMode': marginMode });
+    console.log('Order was submitted !', order['id']);
+    //
+    //
+    // ...
+    // ...
+    // some time later, if you want to repay the loan back (like 'close the position')...
+    // ...
+    // ...
+    //
+    //
+    // set the "repay-back" amount (for this example snippet, this will be same amount that we borrowed above)
+    if (needed_amount_to_borrow !== undefined) {
+        const amount_to_repay_back = needed_amount_to_borrow;
+        // At first, you need to get back the borrowed coin, by making an opposide trade
+        console.log('Making purchase back of ', amount_to_repay_back, ' ', borrow_coin, ' to repay it back.');
+        const purchase_back_price = 1.01;
+        const order_back = await exchange.createOrder(symbol, order_type, (order_side === 'buy' ? 'sell' : 'buy'), amount_to_repay_back, purchase_back_price, { 'marginMode': marginMode });
+        console.log('Now, repaying the loan.');
+        const repayResult = await exchange.repayMargin(borrow_coin, amount_to_repay_back, symbol, { 'marginMode': marginMode });
+        console.log('finished.');
+    }
+}
+await example();

package/examples/js/market-status-and-currency-status.js

@@ -0,0 +1,29 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import log from 'ololog';
+import asTable from 'as-table';
+
+(async function main () {
+
+    let kraken = new ccxt.kraken ()
+    await kraken.loadMarkets ()
+
+    const markets = Object.values (kraken.markets).map (market => ({
+        symbol: market.symbol,
+        active: market.active,
+    }))
+
+    log.bright.green.noLocate ('Markets:')
+    log.green.noLocate (asTable (markets), '\n')
+
+    const currencies = Object.values (kraken.currencies).map (currency => ({
+        code: currency.code,
+        active: currency.active,
+        status: currency.status,
+    }))
+
+    log.bright.yellow.noLocate ('Currencies:')
+    log.yellow.noLocate (asTable (currencies))
+
+}) ()

package/examples/js/ohlcv-console-chart.js

@@ -0,0 +1,29 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asciichart from 'asciichart';
+import asTable from 'as-table';
+import ololog from 'ololog'
+import ansicolor from 'ansicolor';
+
+const log        = ololog.configure ({ locate: false })
+
+ansicolor.nice
+
+//-----------------------------------------------------------------------------
+
+;(async function main () {
+
+    // experimental, not yet implemented for all exchanges
+    // your contributions are welcome ;)
+
+    const indexOfClose = 4 // [ timestamp, open, high, low, close, volume ]
+    const ohlcv = await new ccxt.cex ().fetchOHLCV ('BTC/USD', '1m')
+    const lastPrice = ohlcv[ohlcv.length - 1][indexOfClose] // closing price
+    const plotSeriesData = ohlcv.slice (-80).map (x => x[indexOfClose]) // closing price
+    const bitcoinRate = ('₿ = $' + lastPrice).green
+    const chart = asciichart.plot (plotSeriesData, { height: 15, padding: '            ' })
+    log.yellow ("\n" + chart, bitcoinRate, "\n")
+    process.exit ()
+
+}) ()

package/examples/js/okex-fetch-closed-orders-archive.js

@@ -0,0 +1,31 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+console.log ('CCXT Version:', ccxt.version)
+
+// https://github.com/ccxt/ccxt/issues/10179
+
+async function main () {
+
+    const exchange = new ccxt.okex ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET',
+        'password': 'YOUR_PASSWORD',
+        'options': {
+            'fetchClosedOrders': {
+                'method': 'privateGetTradeOrdersHistoryArchive'
+            }
+        }
+    })
+
+    const markets = await exchange.loadMarkets ()
+
+    exchange.verbose = true
+
+    const orders = await exchange.fetchClosedOrders ()
+    console.log (orders)
+
+}
+
+main ()

package/examples/js/okex-transfer.js

@@ -0,0 +1,51 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+console.log ('CCXT version:', ccxt.version)
+console.log ('This example requires CCXT version 1.54.92 or higher')
+
+async function main () {
+
+    const exchange = new ccxt.okex ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET',
+        'password': 'YOUR_API_KEY_PASSWORD',
+    })
+
+    await exchange.loadMarkets ()
+
+    const code = 'USDT'
+    let tradingBalance = await exchange.fetchFreeBalance (/* { 'type': 'trading' } */)
+    let fundingBalance = await exchange.fetchFreeBalance ({ 'type': 'funding' })
+    console.log ('Trading:', tradingBalance[code], code)
+    console.log ('Funding:', fundingBalance[code], code)
+
+    const oldVerboseMode = exchange.verbose
+    exchange.verbose = process.argv.includes ('--verbose') || process.argv.includes ('-v')
+
+    // https://www.okex.com/docs-v5/en/#rest-api-funding-funds-transfer
+    //
+    //     'spot' == '1'
+    //     'futures' == '3',
+    //     'margin' == '5',
+    //     'swap' == '9',
+    //     'option' == '12',
+    //     'trading' == '18', // unified trading account
+    //     'unified' == '18',
+    //
+    const from = 'trading'
+    const to = 'funding'
+    const amount = 1
+    const transfer = await exchange.transfer (code, amount, from, to)
+    console.log (transfer)
+
+    exchange.verbose = oldVerboseMode
+
+    tradingBalance = await exchange.fetchFreeBalance (/* { 'type': 'spot' } */)
+    fundingBalance = await exchange.fetchFreeBalance ({ 'type': 'funding' })
+    console.log ('Trading:', tradingBalance[code], code)
+    console.log ('Funding:', fundingBalance[code], code)
+}
+
+main ()

package/examples/js/okx-poll-fetch-my-trades.js

@@ -0,0 +1,37 @@
+import ccxt from '../../js/ccxt.js'
+
+console.log ('CCXT Version:', ccxt.version)
+
+async function main () {
+
+    const exchange = new ccxt.okx ({
+
+        // edit for your credentials
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+        'password': 'YOUR_API_PASSWORD',
+    })
+
+    await exchange.loadMarkets ()
+
+    // if this script fails with a rate limiter error
+    // uncomment the following line for debugging purposes
+
+    // exchange.verbose = true
+
+    while (true) {
+
+        try {
+
+            const trades = await exchange.fetchMyTrades ()
+            console.log (new Date(), 'fetched', trades.length, 'trades')
+
+        } catch (e) {
+
+            console.log (e.constructor.name, e.message)
+            break;
+        }
+    }
+}
+
+main ()

package/examples/js/okx-poll-rate-limit.js

@@ -0,0 +1,48 @@
+import ccxt from '../../js/ccxt.js'
+
+console.log ('CCXT Version:', ccxt.version)
+
+async function main () {
+
+    const exchange = new ccxt.okx ({
+
+        // edit for your credentials
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+        'password': 'YOUR_API_PASSWORD',
+
+        'api': {
+            'private': {
+                'get': {
+                    'trade/fills-history': 2.2,
+                },
+            },
+        },
+
+    })
+
+    await exchange.loadMarkets ()
+
+    // if this script fails with a rate limiter error
+    // uncomment the following line for debugging purposes
+
+    // exchange.verbose = true
+
+    const promises=[];
+    for(let i=0;i<100;i++){
+        promises.push(exchange.fetchMyTrades());
+    }
+
+    const allResponses = await Promise.allSettled(promises);
+    allResponses.forEach((result, i) => {
+
+        if(result.status == "fulfilled"){
+            console.log (new Date(), i + 6, 'fetched', result.value.length, 'trades')
+        } else {
+            console.log ("Rejected:", i + 6, result.reason);
+        }
+    });
+
+}
+
+main ()

package/examples/js/order-book-extra-level-depth-param.js

@@ -0,0 +1,20 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import asTable from 'as-table';
+import log from 'ololog';
+import ansicolor from 'ansicolor';
+
+ansicolor.nice
+
+;(async function test () {
+
+    const exchange = new ccxt.bitfinex ()
+    const limit = 5
+    const orders = await exchange.fetchOrderBook ('BTC/USD', limit, {
+        // this parameter is exchange-specific, all extra params have unique names per exchange
+        'group': 1, // 1 = orders are grouped by price, 0 = orders are separate
+    })
+
+    log (orders)
+}) ()

package/examples/js/phemex-create-order-position-with-takeprofit-stoploss.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+// ------------------------------------------------------------------------------
+async function example() {
+    const exchange = new ccxt.phemex({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_API_SECRET',
+    });
+    const symbol = 'XRP/USDT:USDT';
+    const side = 'buy'; // set it to 'buy' for a long position, 'sell' for a short position
+    const order_type = 'limit'; // set it to 'market' or 'limit'
+    const amount = 1; // how many contracts
+    const price = 0.5; // set a price at your desired level
+    // take profit and stop loss prices and types
+    const take_profit_trigger_price = 0.6;
+    const stop_loss_trigger_price = 0.4;
+    const take_profit_limit_price = 0.7;
+    const stop_loss_limit_price = 0.3;
+    await exchange.loadMarkets();
+    // when symbol's price reaches your predefined "trigger price", stop-loss order would be activated as a "market order". but if you want it to be activated as a "limit order", then set a 'price' parameter for it
+    const params = {
+        'posSide': 'Long',
+        'stopLoss': {
+            'triggerPrice': stop_loss_trigger_price,
+            'type': 'limit',
+            'price': stop_loss_limit_price,
+        },
+        'takeProfit': {
+            'triggerPrice': take_profit_trigger_price,
+            'type': 'limit',
+            'price': take_profit_limit_price,
+        },
+    };
+    console.log('-----------------------------------------------------------------------');
+    // exchange.verbose = True  // uncomment for debugging purposes if necessary
+    try {
+        const created_order = await exchange.createOrder(symbol, order_type, side, amount, price, params);
+        console.log('Created an order', created_order);
+        // Fetch all your open orders for this symbol
+        const all_open_orders = await exchange.fetchOpenOrders(symbol);
+        console.log('Fetched all your orders for this symbol', all_open_orders);
+        // To cancel a limit order, use "exchange.cancel_order(created_order['id'], symbol)""
+    }
+    catch (e) {
+        console.log(e.toString());
+    }
+}
+await example();

package/examples/js/poll-ohlcv.js

@@ -0,0 +1,43 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+const ohlcvsBySymbol = {}
+
+function handleAllOHLCVs (exchange, ohlcvs, symbol, timeframe) {
+    console.log ('----------------------------------------------------------')
+    console.log ('Last updated:', exchange.iso8601 (exchange.milliseconds ()))
+    const symbols = Object.keys (ohlcvsBySymbol)
+    for (let i = 0; i < symbols.length; i++) {
+        const symbol = symbols[i]
+        const ohlcvs = ohlcvsBySymbol[symbol]
+        const lastCandle = exchange.safeValue (ohlcvs, ohlcvs.length - 1)
+        const lastTimestamp = lastCandle[0]
+        console.log (exchange.iso8601 (lastTimestamp), symbol, timeframe, lastCandle.slice (1))
+    }
+}
+
+async function pollOHLCV (exchange, symbol, timeframe) {
+    while (true) {
+        try {
+            const response = await exchange.fetchOHLCV (symbol, timeframe)
+            ohlcvsBySymbol[symbol] = response
+            handleAllOHLCVs(exchange, response, symbol, timeframe)
+        } catch (e) {
+            console.log (e.constructor.name, e.message)
+        }
+    }
+}
+
+async function main () {
+
+    const exchange = new ccxt.binance()
+    const markets = await exchange.loadMarkets ()
+    const timeframe = '5m'
+
+    const firstOneHundredSymbols = exchange.symbols.slice (0, 100)
+
+    await Promise.all (firstOneHundredSymbols.map (symbol => pollOHLCV (exchange, symbol, timeframe)))
+}
+
+main ()

package/examples/js/poloniex-fetch-order-books.js

@@ -0,0 +1,35 @@
+
+
+// ----------------------------------------------------------------------------
+
+import ccxt from '../../js/ccxt.js';
+
+// ----------------------------------------------------------------------------
+
+(async () => {
+
+    const exchange = new ccxt.poloniex ({
+        'verbose': process.argv.includes ('--verbose'),
+        'timeout': 60000,
+    })
+
+    try {
+
+        const response = await exchange.fetchOrderBooks ([
+            'ETH/BTC',
+            'LTC/BTC',
+            'OMG/BTC',
+        ])
+        console.log (response);
+        console.log ('Succeeded.')
+
+    } catch (e) {
+
+        console.log ('--------------------------------------------------------')
+        console.log (e.constructor.name, e.message)
+        console.log ('--------------------------------------------------------')
+        console.log (exchange.last_http_response)
+        console.log ('Failed.')
+    }
+
+}) ()

package/examples/js/poloniex-limits-amount-min.js

@@ -0,0 +1,62 @@
+import ccxt from '../../js/ccxt.js';
+import fs from 'fs';
+import ololog from 'ololog'
+
+const log = ololog.configure.unlimited.noLocate,
+      verbose = process.argv.includes ('--verbose'),
+      keysGlobal = 'keys.json',
+      keysLocal = 'keys.local.json',
+      keysFile = fs.existsSync (keysLocal) ? keysLocal : (fs.existsSync (keysGlobal) ? keysGlobal : false),
+      config = keysFile ? require ('../../' + keysFile) : {},
+      exchange = new ccxt.poloniex (ccxt.extend ({
+              enableRateLimit: true,
+              verbose,
+          }, config.poloniex || {}));(async () => {
+
+    const test = async function (symbol) {
+
+        try {
+
+            await exchange.createOrder (symbol, 'limit', 'buy', 0, 0)
+
+        } catch (e) {
+
+            if (e instanceof ccxt.InvalidOrder) {
+
+                const words = e.message.split (' ')
+                let minAmount = parseFloat (words[words.length - 1])
+                log.green ("'" + symbol + "': " + minAmount.toString () + ',')
+
+            } else {
+
+                throw e
+            }
+        }
+    }
+
+    await exchange.loadMarkets ()
+
+    for (let i = 0; i < exchange.symbols.length; i++) {
+
+        try {
+
+            await test (exchange.symbols[i])
+
+        } catch (e) {
+
+            if (e instanceof ccxt.InvalidNonce) {
+
+                log.yellow (e)
+
+            } else {
+
+                log.red (e)
+                throw e
+            }
+        }
+
+
+        await ccxt.sleep (5000) // sleep 5 seconds, no rush, safe delay
+    }
+
+}) ()