ccxt-look 1.81.50

package/js/test/Exchange/test.market.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const assert = require ('assert')
+
+function testMarket (exchange, market, method) {
+    const format = {
+        'id': 'btcusd', // string literal for referencing within an exchange
+        'symbol': 'BTC/USD', // uppercase string literal of a pair of currencies
+        'base': 'BTC', // unified uppercase string, base currency, 3 or more letters
+        'quote': 'USD', // unified uppercase string, quote currency, 3 or more letters
+        'taker': 0.0011, // taker fee, for example, 0.0011 = 0.11%
+        'maker': 0.0009, // maker fee, for example, 0.0009 = 0.09%
+        'baseId': 'btc', // exchange-specific base currency id
+        'quoteId': 'usd', // exchange-specific quote currency id
+        'active': true, // boolean, market status
+        'type': 'spot',
+        'linear': undefined,
+        'inverse': undefined,
+        'spot': true,
+        'swap': false,
+        'future': false,
+        'option': false,
+        'margin': false,
+        'contract': false,
+        'contractSize': 0.001,
+        'expiry': 1656057600000,
+        'expiryDatetime': '2022-06-24T08:00:00.000Z',
+        'optionType': 'put',
+        'strike': 56000,
+        'settle': undefined,
+        'settleId': undefined,
+        'precision': {
+            'price': 8, // integer or fraction
+            'amount': 8, // integer or fraction
+            'cost': 8, // integer or fraction
+        },
+        // value limits when placing orders on this market
+        'limits': {
+            'amount': {
+                'min': 0.01, // order amount should be > min
+                'max': 1000, // order amount should be < max
+            },
+            'price': {
+                'min': 0.01, // order price should be > min
+                'max': 1000, // order price should be < max
+            },
+            // order cost = price * amount
+            'cost': {
+                'min': 0.01, // order cost should be > min
+                'max': 1000, // order cost should be < max
+            },
+        },
+        'info': {}, // the original unparsed market info from the exchange
+    };
+    let keys = Object.keys (format);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const keyPresent = (key in market);
+        assert (keyPresent, key + ' missing ' + exchange.json (market));
+    }
+    keys = [
+        'id',
+        'symbol',
+        'baseId',
+        'quoteId',
+        'base',
+        'quote',
+        'precision',
+        'limits',
+    ];
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        assert (market[key] !== undefined, key + ' undefined ' + exchange.json (market));
+    }
+    assert ((market['taker'] === undefined) || (typeof market['taker'] === 'number'));
+    assert ((market['maker'] === undefined) || (typeof market['maker'] === 'number'));
+    if (market['contract']) {
+        assert (market['linear'] !== market['inverse']);
+    } else {
+        assert ((market['linear'] === undefined) && (market['inverse'] === undefined));
+    }
+    if (market['option']) {
+        assert (market['strike'] !== undefined);
+        assert (market['optionType'] !== undefined);
+    }
+    const validTypes = {
+        'spot': true,
+        'margin': true,
+        'swap': true,
+        'future': true,
+        'option': true,
+    };
+    const type = market['type'];
+    //
+    // binance has type = 'delivery'
+    // https://github.com/ccxt/ccxt/issues/11121
+    //
+    // assert (type in validTypes);
+    //
+    const types = Object.keys (validTypes);
+    for (let i = 0; i < types.length; i++) {
+        const entry = types[i];
+        if (entry in market) {
+            const value = market[entry];
+            assert ((value === undefined) || value || !value);
+        }
+    }
+    //
+    // todo fix binance
+    //
+    // if (market['future']) {
+    //     assert ((market['swap'] === false) && (market['option'] === false));
+    // } else if (market['swap']) {
+    //     assert ((market['future'] === false) && (market['option'] === false));
+    // } else if (market['option']) {
+    //     assert ((market['future'] === false) && (market['swap'] === false));
+    // }
+    // if (market['linear']) {
+    //     assert (market['inverse'] === false);
+    // } else if (market['inverse']) {
+    //     assert (market['linear'] === false);
+    // }
+    // if (market['future']) {
+    //     assert (market['expiry'] !== undefined);
+    //     assert (market['expiryDatetime'] !== undefined);
+    // }
+}
+
+module.exports = testMarket;

