ccxt 4.2.100 → 4.3.2

package/examples/js/bybit-trailing.js

@@ -1,62 +0,0 @@
-'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

@@ -1,154 +0,0 @@
-'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 ();

package/examples/js/coinbase-fetch-all-balances.js

@@ -1,36 +0,0 @@
-"use strict";
-
-const ccxt = require ('../../ccxt.js')
-
-console.log ('CCXT Version:', ccxt.version)
-
-async function fetchAllBalances (exchange) {
-    const params = {}
-    let balance = {}
-    while (true) {
-        const response = await exchange.fetchBalance (params)
-        balance = exchange.extend (balance, response)
-        const info = exchange.safeValue (response, 'info', {})
-        const pagination = exchange.safeValue (info, 'pagination', {})
-        const startingAfter = exchange.safeString (pagination, 'next_starting_after')
-        if (startingAfter !== undefined) {
-            params['starting_after'] = startingAfter
-        } else {
-            break
-        }
-    }
-    return balance
-}
-
-async function main () {
-    const exchange = new ccxt.coinbase ({
-        apiKey: 'YOUR_API_KEY',
-        secret: 'YOUR_API_SECRET',
-    })
-    const markets = await exchange.loadMarkets ()
-    // coinbase.verbose = true // uncomment for debugging purposes if necessary
-    const balance = await fetchAllBalances (exchange)
-    console.log (balance)
-}
-
-main ()

package/examples/js/coinex-fetch-all-deposit-addresses-using-fetchDepositAddress.js

@@ -1,47 +0,0 @@
-"use strict";
-
-const ccxt = require ('../../ccxt')
-
-console.log ('CCXT Version:', ccxt.version)
-
-// https://github.com/ccxt/ccxt/issues/15405
-
-async function main () {
-    
-    const exchange = new ccxt.coinex ({
-        'apiKey': 'YOUR_API_KEY',
-        'secret': 'YOUR_API_SECRET',
-    });
-
-    // exchange.verbose = true // uncomment for debugging purposes
-
-    await exchange.loadMarkets ();
-    const addresses = {};
-    const promises = [];
-
-    async function fetchDepositAddress (currency, network) {
-        try {
-            const response = await exchange.fetchDepositAddress(currency, { 'network': network });
-            addresses[currency][network] = response['address']
-        }
-        catch (err) {
-            console.error(err)
-        }
-    }    
-
-    const currencies = Object.keys (exchange.currencies);
-
-    for (const currency of currencies) {
-        const networks = Object.keys (exchange.currencies[currency]['networks']);
-        for (const network of networks) {
-            addresses[currency] = {};
-            promises.push (fetchDepositAddress (currency, network));
-        }
-    }
-
-    await Promise.all (promises);
-
-    console.log (addresses)
-};
-
-main ();

package/examples/js/coinex-futures.js

@@ -1,75 +0,0 @@
-'use strict';
-
-const ccxt = require ('../../ccxt');
-
-console.log ('CCXT Version:', ccxt.version)
-
-let exchange = new ccxt.coinex({
-    'apiKey': 'YOUR_API_KEY',
-    'secret': 'YOUR_SECRET_KEY',
-})
-
-// Example 1 :: Swap : fetch balance, create a limit swap order with leverage
-async function example1 () {
-    exchange['options']['defaultType'] = 'swap';
-    exchange.options['defaultMarginMode'] = 'cross' // or isolated
-    await exchange.loadMarkets ();
-
-    const symbol = 'ADA/USDT:USDT';
-
-    // fetchBalance
-    const balance = await exchange.fetchBalance ();
-    console.log (balance)
-
-    // set the desired leverage (has to be made before placing the order and for a specific symbol)
-    const leverage = 8;
-    const leverage_response = await exchange.setLeverage(leverage, symbol)
-
-    // create limit order
-    const amount = 50;
-    const price = 0.3 // adjust this accordingly
-    const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', amount, price);
-    console.log ('Created order id:', createOrder['id'])
-}
-
-// Example 2 :: Swap :: open a position and close it
-async function example2 () {
-    exchange['options']['defaultType'] = 'swap';
-    exchange.options['defaultMarginMode'] = 'cross' // or isolated
-    await exchange.loadMarkets ();
-
-    const symbol = 'ADA/USDT:USDT';
-
-    // fetchBalance
-    const balance = await exchange.fetchBalance ();
-    console.log (balance)
-
-    // set the desired leverage (has to be made before placing the order and for a specific symbol)
-    const leverage = 8;
-    const leverage_response = await exchange.setLeverage(leverage, symbol)
-
-    // create market order and open position
-    const amount = 50;
-    const createOrder = await exchange.createOrder (symbol, 'market', 'buy', amount);
-    console.log ('Created order id:', createOrder['id'])
-
-    // check if the order was filled and the position opened
-    const position = await exchange.fetchPositions (symbol);
-    console.log (position)
-
-    // 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, 'market', 'sell', amount, undefined, params);
-    console.log (closePositionOrder);
-}
-
-// -----------------------------------------------------------------------------------------
-
-async function main () {
-    await example1 ();
-    await example2 ();
-}
-
-main ();

