ccxt-look 1.81.50

package/js/test/Exchange/test.fetchMyTrades.js

@@ -0,0 +1,42 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testTrade = require ('./test.trade.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = [
+        'bitso',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchMyTrades...')
+        return
+    }
+
+    if (exchange.has.fetchMyTrades) {
+
+        const trades = await exchange.fetchMyTrades (symbol)
+
+        assert (trades instanceof Array)
+
+        console.log ('fetched', trades.length, 'trades')
+
+        const now = Date.now ()
+
+        for (let i = 0; i < trades.length; i++) {
+            testTrade (exchange, trades[i], symbol, now)
+            if (i > 0) {
+                assert (trades[i].timestamp >= trades[i - 1].timestamp)
+            }
+        }
+
+    } else {
+
+        console.log ('fetching my trades not supported')
+    }
+}

package/js/test/Exchange/test.fetchOHLCV.js

@@ -0,0 +1,46 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testOHLCV = require ('./test.ohlcv.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = [
+        'btcalpha', // issue with 404 on a documented endpoint https://travis-ci.org/ccxt/ccxt/builds/643930431#L2213
+        'bitmex', // an issue with null values,to be resolved later
+        'cex',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchOHLCV...')
+        return
+    }
+
+    if (exchange.has.fetchOHLCV) {
+
+        const timeframe = Object.keys (exchange.timeframes || { '1d': '1d' })[0]
+        const limit = 10
+        const duration = exchange.parseTimeframe (timeframe)
+        const since = exchange.milliseconds () - duration * limit * 1000 - 1000
+
+        const ohlcvs = await exchange.fetchOHLCV (symbol, timeframe, since, limit)
+
+        const now = Date.now ()
+
+        for (let i = 0; i < ohlcvs.length; i++) {
+            const ohlcv = ohlcvs[i]
+            testOHLCV (exchange, ohlcv, symbol, now)
+        }
+
+        console.log (symbol, 'fetched', Object.keys (ohlcvs).length, 'OHLCVs')
+
+        return ohlcvs
+
+    } else {
+
+        console.log ('fetching OHLCV not supported')
+    }
+}

package/js/test/Exchange/test.fetchOpenOrders.js

@@ -0,0 +1,36 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testOrder = require ('./test.order.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    if (exchange.has.fetchOpenOrders) {
+
+        // log ('fetching open orders...')
+
+        const orders = await exchange.fetchOpenOrders (symbol)
+
+        assert (orders instanceof Array)
+
+        console.log ('fetched', orders.length, 'open orders')
+
+        const now = Date.now ()
+
+        for (let i = 0; i < orders.length; i++) {
+            const order = orders[i]
+            testOrder (exchange, order, symbol, now)
+            assert (order.status === 'open')
+        }
+
+        // log (asTable (orders))
+
+    } else {
+
+        console.log ('fetching open orders not supported')
+    }
+}

package/js/test/Exchange/test.fetchOrderBook.js

@@ -0,0 +1,25 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testOrderBook = require ('./test.orderbook.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const method = 'fetchOrderBook'
+
+    if (exchange.has[method]) {
+
+        const orderbook = await exchange[method] (symbol)
+
+        testOrderBook (exchange, orderbook, method, symbol)
+
+        return orderbook
+
+    } else {
+
+        console.log (method + '() not supported')
+    }
+}

package/js/test/Exchange/test.fetchOrderBooks.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testOrderBook = require ('./test.orderbook.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    const randomSymbols = exchange.symbols.slice ().sort (() => 0.5 - Math.random ()).slice (0, 2)
+    const customExchangeParams = ([
+        'yobit',
+        'tidex',
+        'ccex',
+        'liqui',
+        'dsx',
+    ]).reduce ((params, id) => ({ ... params, [id]: [randomSymbols], }), {})
+
+    const args = (exchange.id in customExchangeParams) ? customExchangeParams[exchange.id] : []
+    const method = 'fetchOrderBooks'
+
+    if (exchange.has[method]) {
+
+        const orderbooks = await exchange[method] (... args)
+
+        Object.entries (orderbooks).forEach (([symbol, orderbook]) => {
+            testOrderBook (exchange, orderbook, method, symbol)
+        })
+
+    } else {
+
+        console.log (method + '() not supported')
+    }
+}