package/js/test/Exchange/test.ohlcv.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require ('assert');
+
+function testOHLCV (exchange, ohlcv, symbol, now) {
+
+    const json = exchange.json (ohlcv);
+    assert (ohlcv);
+    assert (Array.isArray (ohlcv), json);
+    const length = ohlcv.length;
+    assert (length >= 6);
+    for (let i = 0; i < ohlcv.length; i++) {
+        assert ((ohlcv[i] === undefined) || (typeof ohlcv[i] === 'number'), json);
+    }
+
+    assert (ohlcv[0] > 1230940800000, json); // 03 Jan 2009 - first block
+    assert (ohlcv[0] < 2147483648000, json); // 19 Jan 2038 - int32 overflows
+
+    const skippedExchanges = [
+        'bitmex', // BitMEX API docs: also note the open price is equal to the close price of the previous timeframe bucket.
+        'vcc', // same as BitMEX, the open price is equal to the close price of the previous timeframe bucket.
+        'delta',
+        'cryptocom',
+    ];
+
+    if (!exchange.inArray (exchange.id, skippedExchanges)) {
+        assert ((ohlcv[1] === undefined) || (ohlcv[2] === undefined) || (ohlcv[1] <= ohlcv[2]), 'open > high, ' + exchange.safeString (ohlcv, 1, 'undefined') + ' > ' + exchange.safeString (ohlcv, 2, 'undefined')); // open <= high
+        assert ((ohlcv[3] === undefined) || (ohlcv[2] === undefined) || (ohlcv[3] <= ohlcv[2]), 'low > high, ' + exchange.safeString (ohlcv, 2, 'undefined') + ' > ' + exchange.safeString (ohlcv, 3, 'undefined')); // low <= high
+        assert ((ohlcv[3] === undefined) || (ohlcv[4] === undefined) || (ohlcv[3] <= ohlcv[4]), 'low > close, ' + exchange.safeString (ohlcv, 3, 'undefined') + ' > ' + exchange.safeString (ohlcv, 4, 'undefined')); // low <= close
+    }
+}
+
+module.exports = testOHLCV;

package/js/test/Exchange/test.order.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const assert = require ('assert');
+
+function testOrder (exchange, order, symbol, now) {
+    assert (order);
+    assert ('id' in order);
+    assert (typeof order['id'] === 'string');
+    assert ('clientOrderId' in order);
+    assert ((order['clientOrderId'] === undefined) || (typeof order['clientOrderId'] === 'string'));
+    assert ('timestamp' in order);
+    assert (typeof order['timestamp'] === 'number');
+    assert (order['timestamp'] > 1230940800000); // 03 Jan 2009 - first block
+    assert (order['timestamp'] < now);
+    assert ('lastTradeTimestamp' in order);
+    assert ('datetime' in order);
+    assert (order['datetime'] === exchange.iso8601 (order['timestamp']));
+    assert ('status' in order);
+    assert ((order['status'] === 'open') || (order['status'] === 'closed') || (order['status'] === 'canceled'));
+    assert ('symbol' in order);
+    assert (order['symbol'] === symbol);
+    assert ('type' in order);
+    assert ((order['type'] === undefined) || (typeof order['type'] === 'string'));
+    assert ('timeInForce' in order);
+    assert ((order['timeInForce'] === undefined) || (typeof order['timeInForce'] === 'string'));
+    assert ('side' in order);
+    assert ((order['side'] === 'buy') || (order['side'] === 'sell'));
+    assert ('price' in order);
+    assert ((order['price'] === undefined) || (typeof order['price'] === 'number'));
+    if (order['price'] !== undefined) {
+        assert (order['price'] > 0);
+    }
+    assert ('amount' in order);
+    assert (typeof order['amount'] === 'number');
+    assert (order['amount'] >= 0);
+    assert ('filled' in order);
+    if (order['filled'] !== undefined) {
+        assert (typeof order['filled'] === 'number');
+        assert ((order['filled'] >= 0) && (order['filled'] <= order['amount']));
+    }
+    assert ('remaining' in order);
+    if (order['remaining'] !== undefined) {
+        assert (typeof order['remaining'] === 'number');
+        assert ((order['remaining'] >= 0) && (order['remaining'] <= order['amount']));
+    }
+    assert ('trades' in order);
+    if (order['trades']) {
+        assert (Array.isArray (order['trades']));
+    }
+    assert ('fee' in order);
+    const fee = order['fee'];
+    if (fee) {
+        assert (typeof fee['cost'] === 'number');
+        if (fee['cost'] !== 0) {
+            assert (typeof fee['currency'] === 'string');
+        }
+    }
+    assert ('info' in order);
+    assert (order['info']);
+}
+
+module.exports = testOrder;