package/examples/js/coinone-fetch-tickers.js

@@ -1,54 +0,0 @@
-
-
-import { nice as ansi } from 'ansicolor';
-import ololog from 'ololog';
-import asTable from 'as-table';
-
-import ccxt from '../../js/ccxt.js';
-
-const { noLocate } = ololog;
-const log = noLocate;
-
-const table = asTable.configure ({
-        delimiter: ' | '.dim,
-        right: true,
-    });
-
-const exchange = new ccxt.coinone ({
-    'verbose': process.argv.includes ('--verbose'),
-})
-
-let printTickersAsTable = function (exchange, tickers) {
-    log (exchange.id.green, exchange.iso8601 (exchange.milliseconds ()))
-    log ('Fetched', Object.values (tickers).length.toString ().green, 'tickers:')
-    log (table (ccxt.sortBy (Object.values (tickers), 'symbol', false)))
-}
-
-async function fetchAllAndPrint () {
-    const tickers = await exchange.fetchTickers ()
-    log ('---------------------------------------- fetchTickers ----------------------------------------')
-    printTickersAsTable (exchange, tickers)
-}
-
-async function fetchOneByOneAndPrint () {
-    const markets = await exchange.loadMarkets ()
-    const symbols = Object.keys (markets)
-    const tickers = []
-
-    log ('---------------------------------------- fetchTicker (one by one) ----------------------------------------')
-
-    for (let i = 0; i < symbols.length; i++) {
-        const ticker = await exchange.fetchTicker (symbols[i])
-        tickers.push (ticker)
-        log (`${i+1} / ${symbols.length}`)
-        log ('\u001b[1A'.repeat (2))  // cursor up
-    }
-
-    printTickersAsTable (exchange, tickers)
-}
-
-(async () => {
-    await fetchAllAndPrint ()
-    log ('\n')
-    await fetchOneByOneAndPrint ()
-}) ()

package/examples/js/coinone-markets.js

@@ -1,16 +0,0 @@
-
-
-import log from 'ololog';
-import ccxt from '../../js/ccxt.js';
-
-const exchange = new ccxt.coinone ({
-    'verbose': process.argv.includes ('--verbose'),
-})
-
-;(async function main () {
-
-    const markets = await exchange.loadMarkets ()
-    log (markets)
-    log ('\n' + exchange['name'] + ' supports ' + Object.keys (markets).length + ' pairs')
-
-}) ()

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

@@ -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/js/cors-proxy.js

@@ -1,5 +0,0 @@
-// JavaScript CORS Proxy
-// Save this in a file like cors.js and run with `node cors [port]`
-// It will listen for your requests on the port you pass in command line or port 8080 by default
-let port = (process.argv.length > 2) ? parseInt (process.argv[2]) : 8080 // default
-require ('cors-anywhere').createServer ().listen (port, '0.0.0.0')

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

@@ -1,55 +0,0 @@
-
-
-// ----------------------------------------------------------------------------
-
-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

@@ -1,71 +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).