ccxt-look 1.81.50

package/js/test/.eslintrc.js

@@ -0,0 +1,42 @@
+'use strict';
+
+module.exports = {
+  "env": {
+    "node": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2017,
+    "sourceType": "script",
+  },
+  "extends": ["eslint:recommended"],
+  "rules": {
+      "semi": ["error", "never"],
+      "no-unused-vars": ["off"],
+      "quotes": ["off", "single"],
+      "func-call-spacing": ["error", "always"],
+      "one-var": "off",
+      "indent": ["error", 4],
+      "comma-style": "off",
+      "no-multi-spaces": "off",
+      "comma-dangle": "off",
+      "spaced-comment": "off",
+      "camelcase": "off",
+      "padded-blocks": "off",
+      "multiline-comment-style": "off",
+      "curly": "off",
+      "rest-spread-spacing": "off",
+      "no-multiple-empty-lines": "off",
+      "no-undef-init": "off",
+      "no-useless-return": "off",
+      "no-console": "off",
+      "operator-linebreak": "off",
+      "key-spacing": "off",
+      "brace-style": "off",
+      "padding-line-between-statements": ["off",
+        { "blankLine": "always", "prev":"function", "next": "*" },
+        { "blankLine": "always", "prev":"directive", "next": "*" },
+        { "blankLine": "always", "prev":"*", "next": "cjs-export" },
+      ],
+      "import/no-extraneous-dependencies": ["error", { "devDependencies": true }],
+    },
+}

package/js/test/Exchange/test.balance.js

@@ -0,0 +1,61 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, balance, method) => {
+
+    const currencies = [
+        'USD',
+        'USDT',
+        'CNY',
+        'EUR',
+        'BTC',
+        'ETH',
+        'JPY',
+        'LTC',
+        'DASH',
+        'DOGE',
+        'UAH',
+        'RUB',
+        'XRP',
+    ]
+
+    assert (typeof balance['total'] === 'object')
+    assert (typeof balance['free'] === 'object')
+    assert (typeof balance['used'] === 'object')
+
+    const codes = Object.keys (balance['total'])
+    for (let i = 0; i < codes.length; i++) {
+        const code = codes[i]
+        const total = balance['total'][code]
+        const free = balance['free'][code]
+        const used = balance['used'][code]
+        if ((total !== undefined) && (free !== undefined) && (used !== undefined)) {
+            assert (total === free + used, 'free and used do not sum to total ' + exchange.id)
+        }
+    }
+
+    let result = currencies
+        .filter ((currency) => (currency in balance) &&
+            (balance[currency]['total'] !== undefined))
+
+    if (result.length > 0) {
+        result = result.map ((currency) => currency + ': ' + balance[currency]['total'])
+        if (exchange.currencies.length > result.length) {
+            result = result.join (', ') + ' + more...'
+        } else {
+            result = result.join (', ')
+        }
+
+    } else {
+
+        result = 'zero balance'
+    }
+
+    console.log (result)
+
+}

package/js/test/Exchange/test.borrowRate.js

@@ -0,0 +1,32 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, borrowRate, method, code) => {
+
+    const format = {
+        'currency': 'USDT',
+        'info': {}, // Or []
+        'timestamp': 1638230400000,
+        'datetime': '2021-11-30T00:00:00.000Z',
+        'rate': 0.0006, // Interest rate
+        // 'period': 86400000,  // Amount of time the interest rate is based on in milliseconds
+    }
+
+    const keys = Object.keys (format)
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        assert (key in borrowRate)
+    }
+
+    console.log (borrowRate['datetime'], exchange.id, method, borrowRate['currency'], borrowRate['rate'])
+
+    // assert (borrowRate['period'] === 86400000 || borrowRate['period'] === 3600000) // Milliseconds in an hour or a day
+    assert (borrowRate['rate'] > 0)
+
+    return borrowRate
+}

package/js/test/Exchange/test.currency.js

