ccxt 4.2.73 → 4.2.75

package/examples/js/create-order-handle-errors.js

@@ -0,0 +1,55 @@
+
+
+// ----------------------------------------------------------------------------
+
+import ccxt from '../../js/ccxt.js';
+
+// ----------------------------------------------------------------------------
+
+(async () => {
+
+    const exchange = new ccxt.bittrex ({
+        'apiKey': 'YOUR_API_KEY',
+        'secret': 'YOUR_SECRET_KEY',
+        'verbose': false, // set to true to see more debugging output
+        'timeout': 60000,
+    })
+
+    // try to load markets first, retry on request timeouts until it succeeds:
+
+    while (true) {
+
+        try {
+
+            await exchange.loadMarkets ();
+            break;
+
+        } catch (e) {
+
+            if (e instanceof ccxt.RequestTimeout)
+                console.log (exchange.iso8601 (Date.now ()), e.constructor.name, e.message)
+        }
+    }
+
+    const symbol = 'ETH/BTC'
+    const orderType = 'limit'
+    const side = 'sell'
+    const amount = 0.321;
+    const price = 0.123;
+
+    // try just one attempt to create an order
+
+    try {
+
+        const response = await exchange.createOrder (symbol, orderType, side, amount, price);
+        console.log (response);
+        console.log ('Succeeded');
+
+    } catch (e) {
+
+        console.log (exchange.iso8601 (Date.now ()), e.constructor.name, e.message)
+        console.log ('Failed');
+
+    }
+
+}) ()

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

@@ -0,0 +1,71 @@
+// @ts-nocheck
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+console.log('CCXT Version:', ccxt.version);
+// ------------------------------------------------------------------------------
+async function example() {
+    // at this moment, only OKX support embedded stop-loss & take-profit orders in unified manner. other exchanges are being added actively and will be available soon.
+    const exchange = new ccxt.okx({
+        "apiKey": "YOUR_API_KEY",
+        "secret": "YOUR_API_SECRET",
+        "password": "YOUR_API_PASSWORD", // if exchange does not require password, comment out this line
+    });
+    const symbol = 'DOGE/USDT:USDT';
+    const side = 'buy'; // 'buy' | 'sell'
+    const order_type = 'limit'; // 'market' | 'limit'
+    const amount = 1; // how many contracts (see `market(symbol).contractSize` to find out coin portion per one contract)
+    await exchange.loadMarkets();
+    const market = exchange.market(symbol);
+    const ticker = await exchange.fetchTicker(symbol);
+    const last_price = ticker['last'];
+    const ask_price = ticker['ask'];
+    const bid_price = ticker['bid'];
+    // if order_type is 'market', then price is not needed
+    let price = undefined;
+    // if order_type is 'limit', then set a price at your desired level
+    if (order_type === 'limit') {
+        price = (side === 'buy') ? bid_price * 0.95 : ask_price * 1.05; // i.e. 5% from current price
+    }
+    // set trigger price for stop-loss/take-profit to 2% from current price
+    // (note, across different exchanges "trigger" price can be also mentioned with different synonyms, like "activation price", "stop price", "conditional price", etc. )
+    const stop_loss_trigger_price = (order_type === 'market' ? last_price : price) * (side === 'buy' ? 0.98 : 1.02);
+    const take_profit_trigger_price = (order_type === 'market' ? last_price : price) * (side === 'buy' ? 1.02 : 0.98);
+    // 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 = {
+        'stopLoss': {
+            'triggerPrice': stop_loss_trigger_price,
+            // set a 'price' to act as limit order, otherwise remove it for a market order
+            'price': stop_loss_trigger_price * 0.98,
+        },
+        'takeProfit': {
+            'triggerPrice': take_profit_trigger_price,
+            // set a 'price' to act as limit order, otherwise remove it for a market order
+            'price': take_profit_trigger_price * 0.98,
+        },
+        // note that some exchanges might require some exchange specific parameter when opening a position, i.e.:
+        // 'posSide': 'long',  // for phemex hedge-mode api
+    };
+    const position_amount = market['contractSize'] * amount;
+    const position_value = position_amount * last_price;
+    // log
+    console.log('Going to open a position', 'for', amount, 'contracts worth', position_amount, market['base'], '~', position_value, market['settle'], 'using', side, order_type, 'order (', (order_type === 'limit' ? exchange.priceToPrecision(symbol, price) : ''), '), using the following params:');
+    console.log(params);
+    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
+        // - use 'fetchOpenOrders' or 'fetchOrders' and filter with 'open' status
+        // - note, that some exchanges might return one order object with embedded stoploss/takeprofit fields, while other exchanges might have separate stoploss/takeprofit order objects
+        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();
+// NOTES:
+// - Sometimes you might experience, when their stop-loss/take-profit order might not become activated, even though on chart the price had crossed that "trigger-price"       order was not executed . That happens because some exchange might be using mark-price (instead of last-price) as a reference-price, so that mark-price might reach your trigger-price and it would activate your SL/TP order (even though on your symbol's chart you are viewing the "last-price" by default, which could have different movements than the mark-price).

