ccxt.js

"use strict";

(function () {

var isNode = (typeof window === 'undefined')

//-----------------------------------------------------------------------------

var capitalize = function (string) {
    return string.length ? (string.charAt (0).toUpperCase () + string.slice (1)) : string
}

var keysort = function (object) {
    const result = {}
    Object.keys (object).sort ().forEach (key => result[key] = object[key])
    return result
}

var extend = function () {
    const result = {}
    for (var i = 0; i < arguments.length; i++)
        if (typeof arguments[i] === 'object')
            Object.keys (arguments[i]).forEach (key =>
                (result[key] = arguments[i][key]))
    return result
}

var omit = function (object) {
    var result = extend (object)
    for (var i = 1; i < arguments.length; i++)
        if (typeof arguments[i] === 'string')
            delete result[arguments[i]]
        else if (Array.isArray (arguments[i]))
            for (var k = 0; k < arguments[i].length; k++)
                delete result[arguments[i][k]]
    return result
}

var indexBy = function (array, key) {
    const result = {}
    for (var i = 0; i < array.length; i++)
        result[array[i][key]] = array[i]
    return result
}

var flat = function (array) {
    return array.reduce ((acc, cur) => acc.concat (cur), [])
}

var urlencode = function (object) {
    return Object.keys (object).map (key => 
        encodeURIComponent (key) + '=' + encodeURIComponent (object[key])).join ('&')
}

//-----------------------------------------------------------------------------

if (isNode) {

    const crypto = require ('crypto')
    var   fetch  = require ('node-fetch')

    var stringToBinary = function (string) {
        return Buffer.from (string, 'binary')
    }

    var stringToBase64 = function (string) {
        return new Buffer (string).toString ('base64')
    }

    var utf16ToBase64 = function (string) {
        return stringToBase64 (string)
    }

    var base64ToBinary = function (string) {
        return Buffer.from (string, 'base64')
    }

    var base64ToString = function (string) {
        return Buffer.from (string, 'base64').toString ()
    }

    var hash = function (request, hash = 'md5', digest = 'hex') {
        return crypto.createHash (hash).update (request).digest (digest)
    }

    var hmac = function (request, secret, hash = 'sha256', digest = 'hex') {
        return crypto.createHmac (hash, secret).update (request).digest (digest)
    }

} else {

    var fetch = function (url, options, verbose = false) {

        return new Promise ((resolve, reject) => {

            if (verbose)
                console.log (url, options)
            
            var xhr = new XMLHttpRequest ()
            var method = options.method || 'GET'

            xhr.open (method, url, true)            
            xhr.onreadystatechange = () => { 
                if (xhr.readyState == 4) {
                    if (xhr.status == 200)
                        resolve (xhr.responseText)
                    else 
                        throw new Error (method, url, xhr.status, xhr.responseText)
                }
            }
            
            if (typeof options.headers != 'undefined')
                for (var header in options.headers)
                    xhr.setRequestHeader (header, options.headers[header])

            xhr.send (options.body)
        })
    }

    var stringToBinary = function (string) {
        return CryptoJS.enc.Latin1.parse (string)
    }

    var stringToBase64 = function (string) {
        return CryptoJS.enc.Latin1.parse (string).toString (CryptoJS.enc.Base64)
    }

    var utf16ToBase64  = function (string) {
        return CryptoJS.enc.Utf16.parse (string).toString (CryptoJS.enc.Base64)
    }

    var base64ToBinary = function (string) {
        return CryptoJS.enc.Base64.parse (string)
    }

    var base64ToString = function (string) {
        return CryptoJS.enc.Base64.parse (string).toString (CryptoJS.enc.Utf8)
    }

    var hash = function (request, hash = 'md5', digest = 'hex') {
        var encoding = (digest === 'binary') ? 'Latin1' : capitalize (digest)
        return CryptoJS[hash.toUpperCase ()] (request).toString (CryptoJS.enc[encoding])
    }

    var hmac = function (request, secret, hash = 'sha256', digest = 'hex') {
        var encoding = (digest === 'binary') ? 'Latin1' : capitalize (digest)
        return CryptoJS['Hmac' + hash.toUpperCase ()] (request, secret).toString (CryptoJS.enc[capitalize (encoding)])
    }
}

var urlencodeBase64 = function (base64string) {
    return base64string.replace (/[=]+$/, '').replace (/\+/g, '-').replace (/\//g, '_') 
}

var jwt = function (request, secret, alg = 'HS256', hash = 'sha256') {
    var encodedHeader = urlencodeBase64 (stringToBase64 (JSON.stringify ({ 'alg': alg, 'typ': 'JWT' })))
    var encodedData = urlencodeBase64 (stringToBase64 (JSON.stringify (request)))
    var token = [ encodedHeader, encodedData ].join ('.')
    var signature = urlencodeBase64 (utf16ToBase64 (hmac (token, secret, hash, 'utf16')))
    return [ token, signature ].join ('.')
}

//-----------------------------------------------------------------------------

var Market = function (config) {

    this.hash = hash
    this.hmac = hmac
    this.jwt = jwt
    this.stringToBinary = stringToBinary
    this.stringToBase64 = stringToBase64
    this.base64ToBinary = base64ToBinary
    this.urlencode = urlencode
    this.omit = omit
    this.extend = extend
    this.flatten = flat
    this.indexBy = indexBy
    this.keysort = keysort
    this.capitalize = capitalize

    this.init = function () {

        if (isNode)
            this.nodeVersion = process.version.match (/\d+\.\d+.\d+/) [0]

        if (this.api)
            Object.keys (this.api).forEach (type => {
                Object.keys (this.api[type]).forEach (method => {
                    var urls = this.api[type][method]
                    for (var i = 0; i < urls.length; i++) {
                        let url = urls[i].trim ()
                        let splitPath = url.split (/[^a-zA-Z0-9]/)

                        let uppercaseMethod  = method.toUpperCase ()
                        let lowercaseMethod  = method.toLowerCase ()
                        let camelcaseMethod  = capitalize (lowercaseMethod)
                        let camelcaseSuffix  = splitPath.map (capitalize).join ('')
                        let underscoreSuffix = splitPath.map (x => x.toLowerCase ()).join ('_')

                        if (camelcaseSuffix.indexOf (camelcaseMethod) === 0)
                            camelcaseSuffix = camelcaseSuffix.slice (camelcaseMethod.length)

                        if (underscoreSuffix.indexOf (lowercaseMethod) === 0)
                            underscoreSuffix = underscoreSuffix.slice (lowercaseMethod.length)

                        let camelcase  = type + camelcaseMethod + capitalize (camelcaseSuffix)
                        let underscore = type + '_' + lowercaseMethod + '_' + underscoreSuffix

                        let f = (params => this.request (url, type, uppercaseMethod, params))

                        this[camelcase]  = f
                        this[underscore] = f
                    }
                })
            })
    }

    // this.fetch = function (url, options) {

    //     if (isNode)
    //         options.headers = extend ({
    //             'User-Agent': 'ccxt/0.1.0 (+https://github.com/kroitor/ccxt) Node.js/' + this.nodeVersion + ' (JavaScript)'
    //         }, options.headers)

    //     if (this.verbose)
    //         console.log (this.id, url, options)

    //     return (fetch ((this.cors ? this.cors : '') + url, options)
    //         .then (response => (typeof response === 'string') ? response : response.text ())
    //         .then (response => {
    //             try {
    //                 return JSON.parse (response)
    //             } catch (e) {
    //                 var cloudflareProtection = response.match (/cloudflare/i) ? 'DDoS protection by Cloudflare' : ''
    //                 if (this.verbose)
    //                     console.log (this.id, response, cloudflareProtection, e)
    //                 throw e
    //             }
    //         }))
    // }

    this.fetch = function (url, method = 'GET', headers = undefined, body = undefined) {

        if (isNode)
            headers = extend ({
                'User-Agent': 'ccxt/0.1.0 (+https://github.com/kroitor/ccxt) Node.js/' + this.nodeVersion + ' (JavaScript)'
            }, headers)

        let options = { 'method': method, 'headers': headers, 'body': body }

        if (this.verbose)
            console.log (this.id, url, options)

        return (fetch ((this.cors ? this.cors : '') + url, options)
            .then (response => (typeof response === 'string') ? response : response.text ())
            .then (response => {
                try {
                    return JSON.parse (response)
                } catch (e) {
                    var cloudflareProtection = response.match (/cloudflare/i) ? 'DDoS protection by Cloudflare' : ''
                    if (this.verbose)
                        console.log (this.id, response, cloudflareProtection, e)
                    throw e
                }
            }))
    }

    this.load_products = 
    this.loadProducts = function () {
        if (this.products)
            return new Promise ((resolve, reject) => resolve (this.products))
        return this.fetchProducts ().then (products => {
            return this.products = indexBy (products, 'symbol')
        })
    }

    this.fetch_products = 
    this.fetchProducts = function () {
        return new Promise ((resolve, reject) => resolve (this.products))
    }

    this.commonCurrencyCode = function (currency) { 
        return (currency === 'XBT') ? 'BTC' : currency
    }

    this.product = function (product) {
        return (((typeof product === 'string') &&
            (typeof this.products != 'undefined') &&
            (typeof this.products[product] != 'undefined')) ? this.products[product] : product)        
    }

    this.product_id = 
    this.productId  = function (product) { 
        return this.product (product).id || product
    }

    this.symbol = function (product) {
        return this.product (product).symbol || product
    }

    this.extract_params = 
    this.extractParams = function (string) {
        var re = /{([a-zA-Z0-9_]+?)}/g
        var matches = []
        let match
        while (match = re.exec (string))
            matches.push (match[1])
        return matches
    }

    this.implode_params = 
    this.implodeParams = function (string, params) {
        for (var property in params)
            string = string.replace ('{' + property + '}', params[property])
        return string
    }

    this.buy = function (product, amount, price = undefined, params = {}) {
        return this.order (product, 'buy', amount, price, params)
    }

    this.sell = function (product, amount, price = undefined, params = {}) {
        return this.order (product, 'sell', amount, price, params)
    }

    this.trade =
    this.order = function (product, side, amount, price = undefined, params = {}) {
        let type = (typeof price == 'undefined') ? 'market' : 'limit'
        return this.createOrder (product, type, side, amount, price, params)
    }

    this.create_buy_order =
    this.createBuyOrder = function (product, type, amount, price = undefined, params = {}) { 
        return this.createOrder (product, type, 'buy',  amount, price, params)
    }

    this.create_sell_order =
    this.createSellOrder = function (product, type, amount, price = undefined, params = {}) {
        return this.createOrder (product, type, 'sell', amount, price, params)
    }

    this.create_limit_buy_order =
    this.createLimitBuyOrder = function (product, amount, price, params = {}) {
        return this.createLimitOrder  (product, 'buy',  amount, price, params)
    }

    this.create_limit_sell_order = 
    this.createLimitSellOrder = function (product, amount, price, params = {}) {
        return this.createLimitOrder (product, 'sell', amount, price, params)
    }

    this.create_market_buy_order =
    this.createMarketBuyOrder = function (product, amount, params = {}) {
        return this.createMarketOrder (product, 'buy',  amount, params)
    }

    this.create_market_sell_order =
    this.createMarketSellOrder = function (product, amount, params = {}) {
        return this.createMarketOrder (product, 'sell', amount, params)
    }

    this.create_limit_order = 
    this.createLimitOrder = function (product, side, amount, price, params = {}) {
        return this.createOrder (product, 'limit',  side, amount, price, params)
    }

    this.create_market_order =
    this.createMarketOrder = function (product, side, amount, params = {}) {
        return this.createOrder (product, 'market', side, amount, undefined, params)
    }

    this.parse_ticker = 
    this.parseTicker = function (ticker, product, replacements = {}) {

        // print (ticker)

        // t = {}
        // t.update (ticker)
        // if replacements: t = self.update (self.lowerkeys (t), replacements)

        // p = self.product (product)

        // result = {}

        // synonyms = {
        //     'high':  [ 'high', 'max', 'h', '24hhigh' ],
        //     'low':   [ 'low',  'min', 'l', '24hlow'  ],
        //     'bid':   [ 'bid',  'buy', 'buy_price' ],
        //     'ask':   [ 'ask',  'sell', 'sell_price' ],
        //     'vwap':  [ 'vwap' ],
        //     'open':  [ 'open' ],
        //     'close': [ 'close' ],
        //     'first': [ 'first' ],
        //     'change': [ 'change' ],
        //     'percentage': [ 'percentage' ],
        //     'last':  [ 'last', 'last_price', 'last_trade', 'last_traded_price', 'lastprice', 'll' ],
        //     'average': [ 'average', 'avg', 'av', 'mid' ],
        //     'baseVolume': [ 'vol_cur' ],
        //     'quoteVolume': [ 'volume', 'vol', 'v', 'a', 'volume_24h', 'volume_24hours', 'rolling_24_hour_volume', '24hvolume' ],
        // }

        // for synonym in synonyms:
        //     value = self.first_of (t, synonyms[synonym])
        //     value = float (value) if value else value
        //     result[synonym] = value
        
        // timestamp = self.first_of (t, [
        //     'time',
        //     'timestamp',
        //     'server_time',
        //     'created',
        //     'created_at',
        //     'updated',
        // ])

        // timestamp = self.parse_time (timestamp)

        // return this.extend (result, {
        //     'timestamp': timestamp,
        //     'datetime': datetime.datetime.utcfromtimestamp (timestamp).isoformat (),
        //     'details': ticker,
        //     'volume': dict ([
        //         (p['base'],  result['baseVolume']),
        //         (p['quote'], result['quoteVolume']),
        //     ]),
        // })
    }

    this.iso8601        = timestamp => new Date (timestamp).toISOString ()
    this.parse8601      = Date.parse 
    this.seconds        = () => Math.floor (this.milliseconds () / 1000)
    this.microseconds   = () => Math.floor (this.milliseconds () * 1000)
    this.milliseconds   = Date.now
    this.nonce          = this.seconds
    this.id             = undefined
    this.rateLimit      = 2000
    this.timeout        = undefined
    this.yyyymmddhhmmss = timestamp => {
        let date = new Date (timestamp)
        let yyyy = date.getUTCFullYear ()
        let MM = date.getUTCMonth ()
        let dd = date.getUTCDay ()
        let hh = date.getUTCHours ()
        let mm = date.getUTCMinutes ()
        let ss = date.getUTCSeconds ()
        MM = MM < 10 ? ('0' + MM) : MM
        dd = dd < 10 ? ('0' + dd) : dd
        hh = hh < 10 ? ('0' + hh) : hh
        mm = mm < 10 ? ('0' + mm) : mm
        ss = ss < 10 ? ('0' + ss) : ss
        return yyyy + '-' + MM + '-' + dd + ' ' + hh + ':' + mm + ':' + ss
    }

    for (var property in config)
        this[property] = config[property]

    this.fetch_balance    = this.fetchBalance
    this.fetch_order_book = this.fetchOrderBook
    this.fetch_ticker     = this.fetchTicker
    this.fetch_trades     = this.fetchTrades
  
    this.verbose = this.log || this.debug || (this.verbosity == 1) || this.verbose

    this.init ()
}

//=============================================================================

var _1broker = {

    'id': '_1broker',
    'name': '1Broker',
    'countries': 'US',
    'rateLimit': 2000,
    'version': 'v2',
    'urls': {
        'api': 'https://1broker.com/api',        
        'www': 'https://1broker.com',
        'doc': 'https://1broker.com/?c=en/content/api-documentation',
    },
    'api': {
        'private': {
            'get': [
                'market/bars',
                'market/categories',
                'market/details',
                'market/list',
                'market/quotes',
                'market/ticks',
                'order/cancel',
                'order/create',
                'order/open',
                'position/close',
                'position/close_cancel',
                'position/edit',
                'position/history',
                'position/open',
                'position/shared/get',
                'social/profile_statistics',
                'social/profile_trades',
                'user/bitcoin_deposit_address',
                'user/details',
                'user/overview',
                'user/quota_status',
                'user/transaction_log',
            ],
        },
    },

    async fetchCategories () {
        let categories = await this.privateGetMarketCategories ();
        return categories['response'];
    },

    async fetchProducts () {
        let categories = await this.fetchCategories ();
        let result = [];
        for (let c = 0; c < categories.length; c++) {
            let category = categories[c];
            let products = await this.privateGetMarketList ({ 
                'category': category.toLowerCase (),
            });
            for (let p = 0; p < products['response'].length; p++) {
                let product = products['response'][p];
                if ((category == 'FOREX') || (category == 'CRYPTO')) {
                    let id = product['symbol'];
                    let symbol = product['name'];
                    let [ base, quote ] = symbol.split ('/');
                    result.push ({
                        'id': id,
                        'symbol': symbol,
                        'base': base,
                        'quote': quote,
                        'info': product,
                    });
                } else {
                    let id = product['symbol'];
                    let symbol = product['symbol'];
                    let name = product['name'];
                    let type = product['type'].toLowerCase ();
                    result.push ({
                        'id': id,
                        'symbol': symbol,
                        'name': name,
                        'type': type,
                        'info': product,
                    });
                }
            }
        }
        return result;
    },

    fetchBalance () { 
        return this.privateGetUserOverview ();
    },

    fetchOrderBook (product) {
        return this.privateGetMarketQuotes ({
            'symbols': this.productId (product),
        });
    },

    fetchTicker (product) {
        return this.privateGetMarketBars ({
            'symbol': this.productId (product),
            'resolution': 60,
            'limit': 1,
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'symbol': this.productId (product),
            'margin': amount,
            'direction': (side == 'sell') ? 'short' : 'long',
            'leverage': 1,
            'type': side,
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['type'] += '_market';
        return this.privateGetOrderCreate (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path + '.php';
        let query = this.extend ({ 'token': (this.apiKey || this.token) }, params);
        url += '?' + this.urlencode (query);
        return this.fetch (url, method);
    },
}

//-----------------------------------------------------------------------------

var cryptocapital = {

    'comment': 'Crypto Capital API',
    'api': {
        'public': {
            'get': [
                'stats',
                'historical-prices',
                'order-book',
                'transactions',
            ],
        },
        'private': {            
            'post': [
                'balances-and-info',
                'open-orders',
                'user-transactions',
                'btc-deposit-address/get',
                'btc-deposit-address/new',
                'deposits/get',
                'withdrawals/get',
                'orders/new',
                'orders/edit',
                'orders/cancel',
                'orders/status',
                'withdrawals/new',
            ],
        },
    },

    fetchBalance () {
        return this.privatePostBalancesAndInfo ();
    },

    fetchOrderBook (product) { 
        return this.publicGetOrderBook ({
            'currency': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let response = await this.publicGetStats ({
            'currency': this.productId (product),
        });
        let ticker = response['stats'];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['max']),
            'low': parseFloat (ticker['min']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_price']),
            'change': parseFloat (ticker['daily_change']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['total_btc_traded']),
        };
    },

    fetchTrades (product) {
        return this.publicGetTransactions ({
            'currency': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'side': side,
            'type': type,
            'currency': this.productId (product),
            'amount': amount,
        };
        if (type == 'limit')
            order['limit_price'] = price;
        return this.privatePostOrdersNew (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path;
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let query = this.extend ({
                'api_key': this.apiKey,
                'nonce': this.nonce (),
            }, params);
            query['signature'] = this.hmac (JSON.stringify (query), this.secret);
            body = JSON.stringify (query);
            headers = { 'Content-Type': 'application/json' };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var _1btcxe = extend (cryptocapital, {

    'id': '_1btcxe',
    'name': '1BTCXE',
    'countries': 'PA', // Panama
    'comment': 'Crypto Capital API',
    'urls': { 
        'api': 'https://1btcxe.com/api',
        'www': 'https://1btcxe.com',
        'docs': 'https://1btcxe.com/api-docs.php',
    },    
    'products': {
        'BTC/USD': { 'id': 'USD', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD', },
        'BTC/EUR': { 'id': 'EUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR', },
        'BTC/CNY': { 'id': 'CNY', 'symbol': 'BTC/CNY', 'base': 'BTC', 'quote': 'CNY', },
        'BTC/RUB': { 'id': 'RUB', 'symbol': 'BTC/RUB', 'base': 'BTC', 'quote': 'RUB', },
        'BTC/CHF': { 'id': 'CHF', 'symbol': 'BTC/CHF', 'base': 'BTC', 'quote': 'CHF', },
        'BTC/JPY': { 'id': 'JPY', 'symbol': 'BTC/JPY', 'base': 'BTC', 'quote': 'JPY', },
        'BTC/GBP': { 'id': 'GBP', 'symbol': 'BTC/GBP', 'base': 'BTC', 'quote': 'GBP', },
        'BTC/CAD': { 'id': 'CAD', 'symbol': 'BTC/CAD', 'base': 'BTC', 'quote': 'CAD', },
        'BTC/AUD': { 'id': 'AUD', 'symbol': 'BTC/AUD', 'base': 'BTC', 'quote': 'AUD', },
        'BTC/AED': { 'id': 'AED', 'symbol': 'BTC/AED', 'base': 'BTC', 'quote': 'AED', },
        'BTC/BGN': { 'id': 'BGN', 'symbol': 'BTC/BGN', 'base': 'BTC', 'quote': 'BGN', },
        'BTC/CZK': { 'id': 'CZK', 'symbol': 'BTC/CZK', 'base': 'BTC', 'quote': 'CZK', },
        'BTC/DKK': { 'id': 'DKK', 'symbol': 'BTC/DKK', 'base': 'BTC', 'quote': 'DKK', },
        'BTC/HKD': { 'id': 'HKD', 'symbol': 'BTC/HKD', 'base': 'BTC', 'quote': 'HKD', },
        'BTC/HRK': { 'id': 'HRK', 'symbol': 'BTC/HRK', 'base': 'BTC', 'quote': 'HRK', },
        'BTC/HUF': { 'id': 'HUF', 'symbol': 'BTC/HUF', 'base': 'BTC', 'quote': 'HUF', },
        'BTC/ILS': { 'id': 'ILS', 'symbol': 'BTC/ILS', 'base': 'BTC', 'quote': 'ILS', },
        'BTC/INR': { 'id': 'INR', 'symbol': 'BTC/INR', 'base': 'BTC', 'quote': 'INR', },
        'BTC/MUR': { 'id': 'MUR', 'symbol': 'BTC/MUR', 'base': 'BTC', 'quote': 'MUR', },
        'BTC/MXN': { 'id': 'MXN', 'symbol': 'BTC/MXN', 'base': 'BTC', 'quote': 'MXN', },
        'BTC/NOK': { 'id': 'NOK', 'symbol': 'BTC/NOK', 'base': 'BTC', 'quote': 'NOK', },
        'BTC/NZD': { 'id': 'NZD', 'symbol': 'BTC/NZD', 'base': 'BTC', 'quote': 'NZD', },
        'BTC/PLN': { 'id': 'PLN', 'symbol': 'BTC/PLN', 'base': 'BTC', 'quote': 'PLN', },
        'BTC/RON': { 'id': 'RON', 'symbol': 'BTC/RON', 'base': 'BTC', 'quote': 'RON', },
        'BTC/SEK': { 'id': 'SEK', 'symbol': 'BTC/SEK', 'base': 'BTC', 'quote': 'SEK', },
        'BTC/SGD': { 'id': 'SGD', 'symbol': 'BTC/SGD', 'base': 'BTC', 'quote': 'SGD', },
        'BTC/THB': { 'id': 'THB', 'symbol': 'BTC/THB', 'base': 'BTC', 'quote': 'THB', },
        'BTC/TRY': { 'id': 'TRY', 'symbol': 'BTC/TRY', 'base': 'BTC', 'quote': 'TRY', },
        'BTC/ZAR': { 'id': 'ZAR', 'symbol': 'BTC/ZAR', 'base': 'BTC', 'quote': 'ZAR', },
    },
})

//-----------------------------------------------------------------------------

var bit2c = {

    'id': 'bit2c',
    'name': 'Bit2C',
    'countries': 'IL', // Israel
    'rateLimit': 3000,
    'urls': {
        'api': 'https://www.bit2c.co.il',
        'www': 'https://www.bit2c.co.il',
        'doc': [
            'https://www.bit2c.co.il/home/api',
            'https://github.com/OferE/bit2c',
        ],
    },
    'api': {
        'public': {
            'get': [
                'Exchanges/{pair}/Ticker',
                'Exchanges/{pair}/orderbook',
                'Exchanges/{pair}/trades',
            ],
        },
        'private': {
            'post': [
                'Account/Balance',
                'Account/Balance/v2',
                'Merchant/CreateCheckout',
                'Order/AccountHistory',
                'Order/AddCoinFundsRequest',
                'Order/AddFund',
                'Order/AddOrder',
                'Order/AddOrderMarketPriceBuy',
                'Order/AddOrderMarketPriceSell',
                'Order/CancelOrder',
                'Order/MyOrders',
                'Payment/GetMyId',
                'Payment/Send',
            ],
        },
    },
    'products': {
        'BTC/NIS': { 'id': 'BtcNis', 'symbol': 'BTC/NIS', 'base': 'BTC', 'quote': 'NIS' },
        'LTC/BTC': { 'id': 'LtcBtc', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'LTC/NIS': { 'id': 'LtcNis', 'symbol': 'LTC/NIS', 'base': 'LTC', 'quote': 'NIS' },
    },

    fetchBalance () {
        return this.privatePostAccountBalanceV2 ();
    },

    fetchOrderBook (product) {
        return this.publicGetExchangesPairOrderbook ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetExchangesPairTicker ({
            'pair': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['h']),
            'low': parseFloat (ticker['l']),
            'bid': undefined,
            'ask': undefined,
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['ll']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['av']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['a']),
        };
    },

    fetchTrades (product) {
        return this.publicGetExchangesPairTrades ({
            'pair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePostOrderAddOrder';
        let order = {
            'Amount': amount,
            'Pair': this.productId (product),
        };
        if (type == 'market') {
            method += 'MarketPrice' + this.capitalize (side);
        } else {
            order['Price'] = price;
            order['Total'] = amount * price;
            order['IsBid'] = (side == 'buy');
        }
        return this[method] (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.implodeParams (path, params);
        if (type == 'public') {
            url += '.json';
        } else {
            let nonce = this.nonce ();
            let query = this.extend ({ 'nonce': nonce }, params);
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'key': this.apiKey,
                'sign': this.hmac (body, this.secret, 'sha512', 'base64'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitbay = {

    'id': 'bitbay',
    'name': 'BitBay',
    'countries': [ 'PL', 'EU', ], // Poland
    'rateLimit': 1000,
    'urls': {
        'www': 'https://bitbay.net',
        'api': {
            'public': 'https://bitbay.net/API/Public',
            'private': 'https://bitbay.net/API/Trading/tradingApi.php',
        },
        'docs': [
            'https://bitbay.net/public-api',
            'https://bitbay.net/account/tab-api',
            'https://github.com/BitBayNet/API',
        ], 
    },
    'api': {
        'public': {
            'get': [
                '{id}/all',
                '{id}/market',
                '{id}/orderbook',
                '{id}/ticker',
                '{id}/trades',
            ],
        },
        'private': {
            'post': [
                'info',
                'trade',
                'cancel',
                'orderbook',
                'orders',
                'transfer',
                'withdraw',
                'history',
                'transactions',
            ],
        },
    },
    'products': {  
        'BTC/USD': { 'id': 'BTCUSD', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/EUR': { 'id': 'BTCEUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'BTC/PLN': { 'id': 'BTCPLN', 'symbol': 'BTC/PLN', 'base': 'BTC', 'quote': 'PLN' },
        'LTC/USD': { 'id': 'LTCUSD', 'symbol': 'LTC/USD', 'base': 'LTC', 'quote': 'USD' },
        'LTC/EUR': { 'id': 'LTCEUR', 'symbol': 'LTC/EUR', 'base': 'LTC', 'quote': 'EUR' },
        'LTC/PLN': { 'id': 'LTCPLN', 'symbol': 'LTC/PLN', 'base': 'LTC', 'quote': 'PLN' },
        'LTC/BTC': { 'id': 'LTCBTC', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'ETH/USD': { 'id': 'ETHUSD', 'symbol': 'ETH/USD', 'base': 'ETH', 'quote': 'USD' },
        'ETH/EUR': { 'id': 'ETHEUR', 'symbol': 'ETH/EUR', 'base': 'ETH', 'quote': 'EUR' },
        'ETH/PLN': { 'id': 'ETHPLN', 'symbol': 'ETH/PLN', 'base': 'ETH', 'quote': 'PLN' },
        'ETH/BTC': { 'id': 'ETHBTC', 'symbol': 'ETH/BTC', 'base': 'ETH', 'quote': 'BTC' },
        'LSK/USD': { 'id': 'LSKUSD', 'symbol': 'LSK/USD', 'base': 'LSK', 'quote': 'USD' },
        'LSK/EUR': { 'id': 'LSKEUR', 'symbol': 'LSK/EUR', 'base': 'LSK', 'quote': 'EUR' },
        'LSK/PLN': { 'id': 'LSKPLN', 'symbol': 'LSK/PLN', 'base': 'LSK', 'quote': 'PLN' },
        'LSK/BTC': { 'id': 'LSKBTC', 'symbol': 'LSK/BTC', 'base': 'LSK', 'quote': 'BTC' },
    },

    fetchBalance () { 
        return this.privatePostInfo ();
    },

    fetchOrderBook (product) {
        return this.publicGetIdOrderbook ({
            'id': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetIdTicker ({
            'id': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['max']),
            'low': parseFloat (ticker['min']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['average']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) { 
        return this.publicGetIdTrades ({
            'id': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let p = this.product (product);
        return this.privatePostTrade (this.extend ({
            'type': side,
            'currency': p['base'],
            'amount': amount,
            'payment_currency': p['quote'],
            'rate': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        if (type == 'public') {
            url += '/' + this.implodeParams (path, params) + '.json';
        } else {
            body = this.urlencode (this.extend ({
                'method': path,
                'moment': this.nonce (),
            }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'API-Key': this.apiKey,
                'API-Hash': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitcoincoid = {

    'id': 'bitcoincoid',
    'name': 'Bitcoin.co.id',
    'countries': 'ID', // Indonesia
    'urls': {
        'api': {
            'public': 'https://vip.bitcoin.co.id/api',
            'private': 'https://vip.bitcoin.co.id/tapi',
        },
        'www': 'https://www.bitcoin.co.id',
        'docs': [
            'https://vip.bitcoin.co.id/trade_api',
            'https://vip.bitcoin.co.id/downloads/BITCOINCOID-API-DOCUMENTATION.pdf',
        ],
    },
    'api': {
        'public': {
            'get': [
                '{pair}/ticker',
                '{pair}/trades',
                '{pair}/depth',
            ],
        },
        'private': {
            'post': [
                'getInfo',
                'transHistory',
                'trade',
                'tradeHistory',
                'openOrders',
                'cancelOrder',
            ],
        },
    },
    'products': {
        'BTC/IDR':  { 'id': 'btc_idr', 'symbol': 'BTC/IDR', 'base': 'BTC', 'quote': 'IDR', 'baseId': 'btc', 'quoteId': 'idr' },
        'BTS/BTC':  { 'id': 'bts_btc', 'symbol': 'BTS/BTC', 'base': 'BTS', 'quote': 'BTC', 'baseId': 'bts', 'quoteId': 'btc' },
        'DASH/BTC': { 'id': 'drk_btc', 'symbol': 'DASH/BTC', 'base': 'DASH', 'quote': 'BTC', 'baseId': 'drk', 'quoteId': 'btc' },
        'DOGE/BTC': { 'id': 'doge_btc', 'symbol': 'DOGE/BTC', 'base': 'DOGE', 'quote': 'BTC', 'baseId': 'doge', 'quoteId': 'btc' },
        'ETH/BTC':  { 'id': 'eth_btc', 'symbol': 'ETH/BTC', 'base': 'ETH', 'quote': 'BTC', 'baseId': 'eth', 'quoteId': 'btc' },
        'LTC/BTC':  { 'id': 'ltc_btc', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC', 'baseId': 'ltc', 'quoteId': 'btc' },
        'NXT/BTC':  { 'id': 'nxt_btc', 'symbol': 'NXT/BTC', 'base': 'NXT', 'quote': 'BTC', 'baseId': 'nxt', 'quoteId': 'btc' },
        'STR/BTC':  { 'id': 'str_btc', 'symbol': 'STR/BTC', 'base': 'STR', 'quote': 'BTC', 'baseId': 'str', 'quoteId': 'btc' },
        'NEM/BTC':  { 'id': 'nem_btc', 'symbol': 'NEM/BTC', 'base': 'NEM', 'quote': 'BTC', 'baseId': 'nem', 'quoteId': 'btc' },
        'XRP/BTC':  { 'id': 'xrp_btc', 'symbol': 'XRP/BTC', 'base': 'XRP', 'quote': 'BTC', 'baseId': 'xrp', 'quoteId': 'btc' },
    },

    fetchBalance () {
        return this.privatePostGetInfo ();
    },

    fetchOrderBook (product) {
        return this.publicGetPairDepth ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let pair = this.product (product);
        let response = await this.publicGetPairTicker ({
            'pair': pair['id'],
        });
        let ticker = response['ticker'];
        let timestamp = parseFloat (ticker['server_time']) * 1000;
        let baseVolume = 'vol_' + pair['baseId'].toLowerCase ();
        let quoteVolume = 'vol_' + pair['quoteId'].toLowerCase ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['average']),
            'baseVolume': parseFloat (ticker[baseVolume]),
            'quoteVolume': parseFloat (ticker[quoteVolume]),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetPairTrades ({
            'pair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let p = this.product (product);
        let order = {
            'pair': p['id'],
            'type': side,
            'price': price,
        };
        let base = p['base'].toLowerCase ();
        order[base] = amount;
        return this.privatePostTrade (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        if (type == 'public') {
            url += '/' + this.implodeParams (path, params);
        } else {
            body = this.urlencode (this.extend ({
                'method': path,
                'nonce': this.nonce (),
            }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Key': this.apiKey,
                'Sign': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitfinex = {

    'id': 'bitfinex',
    'name': 'Bitfinex',
    'countries': 'US',
    'version': 'v1',
    'rateLimit': 2000,
    'urls': {
        'api': 'https://api.bitfinex.com',
        'www': 'https://www.bitfinex.com',
        'docs': [
            'https://bitfinex.readme.io/v1/docs',
            'https://bitfinex.readme.io/v2/docs',
            'https://github.com/bitfinexcom/bitfinex-api-node',
        ],
    },
    'api': {
        'public': {
            'get': [
                'book/{symbol}',
                'candles/{symbol}',
                'lendbook/{currency}',
                'lends/{currency}',
                'pubticker/{symbol}',
                'stats/{symbol}',
                'symbols',
                'symbols_details',
                'today',
                'trades/{symbol}',                
            ],
        },
        'private': {
            'post': [
                'account_infos',
                'balances',
                'basket_manage',
                'credits',
                'deposit/new',
                'funding/close',
                'history',
                'history/movements',
                'key_info',
                'margin_infos',
                'mytrades',
                'offer/cancel',
                'offer/new',
                'offer/status',
                'offers',
                'order/cancel',
                'order/cancel/all',
                'order/cancel/multi',
                'order/cancel/replace',
                'order/new',
                'order/new/multi',
                'order/status',
                'orders',
                'position/claim',
                'positions',
                'summary',
                'taken_funds',
                'total_taken_funds',
                'transfer',
                'unused_taken_funds',
                'withdraw',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetSymbolsDetails ();
        let result = [];
        for (let p = 0; p < products.length; p++) {
            let product = products[p];
            let id = product['pair'].toUpperCase ();
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostBalances ();
    },

    fetchOrderBook (product) {
        return this.publicGetBookSymbol ({ 
            'symbol': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetPubtickerSymbol ({
            'symbol': this.productId (product),
        });
        let timestamp = parseFloat (ticker['timestamp']) * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_price']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['mid']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTradesSymbol ({
            'symbol': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostOrderNew (this.extend ({
            'symbol': this.productId (product),
            'amount': amount.toString (),
            'price': price.toString (),
            'side': side,
            'type': 'exchange ' + type,
            'ocoorder': false,
            'buy_price_oco': 0,
            'sell_price_oco': 0,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = '/' + this.version + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        let url = this.urls['api'] + request;
        if (type == 'public') {            
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            query = this.extend ({
                'nonce': nonce.toString (),
                'request': request,
            }, query);
            let payload = this.stringToBase64 (JSON.stringify (query));
            headers = {
                'X-BFX-APIKEY': this.apiKey,
                'X-BFX-PAYLOAD': payload,
                'X-BFX-SIGNATURE': this.hmac (payload, this.secret, 'sha384'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitlish = {

    'id': 'bitlish',
    'name': 'bitlish',
    'countries': [ 'UK', 'EU', 'RU', ],
    'rateLimit': 2000,    
    'version': 'v1',
    'urls': {
        'api': 'https://bitlish.com/api',
        'www': 'https://bitlish.com',
        'docs': 'https://bitlish.com/api',
    },
    'api': {
        'public': {
            'get': [
                'instruments',
                'ohlcv',
                'pairs',
                'tickers',
                'trades_depth',
                'trades_history',
            ],
        },
        'private': {
            'post': [
                'accounts_operations',
                'balance',
                'cancel_trade',
                'cancel_trades_by_ids',
                'cancel_all_trades',
                'create_bcode',
                'create_template_wallet',
                'create_trade',
                'deposit',
                'list_accounts_operations_from_ts',
                'list_active_trades',
                'list_bcodes',
                'list_my_matches_from_ts',
                'list_my_trades',
                'list_my_trads_from_ts',
                'list_payment_methods',
                'list_payments',
                'redeem_code',
                'resign',
                'signin',
                'signout',
                'trade_details',
                'trade_options',
                'withdraw',
                'withdraw_by_id',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetPairs ();
        let result = [];
        let keys = Object.keys (products);
        for (let p = 0; p < keys.length; p++) {
            let product = products[keys[p]];
            let id = product['id'];
            let symbol = product['name'];
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let tickers = await this.publicGetTickers ();
        let ticker = tickers[p['id']];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['max']),
            'low': parseFloat (ticker['min']),
            'bid': undefined,
            'ask': undefined,
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': parseFloat (ticker['first']),
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': undefined,
            'info': ticker,
        };
    },

    fetchOrderBook (product) {
        return this.publicGetTradesDepth ({
            'pair_id': this.productId (product),
        });
    },

    fetchTrades (product) {
        return this.publicGetTradesHistory ({
            'pair_id': this.productId (product),
        });
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    signIn () {
        return this.privatePostSignin ({
            'login': this.login,
            'passwd': this.password,
        });
    },    

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'pair_id': this.productId (product),
            'dir': (side == 'buy') ? 'bid' : 'ask',
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        return this.privatePostCreateTrade (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            body = JSON.stringify (this.extend ({ 'token': this.apiKey }, params));
            headers = { 'Content-Type': 'application/json' };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitmarket = {

    'id': 'bitmarket',
    'name': 'BitMarket',
    'countries': [ 'PL', 'EU', ],
    'rateLimit': 3000,
    'urls': {
        'api': {
            'public': 'https://www.bitmarket.net',
            'private': 'https://www.bitmarket.pl/api2/', // last slash is critical
        },
        'www': [
            'https://www.bitmarket.pl',
            'https://www.bitmarket.net',
        ],
        'docs': [
            'https://www.bitmarket.net/docs.php?file=api_public.html',
            'https://www.bitmarket.net/docs.php?file=api_private.html',
            'https://github.com/bitmarket-net/api',
        ],
    },
    'api': {
        'public': {
            'get': [
                'json/{market}/ticker',
                'json/{market}/orderbook',
                'json/{market}/trades',
                'json/ctransfer',
                'graphs/{market}/90m',
                'graphs/{market}/6h',
                'graphs/{market}/1d',
                'graphs/{market}/7d',
                'graphs/{market}/1m',
                'graphs/{market}/3m',
                'graphs/{market}/6m',
                'graphs/{market}/1y',
            ],
        },
        'private': {
            'post': [
                'info',
                'trade',
                'cancel',
                'orders',
                'trades',
                'history',
                'withdrawals',
                'tradingdesk',
                'tradingdeskStatus',
                'tradingdeskConfirm',
                'cryptotradingdesk',
                'cryptotradingdeskStatus',
                'cryptotradingdeskConfirm',
                'withdraw',
                'withdrawFiat',
                'withdrawPLNPP',
                'withdrawFiatFast',
                'deposit',
                'transfer',
                'transfers',
                'marginList',
                'marginOpen',
                'marginClose',
                'marginCancel',
                'marginModify',
                'marginBalanceAdd',
                'marginBalanceRemove',
                'swapList',
                'swapOpen',
                'swapClose',
            ],
        },
    },
    'products': {
        'BTC/PLN': { 'id': 'BTCPLN', 'symbol': 'BTC/PLN', 'base': 'BTC', 'quote': 'PLN' },
        'BTC/EUR': { 'id': 'BTCEUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'LTC/PLN': { 'id': 'LTCPLN', 'symbol': 'LTC/PLN', 'base': 'LTC', 'quote': 'PLN' },
        'LTC/BTC': { 'id': 'LTCBTC', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'LMX/BTC': { 'id': 'LiteMineXBTC', 'symbol': 'LMX/BTC', 'base': 'LMX', 'quote': 'BTC' },
    },

    fetchBalance () {
        return this.privatePostInfo ();
    },

    fetchOrderBook (product) { 
        return this.publicGetJsonMarketOrderbook ({
            'market': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetJsonMarketTicker ({
            'market': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetJsonMarketTrades ({
            'market': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostTrade (this.extend ({
            'market': this.productId (product),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        if (type == 'public') {
            url += '/' + this.implodeParams (path + '.json', params);
        } else {
            let nonce = this.nonce ();
            let query = this.extend ({
                'tonce': nonce,
                'method': path,
            }, params);
            body = this.urlencode (query);
            headers = {
                'API-Key': this.apiKey,
                'API-Hash': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitmex = {

    'id': 'bitmex',
    'name': 'BitMEX',
    'countries': 'SC', // Seychelles
    'version': 'v1',
    'rateLimit': 2000,
    'urls': {
        'api': 'https://www.bitmex.com',
        'www': 'https://www.bitmex.com',
        'docs': [
            'https://www.bitmex.com/app/apiOverview',
            'https://github.com/BitMEX/api-connectors/tree/master/official-http',
        ],
    },
    'api': {
        'public': {
            'get': [
                'announcement',
                'announcement/urgent',
                'funding',
                'instrument',
                'instrument/active',
                'instrument/activeAndIndices',
                'instrument/activeIntervals',
                'instrument/compositeIndex',
                'instrument/indices',
                'insurance',
                'leaderboard',
                'liquidation',
                'orderBook',
                'orderBook/L2',
                'quote',
                'quote/bucketed',
                'schema',
                'schema/websocketHelp',
                'settlement',
                'stats',
                'stats/history',
                'trade',
                'trade/bucketed',
            ],
        },
        'private': {
            'get': [
                'apiKey',
                'chat',
                'chat/channels',
                'chat/connected',
                'execution',
                'execution/tradeHistory',
                'notification',
                'order',
                'position',
                'user',
                'user/affiliateStatus',
                'user/checkReferralCode',
                'user/commission',
                'user/depositAddress',
                'user/margin',
                'user/minWithdrawalFee',
                'user/wallet',
                'user/walletHistory',
                'user/walletSummary',
            ],
            'post': [
                'apiKey',
                'apiKey/disable',
                'apiKey/enable',
                'chat',
                'order',
                'order/bulk',
                'order/cancelAllAfter',
                'order/closePosition',
                'position/isolate',
                'position/leverage',
                'position/riskLimit',
                'position/transferMargin',
                'user/cancelWithdrawal',
                'user/confirmEmail',
                'user/confirmEnableTFA',
                'user/confirmWithdrawal',
                'user/disableTFA',
                'user/logout',
                'user/logoutAll',
                'user/preferences',
                'user/requestEnableTFA',
                'user/requestWithdrawal',
            ],
            'put': [
                'order',
                'order/bulk',
                'user',
            ],
            'delete': [
                'apiKey',
                'order',
                'order/all',
            ],
        }
    }, 

    async fetchProducts () {
        let products = await this.publicGetInstrumentActive ();
        let result = [];
        for (let p = 0; p < products.length; p++) {
            let product = products[p];
            let id = product['symbol'];
            let base = product['underlying'];
            let quote = product['quoteCurrency'];
            let isFuturesContract = id != (base + quote);
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let symbol = isFuturesContract ? id : (base + '/' + quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privateGetUserMargin ({ 'currency': 'all' });
    },

    fetchOrderBook (product) {
        return this.publicGetOrderBookL2 ({
            'symbol': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let request = {
            'symbol': this.productId (product),
            'binSize': '1d',
            'partial': true,
            'count': 1,
            'reverse': true,            
        };
        let quotes = await this.publicGetQuoteBucketed (request);
        let quotesLength = quotes.length;
        let quote = quotes[quotesLength - 1];
        let tickers = await this.publicGetTradeBucketed (request);
        let ticker = tickers[0];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (quote['bidPrice']),
            'ask': parseFloat (quote['askPrice']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': parseFloat (ticker['close']),
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['homeNotional']),
            'quoteVolume': parseFloat (ticker['foreignNotional']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrade ({
            'symbol': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'symbol': this.productId (product),
            'side': this.capitalize (side),
            'orderQty': amount,
            'ordType': this.capitalize (type),
        };
        if (type == 'limit')
            order['rate'] = price;
        return this.privatePostOrder (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let query = '/api/' + this.version + '/' + path;
        if (Object.keys (params).length)
            query += '?' + this.urlencode (params);
        let url = this.urls['api'] + query;
        if (type == 'private') {
            let nonce = this.nonce ();
            if (method == 'POST')
                if (Object.keys (params).length)
                    body = JSON.stringify (params);
            let request = [ method, query, nonce.toString (), body || ''].join ('');
            headers = {
                'Content-Type': 'application/json',
                'api-nonce': nonce,
                'api-key': this.apiKey,
                'api-signature': this.hmac (request, this.secret),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bitso = {

    'id': 'bitso',
    'name': 'Bitso',
    'countries': 'MX', // Mexico
    'rateLimit': 2000, // 30 requests per minute
    'version': 'v3',
    'urls': {
        'api': 'https://api.bitso.com',
        'www': 'https://bitso.com',
        'docs': 'https://bitso.com/api_info',
    },
    'api': {
        'public': {
            'get': [
                'available_books',
                'ticker',
                'order_book',
                'trades',
            ],
        },
        'private': {
            'get': [
                'account_status',
                'balance',
                'fees',
                'fundings',
                'fundings/{fid}',
                'funding_destination',
                'kyc_documents',
                'ledger',
                'ledger/trades',
                'ledger/fees',
                'ledger/fundings',
                'ledger/withdrawals',
                'mx_bank_codes',
                'open_orders',
                'order_trades/{oid}',
                'orders/{oid}',
                'user_trades',
                'user_trades/{tid}',
                'withdrawals/',
                'withdrawals/{wid}',
            ],
            'post': [
                'bitcoin_withdrawal',
                'debit_card_withdrawal',
                'ether_withdrawal',
                'orders',
                'phone_number',
                'phone_verification',
                'phone_withdrawal',
                'spei_withdrawal',
            ],
            'delete': [
                'orders/{oid}',
                'orders/all',
            ],
        }
    },

    async fetchProducts () {
        let products = await this.publicGetAvailableBooks ();
        let result = [];
        for (let p = 0; p < products['payload'].length; p++) {
            let product = products['payload'][p];
            let id = product['book'];
            let symbol = id.toUpperCase ().replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privateGetBalance ();
    },

    fetchOrderBook (product) { 
        return this.publicGetOrderBook ({
            'book': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let response = await this.publicGetTicker ({
            'book': this.productId (product),
        });
        let ticker = response['payload'];
        let timestamp = this.parse8601 (ticker['created_at']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ({
            'book': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'book': this.productId (product),
            'side': side,
            'type': type,
            'major': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        return this.privatePostOrders (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let query = '/' + this.version + '/' + this.implodeParams (path, params);
        let url = this.urls['api'] + query;
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            if (Object.keys (params).length)
                body = JSON.stringify (params);
            let nonce = this.nonce ().toString ();
            let request = [ nonce, method, query, body || '' ].join ('');
            let signature = this.hmac (request, this.secret);
            let auth = this.apiKey + ':' + nonce + ':' + signature;
            headers = { 'Authorization': "Bitso " + auth };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bittrex = {

    'id': 'bittrex',
    'name': 'Bittrex',
    'countries': 'US',
    'version': 'v1.1',
    'rateLimit': 2000,
    'urls': {
        'api': 'https://bittrex.com/api',
        'www': 'https://bittrex.com',
        'docs': [ 
            'https://bittrex.com/Home/Api',
            'https://www.npmjs.org/package/node.bittrex.api',
        ],
    },
    'api': {
        'public': {
            'get': [
                'currencies',
                'markethistory',
                'markets',
                'marketsummaries',
                'marketsummary',
                'orderbook',
                'ticker',            
            ],
        },
        'account': {
            'get': [
                'balance',
                'balances',
                'depositaddress',
                'deposithistory',
                'order',
                'orderhistory',
                'withdrawalhistory',
                'withdraw',
            ],
        },
        'market': {
            'get': [
                'buylimit',
                'buymarket',
                'cancel',
                'openorders',
                'selllimit',
                'sellmarket',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < products['result'].length; p++) {
            let product = products['result'][p];
            let id = product['MarketName'];
            let base = product['BaseCurrency'];
            let quote = product['MarketCurrency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.accountGetBalances ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ({
            'market': this.productId (product),
            'type': 'both',
            'depth': 50,
        });
    },

    async fetchTicker (product) {
        let response = await this.publicGetMarketsummary ({
            'market': this.productId (product),
        });
        let ticker = response['result'][0];
        let timestamp = this.parse8601 (ticker['TimeStamp']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['High']),
            'low': parseFloat (ticker['Low']),
            'bid': parseFloat (ticker['Bid']),
            'ask': parseFloat (ticker['Ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['Last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['Volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetMarkethistory ({ 
            'market': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'marketGet' + this.capitalize (side) + type;
        let order = {
            'market': this.productId (product),
            'quantity': amount,
        };
        if (type == 'limit')
            order['rate'] = price;
        return this[method] (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/';
        if (type == 'public') {
            url += type + '/' + method.toLowerCase () + path;
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ();
            url += type + '/';
            if (((type == 'account') && (path != 'withdraw')) || (path == 'openorders'))
                url += method.toLowerCase ();
            url += path + '?' + this.urlencode (this.extend ({
                'nonce': nonce,
                'apikey': this.apiKey,
            }, params));
            headers = { 'apisign': this.hmac (url, this.secret, 'sha512') };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var btcx = {

    'id': 'btcx',
    'name': 'BTCX',
    'countries': [ 'IS', 'US', 'EU', ],
    'rateLimit': 3000, // support in english is very poor, unable to tell rate limits
    'version': 'v1',
    'urls': {
        'api': 'https://btc-x.is/api',
        'www': 'https://btc-x.is',
        'docs': 'https://btc-x.is/custom/api-document.html',
    },
    'api': {
        'public': {
            'get': [
                'depth/{id}/{limit}',
                'ticker/{id}',         
                'trade/{id}/{limit}',
            ],
        },
        'private': {
            'post': [
                'balance',
                'cancel',
                'history',
                'order',
                'redeem',
                'trade',
                'withdraw',
            ],
        },
    },
    'products': {
        'BTC/USD': { 'id': 'btc/usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/EUR': { 'id': 'btc/eur', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    fetchOrderBook (product) { 
        let p = this.product (product);
        return this.publicGetDepthIdLimit ({ 
            'id': this.productId (product),
            'limit': 1000,
        });
    },

    async fetchTicker (product) { 
        let ticker = await this.publicGetTickerId ({
            'id': this.productId (product),
        });
        let timestamp = ticker['time'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTradeIdLimit ({
            'id': this.productId (product),
            'limit': 100,
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostTrade (this.extend ({
            'type': side.toUpperCase (),
            'market': this.productId (product),
            'amount': amount,
            'price': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/';
        if (type == 'public') {
            url += this.implodeParams (path, params);
        } else {
            let nonce = this.nonce ();
            url += type;
            body = this.urlencode (this.extend ({
                'Method': path.toUpperCase (),
                'Nonce': nonce,
            }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Key': this.apiKey,
                'Signature': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var bxinth = {

    'id': 'bxinth',
    'name': 'BX.in.th',
    'countries': 'TH', // Thailand
    'rateLimit': 2000,
    'urls': {
        'api': 'https://bx.in.th/api',
        'www': 'https://bx.in.th',
        'docs': 'https://bx.in.th/info/api',
    },
    'api': {
        'public': {
            'get': [
                '', // ticker
                'options',
                'optionbook',
                'orderbook',
                'pairing',
                'trade',
                'tradehistory',
            ],
        },
        'private': {
            'post': [
                'balance',
                'biller',
                'billgroup',
                'billpay',
                'cancel',
                'deposit',
                'getorders',
                'history',
                'option-issue',
                'option-bid',
                'option-sell',
                'option-myissue',
                'option-mybid',
                'option-myoptions',
                'option-exercise',
                'option-cancel',
                'option-history',
                'order',
                'withdrawal',
                'withdrawal-history',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetPairing ();
        let keys = Object.keys (products);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let product = products[keys[p]];
            let id = product['pairing_id'];
            let base = product['primary_currency'];
            let quote = product['secondary_currency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ({
            'pairing': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let tickers = await this.publicGet ({ 'pairing': p['id'] });
        let ticker = tickers[p['id']];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': parseFloat (ticker['orderbook']['bids']['highbid']),
            'ask': parseFloat (ticker['orderbook']['asks']['highbid']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_price']),
            'change': parseFloat (ticker['change']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume_24hours']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrade ({
            'pairing': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostOrder (this.extend ({
            'pairing': this.productId (product),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path + '/';
        if (Object.keys (params).length)
            url += '?' + this.urlencode (params);
        if (type == 'private') {
            let nonce = this.nonce ();
            let signature = this.hash (this.apiKey + nonce + this.secret, 'sha256');
            body = this.urlencode (this.extend ({
                'key': this.apiKey,
                'nonce': nonce,
                'signature': signature,
                // twofa: this.twofa,
            }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var ccex = {

    'id': 'ccex',
    'name': 'C-CEX',
    'countries': [ 'DE', 'EU', ],
    'rateLimit': 2000,
    'urls': {
        'api': {
            'tickers': 'https://c-cex.com/t',
            'public': 'https://c-cex.com/t/api_pub.html',
            'private': 'https://c-cex.com/t/api.html',
        },
        'www': 'https://c-cex.com',
        'docs': 'https://c-cex.com/?id=api',
    },
    'api': {
        'tickers': {
            'get': [
                'coinnames',
                '{market}',
                'pairs',
                'prices',
                'volume_{coin}',
            ],
        },
        'public': {
            'get': [                
                'balancedistribution',
                'markethistory',
                'markets',
                'marketsummaries',
                'orderbook',
            ],
        },
        'private': {            
            'get': [
                'buylimit',
                'cancel',
                'getbalance',
                'getbalances',                
                'getopenorders',
                'getorder',
                'getorderhistory',
                'mytrades',
                'selllimit',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < products['result'].length; p++) {
            let product = products['result'][p];
            let id = product['MarketName'];
            let base = product['MarketCurrency'];
            let quote = product['BaseCurrency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privateGetBalances ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ({
            'market': this.productId (product),
            'type': 'both',
            'depth': 100,
        });
    },

    async fetchTicker (product) {
        let response = await this.tickersGetMarket ({
            'market': this.productId (product).toLowerCase (),
        });
        let ticker = response['ticker'];
        let timestamp = ticker['updated'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['lastprice']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['avg']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['buysupport']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetMarkethistory ({
            'market': this.productId (product),
            'type': 'both',
            'depth': 100,
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privateGet' + this.capitalize (side) + type;
        return this[method] (this.extend ({
            'market': this.productId (product),
            'quantity': amount,
            'rate': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        if (type == 'private') {
            let nonce = this.nonce ().toString ();
            let query = this.keysort (this.extend ({
                'a': path,
                'apikey': this.apiKey,
                'nonce': nonce,
            }, params));
            url += '?' + this.urlencode (query);
            headers = { 'apisign': this.hmac (url, this.secret, 'sha512') };
        } else if (type == 'public') {
            url += '?' + this.urlencode (this.extend ({
                'a': 'get' + path,
            }, params));
        } else {
            url += '/' + this.implodeParams (path, params) + '.json';
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var cex = {

    'id': 'cex',
    'name': 'CEX.IO',
    'countries': [ 'UK', 'EU', 'CY', 'RU', ],
    'rateLimit': 2000,
    'urls': {
        'api': 'https://cex.io/api',
        'www': 'https://cex.io',
        'docs': 'https://cex.io/cex-api',
    },
    'api': {
        'public': {
            'get': [
                'currency_limits',
                'last_price/{pair}',
                'last_prices/{currencies}',
                'ohlcv/hd/{yyyymmdd}/{pair}',
                'order_book/{pair}',
                'ticker/{pair}',
                'tickers/{currencies}',
                'trade_history/{pair}',
            ],
            'post': [
                'convert/{pair}',
                'price_stats/{pair}',
            ],
        },
        'private': {
            'post': [
                'active_orders_status/',
                'archived_orders/{pair}',
                'balance/',
                'cancel_order/',
                'cancel_orders/{pair}',
                'cancel_replace_order/{pair}',
                'close_position/{pair}',
                'get_address/',
                'get_myfee/',
                'get_order/',
                'get_order_tx/',
                'open_orders/{pair}',
                'open_orders/',
                'open_position/{pair}',
                'open_positions/{pair}',
                'place_order/{pair}',
                'place_order/{pair}',
            ],
        }
    },

    async fetchProducts () {
        let products = await this.publicGetCurrencyLimits ();
        let result = [];
        for (let p = 0; p < products['data']['pairs'].length; p++) {
            let product = products['data']['pairs'][p];
            let id = product['symbol1'] + '/' + product['symbol2'];
            let symbol = id;
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderBookPair ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTickerPair ({
            'pair': this.productId (product),
        });
        let timestamp = parseInt (ticker['timestamp']) * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': parseFloat (ticker['change']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTradeHistoryPair ({
            'pair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'pair': this.productId (product),
            'type': side,
            'amount': amount,            
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['order_type'] = type;
        return this.privatePostPlaceOrderPair (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (type == 'public') {   
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ().toString ();
            body = this.urlencode (this.extend ({
                'key': this.apiKey,
                'signature': this.hmac (nonce + this.uid + this.apiKey, this.secret).toUpperCase (),
                'nonce': nonce,
            }, query));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var coincheck = {

    'id': 'coincheck',
    'name': 'coincheck',
    'countries': [ 'JP', 'ID', ],
    'rateLimit': 2000,
    'urls': {
        'api': 'https://coincheck.com/api',
        'www': 'https://coincheck.com',
        'docs': 'https://coincheck.com/documents/exchange/api',
    },
    'api': {
        'public': {
            'get': [
                'exchange/orders/rate',
                'order_books',
                'rate/{pair}',
                'ticker',
                'trades',
            ],
        },
        'private': {
            'get': [
                'accounts',
                'accounts/balance',
                'accounts/leverage_balance',
                'bank_accounts',
                'deposit_money',
                'exchange/orders/opens',
                'exchange/orders/transactions',
                'exchange/orders/transactions_pagination',
                'exchange/leverage/positions',
                'lending/borrows/matches',
                'send_money',
                'withdraws',
            ],            
            'post': [
                'bank_accounts',
                'deposit_money/{id}/fast',
                'exchange/orders',
                'exchange/transfers/to_leverage',
                'exchange/transfers/from_leverage',
                'lending/borrows',
                'lending/borrows/{id}/repay',
                'send_money',
                'withdraws',
            ],
            'delete': [
                'bank_accounts/{id}',
                'exchange/orders/{id}',
                'withdraws/{id}',
            ],
        },
    },
    'products': {
        'BTC/JPY':  { 'id': 'btc_jpy',  'symbol': 'BTC/JPY',  'base': 'BTC',  'quote': 'JPY' }, // the only real pair
        'ETH/JPY':  { 'id': 'eth_jpy',  'symbol': 'ETH/JPY',  'base': 'ETH',  'quote': 'JPY' },
        'ETC/JPY':  { 'id': 'etc_jpy',  'symbol': 'ETC/JPY',  'base': 'ETC',  'quote': 'JPY' },
        'DAO/JPY':  { 'id': 'dao_jpy',  'symbol': 'DAO/JPY',  'base': 'DAO',  'quote': 'JPY' },
        'LSK/JPY':  { 'id': 'lsk_jpy',  'symbol': 'LSK/JPY',  'base': 'LSK',  'quote': 'JPY' },
        'FCT/JPY':  { 'id': 'fct_jpy',  'symbol': 'FCT/JPY',  'base': 'FCT',  'quote': 'JPY' },
        'XMR/JPY':  { 'id': 'xmr_jpy',  'symbol': 'XMR/JPY',  'base': 'XMR',  'quote': 'JPY' },
        'REP/JPY':  { 'id': 'rep_jpy',  'symbol': 'REP/JPY',  'base': 'REP',  'quote': 'JPY' },
        'XRP/JPY':  { 'id': 'xrp_jpy',  'symbol': 'XRP/JPY',  'base': 'XRP',  'quote': 'JPY' },
        'ZEC/JPY':  { 'id': 'zec_jpy',  'symbol': 'ZEC/JPY',  'base': 'ZEC',  'quote': 'JPY' },
        'XEM/JPY':  { 'id': 'xem_jpy',  'symbol': 'XEM/JPY',  'base': 'XEM',  'quote': 'JPY' },
        'LTC/JPY':  { 'id': 'ltc_jpy',  'symbol': 'LTC/JPY',  'base': 'LTC',  'quote': 'JPY' },
        'DASH/JPY': { 'id': 'dash_jpy', 'symbol': 'DASH/JPY', 'base': 'DASH', 'quote': 'JPY' },
        'ETH/BTC':  { 'id': 'eth_btc',  'symbol': 'ETH/BTC',  'base': 'ETH',  'quote': 'BTC' },
        'ETC/BTC':  { 'id': 'etc_btc',  'symbol': 'ETC/BTC',  'base': 'ETC',  'quote': 'BTC' },
        'LSK/BTC':  { 'id': 'lsk_btc',  'symbol': 'LSK/BTC',  'base': 'LSK',  'quote': 'BTC' },
        'FCT/BTC':  { 'id': 'fct_btc',  'symbol': 'FCT/BTC',  'base': 'FCT',  'quote': 'BTC' },
        'XMR/BTC':  { 'id': 'xmr_btc',  'symbol': 'XMR/BTC',  'base': 'XMR',  'quote': 'BTC' },
        'REP/BTC':  { 'id': 'rep_btc',  'symbol': 'REP/BTC',  'base': 'REP',  'quote': 'BTC' },
        'XRP/BTC':  { 'id': 'xrp_btc',  'symbol': 'XRP/BTC',  'base': 'XRP',  'quote': 'BTC' },
        'ZEC/BTC':  { 'id': 'zec_btc',  'symbol': 'ZEC/BTC',  'base': 'ZEC',  'quote': 'BTC' },
        'XEM/BTC':  { 'id': 'xem_btc',  'symbol': 'XEM/BTC',  'base': 'XEM',  'quote': 'BTC' },
        'LTC/BTC':  { 'id': 'ltc_btc',  'symbol': 'LTC/BTC',  'base': 'LTC',  'quote': 'BTC' },
        'DASH/BTC': { 'id': 'dash_btc', 'symbol': 'DASH/BTC', 'base': 'DASH', 'quote': 'BTC' },
    },

    fetchBalance () {
        return this.privateGetAccountsBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderBooks ();
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTicker ();
        let timestamp = ticker['timestamp'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let prefix = '';
        let order = {
            'pair': this.productId (product),
        };
        if (type == 'market') {
            let order_type = type + '_' + side;
            order['order_type'] = order_type;
            let prefix = (side == buy) ? (order_type + '_') : '';
            order[prefix + 'amount'] = amount;
        } else {
            order['order_type'] = side;
            order['rate'] = price;
            order['amount'] = amount;
        }
        return this.privatePostExchangeOrders (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (type == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ().toString ();
            if (Object.keys (query).length)
                body = this.urlencode (this.keysort (query));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'ACCESS-KEY': this.apiKey,
                'ACCESS-NONCE': nonce,
                'ACCESS-SIGNATURE': this.hmac (nonce + url + (body || ''), this.secret)
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var coinsecure = {

    'id': 'coinsecure',
    'name': 'Coinsecure',
    'countries': 'IN', // India
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'api': 'https://api.coinsecure.in',
        'www': 'https://coinsecure.in',
        'docs': [
            'https://api.coinsecure.in',
            'https://github.com/coinsecure/plugins',
        ],
    },
    'api': {
        'public': {
            'get': [
                'bitcoin/search/confirmation/{txid}',
                'exchange/ask/low',
                'exchange/ask/orders',
                'exchange/bid/high',
                'exchange/bid/orders',
                'exchange/lastTrade',
                'exchange/max24Hr',
                'exchange/min24Hr',
                'exchange/ticker',
                'exchange/trades',
            ],
        },
        'private': {
            'get': [
                'mfa/authy/call',
                'mfa/authy/sms',            
                'netki/search/{netkiName}',
                'user/bank/otp/{number}',
                'user/kyc/otp/{number}',
                'user/profile/phone/otp/{number}',
                'user/wallet/coin/address/{id}',
                'user/wallet/coin/deposit/confirmed/all',
                'user/wallet/coin/deposit/confirmed/{id}',
                'user/wallet/coin/deposit/unconfirmed/all',
                'user/wallet/coin/deposit/unconfirmed/{id}',
                'user/wallet/coin/wallets',
                'user/exchange/bank/fiat/accounts',
                'user/exchange/bank/fiat/balance/available',
                'user/exchange/bank/fiat/balance/pending',
                'user/exchange/bank/fiat/balance/total',
                'user/exchange/bank/fiat/deposit/cancelled',
                'user/exchange/bank/fiat/deposit/unverified',
                'user/exchange/bank/fiat/deposit/verified',
                'user/exchange/bank/fiat/withdraw/cancelled',
                'user/exchange/bank/fiat/withdraw/completed',
                'user/exchange/bank/fiat/withdraw/unverified',
                'user/exchange/bank/fiat/withdraw/verified',
                'user/exchange/ask/cancelled',
                'user/exchange/ask/completed',
                'user/exchange/ask/pending',
                'user/exchange/bid/cancelled',
                'user/exchange/bid/completed',
                'user/exchange/bid/pending',
                'user/exchange/bank/coin/addresses',
                'user/exchange/bank/coin/balance/available',
                'user/exchange/bank/coin/balance/pending',
                'user/exchange/bank/coin/balance/total',
                'user/exchange/bank/coin/deposit/cancelled',
                'user/exchange/bank/coin/deposit/unverified',
                'user/exchange/bank/coin/deposit/verified',
                'user/exchange/bank/coin/withdraw/cancelled',
                'user/exchange/bank/coin/withdraw/completed',
                'user/exchange/bank/coin/withdraw/unverified',
                'user/exchange/bank/coin/withdraw/verified',
                'user/exchange/bank/summary',
                'user/exchange/coin/fee',
                'user/exchange/fiat/fee',
                'user/exchange/kycs',
                'user/exchange/referral/coin/paid',
                'user/exchange/referral/coin/successful',
                'user/exchange/referral/fiat/paid',
                'user/exchange/referrals',
                'user/exchange/trade/summary',
                'user/login/token/{token}',
                'user/summary',
                'user/wallet/summary',
                'wallet/coin/withdraw/cancelled',
                'wallet/coin/withdraw/completed',
                'wallet/coin/withdraw/unverified',
                'wallet/coin/withdraw/verified',
            ],
            'post': [
                'login',
                'login/initiate',
                'login/password/forgot',
                'mfa/authy/initiate',
                'mfa/ga/initiate',
                'signup',
                'user/netki/update',
                'user/profile/image/update',
                'user/exchange/bank/coin/withdraw/initiate',
                'user/exchange/bank/coin/withdraw/newVerifycode',
                'user/exchange/bank/fiat/withdraw/initiate',
                'user/exchange/bank/fiat/withdraw/newVerifycode',
                'user/password/change',
                'user/password/reset',
                'user/wallet/coin/withdraw/initiate',
                'wallet/coin/withdraw/newVerifycode',
            ],
            'put': [
                'signup/verify/{token}',
                'user/exchange/kyc',
                'user/exchange/bank/fiat/deposit/new',
                'user/exchange/ask/new',
                'user/exchange/bid/new',
                'user/exchange/instant/buy',
                'user/exchange/instant/sell',
                'user/exchange/bank/coin/withdraw/verify',
                'user/exchange/bank/fiat/account/new',
                'user/exchange/bank/fiat/withdraw/verify',
                'user/mfa/authy/initiate/enable',
                'user/mfa/ga/initiate/enable',
                'user/netki/create',
                'user/profile/phone/new',
                'user/wallet/coin/address/new',
                'user/wallet/coin/new',
                'user/wallet/coin/withdraw/sendToExchange',
                'user/wallet/coin/withdraw/verify',
            ],
            'delete': [
                'user/gcm/{code}',
                'user/logout',
                'user/exchange/bank/coin/withdraw/unverified/cancel/{withdrawID}',
                'user/exchange/bank/fiat/deposit/cancel/{depositID}',
                'user/exchange/ask/cancel/{orderID}',
                'user/exchange/bid/cancel/{orderID}',
                'user/exchange/bank/fiat/withdraw/unverified/cancel/{withdrawID}',
                'user/mfa/authy/disable/{code}',
                'user/mfa/ga/disable/{code}',
                'user/profile/phone/delete',
                'user/profile/image/delete/{netkiName}',
                'user/wallet/coin/withdraw/unverified/cancel/{withdrawID}',
            ],
        },
    },
    'products': {
        'BTC/INR': { 'id': 'BTC/INR', 'symbol': 'BTC/INR', 'base': 'BTC', 'quote': 'INR' },
    },

    fetchBalance () {
        return this.privateGetUserExchangeBankSummary ();
    },

    fetchOrderBook (product) { 
        return this.publicGetExchangeAskOrders ();
    },

    async fetchTicker (product) {
        let response = await this.publicGetExchangeTicker ();
        let ticker = response['message'];
        let timestamp = ticker['timestamp'];
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['lastPrice']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['coinvolume']),
            'quoteVolume': parseFloat (ticker['fiatvolume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetExchangeTrades ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePutUserExchange';
        let order = {};
        if (type == 'market') {       
            method += 'Instant' + this.capitalize (side);
            if (side == 'buy')
                order['maxFiat'] = amount;
            else
                order['maxVol'] = amount;
        } else {
            let direction = (side == 'buy') ? 'Bid' : 'Ask';
            method += direction + 'New';
            order['rate'] = price;
            order['vol'] = amount;
        }
        return this[method] (self.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (type == 'private') {
            headers = { 'Authorization': this.apiKey };
            if (Object.keys (query).length) {
                body = JSON.stringify (query);
                headers['Content-Type'] = 'application/json';
            }
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var exmo = {

    'id': 'exmo',
    'name': 'EXMO',
    'countries': [ 'ES', 'RU', ], // Spain, Russia
    'rateLimit': 1000, // once every 350 ms ≈ 180 requests per minute ≈ 3 requests per second
    'version': 'v1',
    'urls': {
        'api': 'https://api.exmo.com',
        'www': 'https://exmo.me',
        'docs': [
            'https://exmo.me/ru/api_doc',
            'https://github.com/exmo-dev/exmo_api_lib/tree/master/nodejs',
        ],
    },
    'api': {
        'public': {
            'get': [
                'currency',
                'order_book',
                'pair_settings',
                'ticker',
                'trades',
            ],
        },
        'private': {
            'post': [
                'user_info',
                'order_create',
                'order_cancel',
                'user_open_orders',
                'user_trades',
                'user_cancelled_orders',
                'order_trades',
                'required_amount',
                'deposit_address',
                'withdraw_crypt',
                'withdraw_get_txid',
                'excode_create',
                'excode_load',
                'wallet_history',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetPairSettings ();
        let keys = Object.keys (products);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let product = products[id];
            let symbol = id.replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostUserInfo ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderBook ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let response = await this.publicGetTicker ();
        let p = this.product (product);
        let ticker = response[p['id']];
        let timestamp = ticker['updated'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy_price']),
            'ask': parseFloat (ticker['sell_price']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_trade']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['avg']),
            'baseVolume': parseFloat (ticker['vol']),
            'quoteVolume': parseFloat (ticker['vol_curr']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ({
            'pair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let prefix = '';
        if (type =='market')
            prefix = 'market_';
        let order = {
            'pair': this.productId (product),
            'quantity': amount,
            'price': price || 0,
            'type': prefix + side,
        };
        return this.privatePostOrderCreate (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({ 'nonce': nonce }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Key': this.apiKey,
                'Sign': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var fyb = {

    'rateLimit': 2000,
    'api': {
        'public': {
            'get': [
                'ticker',
                'tickerdetailed',
                'orderbook',
                'trades',
            ],
        },
        'private': {
            'post': [
                'test',
                'getaccinfo',
                'getpendingorders',
                'getorderhistory',
                'cancelpendingorder',
                'placeorder',
                'withdraw',
            ],
        },
    },

    fetchBalance () {
        return this.privatePostGetaccinfo ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ();
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTickerdetailed ();
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostPlaceorder (this.extend ({
            'qty': amount,
            'price': price,
            'type': side[0].toUpperCase ()
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path;
        if (type == 'public') {           
            url += '.json';
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({ 'timestamp': nonce }, params));
            headers = {
                'Content-type': 'application/x-www-form-urlencoded',
                'key': this.apiKey,
                'sig': this.hmac (body, this.secret, 'sha1')
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var fybse = extend (fyb, {
    'id': 'fybse',
    'name': 'FYB-SE',
    'countries': 'SE', // Sweden
    'urls': {
        'api': 'https://www.fybse.se/api/SEK',
        'www': 'https://www.fybse.se',
        'docs': 'http://docs.fyb.apiary.io',
    },
    'products': {
        'BTC/SEK': { 'id': 'SEK', 'symbol': 'BTC/SEK', 'base': 'BTC', 'quote': 'SEK' },
    },
})

//-----------------------------------------------------------------------------

var fybsg = extend (fyb, {
    'id': 'fybsg',
    'name': 'FYB-SG',
    'countries': 'SG', // Singapore
    'urls': {
        'api': 'https://www.fybsg.com/api/SGD',
        'www': 'https://www.fybsg.com',
        'docs': 'http://docs.fyb.apiary.io',
    },
    'products': {
        'BTC/SGD': { 'id': 'SGD', 'symbol': 'BTC/SGD', 'base': 'BTC', 'quote': 'SGD' },
    },
})

//-----------------------------------------------------------------------------

var hitbtc = {

    'id': 'hitbtc',
    'name': 'HitBTC',
    'countries': 'HK', // Hong Kong
    'rateLimit': 2000,
    'version': 1,
    'urls': {
        'api': 'http://api.hitbtc.com',
        'www': 'https://hitbtc.com',
        'docs': [
            'https://hitbtc.com/api',
            'http://hitbtc-com.github.io/hitbtc-api',
            'http://jsfiddle.net/bmknight/RqbYB',
        ],
    },
    'api': {
        'public': {
            'get': [
                '{symbol}/orderbook',
                '{symbol}/ticker',
                '{symbol}/trades',
                '{symbol}/trades/recent',
                'symbols',
                'ticker',
                'time,'
            ],
        },
        'trading': {
            'get': [
                'balance',
                'orders/active',
                'orders/recent',
                'order',
                'trades/by/order',
                'trades',
            ],
            'post': [
                'new_order',
                'cancel_order',
                'cancel_orders',
            ],
        },
        'payment': {
            'get': [
                'balance',
                'address/{currency}',
                'transactions',
                'transactions/{transaction}',
            ],
            'post': [
                'transfer_to_trading',
                'transfer_to_main',
                'address/{currency}',
                'payout',
            ],
        }
    },

    async fetchProducts () {
        let products = await this.publicGetSymbols ();
        let result = [];
        for (let p = 0; p < products['symbols'].length; p++) {
            let product = products['symbols'][p];
            let id = product['symbol'];
            let base = product['commodity'];
            let quote = product['currency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.tradingGetBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetSymbolOrderbook ({
            'symbol': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetSymbolTicker ({
            'symbol': this.productId (product),
        });
        let timestamp = ticker['timestamp'];
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['volume']),
            'quoteVolume': parseFloat (ticker['volume_quote']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetSymbolTrades ({
            'symbol': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'clientOrderId': this.nonce (),
            'symbol': this.productId (product),
            'side': side,
            'quantity': amount,
            'type': type,            
        };
        if (type == 'limit')
            order['price'] = price;
        return this.tradingPostNewOrder (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/api/' + this.version + '/' + type + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (type == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            query = this.extend ({ 'nonce': nonce, 'apikey': this.apiKey }, query);
            if (method == 'POST')
                if (Object.keys (query).length)
                    body = this.urlencode (query);
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'X-Signature': this.hmac (url + (body || ''), this.secret, 'sha512').toLowerCase (),
            };
        }
        url = this.urls['api'] + url;
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var huobi = {

    'id': 'huobi',
    'name': 'Huobi',
    'countries': 'CN',
    'rateLimit': 5000,
    'version': 'v3',
    'urls': {
        'api': 'http://api.huobi.com',
        'www': 'https://www.huobi.com',
        'docs': 'https://github.com/huobiapi/API_Docs_en/wiki',
    },
    'api': {
        'staticmarket': {
            'get': [
                '{id}_kline_{period}',
                'ticker_{id}',
                'depth_{id}',
                'depth_{id}_{length}',
                'detail_{id}',
            ],
        },
        'usdmarket': {
            'get': [
                '{id}_kline_{period}',
                'ticker_{id}',
                'depth_{id}',
                'depth_{id}_{length}',
                'detail_{id}',
            ],
        },
        'trade': {
            'post': [
                'get_account_info',
                'get_orders',
                'order_info',
                'buy',
                'sell',
                'buy_market',
                'sell_market',
                'cancel_order',
                'get_new_deal_orders',
                'get_order_id_by_trade_id',
                'withdraw_coin',
                'cancel_withdraw_coin',
                'get_withdraw_coin_result',
                'transfer',
                'loan',
                'repayment',
                'get_loan_available',
                'get_loans',
            ],            
        },
    },
    'products': {
        'BTC/CNY': { 'id': 'btc', 'symbol': 'BTC/CNY', 'base': 'BTC', 'quote': 'CNY', 'type': 'staticmarket', 'coinType': 1, },
        'LTC/CNY': { 'id': 'ltc', 'symbol': 'LTC/CNY', 'base': 'LTC', 'quote': 'CNY', 'type': 'staticmarket', 'coinType': 2, },
        'BTC/USD': { 'id': 'btc', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD', 'type': 'usdmarket',    'coinType': 1, },
    },

    fetchBalance () {
        return this.tradePostGetAccountInfo ();
    },

    fetchOrderBook (product) {
        let p = this.product (product);
        let method = p['type'] + 'GetDepthId';
        return this[method] ({ 'id': p['id'] });
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let method = p['type'] + 'GetTickerId';
        let response = await this[method] ({ 'id': p['id'] });
        let ticker = response['ticker'];
        let timestamp = parseInt (response['time']) * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        let p = this.product (product);
        let method = p['type'] + 'GetDetailId';
        return this[method] ({ 'id': p['id'] });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let p = this.product (product);
        let method = 'tradePost' + this.capitalize (side);
        let order = {
            'coin_type': p['coinType'],
            'amount': amount,
            'market': p['quote'].toLowerCase (),
        };
        if (type == 'limit')
            order['price'] = price;
        else
            method += this.capitalize (type);
        return this[method] (this.extend (order, params));
    },

    request (path, type = 'trade', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'];
        if (type == 'trade') {
            url += '/api' + this.version;
            let query = this.keysort (this.extend ({
                'method': path,
                'access_key': this.apiKey,
                'created': this.nonce (),
            }, params));
            let queryString = this.urlencode (this.omit (query, 'market'));
            // secret key must be at the end of query to be signed
            queryString += '&secret_key=' + this.secret;
            query['sign'] = this.hash (queryString);
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        } else {
            url += '/' + type + '/' + this.implodeParams (path, params) + '_json.js';
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var jubi = {

    'id': 'jubi',
    'name': 'jubi.com',
    'countries': 'CN',
    'rateLimit': 2000,
    'version': 'v1',
    'urls': {
        'api': 'https://www.jubi.com/api',
        'www': 'https://www.jubi.com',
        'docs': 'https://www.jubi.com/help/api.html',
    },
    'api': {
        'public': {
            'get': [
                'depth',
                'orders',
                'ticker',
            ],
        },
        'private': {
            'post': [
                'balance',
                'trade_add',
                'trade_cancel',
                'trade_list',
                'trade_view',
                'wallet',
            ],
        },
    },
    'products': {
        'BTC/CNY':  { 'id': 'btc',  'symbol': 'BTC/CNY',  'base': 'BTC',  'quote': 'CNY' },
        'ETH/CNY':  { 'id': 'eth',  'symbol': 'ETH/CNY',  'base': 'ETH',  'quote': 'CNY' },
        'ANS/CNY':  { 'id': 'ans',  'symbol': 'ANS/CNY',  'base': 'ANS',  'quote': 'CNY' },
        'BLK/CNY':  { 'id': 'blk',  'symbol': 'BLK/CNY',  'base': 'BLK',  'quote': 'CNY' },
        'DNC/CNY':  { 'id': 'dnc',  'symbol': 'DNC/CNY',  'base': 'DNC',  'quote': 'CNY' },
        'DOGE/CNY': { 'id': 'doge', 'symbol': 'DOGE/CNY', 'base': 'DOGE', 'quote': 'CNY' },
        'EAC/CNY':  { 'id': 'eac',  'symbol': 'EAC/CNY',  'base': 'EAC',  'quote': 'CNY' },
        'ETC/CNY':  { 'id': 'etc',  'symbol': 'ETC/CNY',  'base': 'ETC',  'quote': 'CNY' },
        'FZ/CNY':   { 'id': 'fz',   'symbol': 'FZ/CNY',   'base': 'FZ',   'quote': 'CNY' },
        'GOOC/CNY': { 'id': 'gooc', 'symbol': 'GOOC/CNY', 'base': 'GOOC', 'quote': 'CNY' },
        'GAME/CNY': { 'id': 'game', 'symbol': 'GAME/CNY', 'base': 'GAME', 'quote': 'CNY' },
        'HLB/CNY':  { 'id': 'hlb',  'symbol': 'HLB/CNY',  'base': 'HLB',  'quote': 'CNY' },
        'IFC/CNY':  { 'id': 'ifc',  'symbol': 'IFC/CNY',  'base': 'IFC',  'quote': 'CNY' },
        'JBC/CNY':  { 'id': 'jbc',  'symbol': 'JBC/CNY',  'base': 'JBC',  'quote': 'CNY' },
        'KTC/CNY':  { 'id': 'ktc',  'symbol': 'KTC/CNY',  'base': 'KTC',  'quote': 'CNY' },
        'LKC/CNY':  { 'id': 'lkc',  'symbol': 'LKC/CNY',  'base': 'LKC',  'quote': 'CNY' },
        'LSK/CNY':  { 'id': 'lsk',  'symbol': 'LSK/CNY',  'base': 'LSK',  'quote': 'CNY' },
        'LTC/CNY':  { 'id': 'ltc',  'symbol': 'LTC/CNY',  'base': 'LTC',  'quote': 'CNY' },
        'MAX/CNY':  { 'id': 'max',  'symbol': 'MAX/CNY',  'base': 'MAX',  'quote': 'CNY' },
        'MET/CNY':  { 'id': 'met',  'symbol': 'MET/CNY',  'base': 'MET',  'quote': 'CNY' },
        'MRYC/CNY': { 'id': 'mryc', 'symbol': 'MRYC/CNY', 'base': 'MRYC', 'quote': 'CNY' },        
        'MTC/CNY':  { 'id': 'mtc',  'symbol': 'MTC/CNY',  'base': 'MTC',  'quote': 'CNY' },
        'NXT/CNY':  { 'id': 'nxt',  'symbol': 'NXT/CNY',  'base': 'NXT',  'quote': 'CNY' },
        'PEB/CNY':  { 'id': 'peb',  'symbol': 'PEB/CNY',  'base': 'PEB',  'quote': 'CNY' },
        'PGC/CNY':  { 'id': 'pgc',  'symbol': 'PGC/CNY',  'base': 'PGC',  'quote': 'CNY' },
        'PLC/CNY':  { 'id': 'plc',  'symbol': 'PLC/CNY',  'base': 'PLC',  'quote': 'CNY' },
        'PPC/CNY':  { 'id': 'ppc',  'symbol': 'PPC/CNY',  'base': 'PPC',  'quote': 'CNY' },
        'QEC/CNY':  { 'id': 'qec',  'symbol': 'QEC/CNY',  'base': 'QEC',  'quote': 'CNY' },
        'RIO/CNY':  { 'id': 'rio',  'symbol': 'RIO/CNY',  'base': 'RIO',  'quote': 'CNY' },
        'RSS/CNY':  { 'id': 'rss',  'symbol': 'RSS/CNY',  'base': 'RSS',  'quote': 'CNY' },
        'SKT/CNY':  { 'id': 'skt',  'symbol': 'SKT/CNY',  'base': 'SKT',  'quote': 'CNY' },
        'TFC/CNY':  { 'id': 'tfc',  'symbol': 'TFC/CNY',  'base': 'TFC',  'quote': 'CNY' },
        'VRC/CNY':  { 'id': 'vrc',  'symbol': 'VRC/CNY',  'base': 'VRC',  'quote': 'CNY' },
        'VTC/CNY':  { 'id': 'vtc',  'symbol': 'VTC/CNY',  'base': 'VTC',  'quote': 'CNY' },
        'WDC/CNY':  { 'id': 'wdc',  'symbol': 'WDC/CNY',  'base': 'WDC',  'quote': 'CNY' },
        'XAS/CNY':  { 'id': 'xas',  'symbol': 'XAS/CNY',  'base': 'XAS',  'quote': 'CNY' },
        'XPM/CNY':  { 'id': 'xpm',  'symbol': 'XPM/CNY',  'base': 'XPM',  'quote': 'CNY' },
        'XRP/CNY':  { 'id': 'xrp',  'symbol': 'XRP/CNY',  'base': 'XRP',  'quote': 'CNY' },
        'XSGS/CNY': { 'id': 'xsgs', 'symbol': 'XSGS/CNY', 'base': 'XSGS', 'quote': 'CNY' },
        'YTC/CNY':  { 'id': 'ytc',  'symbol': 'YTC/CNY',  'base': 'YTC',  'quote': 'CNY' },
        'ZET/CNY':  { 'id': 'zet',  'symbol': 'ZET/CNY',  'base': 'ZET',  'quote': 'CNY' },
        'ZCC/CNY':  { 'id': 'zcc',  'symbol': 'ZCC/CNY',  'base': 'ZCC',  'quote': 'CNY' },        
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetDepth ({
            'coin': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTicker ({ 
            'coin': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['vol']),
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetOrders ({
            'coin': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        return this.privatePostTradeAdd (this.extend ({
            'amount': amount,
            'price': price,
            'type': side,
            'coin': this.productId (product),
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (type == 'public') {  
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString ();
            let query = this.extend ({
                'key': this.apiKey,
                'nonce': nonce,
            }, params);
            query['signature'] = this.hmac (this.urlencode (query), this.hash (this.secret));
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------
// kraken is also owner of ex. Coinsetter / CaVirtEx / Clevercoin

var kraken = {

    'id': 'kraken',
    'name': 'Kraken',
    'countries': 'US',
    'version': '0',
    'rateLimit': 3000,
    'urls': {
        'api': 'https://api.kraken.com',
        'www': 'https://www.kraken.com',
        'docs': [
            'https://www.kraken.com/en-us/help/api',
            'https://github.com/nothingisdead/npm-kraken-api',
        ],
    },
    'api': {
        'public': {
            'get': [
                'Assets',
                'AssetPairs',
                'Depth',
                'OHLC',
                'Spread',
                'Ticker',
                'Time',
                'Trades',
            ],
        },
        'private': {
            'post': [
                'AddOrder',
                'Balance',
                'CancelOrder',
                'ClosedOrders',
                'DepositAddresses',
                'DepositMethods',
                'DepositStatus',
                'Ledgers',
                'OpenOrders',
                'OpenPositions', 
                'QueryLedgers', 
                'QueryOrders', 
                'QueryTrades',
                'TradeBalance',
                'TradesHistory',
                'TradeVolume',
                'Withdraw',
                'WithdrawCancel', 
                'WithdrawInfo',                 
                'WithdrawStatus',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetAssetPairs ();
        let keys = Object.keys (products['result']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let product = products['result'][id];
            let base = product['base'];
            let quote = product['quote'];
            if ((base[0] == 'X') || (base[0] == 'Z'))
                base = base.slice (1);
            if ((quote[0] == 'X') || (quote[0] == 'Z'))
                quote = quote.slice (1);
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let darkpool = id.indexOf ('.d') >= 0;
            let symbol = darkpool ? product['altname'] : (base + '/' + quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchOrderBook (product) {
        return this.publicGetDepth  ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let response = await this.publicGetTicker ({
            'pair': p['id'],
        });
        let ticker = response['result'][p['id']];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['h'][1]),
            'low': parseFloat (ticker['l'][1]),
            'bid': parseFloat (ticker['b'][0]),
            'ask': parseFloat (ticker['a'][0]),
            'vwap': parseFloat (ticker['p'][1]),
            'open': parseFloat (ticker['o']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['c'][0]),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['v'][1]),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ({
            'pair': this.productId (product),
        });
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'pair': this.productId (product),
            'type': side,
            'ordertype': type,
            'volume': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        return this.privatePostAddOrder (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {  
        let url = '/' + this.version + '/' + type + '/' + path;
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString ();
            let query = this.extend ({ 'nonce': nonce }, params);
            body = this.urlencode (query);
            query = this.stringToBinary (url + this.hash (nonce + body, 'sha256', 'binary'));
            let secret = this.base64ToBinary (this.secret);
            headers = {
                'API-Key': this.apiKey,
                'API-Sign': this.hmac (query, secret, 'sha512', 'base64'),
                'Content-type': 'application/x-www-form-urlencoded',
            };
        }
        url = this.urls['api'] + url;
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var luno = {

    'id': 'luno',
    'name': 'luno',
    'countries': [ 'UK', 'SG', 'ZA', ],
    'rateLimit': 5000,
    'version': '1',
    'urls': {
        'api': 'https://api.mybitx.com/api',
        'www': 'https://www.luno.com',
        'docs': [
            'https://npmjs.org/package/bitx',
            'https://github.com/bausmeier/node-bitx',
        ],
    },
    'api': {
        'public': {
            'get': [
                'orderbook',
                'ticker',
                'tickers',
                'trades',
            ],
        },
        'private': {
            'get': [
                'accounts/{id}/pending',
                'accounts/{id}/transactions',
                'balance',
                'fee_info',
                'funding_address',
                'listorders',
                'listtrades',
                'orders/{id}',
                'quotes/{id}',
                'withdrawals',
                'withdrawals/{id}',
            ],
            'post': [
                'accounts',
                'postorder',
                'marketorder',
                'stoporder',
                'funding_address',
                'withdrawals',
                'send',
                'quotes',
                'oauth2/grant',
            ],
            'put': [
                'quotes/{id}',
            ],
            'delete': [
                'quotes/{id}',
                'withdrawals/{id}',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetTickers ();
        let result = [];
        for (let p = 0; p < products['tickers'].length; p++) {
            let product = products['tickers'][p];
            let id = product['pair'];
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privateGetBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTicker ({
            'pair': this.productId (product),
        });
        let timestamp = ticker['timestamp'];
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_trade']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['rolling_24_hour_volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ({
            'pair': this.productId (product)
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost';
        let order = { 'pair': this.productId (product) };
        if (type == 'market') {
            method += 'Marketorder';
            order['type'] = side.toUpperCase ();
            if (side == 'buy')
                order['counter_volume'] = amount;
            else
                order['base_volume'] = amount;            
        } else {
            method += 'Order';
            order['volume'] = amount;
            order['price'] = price;
            if (side == 'buy')
                order['type'] = 'BID';
            else
                order['type'] = 'ASK';
        }
        return this[method] (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (Object.keys (query).length)
            url += '?' + this.urlencode (query);
        if (type == 'private') {
            let auth = this.stringToBase64 (this.apiKey + ':' + this.secret);
            headers = { 'Authorization': 'Basic ' + auth };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------
// OKCoin 
// China
// https://www.okcoin.com/
// https://www.okcoin.com/rest_getStarted.html
// https://github.com/OKCoin/websocket
// https://www.npmjs.com/package/okcoin.com
// https://www.okcoin.cn
// https://www.okcoin.cn/rest_getStarted.html

var okcoin = {

    'version': 'v1',
    'rateLimit': 2000, // up to 3000 requests per 5 minutes ≈ 600 requests per minute ≈ 10 requests per second ≈ 100 ms
    'api': {
        'public': {
            'get': [
                'depth',
                'exchange_rate',
                'future_depth',
                'future_estimated_price',
                'future_hold_amount',
                'future_index',
                'future_kline',
                'future_price_limit',
                'future_ticker',
                'future_trades',
                'kline',
                'otcs',
                'ticker',
                'trades',    
            ],
        },
        'private': {
            'post': [
                'account_records',
                'batch_trade',
                'borrow_money',
                'borrow_order_info',
                'borrows_info',
                'cancel_borrow',
                'cancel_order',
                'cancel_otc_order',
                'cancel_withdraw',
                'future_batch_trade',
                'future_cancel',
                'future_devolve',
                'future_explosive',
                'future_order_info',
                'future_orders_info',
                'future_position',
                'future_position_4fix',
                'future_trade',
                'future_trades_history',
                'future_userinfo',
                'future_userinfo_4fix',
                'lend_depth',
                'order_fee',
                'order_history',
                'order_info',
                'orders_info',
                'otc_order_history',
                'otc_order_info',
                'repayment',
                'submit_otc_order',
                'trade',
                'trade_history',
                'trade_otc_order',
                'withdraw',
                'withdraw_info',
                'unrepayments_info',
                'userinfo',
            ],
        },
    },

    fetchOrderBook (product) {
        return this.publicGetDepth ({
            'symbol': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let response = await this.publicGetTicker ({
            'symbol': this.productId (product),
        });
        let ticker = response['ticker'];
        let timestamp = parseInt (response['date']) * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTrades ({
            'symbol': this.productId (product),
        });
    },

    fetchBalance () {
        return this.privatePostUserinfo ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'symbol': this.productId (product),
            'type': side,
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['type'] += '_market';
        return this.privatePostTrade (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/api/' + this.version + '/' + path + '.do';   
        if (type == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let query = this.keysort (this.extend ({
                'api_key': this.apiKey,
            }, params));
            // secret key must be at the end of query
            let queryString = this.urlencode (query) + '&secret_key=' + this.secret;
            query['sign'] = this.hash (queryString).toUpperCase ();
            body = this.urlencode (query);
            headers = { 'Content-type': 'application/x-www-form-urlencoded' };
        }
        url = this.urls['api'] + url;
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var okcoincny = extend (okcoin, {
    'id': 'okcoincny',
    'name': 'OKCoin CNY',
    'countries': 'CN',
    'urls': {
        'api': 'https://www.okcoin.cn',
        'www': 'https://www.okcoin.cn',
        'docs': 'https://www.okcoin.cn/rest_getStarted.html',
    },
    'products': {
        'BTC/CNY': { 'id': 'btc_cny', 'symbol': 'BTC/CNY', 'base': 'BTC', 'quote': 'CNY' },
        'LTC/CNY': { 'id': 'ltc_cny', 'symbol': 'LTC/CNY', 'base': 'LTC', 'quote': 'CNY' },
    },
})

//-----------------------------------------------------------------------------

var okcoinusd = extend (okcoin, {
    'id': 'okcoinusd',
    'name': 'OKCoin USD',
    'countries': [ 'CN', 'US' ],
    'urls': {
        'api': 'https://www.okcoin.com',
        'www': 'https://www.okcoin.com',
        'docs': [
            'https://www.okcoin.com/rest_getStarted.html',
            'https://www.npmjs.com/package/okcoin.com',
        ],
    },
    'products': {
        'BTC/USD': { 'id': 'btc_usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'LTC/USD': { 'id': 'ltc_usd', 'symbol': 'LTC/USD', 'base': 'LTC', 'quote': 'USD' },
    },
})

//-----------------------------------------------------------------------------

var poloniex = {

    'id': 'poloniex',
    'name': 'Poloniex',
    'countries': 'US',
    'rateLimit': 1000, // 6 calls per second
    'urls': {
        'api': {
            'public': 'https://poloniex.com/public',
            'private': 'https://poloniex.com/tradingApi',
        },
        'www': 'https://poloniex.com',
        'docs': [
            'https://poloniex.com/support/api/',
            'http://pastebin.com/dMX7mZE0',
        ],
    },
    'api': {
        'public': {
            'get': [
                'return24hVolume',
                'returnChartData',
                'returnCurrencies',
                'returnLoanOrders',
                'returnOrderBook',
                'returnTicker',
                'returnTradeHistory',
            ],
        },
        'private': {
            'post': [
                'buy',
                'cancelLoanOffer',
                'cancelOrder',
                'closeMarginPosition',
                'createLoanOffer',
                'generateNewAddress',
                'getMarginPosition',
                'marginBuy',
                'marginSell',
                'moveOrder',
                'returnActiveLoans',
                'returnAvailableAccountBalances',
                'returnBalances',
                'returnCompleteBalances',
                'returnDepositAddresses',
                'returnDepositsWithdrawals',
                'returnFeeInfo',
                'returnLendingHistory',
                'returnMarginAccountSummary',
                'returnOpenLoanOffers',
                'returnOpenOrders',
                'returnOrderTrades',
                'returnTradableBalances',
                'returnTradeHistory',
                'sell',
                'toggleAutoRenew',
                'transferBalance',
                'withdraw',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetReturnTicker ();
        let keys = Object.keys (products);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let product = products[id];
            let symbol = id.replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostReturnCompleteBalances ({
            'account': 'all',
        });
    },

    fetchOrderBook (product) {
        return this.publicGetReturnOrderBook ({
            'currencyPair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let tickers = await this.publicGetReturnTicker ();
        let ticker = tickers[p['id']];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high24hr']),
            'low': parseFloat (ticker['low24hr']),
            'bid': parseFloat (ticker['highestBid']),
            'ask': parseFloat (ticker['lowestAsk']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': undefined,
            'change': parseFloat (ticker['percentChange']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['baseVolume']),
            'quoteVolume': parseFloat (ticker['quoteVolume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetReturnTradeHistory ({
            'currencyPair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side);
        return this[method] (this.extend ({
            'currencyPair': this.productId (product),
            'rate': price,
            'amount': amount,
        }, params));
    },

    cancelOrder (id, params = {}) {
        return this.privatePostCancelOrder (this.extend ({
            'orderNumber': id,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        let query = this.extend ({ 'command': path }, params);
        if (type == 'public') {
            url += '?' + this.urlencode (query);
        } else {
            query['nonce'] = this.nonce ();
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Key': this.apiKey,
                'Sign': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var quadrigacx = {

    'id': 'quadrigacx',
    'name': 'QuadrigaCX',
    'countries': 'CA',
    'rateLimit': 2000,
    'version': 'v2',
    'urls': {
        'api': 'https://api.quadrigacx.com',
        'www': 'https://www.quadrigacx.com',
        'docs': 'https://www.quadrigacx.com/api_info',
    },
    'api': {
        'public': {
            'get': [
                'order_book',
                'ticker',                
                'transactions',
            ],
        },
        'private': {
            'post': [
                'balance',
                'bitcoin_deposit_address',
                'bitcoin_withdrawal',
                'buy',
                'cancel_order',
                'ether_deposit_address',
                'ether_withdrawal',
                'lookup_order',
                'open_orders',
                'sell',
                'user_transactions',
            ],
        },
    },
    'products': {
        'BTC/CAD': { 'id': 'btc_cad', 'symbol': 'BTC/CAD', 'base': 'BTC', 'quote': 'CAD' },
        'BTC/USD': { 'id': 'btc_usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'ETH/BTC': { 'id': 'eth_btc', 'symbol': 'ETH/BTC', 'base': 'ETH', 'quote': 'BTC' },
        'ETH/CAD': { 'id': 'eth_cad', 'symbol': 'ETH/CAD', 'base': 'ETH', 'quote': 'CAD' },
    },

    fetchBalance () {
        return this.privatePostBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderBook ({
            'book': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetTicker ({
            'book': this.productId (product),
        });
        let timestamp = parseInt (ticker['timestamp']) * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTransactions ({
            'book': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side); 
        let order = {
            'amount': amount,
            'book': this.productId (product),
        };
        if (type == 'limit')
            order['price'] = price;
        return this[method] (this.extend (order, params));
    },

    cancelOrder (id, params = {}) {
        return this.privatePostCancelOrder (this.extend ({ id }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (type == 'public') {
            url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ();
            let request = [ nonce, this.uid, this.apiKey ].join ('');
            let signature = this.hmac (request, this.secret);
            let query = this.extend ({ 
                'key': this.apiKey,
                'nonce': nonce,
                'signature': signature,
            }, params);
            body = JSON.stringify (query);
            headers = {
                'Content-Type': 'application/json',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var quoine = {

    'id': 'quoine',
    'name': 'QUOINE',
    'countries': [ 'JP', 'SG', 'VN' ],
    'version': 2,
    'rateLimit': 2000,
    'urls': {
        'api': 'https://api.quoine.com',
        'www': 'https://www.quoine.com',
        'docs': 'https://developers.quoine.com',
    },
    'api': {
        'public': {
            'get': [
                'products',
                'products/{id}',
                'products/{id}/price_levels',
                'executions',
                'ir_ladders/{currency}',
            ],
        },
        'private': {
            'get': [
                'accounts/balance',
                'crypto_accounts',
                'executions/me',
                'fiat_accounts',
                'loan_bids',
                'loans',
                'orders',
                'orders/{id}',
                'orders/{id}/trades',
                'trades',
                'trades/{id}/loans',
                'trading_accounts',
                'trading_accounts/{id}',
            ],
            'post': [
                'fiat_accounts',
                'loan_bids',
                'orders',
            ],
            'put': [
                'loan_bids/{id}/close',
                'loans/{id}',
                'orders/{id}',
                'orders/{id}/cancel',
                'trades/{id}',
                'trades/{id}/close',
                'trades/close_all',
                'trading_accounts/{id}',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetProducts ();
        let result = [];
        for (let p = 0; p < products.length; p++) {
            let product = products[p];
            let id = product['id'];
            let base = product['base_currency'];
            let quote = product['quoted_currency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privateGetAccountsBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetProductsIdPriceLevels ({
            'id': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetProductsId ({
            'id': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high_market_ask']),
            'low': parseFloat (ticker['low_market_bid']),
            'bid': parseFloat (ticker['market_bid']),
            'ask': parseFloat (ticker['market_ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last_traded_price']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['volume_24h']),
            'quoteVolume': undefined,
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetExecutions ({
            'product_id': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'order_type': type,
            'product_id': this.productId (product),
            'side': side,
            'quantity': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        return this.privatePostOrders (this.extend ({
            'order': order,
        }, params));
    },

    cancelOrder (id, params = {}) {
        return this.privatePutOrdersIdCancel (this.extend ({
            'id': id,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        headers = {
            'X-Quoine-API-Version': this.version,
            'Content-type': 'application/json',
        };
        if (type == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let request = {
                'path': url, 
                'nonce': nonce, 
                'token_id': this.apiKey,
                'iat': Math.floor (nonce / 1000), // issued at
            };
            if (Object.keys (query).length)
                body = JSON.stringify (query);
            headers['X-Quoine-Auth'] = this.jwt (request, this.secret);
        }
        return this.fetch (this.urls['api'] + url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var therock = {

    'id': 'therock',
    'name': 'TheRockTrading',
    'countries': 'MT',
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'api': 'https://api.therocktrading.com',
        'www': 'https://therocktrading.com',
        'docs': 'https://api.therocktrading.com/doc/',
    },
    'api': {
        'public': {
            'get': [
                'funds/{id}/orderbook',
                'funds/{id}/ticker',
                'funds/{id}/trades',
                'funds/tickers',
            ],
        },
        'private': {
            'get': [
                'balances',
                'balances/{id}',
                'discounts',
                'discounts/{id}',
                'funds',
                'funds/{id}',
                'funds/{id}/trades',
                'funds/{fund_id}/orders',
                'funds/{fund_id}/orders/{id}',                
                'funds/{fund_id}/position_balances',
                'funds/{fund_id}/positions',
                'funds/{fund_id}/positions/{id}',
                'transactions',
                'transactions/{id}',
                'withdraw_limits/{id}',
                'withdraw_limits',
            ],
            'post': [
                'atms/withdraw',
                'funds/{fund_id}/orders',
            ],
            'delete': [
                'funds/{fund_id}/orders/{id}',
                'funds/{fund_id}/orders/remove_all',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetFundsTickers ();
        let result = [];
        for (let p = 0; p < products['tickers'].length; p++) {
            let product = products['tickers'][p];
            let id = product['fund_id'];
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () { 
        return this.privateGetBalances ();
    },

    fetchOrderBook (product) {
        return this.publicGetFundsIdOrderbook ({
            'id': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.publicGetFundsIdTicker ({
            'id': this.productId (product),
        });
        let timestamp = this.parse8601 (ticker['date']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': parseFloat (ticker['close']),
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['volume_traded']),
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetFundsIdTrades ({
            'id': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new Error (this.id + ' allows limit orders only');
        return this.privatePostFundsFundIdOrders (this.extend ({
            'fund_id': this.productId (product),
            'side': side,
            'amount': amount,
            'price': price,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (type == 'private') {
            let nonce = this.nonce ().toString ();
            headers = {
                'X-TRT-KEY': this.apiKey,
                'X-TRT-NONCE': nonce,
                'X-TRT-SIGN': this.hmac (nonce + url, this.secret, 'sha512'),
            };
            if (Object.keys (query).length) {
                body = JSON.stringify (query);
                headers['Content-Type'] = 'application/json';
            }
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var vaultoro = {

    'id': 'vaultoro',
    'name': 'Vaultoro',
    'countries': 'CH',
    'rateLimit': 1000,
    'version': 1,
    'urls': {
        'api': 'https://api.vaultoro.com',
        'www': 'https://www.vaultoro.com',
        'docs': 'https://api.vaultoro.com',
    },
    'api': {
        'public': {
            'get': [
                'bidandask',
                'buyorders',
                'latest',
                'latesttrades',
                'markets',
                'orderbook',
                'sellorders',
                'transactions/day',
                'transactions/hour',
                'transactions/month',
            ],
        },
        'private': {
            'get': [
                'balance',
                'mytrades',
                'orders',
            ],
            'post': [
                'buy/{symbol}/{type}',
                'cancel/{orderid',
                'sell/{symbol}/{type}',
                'withdraw',
            ],
        },
    },

    async fetchProducts () {
        let result = [];
        let products = await this.publicGetMarkets ();
        let product = products['data'];
        let base = product['BaseCurrency'];
        let quote = product['MarketCurrency'];
        let symbol = base + '/' + quote;
        let baseId = base;
        let quoteId = quote;
        let id = product['MarketName'];
        result.push ({
            'id': id,
            'symbol': symbol,
            'base': base,
            'quote': quote,
            'baseId': baseId,
            'quoteId': quoteId,
            'info': product,
        });
        return result;
    },

    fetchBalance () {
        return this.privateGetBalance ();
    },

    fetchOrderBook (product) {
        return this.publicGetOrderbook ();
    },

    async fetchTicker (product) {
        let quote = await this.publicGetBidandask ();
        let bidsLength = quote['bids'].length;
        let bid = quote['bids'][bidsLength - 1];
        let ask = quote['asks'][0];
        let response = await this.publicGetMarkets ();
        let ticker = response['data'];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['24hHigh']),
            'low': parseFloat (ticker['24hLow']),
            'bid': bid[0],
            'ask': ask[0],
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['lastPrice']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['24hVolume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetTransactionsDay ();
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let p = this.product (product);
        let method = 'privatePost' + this.capitalize (side) + 'SymbolType';
        return this[method] (this.extend ({
            'symbol': p['quoteId'].toLowerCase (),
            'type': type,
            'gld': amount,
            'price': price || 1,
        }, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/';
        if (type == 'public') {
            url += path;
        } else {
            let nonce = this.nonce ();
            url += this.version + '/' + this.implodeParams (path, params);
            let query = this.extend ({
                'nonce': nonce,
                'apikey': this.apiKey,
            }, this.omit (params, this.extractParams (path)));
            url += '?' + this.urlencode (query);
            headers = {
                'Content-Type': 'application/json',
                'X-Signature': this.hmac (url, this.secret)
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var virwox = {

    'id': 'virwox',
    'name': 'VirWoX',
    'countries': 'AT',
    'rateLimit': 1000,
    'urls': {
        'api': {
            'public': 'http://api.virwox.com/api/json.php',
            'private': 'https://www.virwox.com/api/trading.php',
        },
        'www': 'https://www.virwox.com',
        'docs': 'https://www.virwox.com/developers.php',
    },
    'api': {
        'public': {
            'get': [
                'getInstruments',
                'getBestPrices',
                'getMarketDepth',
                'estimateMarketOrder',
                'getTradedPriceVolume',
                'getRawTradeData',
                'getStatistics',
                'getTerminalList',
                'getGridList',
                'getGridStatistics',
            ],
            'post': [
                'getInstruments',
                'getBestPrices',
                'getMarketDepth',
                'estimateMarketOrder',
                'getTradedPriceVolume',
                'getRawTradeData',
                'getStatistics',
                'getTerminalList',
                'getGridList',
                'getGridStatistics',
            ],
        },
        'private': {
            'get': [
                'cancelOrder',
                'getBalances',
                'getCommissionDiscount',
                'getOrders',
                'getTransactions',
                'placeOrder',
            ],
            'post': [
                'cancelOrder',
                'getBalances',
                'getCommissionDiscount',
                'getOrders',
                'getTransactions',
                'placeOrder',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.publicGetInstruments ();
        let keys = Object.keys (products['result']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let product = products['result'][keys[p]];
            let id = product['instrumentID'];
            let symbol = product['symbol'];
            let base = product['longCurrency'];
            let quote = product['shortCurrency'];
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.privatePostGetBalances ();
    },

    fetchBestPrices (product) {
        return this.publicPostGetBestPrices ({
            'symbols': [ this.symbol (product) ],
        });
    }, 

    fetchOrderBook (product) {
        return this.publicPostGetMarketDepth ({
            'symbols': [ this.symbol (product) ],
            'buyDepth': 100,
            'sellDepth': 100,
        });
    },

    async fetchTicker (product) {
        let end = this.milliseconds ();
        let start = end - 86400000;
        let response = await this.publicGetTradedPriceVolume ({
            'instrument': this.symbol (product),
            'endDate': this.yyyymmddhhmmss (end),
            'startDate': this.yyyymmddhhmmss (start),
            'HLOC': 1,
        });
        let tickers = response['result']['priceVolumeList'];
        let keys = Object.keys (tickers);
        let length = keys.length;
        let lastKey = keys[length - 1];
        let ticker = tickers[lastKey];
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': undefined,
            'ask': undefined,
            'vwap': undefined,
            'open': parseFloat (ticker['open']),
            'close': parseFloat (ticker['close']),
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['longVolume']),
            'quoteVolume': parseFloat (ticker['shortVolume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.publicGetRawTradeData ({
            'instrument': this.symbol (product),
            'timespan': 3600,
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        let order = {
            'instrument': this.symbol (product),
            'orderType': side.toUpperCase (),
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        return this.privatePostPlaceOrder (this.extend (order, params));
    },

    request (path, type = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][type];
        let auth = {};
        if (type == 'public') {
            auth['key'] = this.apiKey;
            auth['user'] = this.login;
            auth['pass'] = this.password;
        }
        let nonce = this.nonce ();
        if (method == 'GET') {
            url += '?' + this.urlencode (this.extend ({ 
                'method': path, 
                'id': nonce,
            }, auth, params));
        } else {
            headers = { 'Content-type': 'application/json' };
            body = JSON.stringify ({ 
                'method': path, 
                'params': this.extend (auth, params),
                'id': nonce,
            });
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var yobit = {

    'id': 'yobit',
    'name': 'YoBit',
    'countries': 'RU',
    'rateLimit': 2000, // responses are cached every 2 seconds
    'version': 3,
    'urls': {
        'api': 'https://yobit.net',
        'www': 'https://www.yobit.net',
        'docs': 'https://www.yobit.net/en/api/',
    },
    'api': {
        'api': {
            'get': [
                'depth/{pairs}',
                'info',
                'ticker/{pairs}',
                'trades/{pairs}',
            ],
        },
        'tapi': {
            'post': [
                'ActiveOrders',
                'CancelOrder',
                'GetDepositAddress',
                'getInfo',
                'OrderInfo',
                'Trade',                
                'TradeHistory',
                'WithdrawCoinsToAddress',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.apiGetInfo ();
        let keys = Object.keys (products['pairs']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let product = products['pairs'][id];
            let symbol = id.toUpperCase ().replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.tapiPostGetInfo ();
    },

    fetchOrderBook (product) {
        return this.apiGetDepthPairs ({
            'pairs': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let p = this.product (product);
        let tickers = await this.apiGetTickerPairs ({
            'pairs': p['id'],
        });
        let ticker = tickers[p['id']];
        let timestamp = ticker['updated'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['buy']),
            'ask': parseFloat (ticker['sell']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['avg']),
            'baseVolume': parseFloat (ticker['vol_cur']),
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.apiGetTradesPairs ({
            'pairs': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new Error (this.id + ' allows limit orders only');
        return this.tapiPostTrade (this.extend ({
            'pair': this.productId (product),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
    },

    cancelOrder (id, params = {}) {
        return this.tapiPostCancelOrder (this.extend ({
            'order_id': id,
        }, params));
    },

    request (path, type = 'api', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + type;
        if (type == 'api') {
            url += '/' + this.version + '/' + this.implodeParams (path, params);
            let query = this.omit (params, this.extractParams (path));
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let query = this.extend ({ 'method': path, 'nonce': nonce }, params);
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'key': this.apiKey,
                'sign': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//-----------------------------------------------------------------------------

var zaif = {

    'id': 'zaif',
    'name': 'Zaif',
    'countries': 'JP',
    'rateLimit': 3000,
    'version': '1',
    'urls': {
        'api': 'https://api.zaif.jp',
        'www': 'https://zaif.jp',
        'docs': [
            'https://corp.zaif.jp/api-docs',
            'https://corp.zaif.jp/api-docs/api_links',
            'https://www.npmjs.com/package/zaif.jp',
            'https://github.com/you21979/node-zaif',
        ],
    },
    'api': {
        'api': {
            'get': [
                'depth/{pair}',
                'currencies/{pair}',
                'currencies/all',
                'currency_pairs/{pair}',
                'currency_pairs/all',
                'last_price/{pair}',
                'ticker/{pair}',
                'trades/{pair}',
            ],
        },
        'tapi': {
            'post': [
                'active_orders',
                'cancel_order',
                'deposit_history',
                'get_id_info',
                'get_info',
                'get_info2',
                'get_personal_info',
                'trade',
                'trade_history',
                'withdraw',
                'withdraw_history',
            ],
        },
        'ecapi': {
            'post': [
                'createInvoice',
                'getInvoice',
                'getInvoiceIdsByOrderNumber',
                'cancelInvoice',
            ],
        },
    },

    async fetchProducts () {
        let products = await this.apiGetCurrencyPairsAll ();
        let result = [];
        for (let p = 0; p < products.length; p++) {
            let product = products[p];
            let id = product['currency_pair'];
            let symbol = product['name'];
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': product,
            });
        }
        return result;
    },

    fetchBalance () {
        return this.tapiPostGetInfo ();
    },

    fetchOrderBook (product) {
        return this.apiGetDepthPair  ({
            'pair': this.productId (product),
        });
    },

    async fetchTicker (product) {
        let ticker = await this.apiGetTickerPair ({
            'pair': this.productId (product),
        });
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['bid']),
            'ask': parseFloat (ticker['ask']),
            'vwap': parseFloat (ticker['vwap']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    fetchTrades (product) {
        return this.apiGetTradesPair ({
            'pair': this.productId (product),
        });
    },

    createOrder (product, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new Error (this.id + ' allows limit orders only');
        return this.tapiPostTrade (this.extend ({
            'currency_pair': this.productId (product),
            'action': (side == 'buy') ? 'bid' : 'ask',
            'amount': amount,
            'price': price,
        }, params));
    },

    cancelOrder (id, params = {}) {
        return this.tapiPostCancelOrder (this.extend ({
            'order_id': id,
        }, params));
    },

    request (path, type = 'api', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + type;
        if (type == 'api') {
            url += '/' + this.version + '/' + this.implodeParams (path, params);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({
                'method': path,
                'nonce': nonce,
            }, params));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Key': this.apiKey,
                'Sign': this.hmac (body, this.secret, 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

//=============================================================================

var markets = {

    '_1broker':    _1broker,
    '_1btcxe':     _1btcxe,
    'bit2c':       bit2c,
    'bitbay':      bitbay,
    'bitcoincoid': bitcoincoid,
    'bitfinex':    bitfinex,
    'bitlish':     bitlish,
    'bitmarket':   bitmarket,
    'bitmex':      bitmex,
    'bitso':       bitso, 
    'bittrex':     bittrex,
    'btcx':        btcx,
    'bxinth':      bxinth,
    'ccex':        ccex,
    'cex':         cex,
    'coincheck':   coincheck,
    'coinsecure':  coinsecure,
    'exmo':        exmo,
    'fybse':       fybse,
    'fybsg':       fybsg,
    'hitbtc':      hitbtc,
    'huobi':       huobi,
    'jubi':        jubi,
    'kraken':      kraken,
    'luno':        luno,
    'okcoincny':   okcoincny,
    'okcoinusd':   okcoinusd,
    'poloniex':    poloniex,
    'quadrigacx':  quadrigacx,
    'quoine':      quoine,
    'therock':     therock,
    'vaultoro':    vaultoro,
    'virwox':      virwox,
    'yobit':       yobit,
    'zaif':        zaif,
}

let defineAllMarkets = function (markets) {
    let result = {}
    for (let id in markets)
        result[id] = function (params) {
            return new Market (extend (markets[id], params))
        }
    return result
}

if (isNode)
    module.exports = defineAllMarkets (markets)
else
    window.ccxt = defineAllMarkets (markets)

}) ()