package/js/test/Exchange/test.orderbook.js

@@ -0,0 +1,61 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, orderbook, method, symbol) => {
+
+    const format = {
+        // 'symbol': 'ETH/BTC', // reserved
+        'bids': [],
+        'asks': [],
+        'timestamp': 1234567890,
+        'datetime': '2017-09-01T00:00:00',
+        'nonce': 134234234,
+        // 'info': {},
+    }
+
+    const keys = Object.keys (format)
+    for (let i = 0; i < keys.length; i++) {
+        assert (keys[i] in orderbook)
+    }
+
+    const bids = orderbook['bids']
+    const asks = orderbook['asks']
+
+    for (let i = 0; i < bids.length; i++) {
+        if (bids.length > (i + 1)) {
+            assert (bids[i][0] >= bids[i + 1][0])
+        }
+        assert (typeof bids[i][0] === 'number')
+        assert (typeof bids[i][1] === 'number')
+    }
+
+    for (let i = 0; i < asks.length; i++) {
+        if (asks.length > (i + 1)) {
+            assert (asks[i][0] <= asks[i + 1][0])
+        }
+        assert (typeof asks[i][0] === 'number')
+        assert (typeof asks[i][1] === 'number')
+    }
+
+    if (![
+
+        'bitrue',
+        'ftxus',
+        'mexc',
+        'xbtce',
+        'upbit', // an orderbook might have a 0-price ask occasionally
+
+    ].includes (exchange.id)) {
+
+        if (bids.length && asks.length) {
+            assert (bids[0][0] <= asks[0][0], 'bids[0][0]:', bids[0][0], 'of', bids.length, 'asks[0][0]:', asks[0][0], 'of', asks.length)
+        }
+    }
+
+    console.log (symbol, method, orderbook['nonce'] || orderbook['datetime'], bids.length, 'bids:', bids[0], asks.length, 'asks:', asks[0])
+}

package/js/test/Exchange/test.position.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const assert = require ('assert');
+
+function testPosition (exchange, position, symbol, now) {
+    assert (position);
+    assert ('id' in position);
+    assert (position['id'] === undefined || typeof position['id'] === 'string');
+    assert ('timestamp' in position);
+    assert (position['timestamp'] === undefined || typeof position['timestamp'] === 'number');
+    assert (position['timestamp'] === undefined || position['timestamp'] > 1230940800000); // 03 Jan 2009 - first cryptocurrency block creation time
+    assert (position['timestamp'] === undefined || position['timestamp'] < now);
+    assert ('datetime' in position);
+    assert (position['datetime'] === exchange.iso8601 (position['timestamp']));
+    assert ('symbol' in position);
+    assert (symbol === undefined || position['symbol'] === symbol);
+    assert ('info' in position);
+    assert (position['info']);
+}
+
+module.exports = testPosition;

package/js/test/Exchange/test.throttle.js

