ccxt 4.2.99 → 4.3.1

package/examples/js/huobi-swaps.js

@@ -1,70 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-
-const exchange = new ccxt.huobi ({
-    'apiKey': 'YOUR_API_KEY',
-    'secret': 'YOUR_SECRET_KEY',
-    'options': {
-        'defaultType': 'swap',
-    },
-})
-
-;(async () => {
-    const markets = await exchange.loadMarkets ()
-
-    // exchange.verbose = true // uncomment for debugging purposes if necessary
-
-    // creating and canceling a linear swap (limit) order
-    let symbol = 'ADA/USDT:USDT'
-    let type = 'limit'
-    let side = 'buy'
-    let offset= 'open'
-    let leverage = 1
-    let amount = 1
-    let price = 1 // 1 contract = 10 ADA = 10 usd in this case
-    let params = {
-        'offset': offset,
-        'lever_rate': leverage,
-    }
-
-    try {
-        // fetching current balance
-        const balance = await exchange.fetchBalance()
-        // console.log(balance)
-
-        // placing an order
-        const order = await exchange.createOrder (symbol, type, side, amount, price, params)
-        console.log (order)
-
-        // fetching open orders
-        const openOrders = await exchange.fetchOpenOrders(symbol)
-        console.log(openOrders)
-
-        // canceling an order
-        const cancel = await exchange.cancelOrder (order['id'], symbol)
-        console.log (cancel)
-    } catch (e) {
-        console.log (e.constructor.name, e.message)
-    }
-
-    // creating and canceling an inverse swap (limit) order
-    symbol = 'ADA/USD:ADA'
-    type = 'limit'
-    side = 'buy'
-    offset = 'open'
-    leverage = 1
-    amount = 1
-    price = 1 // 1 contract = 10 ADA = 10 usd in this case
-    params = {
-        'offset': offset,
-        'lever_rate': leverage,
-    }
-
-    try {
-        const order = await exchange.createOrder (symbol, type, side, amount, price, params)
-        console.log (order)
-        const cancel = await exchange.cancelOrder (order['id'], symbol)
-        console.log (cancel)
-    } catch (e) {
-        console.log (e.constructor.name, e.message)
-    }
-}) ()

package/examples/js/huobipro-market-buy-sell-fetch-trading-limits.js