package/examples/js/create-order-with-retry.js

@@ -0,0 +1,65 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+// ----------------------------------------------------------------------------
+
+const tryToCreateOrder = async function (exchange, symbol, type, side, amount, price, params) {
+
+    try {
+
+        const order = await exchange.createOrder (symbol, type, side, amount, price, params)
+        return order
+
+    } catch (e) {
+
+        console.log (e.constructor.name, e.message)
+
+        if (e instanceof ccxt.NetworkError) {
+
+            // retry on networking errors
+            return false
+
+        } else {
+
+            throw e // break on all other exceptions
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+const exchange = new ccxt.bytetrade ({
+    'apiKey': 'classic123', // edit here
+    'secret': 'ebcefff7de475ffe15e864ca3e3e410edf7e94fffd1f9af34edf9434e2bfff1b',  // edit here
+})
+
+//
+// make a classic bytetrade account - one that is linked to an email or phone number
+// then click on your username in the top right and then export
+// you will get a file like this:
+//
+// future garage icon motion panda garage motion task science head garage notable
+// ebcefff7de475ffe15e864ca3e3e410edf7e94fffd1f9af34edf9434e2bfff1b
+// classic123
+//
+// the second line is your secret and the third line is your apiKey
+//
+
+const symbol = 'XRP/USDT' // edit here
+const type = 'limit '     // edit here
+const side = 'buy'        // edit here
+const amount = 10         // edit here
+const price = 1           // edit here
+const params = {}         // edit here
+
+;(async () => {
+    let order = false
+    while (true) {
+        order = await tryToCreateOrder (exchange, symbol, type, side, amount, price, params)
+        if (order !== false) {
+            break
+        }
+    }
+    console.log (order)
+}) ()

package/examples/js/create-order-ws-example.js

@@ -0,0 +1,25 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+async function example() {
+    const exchange = new ccxt.pro.binance({
+        'apiKey': 'MY_API_KEY',
+        'secret': 'MY_SECRET',
+    });
+    exchange.setSandboxMode(true);
+    exchange.verbose = true; // uncomment for debugging purposes if necessary
+    // load markets
+    await exchange.loadMarkets();
+    const symbol = 'ETH/USDT';
+    const type = 'limit';
+    const side = 'buy';
+    const amount = 0.01;
+    let price = 1000;
+    let orders = [];
+    for (let i = 1; i < 5; i++) {
+        const response = await exchange.createOrderWs(symbol, type, side, amount, price);
+        price += i;
+        orders.push(response);
+    }
+    console.log(orders);
+}
+await example();

package/examples/js/create-orders-example.js

@@ -0,0 +1,17 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+async function example() {
+    const exchange = new ccxt.binance({
+        'apiKey': 'MY_API_KEY',
+        'secret': 'MY_SECRET',
+    });
+    exchange.setSandboxMode(true);
+    await exchange.loadMarkets();
+    exchange.verbose = true; // uncomment for debugging purposes if necessary
+    const orders = await exchange.createOrders([
+        { 'symbol': 'LTC/USDT:USDT', 'type': 'limit', 'side': 'buy', 'amount': 10, 'price': 55 },
+        { 'symbol': 'ETH/USDT:USDT', 'type': 'market', 'side': 'buy', 'amount': 0.5 },
+    ]);
+    console.log(orders);
+}
+await example();

package/examples/js/create-trailing-amount-order.js

@@ -0,0 +1,36 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+async function example() {
+    const exchange = new ccxt.bingx({
+        'apiKey': 'MY_API_KEY',
+        'secret': 'MY_SECRET',
+    });
+    // exchange.setSandboxMode (true);
+    // exchange.verbose = true; // uncomment for debugging purposes if necessary
+    await exchange.loadMarkets();
+    const symbol = 'BTC/USDT:USDT';
+    const order_type = 'market';
+    const side = 'sell';
+    const amount = 0.0001;
+    const price = undefined;
+    const reduceOnly = true;
+    const trailingAmount = 100;
+    // const trailingTriggerPrice = undefined; // not supported on all exchanges
+    const params = {
+        'reduceOnly': reduceOnly,
+        'trailingAmount': trailingAmount,
+        // 'trailingTriggerPrice': trailingTriggerPrice,
+    };
+    try {
+        const create_order = await exchange.createOrder(symbol, order_type, side, amount, price, params);
+        // Alternatively use the createTrailingAmountOrder method:
+        // const create_order = await exchange.createTrailingAmountOrder (symbol, order_type, side, amount, price, trailingAmount, trailingTriggerPrice, {
+        //     'reduceOnly': reduceOnly,
+        // });
+        console.log(create_order);
+    }
+    catch (e) {
+        console.log(e.toString());
+    }
+}
+await example();

package/examples/js/create-trailing-percent-order.js

@@ -0,0 +1,36 @@
+import ccxt from '../../js/ccxt.js';
+// AUTO-TRANSPILE //
+async function example() {
+    const exchange = new ccxt.bingx({
+        'apiKey': 'MY_API_KEY',
+        'secret': 'MY_SECRET',
+    });
+    // exchange.setSandboxMode (true);
+    // exchange.verbose = true; // uncomment for debugging purposes if necessary
+    await exchange.loadMarkets();
+    const symbol = 'BTC/USDT:USDT';
+    const order_type = 'market';
+    const side = 'sell';
+    const amount = 0.0001;
+    const price = undefined;
+    const reduceOnly = true;
+    const trailingPercent = 10;
+    // const trailingTriggerPrice = undefined; // not supported on all exchanges
+    const params = {
+        'reduceOnly': reduceOnly,
+        'trailingPercent': trailingPercent,
+        // 'trailingTriggerPrice': trailingTriggerPrice,
+    };
+    try {
+        const create_order = await exchange.createOrder(symbol, order_type, side, amount, price, params);
+        // Alternatively use the createTrailingAmountOrder method:
+        // const create_order = await exchange.createTrailingPercentOrder (symbol, order_type, side, amount, price, trailingPercent, trailingTriggerPrice, {
+        //     'reduceOnly': reduceOnly,
+        // });
+        console.log(create_order);
+    }
+    catch (e) {
+        console.log(e.toString());
+    }
+}
+await example();

package/examples/js/credentials.json

@@ -0,0 +1,5 @@
+{
+    "hitbtc":        { "apiKey": "b6aad581670b30fb25d1c91cdbe8ca5c", "secret": "fa394ced37a488f9b5826a2d9ce39ae3" },
+    "bitso":         { "apiKey": "xZnHRmdlgJ", "secret": "e156bb7f7ab3a831afbc7a80f7866b9e" },
+    "coincheck":     { "apiKey": "dCyzY2T6w0DFhaco", "secret": "JpI0eMmxfa0tEpk3X-dNwyclSASJkl-S" }
+}

package/examples/js/custom-proxy-agent-for-js.js

@@ -0,0 +1,10 @@
+// @ts-nocheck
+// to set custom "proxy-agent" for ccxt
+import ccxt from 'ccxt';
+import HttpProxyAgent from 'http-proxy-agent';
+const proxy = 'http://1.2.3.4:5678';
+const agent = new HttpProxyAgent(proxy); // or HttpsProxyAgent if you need http
+// then pass it through constructor:
+const kraken = new ccxt.kraken({ agent });
+// or set it later:
+kraken.agent = agent;

package/examples/js/custom-proxy-url.js

@@ -0,0 +1,23 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+(async function main () {
+
+    const kraken1 = new ccxt.kraken ({
+        proxy: function (url) {
+            return 'https://example.com/?url=' + encodeURIComponent (url)
+        },
+    })
+
+    console.log (await kraken1.loadMarkets ())
+
+    const kraken2 = new ccxt.kraken ({
+        proxy: function (url) {
+            return 'https://cors-anywhere.herokuapp.com/' + url
+        },
+    })
+
+    console.log (await kraken2.loadMarkets ())
+
+}) ()

package/examples/js/delta-maintenance-margin-rate-max-leverage.js

@@ -0,0 +1,60 @@
+import ccxt from '../../js/ccxt.js';
+
+console.log ('CCXT Version:', ccxt.version);
+
+function getMaxLeverage (market, positionSize) {
+    /**
+     * @description Equation taken from https://www.delta.exchange/contracts/
+     * @param {object} market CCXT market
+     * @param {float} positionSize The value of the position in quote currency
+     * @returns The maximum leverage available for the market for the given position size
+     */
+    const info = market['info'];
+    const maxLeverageNotional = Number (info['max_leverage_notional']);
+    const initialMarginScalingFactor = Number (info['initial_margin_scaling_factor']);
+    let initialMargin = Number (info['initial_margin']);
+
+    if (positionSize <= maxLeverageNotional) {
+        const initialMarginRatio = initialMargin / 100;
+        return 1 / initialMarginRatio;
+    } else {
+        initialMargin = initialMargin + (initialMarginScalingFactor * (positionSize - maxLeverageNotional));
+        const initialMarginRatio = initialMargin / 100;
+        return 1 / initialMarginRatio;
+    }
+}
+
+function getMaintenanceMarginRate (market, positionSize) {
+    /**
+     * @description Equation taken from https://www.delta.exchange/contracts/
+     * @param {object} market CCXT market
+     * @param {float} positionSize The value of the position in quote currency
+     * @returns The maintenance margin rate as a percentage for the market with the given position size
+     */
+    const info = market['info'];
+    const maxLeverageNotional = Number (info['max_leverage_notional']);
+    const maintenanceMarginScalingFactor = Number (info['maintenance_margin_scaling_factor']);
+    const maintenanceMargin = Number (info['maintenance_margin']);
+
+    if (positionSize <= maxLeverageNotional) {
+        return maintenanceMargin;
+    } else {
+        return maintenanceMargin + (maintenanceMarginScalingFactor * (positionSize - maxLeverageNotional));
+    }
+}
+
+async function main () {
+
+    const exchange = new ccxt.delta();
+    await exchange.loadMarkets ();
+    
+    const symbol = 'ADA/USDT:USDT';
+    const market = exchange.market (symbol);
+
+    // Gets the maximum leverage and maintenance margin rate for a position worth 100,000 USDT on the ADA/USDT:USDT market
+    const maxLeverage = getMaxLeverage(market, 100000);
+    const maintenanceMarginRate = getMaintenanceMarginRate(market, 100000);
+    console.log(maxLeverage, maintenanceMarginRate);
+}
+
+main ()

package/examples/js/env-variables.js

@@ -0,0 +1,26 @@
+
+
+// ----------------------------------------------------------------------------
+
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog'
+
+// ----------------------------------------------------------------------------
+
+const log = ololog.configure.handleNodeErrors (), asTable = require("as-table").configure({ delimiter: " | " });
+
+// ----------------------------------------------------------------------------
+
+(async () => {
+
+    const exchange = new ccxt.coinbase ({
+        verbose: process.argv.includes ('--verbose'),
+        timeout: 60000,
+        apiKey: process.env.KEY,
+        secret: process.env.SECRET
+    });
+
+    const balance = await exchange.fetchBalance ()
+    log.green (balance)
+
+})()

package/examples/js/error-handling.js

@@ -0,0 +1,89 @@
+
+
+import ccxt from '../../js/ccxt.js';
+
+const verbose   = process.argv.includes ('--verbose');
+
+//-----------------------------------------------------------------------------
+
+const printSupportedExchanges = () => console.log ('Supported exchanges:', ccxt.exchanges.join (', '))
+
+const printUsage = () => {
+    console.log ('Usage: node', process.argv[1], 'id'.green)
+    printSupportedExchanges ()
+}
+
+const run = async (id) => {
+
+    // check if the exchange is supported by ccxt
+    const exchangeFound = ccxt.exchanges.indexOf (id) > -1
+
+    if (exchangeFound) {
+
+        console.log ('Instantiating', id, 'exchange')
+
+        // instantiate the exchange by id
+        const exchange = new ccxt[id] ({ verbose })
+
+        // try to load markets and catch the errors if any
+        try {
+
+            await exchange.loadMarkets ()
+
+        } catch (e) {
+
+            if (e instanceof ccxt.NetworkError) {
+                console.log (exchange.id, 'loadMarkets failed due to a network error:', e.message)
+            } else if (e instanceof ccxt.ExchangeError) {
+                console.log (exchange.id, 'loadMarkets failed due to exchange error:', e.message)
+            } else {
+                console.log (exchange.id, 'loadMarkets failed with:', e.message)
+            }
+
+            // rethrow the error "higher up" the call chain
+            throw e
+        }
+
+        // try to fetch a ticker and catch the errors if any
+        try {
+
+            const symbol = 'ETH/BTC'
+            const response = await exchange.fetchTicker (symbol)
+            console.log (response)
+
+        } catch (e) {
+
+            if (e instanceof ccxt.NetworkError) {
+                console.log (exchange.id, 'fetchTicker failed due to a network error:', e.message)
+            } else if (e instanceof ccxt.ExchangeError) {
+                console.log (exchange.id, 'fetchTicker failed due to exchange error:', e.message)
+            } else {
+                console.log (exchange.id, 'fetchTicker failed with:', e.message)
+            }
+
+            // rethrow the error "higher up" the call chain
+            throw e
+        }
+
+    } else {
+
+        console.log ('Exchange', id, 'not found')
+        printSupportedExchanges ()
+    }
+}
+
+;(async function main () {
+
+    if (process.argv.length > 2) {
+
+        let id = process.argv[2]
+        await run (id)
+
+    } else {
+
+        printUsage ()
+    }
+
+    process.exit ()
+
+}) ()

package/examples/js/exchange-capabilities.js

@@ -0,0 +1,135 @@
+
+
+import ccxt from '../../js/ccxt.js';
+import ololog from 'ololog';
+import ansicolor from 'ansicolor';
+import asTable from 'as-table';
+
+const { noLocate } = ololog;
+const log = noLocate;
+
+ansicolor.nice
+
+
+
+const csv = process.argv.includes ('--csv'), delimiter = csv ? ',' : '|', asTableConfig = { delimiter: ' ' + delimiter + ' ', /* print: require ('string.ify').noPretty  */ }
+
+asTable.configure (asTableConfig);
+
+const sortCertified = process.argv.includes ('--sort-certified') || process.argv.includes ('--certified')
+const exchangesArgument = process.argv.find (arg => arg.startsWith ('--exchanges='))
+const exchangesArgumentParts = exchangesArgument ? exchangesArgument.split ('=') : []
+const selectedExchanges = (exchangesArgumentParts.length > 1) ? exchangesArgumentParts[1].split (',') : []
+
+console.log (ccxt.iso8601 (ccxt.milliseconds ()))
+console.log ('CCXT v' + ccxt.version)
+
+async function main () {
+
+    let total = 0
+    let notImplemented = 0
+    let inexistentApi = 0
+    let implemented = 0
+    let emulated = 0
+
+    const exchangeNames = ccxt.exchanges
+    let exchanges = exchangeNames.map (id => new ccxt[id] ())
+    exchanges = exchanges.map (exchange => exchange.pro ? new ccxt.pro[exchange.id] () : exchange)
+    if (sortCertified) {
+        exchanges.sort((a, b) => {
+            if (a.certified && !b.certified) {
+                return -1;
+            } else if (!a.certified && b.certified) {
+                return 1;
+            } else {
+                return 0;
+            }
+        });
+    }
+    const metainfo = ccxt.flatten (exchanges.map (exchange => Object.keys (exchange.has)))
+    const reduced = metainfo.reduce ((previous, current) => {
+        previous[current] = (previous[current] || 0) + 1
+        return previous
+    }, {})
+    const unified = Object.entries (reduced).filter (([ _, count ]) => count > 1)
+    const methods = unified.map (([ method, _ ]) => method).sort ()
+    if (selectedExchanges.length > 0) {
+        exchanges = exchanges.filter ((exchange) => selectedExchanges.includes(exchange.id))
+    }
+    const table = asTable (exchanges.map (exchange => {
+        let result = {};
+        const basics = [
+            'CORS',
+            'spot',
+            'margin',
+            'swap',
+            'future',
+            'option',
+        ];
+
+        ccxt.unique (basics.concat (methods)).forEach (key => {
+
+            total += 1
+
+            let coloredString = '';
+
+            const feature = exchange.has[key]
+            const isFunction = (typeof exchange[key] === 'function')
+            const isBasic = basics.includes (key)
+
+            if (feature === false) {
+                // if explicitly set to 'false' in exchange.has (to exclude mistake, we check if it's undefined too)
+                coloredString = exchange.id.red.dim
+                inexistentApi += 1
+            } else if (feature === 'emulated') {
+                // if explicitly set to 'emulated' in exchange.has
+                coloredString = exchange.id.yellow
+                emulated += 1
+            } else if (feature) {
+                if (isBasic) {
+                    // if neither 'false' nor 'emulated', and if  method exists
+                    coloredString = exchange.id.green
+                    implemented += 1
+                } else {
+                    if (isFunction) {
+                        coloredString = exchange.id.green
+                        implemented += 1
+                    } else {
+                        // the feature is available in exchange.has and not implemented
+                        // this is an error
+                        coloredString = exchange.id.lightMagenta
+                    }
+                }
+            } else {
+                coloredString = exchange.id.lightRed
+                notImplemented += 1
+            }
+
+            result[key] = coloredString
+        })
+
+        return result
+    }))
+
+    if (csv) {
+        let lines = table.split ("\n")
+        lines = lines.slice (0, 1).concat (lines.slice (2))
+        log (lines.join ("\n"))
+    } else {
+        log (table)
+    }
+
+    log ('Summary: ',
+        ccxt.exchanges.length.toString (), 'exchanges; ',
+        'Methods [' + total.toString () + ' total]: ',
+        implemented.toString ().green, 'implemented,',
+        emulated.toString ().yellow, 'emulated,',
+        (inexistentApi.toString ().red.dim), 'inexistentApi,',
+        (notImplemented.toString ().lightRed), 'notImplemented',
+    )
+
+    log("\nMessy? Try piping to less (e.g. node script.js | less -S -R)\n".red)
+
+}
+
+main ()