package/js/test/Exchange/test.fetchOrders.js

@@ -0,0 +1,41 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testOrder = require ('./test.order.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = [
+        'bitmart',
+        'rightbtc',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchMyTrades...')
+        return
+    }
+
+    if (exchange.has.fetchOrders) {
+
+        const orders = await exchange.fetchOrders (symbol)
+
+        console.log ('fetched', orders.length, 'orders, asserting each...')
+
+        assert (orders instanceof Array)
+
+        const now = Date.now ()
+
+        for (let i = 0; i < orders.length; i++) {
+            const order = orders[i]
+            testOrder (exchange, order, symbol, now)
+        }
+
+    } else {
+
+        console.log ('fetching orders not supported')
+    }
+}

package/js/test/Exchange/test.fetchPositions.js

@@ -0,0 +1,47 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testPosition = require ('./test.position.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = [
+        'bitmart',
+        'rightbtc',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchPositions...')
+        return
+    }
+
+    if (exchange.has['fetchPositions']) {
+        const now = Date.now ()
+
+        // without symbol
+        const positions = await exchange.fetchPositions ()
+        console.log ('fetched', positions.length, 'positions, asserting each...')
+        assert (positions instanceof Array)
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i]
+            testPosition (exchange, position, undefined, now)
+        }
+        
+        // with symbol
+        const positionsForSymbol = await exchange.fetchPositions ([ symbol ])
+        console.log ('fetched', positions.length, 'positions (' + symbol + '), asserting each...')
+        assert (positionsForSymbol instanceof Array)
+        for (let i = 0; i < positionsForSymbol.length; i++) {
+            const position = positionsForSymbol[i]
+            testPosition (exchange, position, symbol, now)
+        }
+
+    } else {
+
+        console.log ('fetching positions not supported')
+    }
+}

package/js/test/Exchange/test.fetchStatus.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    if (exchange.has.fetchStatus) {
+
+        const method = 'fetchStatus'
+        const status = await exchange[method] ()
+
+        const sampleStatus = {
+            'status': 'ok', // 'ok', 'shutdown', 'error', 'maintenance'
+            'updated': undefined, // integer, last updated timestamp in milliseconds if updated via the API
+            'eta': undefined, // when the maintenance or outage is expected to end
+            'url': undefined, // a link to a GitHub issue or to an exchange post on the subject
+        }
+
+        const keys = Object.keys (sampleStatus)
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]
+            assert (key in status)
+        }
+
+        return status
+
+    } else {
+
+        console.log ('fetching status not supported')
+    }
+}

package/js/test/Exchange/test.fetchTicker.js

@@ -0,0 +1,38 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testTicker = require ('./test.ticker.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const method = 'fetchTicker'
+
+    const skippedExchanges = [
+        'digifinex',
+        'currencycom'
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping ' + method + '...')
+        return
+    }
+
+    if (exchange.has[method]) {
+
+        const ticker = await exchange.fetchTicker (symbol)
+
+        testTicker (exchange, ticker, method, symbol)
+
+        console.log (symbol, method, ticker['datetime'], 'bid:', ticker['bid'], 'ask:', ticker['ask'])
+
+        return ticker
+
+    } else {
+
+        console.log (symbol, 'fetchTicker () not supported')
+    }
+}
+

package/js/test/Exchange/test.fetchTickers.js

