ccxt 4.2.73 → 4.2.74

package/examples/js/huobi-futures.js

@@ -0,0 +1,71 @@
+import ccxt from '../../js/ccxt.js';
+
+const exchange = new ccxt.huobi ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET',
+    'options': {
+        'defaultType': 'future',
+    },
+})
+
+;(async () => {
+    const markets = await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    // creating and canceling a linear future (limit) order
+    let symbol = 'ETH/USDT:USDT-220121' // the last segment is the date of expiration (can be next week, next quarter, ...) adjust it accordingly
+    let type = 'limit'
+    let side = 'buy'
+    let offset= 'open'
+    let leverage = 1
+    let amount = 1
+    let price = 1
+    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 a inverse future (limit) order
+    symbol = 'ADA/USD:ADA-220121' // the last segment is the date of expiration (can be next week, next quarter, ...) adjust it accordingly
+    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/huobi-open-close-contract.js

@@ -0,0 +1,63 @@
+import ccxt from '../../js/ccxt.js';
+
+const exchange = new ccxt.huobi ({
+    'apiKey': 'YOUR_API_KEY',
+    'secret': 'YOUR_SECRET',
+    'options': {
+        'defaultType': 'swap',
+        'marginMode': 'cross'
+    },
+})
+
+;(async () => {
+    const markets = await exchange.loadMarkets ()
+
+    // exchange.verbose = true // uncomment for debugging purposes if necessary
+
+    // Example: creating and closing a contract
+    let symbol = 'ADA/USDT:USDT' // market positions for contracts not available
+    let type = 'limit'
+    let side = 'buy'
+    let offset= 'open'
+    let leverage = 1
+    let amount = 1
+    let price = 1
+    let clientOrderId = 6;
+    let params = {
+        'offset': offset,
+        'lever_rate': leverage,
+        'client_order_id': clientOrderId
+    }
+
+    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 position
+        const position = await exchange.fetchPosition(symbol)
+        console.log(position)
+
+
+        // closing it by issuing an oposite contract 
+        // warning: since we can only place limit orders
+        // it might take a while (depending on the price we choose and market fluctuations) 
+        // to the order be fulfilled
+        // and therefore close our previous position
+        side = 'sell'
+        type = 'limit'
+        offset = 'close'
+        reduce_only = 1 // 1 : yes, 0: no
+        clientOrderId = 9
+        price = 1.147 // adjust this accordingly
+        params = {'offset': offset, 'reduce_only': reduce_only, 'client_order_id': clientOrderId}
+        const opositeOrder = await exchange.createOrder (symbol, type, side, amount, price, params)
+        console.log (opositeOrder)
+    } catch (e) {
+        console.log (e.constructor.name, e.message)
+    }
+}) ()

package/examples/js/huobi-swaps.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+
+
+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 ()