@@ -1,98 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-import ololog from 'ololog'
-
-const log = ololog.configure .unlimited.handleNodeErrors (),
-      { NotSupported } = ccxt,
-      enableRateLimit = true,
-      symbol = 'ADA/BTC',
-      side = 'buy',
-      // set createMarketBuyOrderRequiresPrice to true or false to see the difference
-      type = 'market',
-      // default is true
-      createMarketBuyOrderRequiresPrice = true,
-      amount = 191.03,
-      price = 0.000011,
-      options = { createMarketBuyOrderRequiresPrice },
-      exchange = new ccxt.huobipro ({ enableRateLimit, options });
-
-// This is an example that demonstrates the issues discussed here:
-// https://github.com/ccxt/ccxt/issues/564
-// https://github.com/ccxt/ccxt/issues/3427
-// https://github.com/ccxt/ccxt/issues/3460
-// https://github.com/ccxt/ccxt/issues/4799
-
-log.green ('CCXT', ccxt.version)
-
-;(async () => {
-
-    // preload them first
-    await exchange.loadMarkets ()
-
-    // huobipro has this
-    if (!exchange.has['fetchTradingLimits']) {
-        throw new NotSupported (exchange.id + ' does not have fetchTradingLimits() yet, make sure your version of CCXT is up to date');
-    }
-
-    // In this particular case it requires an array of symbols
-    // otherwise it will load all of them one by one.
-    // Loading all limits without specifying
-    // the array of symbols might take a lot of time.
-
-    // The array of symbols will contain just one symbol of interest.
-    const arrayOfSymbols = [ symbol ]
-
-    const allLimits = await exchange.fetchTradingLimits (arrayOfSymbols)
-
-    // { 'ADA/BTC': {   info: {                                  symbol: "adabtc",
-    //                                       'buy-limit-must-less-than':  1.1,
-    //                                   'sell-limit-must-greater-than':  0.9,
-    //                                  'limit-order-must-greater-than':  0.1,
-    //                                     'limit-order-must-less-than':  5000000,
-    //                             'market-buy-order-must-greater-than':  0.0001,
-    //                                'market-buy-order-must-less-than':  100,
-    //                            'market-sell-order-must-greater-than':  0.1,
-    //                               'market-sell-order-must-less-than':  500000,
-    //                           'limit-order-before-open-greater-than':  999999999,
-    //                              'limit-order-before-open-less-than':  0,
-    //                                'circuit-break-when-greater-than':  10000,
-    //                                   'circuit-break-when-less-than':  10,
-    //                          'market-sell-order-rate-must-less-than':  0.1,
-    //                           'market-buy-order-rate-must-less-than':  0.1        },
-    //                limits: { amount: { min: 0.1, max: 5000000 } }                    } }
-
-    const limits = allLimits[symbol]
-    log.yellow (symbol, 'limits:')
-    log.yellow (limits)
-
-    // To make things a bit more complicated huobipro specifies
-    // different minimums for market and limit orders
-    // and different minimums for buy/sell directions
-    // therefore we have to work with it in an exchange-specific way
-    // using the 'info' field from the response – that is
-    // until this aspect is completely unified in ccxt.
-
-    const info = limits['info']
-    const typeSide = type + '-' + side
-
-    const min = info[typeSide + '-order-must-greater-than']
-    const max = info[typeSide + '-order-must-less-than']
-
-    // huobipro requires the amount in quote currency for market sell orders
-    // huobipro requires the cost in quote currency for market buy orders
-    // cost = amount * price
-
-    const cost = createMarketBuyOrderRequiresPrice ? (amount * price) : amount
-
-    let color = 'red'
-
-    if ((min !== undefined) && (cost < min)) {
-        log[color] ('The cost is below minimum:', cost, '<', min)
-    } else if ((max !== undefined) && (cost > max)) {
-        log[color] ('The cost is above maximum:', cost, '>', max)
-    } else {
-        color = 'green'
-    }
-
-    log[color] ({ min, max, cost })
-
-}) ()

package/examples/js/hybridCJSExample.cjs

@@ -1,19 +0,0 @@
-
-const ccxt = require('ccxt');
-
-console.log('--------------------------------------------')
-console.log('Yey importing ccxt as a cjs module!!!!!')
-console.log('Version:', ccxt.version)
-console.log('--------------------------------------------')
-
-const exchange = new ccxt.huobi ({
-    'apiKey': 'YOUR_API_KEY',
-    'secret': 'YOUR_SECRET_KEY',
-    'options': {
-        'defaultType': 'swap',
-    },
-})
-;(async () => {
-const result = await exchange.fetchBalance();
-console.log(result)
-}) ()

package/examples/js/hybridESMExample.js

@@ -1,19 +0,0 @@
-import {version, huobi} from 'ccxt';
-
-console.log('--------------------------------------------')
-console.log('Yey importing ccxt as an ESM module!!!!!')
-console.log('Version:', version)
-console.log('--------------------------------------------')
-
-const exchange = new huobi ({
-    'apiKey': 'YOUR_API_KEY',
-    'secret': 'YOUR_SECRET_KEY',
-    'options': {
-        'defaultType': 'swap',
-    },
-})
-
-;(async () => {
-    const result = await exchange.fetchBalance();
-    console.log(result)
-    }) ()

package/examples/js/idex-fetch-balance.js

@@ -1,13 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-
-const idex = ccxt.idex ({
-    'apiKey': 'YOUR_IDEX_API_KEY',
-    'secret': 'YOUR_IDEX_SECRET',
-    'walletAddress': '0xYOUR_ETHEREUM_WALLET_ADDRESS',
-    'privateKey': '0xYOUR_ETHEREUM_PRIVATE_KEY',
-    'verbose': 0,
-})
-
-;(async () => {
-    console.log (await idex.fetchBalance ())
-}) ()

package/examples/js/instantiate-all-at-once.js