@@ -0,0 +1,49 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testTicker = require ('./test.ticker.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = [
+        'binance',
+        'digifinex',
+        'currencycom',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetch all tickers...')
+        return
+    }
+
+    if (exchange.has.fetchTickers) {
+
+        // log ('fetching all tickers at once...')
+
+        const method = 'fetchTickers'
+        let tickers = undefined
+
+        try {
+
+            tickers = await exchange[method] ()
+            console.log ('fetched all', Object.keys (tickers).length, 'tickers')
+
+        } catch (e) {
+
+            console.log ('failed to fetch all tickers, fetching multiple tickers at once...')
+            tickers = await exchange[method] ([ symbol ])
+            console.log ('fetched', Object.keys (tickers).length, 'tickers')
+        }
+
+        Object.values (tickers).forEach ((ticker) => testTicker (exchange, ticker, undefined, symbol))
+        return tickers
+
+    } else {
+
+        console.log ('fetching all tickers at once not supported')
+    }
+}
+

package/js/test/Exchange/test.fetchTrades.js

@@ -0,0 +1,39 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testTrade = require ('./test.trade.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const skippedExchanges = []
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchTrades...')
+        return
+    }
+
+    if (exchange.has.fetchTrades) {
+
+        const trades = await exchange.fetchTrades (symbol)
+        assert (trades instanceof Array)
+        console.log (symbol, 'fetched', Object.values (trades).length, 'trades')
+        const now = Date.now ()
+        for (let i = 0; i < trades.length; i++) {
+            testTrade (exchange, trades[i], symbol, now)
+            if (i > 0) {
+                if (trades[i].timestamp && trades[i - 1].timestamp) {
+                    assert (trades[i].timestamp >= trades[i - 1].timestamp)
+                }
+            }
+
+        }
+
+    } else {
+
+        console.log (symbol, 'fetchTrades () not supported')
+    }
+}

package/js/test/Exchange/test.fetchTradingFee.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const testTradingFee = require ('./test.tradingFee.js')
+
+module.exports = async (exchange, symbol) => {
+    const skippedExchanges = []
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchTradingFee...')
+        return
+    }
+    if (exchange.has.fetchTradingFee) {
+        const fee = await exchange.fetchTradingFee (symbol)
+        testTradingFee (exchange, symbol, fee)
+        return fee
+    } else {
+        console.log ('fetching trading fees not supported')
+    }
+}

package/js/test/Exchange/test.fetchTradingFees.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const testTradingFee = require ("./test.tradingFee")
+
+module.exports = async (exchange) => {
+    const skippedExchanges = []
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchTradingFees...')
+        return
+    }
+    if (exchange.has.fetchTradingFees) {
+        const fees = await exchange.fetchTradingFees ()
+        const symbols = Object.keys (fees)
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i]
+            testTradingFee (exchange, symbol, fees[symbol])
+        }
+        return fees
+    } else {
+        console.log ('fetching trading fees not supported')
+    }
+}

package/js/test/Exchange/test.fetchTransactions.js

@@ -0,0 +1,31 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testTransaction = require ('./test.transaction.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code) => {
+
+    if (exchange.has.fetchTransactions) {
+
+        const transactions = await exchange.fetchTransactions (code)
+
+        console.log ('fetched', transactions.length, 'transactions, asserting each...')
+
+        assert (transactions instanceof Array)
+
+        const now = Date.now ()
+
+        for (let i = 0; i < transactions.length; i++) {
+            const transaction = transactions[i]
+            testTransaction (exchange, transaction, code, now)
+        }
+
+    } else {
+
+        console.log ('fetching transactions not supported')
+    }
+}

package/js/test/Exchange/test.fetchWithdrawals.js

@@ -0,0 +1,31 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testTransaction = require ('./test.transaction.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code) => {
+
+    if (exchange.has.fetchWithdrawals) {
+
+        const transactions = await exchange.fetchWithdrawals (code)
+
+        console.log ('fetched', transactions.length, 'withdrawals, asserting each...')
+
+        assert (transactions instanceof Array)
+
+        const now = Date.now ()
+
+        for (let i = 0; i < transactions.length; i++) {
+            const transaction = transactions[i]
+            testTransaction (exchange, transaction, code, now)
+        }
+
+    } else {
+
+        console.log ('fetching withdrawals not supported')
+    }
+}

package/js/test/Exchange/test.ledgerItem.js