@@ -0,0 +1,52 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = (exchange, currency, method) => {
+
+    const format = {
+        'id': 'btc', // string literal for referencing within an exchange
+        'code': 'BTC', // uppercase string literal of a pair of currencies
+        //----------------------------------------------------------------------
+        // commented temporarily to bring currencies to consistency first
+        // 'name': 'Bitcoin', // uppercase string, base currency, 3 or more letters
+        // 'quote': 'USD', // uppercase string, quote currency, 3 or more letters
+        // 'withdraw': true, // can withdraw
+        // 'deposit': true, // can deposit
+        // 'active': true, // can both withdraw & deposit
+        // 'precision': 8, // number of decimal digits "after the dot"
+        // 'limits': { // value limits when placing orders on this market
+        //     '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
+        //     },
+        //     'cost':  { // order cost = price * amount
+        //         'min': 0.01, // order cost should be > min
+        //         'max': 1000, // order cost should be < max
+        //     },
+        // },
+        // 'info': {}, // the original unparsed market info from the exchange
+        //----------------------------------------------------------------------
+    }
+
+    const keys = Object.keys (format)
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        assert (key in currency)
+    }
+
+    // expect (currency['precision']).to.not.be.undefined
+    // expect (currency['limits']['amount']['min']).to.not.be.undefined
+    // expect (currency['limits']['price']['min']).to.not.be.undefined
+    // expect (market['limits']['cost']['min']).to.not.be.undefined
+
+    return currency
+}

package/js/test/Exchange/test.fetchBalance.js

@@ -0,0 +1,23 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testBalance = require ('./test.balance.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    if (!(exchange.has.fetchBalance)) {
+        console.log (exchange.id, ' does not have fetchBalance')
+        return
+    }
+
+    console.log ('fetching balance...')
+
+    const response = await exchange.fetchBalance ()
+
+    testBalance (exchange, response)
+
+    return response
+}

package/js/test/Exchange/test.fetchBorrowInterest.js

@@ -0,0 +1,59 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code, symbol) => {
+
+    const method = 'fetchBorrowInterest'
+
+    if (exchange.has[method]) {
+
+        const format = {
+            'account': 'BTC/USDT',
+            'currency': 'USDT',
+            'interest': '0.1444',
+            'interestRate': 0.0006,
+            'amountBorrowed': 30.0,
+            'timestamp': 1638230400000,
+            'datetime': '2021-11-30T00:00:00.000Z',
+            'info': {},
+        }
+
+        const interest = await exchange.fetchBorrowInterest (code, symbol)
+
+        console.log (code, method, interest['datetime'], 'symbol: ', symbol,  'interest: ', interest['interest'], 'interestRate: ', interest['interestRate'], 'amountBorrowed: ', interest['amountBorrowed'])
+
+        if (code) {
+            assert (interest['currency'] === code)
+        }
+        assert (interest['account'] === symbol || interest['account'] === undefined)
+
+        const keys = Object.keys (format)
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]
+            assert (key in interest)
+        }
+
+        if (interest['amountBorrowed'] !== undefined) {
+            assert (interest['amountBorrowed'] >= 0)
+        }
+        if (interest['interestRate'] !== undefined) {
+            assert (interest['interestRate'] > 0)
+        }
+        if (interest['interest'] !== undefined) {
+            assert (interest['interest'] >= 0)
+        }
+        if (interest['timestamp'] !== undefined) {
+            assert (interest['timestamp'] > 1640933203000)
+        }
+
+        return interest
+
+    } else {
+        console.log (code, 'fetchBorrowInterest () not supported')
+    }
+}

package/js/test/Exchange/test.fetchBorrowRate.js

@@ -0,0 +1,32 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testBorrowRate = require ('./test.borrowRate.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code) => {
+
+    const method = 'fetchBorrowRate'
+
+    if (exchange.has[method]) {
+
+        const borrowRate = await exchange.fetchBorrowRate (code)
+
+        testBorrowRate (exchange, borrowRate, method, code)
+
+        console.log (code, method, borrowRate['datetime'], 'rate:', borrowRate['rate'], 'period:', borrowRate['period'])
+
+        if (code) {
+            assert (borrowRate['currency'] === code)
+        }
+
+        return borrowRate
+
+    } else {
+
+        console.log (code, 'fetchBorrowRate () not supported')
+    }
+}