@@ -1,46 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-
-async function test () {
-
-    let exchanges = { 
-        "bittrex": {
-            "apiKey": "YOUR_API_KEY", 
-            "secret": "YOUR_SECRET",
-        },
-        "bitfinex": { 
-            "apiKey": "YOUR_API_KEY", 
-            "secret": "YOUR_SECRET"
-        },
-    }
-
-    let ids = ccxt.exchanges.filter (id => id in exchanges)
-
-    await Promise.all (ids.map (async id => {
-
-        console.log (exchanges[id])
-
-        // instantiate the exchange
-        let exchange = new ccxt[id] (exchanges[id])
-        console.log (exchange.id, exchange.apiKey)
-        exchanges[id] = exchange
-
-        // load markets
-        await exchange.loadMarkets ()
-        console.log (exchange.id, 'loaded')
-
-        // check the balance
-        if (exchange.apiKey) {
-            let balance = await exchange.fetchBalance ()
-            console.log (exchange.id, balance)
-        }
-
-        return exchange
-    }))
-
-    // when all of them are ready, do your other things
-    console.log ('Loaded exchanges:', ids.join (', '))
-}
-
-test ()

package/examples/js/instantiate-all-from-json.js

@@ -1,31 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import settings from './credentials.json';
-
-async function test () {
-
-    const ids = ccxt.exchanges.filter (id => id in settings)
-
-    const exchanges = ccxt.indexBy (await Promise.all (ids.map (async id => {
-
-        // instantiate the exchange
-        let exchange = new ccxt[id] (settings[id])
-
-        // load markets
-        await exchange.loadMarkets ()
-
-        // check the balance
-        if (exchange.apiKey) {
-            let balance = await exchange.fetchBalance ()
-            console.log (exchange.id, balance['free'])
-        }
-
-        return exchange
-    })), 'id')
-
-    // when all of them are ready, do your other things
-    console.log ('Loaded exchanges:', Object.keys (exchanges).join (', '))
-}
-
-test ()

package/examples/js/kraken-create-and-close-position.js

@@ -1,54 +0,0 @@
-// @ts-nocheck
-import ccxt from '../../js/ccxt.js';
-// AUTO-TRANSPILE //
-console.log('CCXT Version:', ccxt.version);
-// ------------------------------------------------------------------------------
-async function example() {
-    const exchange = new ccxt.kraken({
-        "apiKey": "YOUR_API_KEY",
-        "secret": "YOUR_API_SECRET",
-    });
-    const symbol = 'UNI/USD';
-    let side = 'buy'; // set it to 'buy' for a long position, 'sell' for a short position
-    const order_type = 'market'; // set it to 'market' or 'limit'
-    const amount = 1;
-    const leverage = 2;
-    await exchange.loadMarkets();
-    const market = exchange.market(symbol);
-    // 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
-    // you can fetch the ticker and update price
-    // const ticker = await exchange.fetchTicker (symbol);
-    // const last_price = ticker['last'];
-    // const ask_price = ticker['ask'];
-    // const bid_price = ticker['bid'];
-    // if (order_type === 'limit') {
-    //     price = (side === 'buy') ? bid_price * 0.95 : ask_price * 1.05; // i.e. 5% from current price
-    // }
-    const params = {
-        'leverage': leverage,
-    };
-    // log
-    console.log('Going to open a position', 'for', amount, 'worth', amount, market['base'], '~', 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 closed orders for this symbol (because we used market order)
-        // - use 'fetchClosedOrders' or 'fetchOrders' and filter with 'closed' status
-        const all_closed_orders = await exchange.fetchClosedOrders(symbol);
-        console.log("Fetched all your closed orders for this symbol", all_closed_orders);
-        const all_open_positions = await exchange.fetchPositions(symbol);
-        console.log("Fetched all your positions for this symbol", all_open_positions);
-        // To close a position:
-        // - long position (buy), you can create a sell order: exchange.createOrder (symbol, order_type, 'sell', amount, price, params);
-        // - short position (sell), you can create a buy order: exchange.createOrder (symbol, order_type, 'buy', amount, price, params);
-    }
-    catch (e) {
-        console.log(e.toString());
-    }
-}
-await example();

package/examples/js/kraken-fetch-order-trades.js