@@ -0,0 +1,46 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, item, code, now) => {
+    assert (typeof item === 'object')
+    assert ('id' in item)
+    assert (item['id'] === undefined || typeof item['id'] === 'string')
+    assert ('direction' in item)
+    assert (item['direction'] === 'in' || item['direction'] === 'out')
+    assert ('account' in item)
+    assert (item['account'] === undefined || typeof item['account'] === 'string')
+    assert ('referenceId' in item)
+    assert (item['referenceId'] === undefined || typeof item['referenceId'] === 'string')
+    assert ('referenceAccount' in item)
+    assert (item['referenceAccount'] === undefined || typeof item['referenceAccount'] === 'string')
+    assert ('type' in item)
+    // expect (item.type).to.be.oneOf (['trade', 'transaction', 'margin', 'cashback', 'referral', 'transfer', 'fee', /* TODO: add more types here */ ])
+    assert ('currency' in item)
+    assert ((item['currency'] === undefined) || (item['currency'] in exchange.currencies))
+    assert ('amount' in item)
+    assert ((item['amount'] === undefined) || (typeof item['amount'] === 'number'))
+    assert ('before' in item)
+    assert ((item['before'] === undefined) || (typeof item['before'] === 'number'))
+    assert ('after' in item)
+    assert ((item['after'] === undefined) || (typeof item['after'] === 'number'))
+    assert ('timestamp' in item)
+    assert ((item['timestamp'] === undefined) || (typeof item['timestamp'] === 'number'))
+    assert (item['timestamp'] >= 1230940800000)
+    assert (item['timestamp'] <= now)
+    assert ('datetime' in item)
+    assert (item['datetime'] === exchange.iso8601 (item['timestamp']))
+    assert ('fee' in item)
+    if (item['fee'] !== undefined) {
+        assert (typeof item['fee'] === 'object')
+        assert ('cost' in item['fee'])
+        assert ((item['fee']['cost'] === undefined) || (typeof item['fee']['cost'] === 'number'))
+        assert ('currency' in item['fee'])
+    }
+    assert ('info' in item)
+    assert ((item['info'] === undefined) || (typeof item['info'] === 'object'))
+}

package/js/test/Exchange/test.leverageTier.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require ('assert');
+
+function testLeverageTier (exchange, method, tier) {
+    const format = {
+        'tier': 1,
+        'minNotional': 0,
+        'maxNotional': 5000,
+        'maintenanceMarginRate': 0.01,
+        'maxLeverage': 25,
+        'info': {},
+    };
+    const keys = Object.keys (format);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        assert (key in tier);
+    }
+    assert (typeof tier['tier'] === 'number');
+    assert (typeof tier['minNotional'] === 'number');
+    assert (typeof tier['maxNotional'] === 'number');
+    assert (typeof tier['maintenanceMarginRate'] === 'number');
+    assert (typeof tier['maxLeverage'] === 'number');
+    assert (tier['tier'] >= 0);
+    assert (tier['minNotional'] >= 0);
+    assert (tier['notionalCap'] >= 0);
+    assert (tier['maintenanceMarginRate'] <= 1);
+    assert (tier['maxLeverage'] >= 1);
+    console.log (exchange.id, method, tier['tier'], tier['minNotional'], tier['maxNotional'], tier['maintenanceMarginRate'], tier['maxLeverage']);
+    return tier;
+}
+
+module.exports = testLeverageTier;

package/js/test/Exchange/test.loadMarkets.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testMarket = require ('./test.market.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    const skippedExchanges = [
+        'bitforex',
+    ]
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping loadMarkets...')
+        return
+    }
+
+    if (exchange.has.loadMarkets) {
+
+        const method = 'loadMarkets'
+        const markets = await exchange[method] ()
+        const values = Object.values (markets)
+        for (let i = 0; i < values.length; i++) {
+            const market = values[i]
+            testMarket (exchange, market, method)
+        }
+        return markets
+
+    } else {
+
+        console.log ('loading markets not supported')
+    }
+}