package/js/test/Exchange/test.fetchBorrowRates.js

@@ -0,0 +1,28 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testBorrowRate = require ('./test.borrowRate.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    if (exchange.has.fetchBorrowRates) {
+
+        const method = 'fetchBorrowRates'
+        const borrowRates = await exchange[method] ()
+        console.log ('fetched all', Object.keys (borrowRates).length, 'borrow rates')
+
+        const values = Object.values (borrowRates)
+        for (let i = 0; i < values.length; i++) {
+            const borrowRate = values[i]
+            testBorrowRate (exchange, borrowRate, method)
+        }
+        return borrowRates
+
+    } else {
+
+        console.log ('fetching all borrow rates at once not supported')
+    }
+}

package/js/test/Exchange/test.fetchClosedOrders.js

@@ -0,0 +1,32 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testOrder = require ('./test.order.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    if (exchange.has.fetchClosedOrders) {
+
+        const orders = await exchange.fetchClosedOrders (symbol)
+
+        console.log ('fetched', orders.length, 'closed orders, testing 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)
+            assert (order.status === 'closed' || order.status === 'canceled')
+        }
+
+    } else {
+
+        console.log ('fetching closed orders not supported')
+    }
+}

package/js/test/Exchange/test.fetchCurrencies.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testCurrency = require ('./test.currency.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    const skippedExchanges = []
+
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchCurrencies...')
+        return
+    }
+
+    if (exchange.has.fetchCurrencies === true || exchange.has.fetchCurrencies === 'emulated') {
+
+        const method = 'fetchCurrencies'
+        const currencies = await exchange[method] ()
+        if (currencies !== undefined) {
+            const values = Object.values (currencies)
+            for (let i = 0; i < values.length; i++) {
+                const currency = values[i]
+                testCurrency (exchange, currency, method)
+            }
+        }
+        return currencies
+
+    } else {
+
+        console.log ('fetching currencies not supported')
+    }
+}

package/js/test/Exchange/test.fetchDeposits.js

@@ -0,0 +1,31 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testTransaction = require ('./test.transaction.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code) => {
+
+    if (exchange.has.fetchDeposits) {
+
+        const transactions = await exchange.fetchDeposits (code)
+
+        console.log ('fetched', transactions.length, 'deposits, 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 deposits not supported')
+    }
+}

package/js/test/Exchange/test.fetchFundingFees.js

@@ -0,0 +1,19 @@
+'use strict'
+
+module.exports = async (exchange) => {
+    const skippedExchanges = [
+        'bibox', // fetchFundingFees should be rewritten to fetchFundingFee
+    ]
+    if (skippedExchanges.includes (exchange.id)) {
+        console.log (exchange.id, 'found in ignored exchanges, skipping fetchFundingFees...')
+        return
+    }
+    if (exchange.has.fetchFundingFees) {
+        const method = 'fetchFundingFees'
+        const fees = await exchange[method] ()
+        console.log (fees)
+        return fees
+    } else {
+        console.log ('fetching funding fees not supported')
+    }
+}

package/js/test/Exchange/test.fetchFundingRateHistory.js

@@ -0,0 +1,40 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange) => {
+
+    const format = {
+        'currency': 'USDT',
+        'info': {}, // Or []
+        'timestamp': 1638230400000,
+        'datetime': '2021-11-30T00:00:00.000Z',
+        'rate': 0.0006,
+    }
+
+    if (exchange.has.fetchFundingRateHistory) {
+
+        const method = 'fetchFundingRateHistory'
+        const fundingRates = await exchange[method] ()
+        console.log ('fetched all', fundingRates.length, 'funding rates')
+
+        for (let i = 0; i < fundingRates.length; i++) {
+            const fundingRate = fundingRates[i]
+            const keys = Object.keys (format)
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i]
+                assert (key in fundingRate)
+            }
+            assert (fundingRate['rate'] >= 0)
+            assert (fundingRate['timestamp'] >= 1199145600000) // 2008-01-01 00:00:00
+        }
+        return fundingRates
+
+    } else {
+        console.log ('fetchFundingRateHistory not supported')
+    }
+}