@@ -1,33 +0,0 @@
-import ccxt from '../../js/ccxt.js';
-
-(async () => {
-
-    const exchange = new ccxt.kraken ({
-        'apiKey': 'YOUR_API_KEY',
-        'secret': 'YOUR_SECRET',
-        // 'verbose': true,
-    })
-
-    const orders = await exchange.fetchClosedOrders ();
-
-    for (let i = 0; i < orders.length; i++) {
-        const order = await exchange.fetchOrder (orders[i]['id']);
-        const trades = await exchange.fetchOrderTrades (order['id'], undefined, undefined, undefined, order);
-        console.log (trades);
-    }
-
-    //
-    // alternatively:
-    //
-    // const params = {
-    //     'trades': [
-    //         'TT5UC3-GOIRW-6AZZ6R',
-    //         'TIY6G4-LKLAI-Y3GD4A',
-    //         'T57FVC-OB4LN-Z55WUL',
-    //         'TIMIRG-WUNNE-RRJ6GT',
-    //     ]
-    // }
-    //
-    // const trades = await exchange.fetchOrderTrades (order['id'], undefined, undefined, undefined, params);
-
-}) ()

package/examples/js/kraken-margin-trading.js

@@ -1,89 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-
-console.log ('CCXT Version:', ccxt.version)
-
-async function main () {
-
-    const exchange = new ccxt.kraken ({
-        "apiKey": "YOUR_API_KEY",
-        "secret": "YOUR_SECRET",
-    })
-
-    console.log ('-----------------------------------------------------------')
-
-    console.log ('Loading markets...')
-    const markets = await exchange.loadMarkets ()
-    console.log ('Markets loaded')
-
-    // exchange.verbose = true // uncomment for debugging purposes
-
-    try {
-
-        const symbol = 'ETH/USDT'
-            , market = exchange.market (symbol)
-            , { base, quote } = market
-            , type = 'market'
-            , amount = market['limits']['amount']['min']
-            , price = undefined
-            , params = {
-                'leverage': 2,
-            }
-
-        console.log ('-----------------------------------------------------------')
-
-        // https://www.kraken.com/en-us/features/api#add-standard-order
-
-        console.log ('Placing order...')
-        let order = await exchange.createOrder (symbol, type, 'buy', amount, price, params)
-        console.log ('Order placed:')
-        console.log (order)
-
-        console.log ('-----------------------------------------------------------')
-
-        // https://www.kraken.com/en-us/features/api#get-open-positions
-
-        console.log ('Fetching open positions...')
-        const positionsParams = { 'docalcs': true }
-        let openPositions = await exchange.fetchPositions (positionsParams)
-        console.log ('Current positions:')
-        console.log (openPositions)
-
-        console.log ('-----------------------------------------------------------')
-
-        console.log ('Fetching balance...')
-        let balance = await exchange.fetchTotalBalance ()
-        console.log ('Fetched balance:')
-        console.log (base, balance[base], '(base)')
-        console.log (quote, balance[quote], '(quote)')
-
-        console.log ('-----------------------------------------------------------')
-
-        console.log ('Closing the position...')
-        order = await exchange.createOrder (symbol, type, 'sell', amount, price, params)
-        console.log ('Got a response:')
-        console.log (order)
-
-        console.log ('-----------------------------------------------------------')
-
-        console.log ('Fetching open positions again...')
-        openPositions = await exchange.fetchPositions (positionsParams)
-        console.log ('Current positions:')
-        console.log (openPositions)
-
-        console.log ('-----------------------------------------------------------')
-
-        console.log ('Fetching balance...')
-        balance = await exchange.fetchTotalBalance ()
-        console.log ('Fetched balance:')
-        console.log (base, balance[base], '(base)')
-        console.log (quote, balance[quote], '(quote)')
-
-    } catch (e) {
-
-        console.log (e.constructor.name, e.message)
-    }
-}
-
-main ()

package/examples/js/kucoin-rate-limit.js

@@ -1,38 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-
-async function main () {
-
-    const exchange = new ccxt.kucoin()
-    const markets = await exchange.loadMarkets ()
-    const timeframe = '5m'
-    const symbol = 'BTC/USDT'
-    const since = undefined
-    const limit = 1000
-
-    let i = 0
-    while (true) {
-        try {
-            const ohlcvs = await exchange.fetchOHLCV(symbol, timeframe, since, limit)
-            const now = exchange.milliseconds()
-            const datetime = exchange.iso8601(now)
-            console.log(datetime, i, 'fetched', ohlcvs.length, symbol, timeframe, 'candles',
-                'from', exchange.iso8601(ohlcvs[0][0]),
-                'to', exchange.iso8601(ohlcvs[ohlcvs.length-1][0]))
-        } catch (e) {
-            if (e instanceof ccxt.RateLimitExceeded) {
-                const now = exchange.milliseconds()
-                const datetime = exchange.iso8601(now)
-                console.log(datetime, i, e.constructor.name, e.message)
-                await exchange.sleep(10000)
-            } else {
-                console.log(e.constructor.name, e.message)
-                throw e
-            }
-        }
-        i += 1
-    }
-}
-
-main ()