@@ -0,0 +1,94 @@
+const { throttle } = require ('../../base/functions/throttle')
+
+const delta = 10
+const testCases = [
+    {
+        'tokens': 0,
+        'refillRate': 1 / 50,
+        'cost': 1,
+        'runs': 100,
+    },
+    {
+        'tokens': 20,
+        'refillRate': 1 / 50,
+        'cost': 1,
+        'runs': 100,
+    },
+    {
+        'tokens': 40,
+        'refillRate': 1 / 50,
+        'cost': 1,
+        'runs': 100,
+    },
+    {
+        'tokens': 0,
+        'refillRate': 1 / 20,
+        'cost': 1,
+        'runs': 100,
+    },
+    {
+        'tokens': 100,
+        'refillRate': 1 / 20,
+        'cost': 5,
+        'runs': 50,
+    },
+    {
+        'tokens': 0,
+        'refillRate': 1 / 40,
+        'cost': 2,
+        'runs': 50,
+    },
+    {
+        'tokens': 1,
+        'refillRate': 1 / 100,
+        'cost': 1,
+        'runs': 10,
+    },
+    {
+        'tokens': 5,
+        'refillRate': 1 / 100,
+        'cost': 1,
+        'runs': 10,
+    },
+    {
+        'tokens': 0,
+        'refillRate': 1 / 500,
+        'cost': 1,
+        'runs': 10,
+    },
+    {
+        'tokens': 0,
+        'refillRate': 1 / 10,
+        'cost': 1,
+        'runs': 500,
+    },
+]
+
+
+let number = 0
+for (const test of testCases) {
+    test['number'] = number++
+    const instantlyComplete = test['tokens'] / test['cost']
+    // after that each run will take cost and the total time will be runs * cost / refillRate
+    const remaining = test['runs'] - instantlyComplete - 1
+    test['expected'] = remaining * test['cost'] / test['refillRate']
+}
+
+async function runner (test) {
+    const throttler = throttle ({
+        'refillRate': test['refillRate'],
+        'tokens': test['tokens'],
+    })
+    const start = performance.now ()
+    for (let i = 0; i < test['runs']; i++) {
+        await throttler (test['cost'])
+    }
+    const end = performance.now ()
+    const elapsed = end - start
+    const result = Math.abs (elapsed - test['expected']) < delta
+    console.log (`case ${test['number']} ${result ? 'suceeded' : 'failed'} in ${elapsed}ms expected ${test['expected']}ms`)
+}
+
+for (const test of testCases) {
+    runner (test)
+}

package/js/test/Exchange/test.ticker.js

@@ -0,0 +1,95 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, ticker, method, symbol) => {
+
+    const format = {
+        'symbol':       'ETH/BTC',
+        'info':          {},
+        'timestamp':     1234567890,
+        'datetime':     '2017-09-01T00:00:00',
+        'high':          1.234, // highest price
+        'low':           1.234, // lowest price
+        'bid':           1.234, // current best bid (buy) price
+        'bidVolume':     1.234, // current best bid (buy) amount (may be missing or undefined)
+        'ask':           1.234, // current best ask (sell) price
+        'askVolume':     1.234, // current best ask (sell) amount (may be missing or undefined)
+        'vwap':          1.234, // volume weighed average price
+        'open':          1.234, // opening price
+        'close':         1.234, // price of last trade (closing price for current period)
+        'last':          1.234, // same as `close`, duplicated for convenience
+        'previousClose': 1.234, // closing price for the previous period
+        'change':        1.234, // absolute change, `last - open`
+        'percentage':    1.234, // relative change, `(change/open) * 100`
+        'average':       1.234, // average price, `(last + open) / 2`
+        'baseVolume':    1.234, // volume of base currency
+        'quoteVolume':   1.234, // volume of quote currency
+    }
+
+    const keys = Object.keys (format)
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        assert (key in ticker)
+    }
+
+    assert (!('first' in ticker), '`first` field leftover in ' + exchange.id)
+    assert (ticker['last'] === ticker['close'], '`last` != `close` in ' + exchange.id)
+
+    if (method !== undefined) {
+        console.log (ticker['datetime'], exchange.id, method, ticker['symbol'], ticker['last'])
+    }
+
+    // const { high, low, vwap, baseVolume, quoteVolume } = ticker
+    // this assert breaks QuadrigaCX sometimes... still investigating
+    // if (vwap) {
+    //     assert (vwap >= low && vwap <= high)
+    // }
+    // if (baseVolume && quoteVolume && high && low) {
+    //     assert (quoteVolume >= baseVolume * low) // this assertion breaks therock
+    //     assert (quoteVolume <= baseVolume * high)
+    // }
+    // if (baseVolume && vwap) {
+    //     assert (quoteVolume)
+    // }
+    // if (quoteVolume && vwap) {
+    //     assert (baseVolume)
+    // }
+
+    if (![
+
+        'bigone',
+        'bitmart',
+        'bitrue',
+        'btcturk',
+        'bybit',
+        'coss',
+        'ftx',
+        'ftxus',
+        'gateio', // some ticker bids are greaters than asks
+        'idex',
+        'mercado',
+        'mexc',
+        'okex',
+        'poloniex',
+        'qtrade',
+        'southxchange', // https://user-images.githubusercontent.com/1294454/59953532-314bea80-9489-11e9-85b3-2a711ca49aa7.png
+        'timex',
+        'xbtce',
+
+    ].includes (exchange.id)) {
+
+        if (ticker['baseVolume'] || ticker['quoteVolume']) {
+            if (ticker['bid'] && ticker['ask']) {
+                assert (ticker['bid'] <= ticker['ask'], (ticker['symbol'] ? (ticker['symbol'] + ' ') : '') + 'ticker bid is greater than ticker ask!')
+            }
+        }
+
+    }
+
+    return ticker
+}

