ccxt 4.2.99 → 4.3.1

package/examples/ts/cli.ts

@@ -1,397 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import ansi from 'ansicolor'
-import asTable from 'as-table'
-import ololog from 'ololog'
-import ccxt from '../../ts/ccxt.js'
-import { Agent } from 'https'
-
-const fsPromises = fs.promises;
-ansi.nice
-const log = ololog.configure ({ locate: false }).unlimited
-const { ExchangeError , NetworkError} = ccxt
-//-----------------------------------------------------------------------------
-
-let [processPath, , exchangeId, methodName, ... params] = process.argv.filter (x => !x.startsWith ('--'))
-    , verbose = process.argv.includes ('--verbose')
-    , debug = process.argv.includes ('--debug')
-    , poll = process.argv.includes ('--poll')
-    , no_send = process.argv.includes ('--no-send')
-    , no_load_markets = process.argv.includes ('--no-load-markets')
-    , details = process.argv.includes ('--details')
-    , no_table = process.argv.includes ('--no-table')
-    , table = process.argv.includes ('--table')
-    , iso8601 = process.argv.includes ('--iso8601')
-    , cors = process.argv.includes ('--cors')
-    , cache_markets = process.argv.includes ('--cache-markets')
-    , testnet =
-        process.argv.includes ('--test') ||
-        process.argv.includes ('--testnet') ||
-        process.argv.includes ('--sandbox')
-    , signIn = process.argv.includes ('--sign-in') || process.argv.includes ('--signIn')
-    , isSpot = process.argv.includes ('--spot')
-    , isSwap = process.argv.includes ('--swap')
-    , isFuture = process.argv.includes ('--future')
-    , isOption = process.argv.includes ('--option')
-    , shouldCreateRequestReport = process.argv.includes ('--report')
-    , shouldCreateResponseReport = process.argv.includes ('--response')
-    , shouldCreateBoth = process.argv.includes ('--static')
-
-//-----------------------------------------------------------------------------
-
-log ((new Date ()).toISOString())
-log ('Node.js:', process.version)
-log ('CCXT v' + ccxt.version)
-
-//-----------------------------------------------------------------------------
-
-process.on ('uncaughtException',  e => { log.bright.red.error (e); log.red.error (e.message); process.exit (1) })
-process.on ('unhandledRejection', e => { log.bright.red.error (e); log.red.error ((e as any).message); process.exit (1) })
-
-//-----------------------------------------------------------------------------
-
-// set up keys and settings, if any
-const keysGlobal = path.resolve ('keys.json')
-const keysLocal = path.resolve ('keys.local.json')
-
-const keysFile = fs.existsSync (keysLocal) ? keysLocal : keysGlobal
-const settingsFile  = fs.readFileSync(keysFile);
-// eslint-disable-next-line import/no-dynamic-require, no-path-concat
-let settings = JSON.parse(settingsFile.toString())
-settings = settings[exchangeId] || {}
-
-
-//-----------------------------------------------------------------------------
-
-const timeout = 30000
-let exchange = undefined as any
-
-
-
-const httpsAgent = new Agent ({
-    ecdhCurve: 'auto',
-    keepAlive: true,
-})
-
-
-// check here if we have a arg like this: binance.fetchOrders()
-const callRegex = /\s*(\w+)\s*\.\s*(\w+)\s*\(([^()]*)\)/
-if (callRegex.test (exchangeId)) {
-    const res = callRegex.exec (exchangeId) as any;
-    exchangeId = res[1];
-    methodName = res[2];
-    params = res[3].split(",").map(x => x.trim());
-}
-
-try {
-    if ((ccxt.pro as any).exchanges.includes(exchangeId)) {
-        exchange = new (ccxt.pro)[exchangeId] ({ timeout, httpsAgent, ... settings })
-    } else {
-        exchange = new (ccxt)[exchangeId] ({ timeout, httpsAgent, ... settings })
-    }
-
-    if (exchange === undefined) {
-        process.exit ()
-    }
-
-    if (isSpot) {
-        exchange.options['defaultType'] = 'spot';
-    } else if (isSwap) {
-        exchange.options['defaultType'] = 'swap';
-    } else if (isFuture) {
-        exchange.options['defaultType'] = 'future';
-    } else if (isOption) {
-        exchange.options['defaultType'] = 'option';
-    }
-
-    // check auth keys in env var
-    const requiredCredentials = exchange.requiredCredentials;
-    for (const [credential, isRequired] of Object.entries (requiredCredentials)) {
-        if (isRequired && exchange[credential] === undefined) {
-            const credentialEnvName = (exchangeId + '_' + credential).toUpperCase () // example: KRAKEN_APIKEY
-            let credentialValue = process.env[credentialEnvName]
-            if (credentialValue) {
-                if (credentialValue.indexOf('---BEGIN') > -1) {
-                    credentialValue = (credentialValue as any).replaceAll('\\n', '\n');
-                }
-                exchange[credential] = credentialValue
-            }
-        }
-    }
-
-    if (testnet) {
-        exchange.setSandboxMode (true)
-    }
-
-} catch (e) {
-
-    log.red (e)
-    printUsage ()
-    process.exit ()
-}
-
-//-----------------------------------------------------------------------------
-
-function createRequestTemplate(exchange, methodName, args, result) {
-    const final = {
-        'description': 'Fill this with a description of the method call',
-        'method': methodName,
-        'url': exchange.last_request_url ?? '',
-        'input': args,
-        'output': exchange.last_request_body ?? undefined
-    }
-    log('Report: (paste inside static/request/' + exchange.id + '.json ->' + methodName + ')')
-    log.green('-------------------------------------------')
-    log (JSON.stringify (final, null, 2))
-    log.green('-------------------------------------------')
-}
-
-//-----------------------------------------------------------------------------
-
-function createResponseTemplate(exchange, methodName, args, result) {
-    const final = {
-        'description': 'Fill this with a description of the method call',
-        'method': methodName,
-        'input': args,
-        'httpResponse': exchange.last_json_response ?? exchange.last_http_response,
-        'parsedResponse': result
-    }
-    log('Report: (paste inside static/response/' + exchange.id + '.json ->' + methodName + ')')
-    log.green('-------------------------------------------')
-    log (JSON.stringify (final, function(k, v) { return v === undefined ? null : v; }, 2))
-    log.green('-------------------------------------------')
-}
-
-//-----------------------------------------------------------------------------
-
-function printSupportedExchanges () {
-    log ('Supported exchanges:', (ccxt.exchanges.join (', ') as any).green)
-}
-
-//-----------------------------------------------------------------------------
-
-function printUsage () {
-    log ('This is an example of a basic command-line interface to all exchanges')
-    log ('Usage: node', process.argv[1], ('id' as any).green, ('method' as any).yellow, ('"param1" param2 "param3" param4 ...' as any).blue)
-    log ('Examples:')
-    log ('node', process.argv[1], 'okcoin fetchOHLCV BTC/USD 15m')
-    log ('node', process.argv[1], 'bitfinex fetchBalance')
-    log ('node', process.argv[1], 'kraken fetchOrderBook ETH/BTC')
-    printSupportedExchanges ()
-    log ('Supported options:')
-    log ('--verbose         Print verbose output')
-    log ('--debug           Print debugging output')
-    log ('--poll            Repeat continuously in rate-limited mode')
-    log ('--no-send         Print the request but do not actually send it to the exchange (sets verbose and load-markets)')
-    log ('--no-load-markets Do not pre-load markets (for debugging)')
-    log ('--details         Print detailed fetch responses')
-    log ('--no-table        Do not print the fetch response as a table')
-    log ('--table           Print the fetch response as a table')
-    log ('--iso8601         Print timestamps as ISO8601 datetimes')
-    log ('--cors            use CORS proxy for debugging')
-    log ('--sign-in         Call signIn() if any')
-    log ('--sandbox         Use the exchange sandbox if available, same as --testnet')
-    log ('--testnet         Use the exchange testnet if available, same as --sandbox')
-    log ('--test            Use the exchange testnet if available, same as --sandbox')
-    log ('--cache-markets   Cache the loaded markets in the .cache folder in the current directory')
-}
-
-//-----------------------------------------------------------------------------
-
-const printHumanReadable = (exchange, result) => {
-    if (!no_table && Array.isArray (result) || table) {
-        result = Object.values (result)
-        let arrayOfObjects = (typeof result[0] === 'object')
-
-        if (details)
-            result.forEach (object => {
-                if (arrayOfObjects)
-                    log ('-------------------------------------------')
-                log (object)
-            })
-
-        if (arrayOfObjects || table && Array.isArray (result)) {
-            const configuredAsTable = (asTable as any).configure ({
-                delimiter: (' | ' as any).lightGray.dim,
-                right: true,
-                title: x => (String (x) as any).lightGray,
-                dash: ('-' as any).lightGray.dim,
-                print: x => {
-                    if (typeof x === 'object') {
-                        const j = JSON.stringify (x).trim ()
-                        if (j.length < 100) return j
-                    }
-                    return String (x)
-                }
-            })
-            log (result.length > 0 ? configuredAsTable (result.map (element => {
-                let keys = Object.keys (element)
-                delete element['info']
-                keys.forEach (key => {
-                    if (!iso8601)
-                        return element[key]
-                    try {
-                        const iso8601 = exchange.iso8601 (element[key])
-                        if (iso8601.match (/^20[0-9]{2}[-]?/))
-                            element[key] = iso8601
-                        else
-                            throw new Error ('wrong date')
-                    } catch (e) {
-                        return element[key]
-                    }
-                })
-                return element
-            })) : result)
-            log (result.length, 'objects');
-        } else {
-            console.dir (result, { depth: null })
-            log (result.length, 'objects');
-        }
-    } else {
-        console.dir (result, { depth: null, maxArrayLength: null })
-    }
-}
-
-//-----------------------------------------------------------------------------
-
-async function run () {
-
-    if (!exchangeId) {
-
-        printUsage ()
-
-    } else {
-
-        let args = params
-            .map (s => s.match (/^[0-9]{4}[-][0-9]{2}[-][0-9]{2}[T\s]?[0-9]{2}[:][0-9]{2}[:][0-9]{2}/g) ? exchange.parse8601 (s) : s)
-            .map (s => (() => { 
-                if (s.match ( /^\d+$/g)) return s < Number.MAX_SAFE_INTEGER ? Number (s) : s
-                try {return eval ('(() => (' + s + ')) ()') } catch (e) { return s }
-            }) ())
-
-        const www = Array.isArray (exchange.urls.www) ? exchange.urls.www[0] : exchange.urls.www
-
-        if (cors) {
-            exchange.proxy = 'https://cors-anywhere.herokuapp.com/';
-            exchange.origin = exchange.uuid ()
-        }
-
-        no_load_markets = no_send ? true : no_load_markets
-
-        if (debug) {
-            exchange.verbose = verbose
-        }
-
-        const path = '.cache/' + exchangeId + '-markets.json'
-
-        if (!no_load_markets) {
-            try {
-                await fsPromises.access (path, fs.constants.R_OK)
-                exchange.markets = JSON.parse ((await fsPromises.readFile (path)).toString())
-            } catch {
-                await exchange.loadMarkets ()
-                if (cache_markets) {
-                    await fsPromises.writeFile (path, JSON.stringify (exchange.markets))
-                }
-            }
-        }
-
-        if (signIn && exchange.has.signIn) {
-            await exchange.signIn ()
-        }
-
-        exchange.verbose = verbose
-
-        if (no_send) {
-
-            exchange.verbose = no_send
-            exchange.fetch = function fetch (url, method = 'GET', headers = undefined, body = undefined) {
-                log.dim.noLocate ('-------------------------------------------')
-                log.dim.noLocate (exchange.iso8601 (exchange.milliseconds ()))
-                log.green.unlimited ({
-                    url,
-                    method,
-                    headers,
-                    body,
-                })
-            }
-        }
-
-        if (methodName) {
-
-            if (typeof exchange[methodName] === 'function') {
-
-                log (exchange.id + '.' + methodName, '(' + args.join (', ') + ')')
-
-                let start = exchange.milliseconds ()
-                let end = exchange.milliseconds ()
-
-                let i = 0;
-
-                let isWsMethod = false
-                if (methodName.startsWith("watch")) { // handle WS methods
-                    isWsMethod = true;
-                }
-
-                while (true) {
-                    try {
-                        const result = await exchange[methodName] (... args)
-                        end = exchange.milliseconds ()
-                        if (!isWsMethod) {
-                            log (exchange.iso8601 (end), 'iteration', i++, 'passed in', end - start, 'ms\n')
-                        }
-                        printHumanReadable (exchange, result)
-                        if (!isWsMethod) {
-                            log (exchange.iso8601 (end), 'iteration', i, 'passed in', end - start, 'ms\n')
-                        }
-                        if (shouldCreateRequestReport || shouldCreateBoth) {
-                            createRequestTemplate(exchange, methodName, args, result)
-                        }
-                        if (shouldCreateResponseReport || shouldCreateBoth) {
-                            createResponseTemplate(exchange, methodName, args, result)
-                        }
-                        start = end
-                    } catch (e) {
-                        if (e instanceof ExchangeError) {
-                            log.red (e.constructor.name, e.message)
-                        } else if (e instanceof NetworkError) {
-                            log.yellow (e.constructor.name, e.message)
-                        }
-
-                        log.dim ('---------------------------------------------------')
-
-                        // rethrow for call-stack // other errors
-                        throw e
-
-                    }
-
-                    if (debug) {
-                        const keys = Object.keys (httpsAgent.freeSockets)
-                        const firstKey = keys[0]
-                        let httpAgent = httpsAgent.freeSockets[firstKey] as any;
-                        log (firstKey, httpAgent.length)
-                    }
-
-                    if (!poll && !isWsMethod){
-                        break
-                    }
-                }
-
-            } else if (exchange[methodName] === undefined) {
-                log.red (exchange.id + '.' + methodName + ': no such property')
-            } else {
-                printHumanReadable (exchange, exchange[methodName])
-            }
-        } else {
-            log (exchange)
-        }
-    }
-
-}
-
-//-----------------------------------------------------------------------------
-
-run ()
-
-export  {
-}