package/examples/js/latoken-example.js

@@ -1,108 +0,0 @@
-
-
-import ccxt from '../../js/ccxt.js';
-import ololog from 'ololog';
-import asTable from 'as-table';
-
-
-const table   = asTable.configure ({ delimiter: ' | ' }),
-      //-----------------------------------------------------------------------------
-      log       = ololog.unlimited.noLocate.handleNodeErrors ();(async function main () {
-
-    const symbol = 'BTC/USDT'
-
-    const exchange = new ccxt.latoken ({
-        'verbose': process.argv.includes ('--verbose'),
-        // uncomment and change for your keys to enable private calls
-        // 'apiKey': 'YOUR_API_KEY',
-        // 'secret': 'YOUR_API_SECRET',
-    })
-
-    await exchange.loadMarkets ()
-
-    log ('-------------------------------------------------------------------')
-
-    log (exchange.id, 'has', exchange.has)
-
-    // public API
-
-    log ('-------------------------------------------------------------------')
-
-    const markets = Object.values (exchange.markets)
-    log ('Loaded', markets.length, exchange.id, 'markets:')
-    log (table (markets.map (x => exchange.omit (x, [ 'info', 'limits', 'precision' ]))))
-
-    log ('-------------------------------------------------------------------')
-
-    const currencies = Object.values (exchange.currencies)
-    log ('Loaded', currencies.length, exchange.id, 'currencies:')
-    log (table (currencies.map (x => exchange.omit (x, [ 'info', 'limits' ]))))
-
-    log ('-------------------------------------------------------------------')
-
-    const time = await exchange.fetchTime ()
-    log ('Exchange time:', exchange.iso8601 (time))
-
-    log ('-------------------------------------------------------------------')
-
-    const ticker = await exchange.fetchTicker (symbol)
-    log (ticker)
-
-    log ('-------------------------------------------------------------------')
-
-    const tickers = await exchange.fetchTickers ()
-    log (table (Object.values (tickers).map (x =>
-        exchange.omit (x, [ 'info', 'bid', 'ask', 'bidVolume', 'askVolume', 'timestamp' ]))))
-
-    log ('-------------------------------------------------------------------')
-
-    const orderbook = await exchange.fetchOrderBook (symbol)
-    log (orderbook)
-
-    log ('-------------------------------------------------------------------')
-
-    const trades = await exchange.fetchTrades (symbol)
-    log (table (trades.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
-
-    log ('-------------------------------------------------------------------')
-
-    // private API
-
-    if (exchange.checkRequiredCredentials (false)) {
-
-        const balance = await exchange.fetchBalance ()
-        log (exchange.omit (balance, [ 'info' ]))
-
-        log ('-------------------------------------------------------------------')
-
-        const order = await exchange.createOrder (symbol, 'limit', 'buy', 0.001, 10000)
-        log (order)
-
-        log ('-------------------------------------------------------------------')
-
-        const openOrders = await exchange.fetchOpenOrders (symbol)
-        log (table (openOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
-
-        log ('-------------------------------------------------------------------')
-
-        const canceled = await exchange.cancelOrder (order['id'], order['symbol'])
-        log (canceled)
-
-        log ('-------------------------------------------------------------------')
-
-        const closedOrders = await exchange.fetchClosedOrders (symbol)
-        log (table (closedOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
-
-        log ('-------------------------------------------------------------------')
-
-        const canceledOrders = await exchange.fetchCanceledOrders (symbol)
-        log (table (canceledOrders.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
-
-        log ('-------------------------------------------------------------------')
-
-        const myTrades = await exchange.fetchMyTrades (symbol)
-        log (table (myTrades.map (x => exchange.omit (x, [ 'info', 'timestamp' ]))))
-
-    }
-
-}) ()