package/js/test/Exchange/test.trade.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const assert = require ('assert');
+
+function testTrade (exchange, trade, symbol, now) {
+    assert (trade);
+    const sampleTrade = {
+        'info': { 'a': 1, 'b': 2, 'c': 3 },    // the original decoded JSON as is
+        'id': '12345-67890:09876/54321',       // string trade id
+        'timestamp': 1502962946216,            // Unix timestamp in milliseconds
+        'datetime': '2017-08-17 12:42:48.000', // ISO8601 datetime with milliseconds
+        'symbol': 'ETH/BTC',                   // symbol
+        'order': '12345-67890:09876/54321',    // string order id or undefined/None/null
+        'type': 'limit',                       // order type, 'market', 'limit' or undefined/None/null
+        'side': 'buy',                         // direction of the trade, 'buy' or 'sell'
+        'takerOrMaker': 'taker',               // string, 'taker' or 'maker'
+        'price': 0.06917684,                   // float price in quote currency
+        'amount': 1.5,                         // amount of base currency
+        'cost': 0.10376526,                    // total cost (including fees), `price * amount`
+    };
+    const keys = Object.keys (sampleTrade);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        assert (key in trade);
+    }
+    const fee = ('fee' in trade) ? trade['fee'] : undefined;
+    const fees = ('fees' in trade) ? trade['fees'] : undefined;
+    // logical XOR
+    // doesn't work when both fee is defined and fees is defined
+    // if (fee || fees) {
+    //     assert (!(fee && fees));
+    // }
+    if (fee) {
+        assert (('cost' in fee) && ('currency' in fee));
+    }
+    if (fees) {
+        assert (Array.isArray (fees));
+        for (let i = 0; i < fees.length; i++) {
+            const fee = fees[i];
+            assert (('cost' in fee) && ('currency' in fee));
+        }
+    }
+    const id = trade['id'];
+    assert ((id === undefined) || (typeof id === 'string'));
+    const timestamp = trade['timestamp'];
+    assert (typeof timestamp === 'number' || timestamp === undefined);
+    if (timestamp) {
+        assert (timestamp > 1230940800000); // 03 Jan 2009 - first block
+        assert (timestamp < 2147483648000); // 19 Jan 2038 - int32 overflows
+        const adjustedNow = now + 60000;
+        assert (timestamp < adjustedNow, 'trade.timestamp is greater than or equal to current time: trade: ' + exchange.iso8601 (timestamp) + ' now: ' + exchange.iso8601 (now));
+    }
+    assert (trade['datetime'] === exchange.iso8601 (timestamp));
+    assert (trade['symbol'] === symbol, 'trade symbol is not equal to requested symbol: trade: ' + trade['symbol'] + ' requested: ' + symbol);
+    assert (trade['type'] === undefined || typeof trade['type'] === 'string');
+    assert (trade['side'] === undefined || trade['side'] === 'buy' || trade['side'] === 'sell', 'unexpected trade side ' + trade['side']);
+    assert (trade['order'] === undefined || typeof trade['order'] === 'string');
+    assert (typeof trade['price'] === 'number', 'trade.price is not a number');
+    assert (trade['price'] > 0);
+    assert (typeof trade['amount'] === 'number', 'trade.amount is not a number');
+    assert (trade['amount'] >= 0);
+    assert (trade['cost'] === undefined || typeof trade['cost'] === 'number', 'trade.cost is not a number');
+    assert (trade['cost'] === undefined || trade['cost'] >= 0);
+    const takerOrMaker = trade['takerOrMaker'];
+    assert (takerOrMaker === undefined || takerOrMaker === 'taker' || takerOrMaker === 'maker');
+}
+
+module.exports = testTrade;