package/examples/ts/compare-two-exchanges-capabilities.ts

@@ -1,36 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-
-// AUTO-TRANSPILE //
-
-async function example () {
-    const prefix = '-';
-    const exchange_1 = new ccxt.okx ();
-    const exchange_2 = new ccxt.htx ();
-    const keys_1 = Object.keys (exchange_1.has);
-    const keys_2 = Object.keys (exchange_2.has);
-    // check missing from exchange-1
-    console.log ('### checking missing functionalities from exchange-1:', exchange_1.id);
-    for (let i = 0; i < keys_2.length; i++) {
-        const key = keys_2[i];
-        if (exchange_2.has[key]) {
-            if (!keys_1.includes (key)) {
-                console.log (prefix, key, 'does not exist in', exchange_1.id, 'as opposed to', exchange_2.id);
-            } else if (exchange_2.has[key] !== exchange_1.has[key]) {
-                console.log (prefix, key, '> ', exchange_1.id, ':', exchange_1.has[key], ',', exchange_2.id, ':', exchange_2.has[key]);
-            }
-        }
-    }
-    // check missing from exchange-2
-    console.log ('### checking missing functionalities from exchange-2:', exchange_2.id);
-    for (let i = 0; i < keys_1.length; i++) {
-        const key = keys_1[i];
-        if (exchange_1.has[key]) {
-            if (!keys_2.includes (key)) {
-                console.log (prefix, key, 'does not exist in', exchange_2.id, 'as opposed to', exchange_1.id);
-            } else if (exchange_1.has[key] !== exchange_2.has[key]) {
-                console.log (prefix, key, '> ', exchange_2.id, ':', exchange_2.has[key], ',', exchange_1.id, ':', exchange_1.has[key]);
-            }
-        }
-    }
-}
-await example ();

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

@@ -1,89 +0,0 @@
-// @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/ts/create-order-ws-example.ts

@@ -1,33 +0,0 @@
-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/ts/create-orders-example.ts

@@ -1,21 +0,0 @@
-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/ts/create-trailing-amount-order.ts

@@ -1,37 +0,0 @@
-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/ts/create-trailing-percent-order.ts

@@ -1,37 +0,0 @@
-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/ts/custom-proxy-agent-for-js.ts

@@ -1,14 +0,0 @@
-// @ts-nocheck
-
-// to set custom "proxy-agent" for ccxt
-
-import ccxt from 'ccxt';
-import HttpProxyAgent from 'http-proxy-agent';
-import HttpsProxyAgent from 'https-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;