package/js/test/Exchange/test.fetchL2OrderBook.js

@@ -0,0 +1,23 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const testOrderBook = require ('./test.orderbook.js')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, symbol) => {
+
+    const method = 'fetchL2OrderBook'
+
+    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.fetchLedger.js

@@ -0,0 +1,42 @@
+'use strict'
+
+// ----------------------------------------------------------------------------
+
+const assert = require ('assert')
+    , testLedgerItem = require ('./test.ledgerItem')
+
+// ----------------------------------------------------------------------------
+
+module.exports = async (exchange, code) => {
+
+    if (exchange.has.fetchLedger) {
+
+        const items = await exchange.fetchLedger (code)
+
+        assert (items instanceof Array)
+
+        console.log ('Fetched', items.length, 'ledger items')
+
+        const now = Date.now ()
+
+        for (let i = 0; i < items.length; i++) {
+            testLedgerItem (exchange, items[i], code, now)
+            if (i > 0) {
+                assert (items[i].timestamp >= items[i - 1].timestamp)
+            }
+        }
+
+        if (exchange.has.fetchLedgerItem) {
+            const { id } = items.pop ()
+            let item = await exchange.fetchLedgerItem (id)
+            if (Array.isArray (item)) {
+                item = item[0]
+            }
+            testLedgerItem (exchange, item, code, now)
+        }
+
+    } else {
+
+        console.log ('Fetching ledger items not supported')
+    }
+}

package/js/test/Exchange/test.fetchLeverageTiers.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require ('assert')
+    , testLeverageTier = require ('./test.leverageTier.js')
+
+
+module.exports = async (exchange, symbol) => {
+    const method = 'fetchLeverageTiers';
+    // const format = {
+    //     'RAY/USDT': [
+    //       {},
+    //     ],
+    // };
+    if (exchange.has[method]) {
+        const tiers = await exchange [method] ([ symbol ]);
+        const tierKeys = Object.keys (tiers);
+        const numTierKeys = tierKeys.length;
+        assert (numTierKeys >= 1);
+        console.log (method + 'for ' + numTierKeys + ' markets');
+        for (let i = 0; i < numTierKeys; i++) {
+            const tiersForSymbol = tiers [ tierKeys[i] ];
+            const arrayLength = tiersForSymbol.length;
+            assert (arrayLength >= 1);
+            for (let j=0; j < tiersForSymbol.length; j++) {
+                const tier = tiersForSymbol[j];
+                testLeverageTier (exchange, method, tier);
+            }
+        }
+        return tiers;
+    } else {
+        console.log (method + ' not supported');
+    }
+}

package/js/test/Exchange/test.fetchMarketLeverageTiers.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require ('assert')
+    , testLeverageTier = require ('./test.leverageTier.js')
+
+
+module.exports = async (exchange, symbol) => {
+    const method = 'fetchMarketLeverageTiers';
+    if (exchange.has[method]) {
+        const tiers = await exchange [method] (symbol);
+        console.log (method + 'for ' + symbol);
+        const arrayLength = tiers.length;
+        assert (arrayLength >= 1);
+        for (let j=0; j < tiers.length; j++) {
+            const tier = tiers[j];
+            testLeverageTier (exchange, method, tier);
+        }
+        return tiers;
+    } else {
+        console.log (method + ' not supported');
+    }
+}

package/js/test/Exchange/test.fetchMarkets.js

@@ -0,0 +1,33 @@
+'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 fetchMarkets...')
+        return
+    }
+
+    if (exchange.has.fetchMarkets) {
+
+        // log ('fetching markets...')
+
+        const method = 'fetchMarkets'
+        const markets = await exchange[method] ()
+        Object.values (markets).forEach ((market) => testMarket (exchange, market, method))
+        return markets
+
+    } else {
+
+        console.log ('fetching markets not supported')
+    }
+}