package/js/test/Exchange/test.tradingFee.js

@@ -0,0 +1,34 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+//  ---------------------------------------------------------------------------
+
+function testTradingFee (exchange = undefined, symbol, fee) {
+    assert (fee, 'fee is undefined')
+    const sampleFee = {
+        'info': { 'a': 1, 'b': 2, 'c': 3 },
+        'symbol': 'ETH/BTC',
+        'maker': 0.002,
+        'taker': 0.003,
+    }
+    const keys = Object.keys (sampleFee)
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        assert (key in fee, 'fee key ' + key + ' not found')
+    }
+    assert (fee['symbol'] === symbol, 'trade symbol is not equal to requested symbol: trade: ' + fee['symbol'] + ' requested: ' + symbol)
+    assert (typeof fee['maker'] === 'number', 'maker fee is not a number')
+    assert (typeof fee['taker'] === 'number', 'taker fee is not a number')
+    if ('percentage' in fee) {
+        assert (typeof fee['percentage'] === 'boolean', 'percentage is not a boolean')
+    }
+    if ('tierBased' in fee) {
+        assert (typeof fee['tierBased'] === 'boolean', 'percentage is not a boolean')
+    }
+    return fee
+}
+
+module.exports = testTradingFee

package/js/test/Exchange/test.transaction.js

@@ -0,0 +1,35 @@
+'use strict';
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert');
+
+//  ---------------------------------------------------------------------------
+
+function testTransaction (exchange, transaction, code, now) {
+    assert (transaction);
+    assert ((transaction['id'] === undefined) || (typeof transaction['id'] === 'string'));
+    assert (typeof transaction['timestamp'] === 'number');
+    assert (transaction['timestamp'] > 1230940800000); // 03 Jan 2009 - first block
+    assert (transaction['timestamp'] < now);
+    assert ('updated' in transaction);
+    assert ('address' in transaction);
+    assert ('tag' in transaction);
+    assert ('txid' in transaction);
+    assert (transaction['datetime'] === exchange.iso8601 (transaction['timestamp']));
+    assert ((transaction['status'] === 'ok') || (transaction['status'] === 'pending') || (transaction['status'] === 'canceled'));
+    assert (transaction['currency'] === code);
+    assert (typeof transaction['type'] === 'string');
+    assert (transaction['type'] === 'deposit' || transaction['type'] === 'withdrawal');
+    assert (typeof transaction['amount'] === 'number');
+    assert (transaction['amount'] >= 0);
+    if (transaction['fee']) {
+        assert (typeof transaction['fee']['cost'] === 'number');
+        if (transaction['fee']['cost'] !== 0) {
+            assert (typeof transaction['fee']['currency'] === 'string');
+        }
+    }
+    assert (transaction.info);
+}
+
+module.exports = testTransaction;