ccxt.js

"use strict";

(function () {

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

var version = '1.3.92'
var isNode  = (typeof window === 'undefined')
var isReactNative = (typeof navigator !== 'undefined') && navigator &&
    navigator.product && navigator.product == 'ReactNative' || false

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

class CCXTError extends Error {
    constructor (message) {
        super (message)
        // a workaround to make `instanceof CCXTError` work in ES5
        this.constructor = CCXTError
        this.__proto__   = CCXTError.prototype
        this.message     = message
    }
}

class ExchangeError extends CCXTError {
    constructor (message) {
        super (message)
        this.constructor = ExchangeError
        this.__proto__   = ExchangeError.prototype
        this.message     = message
    }
}

class AuthenticationError extends CCXTError {
    constructor (message) {
        super (message)
        this.constructor = AuthenticationError
        this.__proto__   = AuthenticationError.prototype
        this.message     = message
    }
}

class NetworkError extends CCXTError {
    constructor (message) {
        super (message)
        this.constructor = NetworkError
        this.__proto__   = NetworkError.prototype
        this.message     = message
    }
}

class DDoSProtection extends NetworkError {
    constructor (message) {
        super (message)
        this.constructor = DDoSProtection
        this.__proto__   = DDoSProtection.prototype
        this.message     = message
    }
}

class RequestTimeout extends NetworkError {
    constructor (message) {
        super (message)
        this.constructor = RequestTimeout
        this.__proto__   = RequestTimeout.prototype
        this.message     = message
    }
}

class ExchangeNotAvailable extends NetworkError {
    constructor (message) {
        super (message)
        this.constructor = ExchangeNotAvailable
        this.__proto__   = ExchangeNotAvailable.prototype
        this.message     = message
    }
}

//-----------------------------------------------------------------------------
// utility helpers

const sleep = ms => new Promise (resolve => setTimeout (resolve, ms));

const decimal = float => parseFloat (float).toString ()

const timeout = (ms, promise) =>
        Promise.race ([
            promise,
            sleep (ms).then (() => { throw new RequestTimeout ('request timed out') })
        ])

const capitalize = string => string.length ? (string.charAt (0).toUpperCase () + string.slice (1)) : string

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

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

const omit = function (object) {
    const result = extend (object)
    for (let 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
}

const indexBy = (array, key) => {
    const result = {}
    for (var i = 0; i < array.length; i++) {
        let element = array[i]
        if (typeof element[key] != 'undefined') {
            result[element[key]] = element
        }
    }
    return result
}

const sortBy = (array, key, descending = false) => {
    descending = descending ? -1 : 1
    return array.sort ((a, b) => ((a[key] < b[key]) ? -descending : ((a[key] > b[key]) ? descending : 0)))
}

const flatten = (array, result = []) => {
    for (let i = 0, length = array.length; i < length; i++) {
        const value = array[i]
        if (Array.isArray (value)) {
            flatten (value, result)
        } else {
            result.push (value)
        }
    }
    return result
}

const unique = array => array.filter ((value, index, self) => (self.indexOf (value) == index))

const pluck = (array, key) => array
                                .filter (element => (typeof element[key] != 'undefined'))
                                .map (element => element[key])

const urlencode = object => qs.stringify (object)

const sum = (...args) => {
    const result = args.filter (arg => typeof arg != 'undefined')
    return (result.length > 0) ?
        result.reduce ((sum, value) => sum + value, 0) : undefined
}

const ordered = x => x // a stub to keep assoc keys in order, in JS it does nothing, it's mostly for Python

//-----------------------------------------------------------------------------
// platform-specific code (Node.js / Web Browsers)

if (isNode) {

    var CryptoJS = module.require ('crypto-js')
    var fetch    = module.require ('node-fetch')
    var qs       = module.require ('qs')

} else if (isReactNative) {

    var CryptoJS = require ('crypto-js')
    var fetch    = window.fetch
    var qs       = require ('qs')

} else {

    // a quick fetch polyfill

    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 { // [403, 404, ...].indexOf (xhr.status) >= 0
                        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)
        })
    }
}

//-----------------------------------------------------------------------------
// string ←→ binary ←→ base64 conversion routines

const stringToBinary = str => {
    const arr = new Uint8Array (str.length)
    for (let i = 0; i < str.length; i++) { arr[i] = str.charCodeAt(i); }
    return CryptoJS.lib.WordArray.create (arr)
}

const stringToBase64 = string => CryptoJS.enc.Latin1.parse (string).toString (CryptoJS.enc.Base64)
    , utf16ToBase64  = string => CryptoJS.enc.Utf16 .parse (string).toString (CryptoJS.enc.Base64)
    , base64ToBinary = string => CryptoJS.enc.Base64.parse (string)
    , base64ToString = string => CryptoJS.enc.Base64.parse (string).toString (CryptoJS.enc.Utf8)
    , binaryToString = string => string

const binaryConcat = (...args) => args.reduce ((a, b) => a.concat (b))

// url-safe-base64 without equals signs, with + replaced by - and slashes replaced by underscores
const urlencodeBase64 = base64string => base64string.replace (/[=]+$/, '')
                                                    .replace (/\+/g, '-')
                                                    .replace (/\//g, '_')

//-----------------------------------------------------------------------------
// cryptography

const hash = (request, hash = 'md5', digest = 'hex') => {
    const result = CryptoJS[hash.toUpperCase ()] (request)
    return (digest == 'binary') ? result : result.toString (CryptoJS.enc[capitalize (digest)])
}

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

//-----------------------------------------------------------------------------
// a JSON Web Token authentication method

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

//-----------------------------------------------------------------------------
// the base class

const Exchange = function (config) {

    this.hash = hash
    this.hmac = hmac
    this.jwt = jwt // JSON Web Token
    this.binaryConcat = binaryConcat
    this.stringToBinary = stringToBinary
    this.stringToBase64 = stringToBase64
    this.base64ToBinary = base64ToBinary
    this.base64ToString = base64ToString
    this.binaryToString = binaryToString
    this.utf16ToBase64 = utf16ToBase64
    this.urlencode = urlencode
    this.omit = omit
    this.pluck = pluck
    this.unique = unique
    this.extend = extend
    this.flatten = flatten
    this.indexBy = indexBy
    this.sortBy = sortBy
    this.keysort = keysort
    this.decimal = decimal
    this.capitalize = capitalize
    this.json = JSON.stringify
    this.sum = sum
    this.ordered = ordered

    this.encode = string => string
    this.decode = string => string

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

    this.init = function () {

        this.orders = {}
        this.trades = {}

        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.trim ().toLowerCase ()).filter (x => x.length > 0).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
                    }
                })
            })

        if (this.markets)
            this.setMarkets (this.markets);
    }

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

        if (isNode && this.userAgent)
            if (typeof this.userAgent == 'string')
                headers = extend ({ 'User-Agent': this.userAgent }, headers)
            else if ((typeof this.userAgent == 'object') && ('User-Agent' in this.userAgent))
                headers = extend (this.userAgent, headers)

        if (this.proxy.length)
            headers = extend ({ 'Origin': '*' }, headers)

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

        url = this.proxy + url

        if (this.verbose)
            console.log (this.id, method, url, "\nRequest:\n", options)

        return timeout (this.timeout, fetch (url, options)
            .catch (e => {
                if (isNode) {
                    throw new ExchangeNotAvailable ([ this.id, method, url, e.type, e.message ].join (' '))
                }
                throw e // rethrow all unknown errors
            })
            .then (response => {

                if (typeof response == 'string')
                    return response

                return response.text ().then (text => {
                    if (this.verbose)
                        console.log (this.id, method, url, text ? ("\nResponse:\n" + text) : '')
                    if ((response.status >= 200) && (response.status <= 300))
                        return text
                    let error = undefined
                    let details = text
                    if ([ 429 ].indexOf (response.status) >= 0) {
                        error = DDoSProtection
                    } else if ([ 404, 409, 500, 501, 502, 521, 525 ].indexOf (response.status) >= 0) {
                        error = ExchangeNotAvailable
                    } else if ([ 400, 403, 405, 503 ].indexOf (response.status) >= 0) {
                        let ddosProtection = text.match (/cloudflare|incapsula/i)
                        if (ddosProtection) {
                            error = DDoSProtection
                        } else {
                            error = ExchangeNotAvailable
                            details = text + ' (possible reasons: ' + [
                                'invalid API keys',
                                'bad or old nonce',
                                'exchange is down or offline',
                                'on maintenance',
                                'DDoS protection',
                                'rate-limiting',
                            ].join (', ') + ')'
                        }
                    } else if ([ 408, 504 ].indexOf (response.status) >= 0) {
                        error = RequestTimeout
                    } else if ([ 401, 422, 511 ].indexOf (response.status) >= 0) {
                        error = AuthenticationError
                    } else {
                        error = Error
                    }
                    throw new error ([ this.id, method, url, response.status, response.statusText, details ].join (' '))
                })
            }).then (response => this.handleResponse (url, method, headers, response)))
    }

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

        try {

            return JSON.parse (body)

        } catch (e) {

            let maintenance = body.match (/offline|busy|retry|wait|unavailable|maintain|maintenance|maintenancing/i)
            let ddosProtection = body.match (/cloudflare|incapsula|overload/i)

            if (e instanceof SyntaxError) {

                let error = ExchangeNotAvailable
                let details = 'not accessible from this location at the moment'
                if (maintenance)
                    details = 'offline, on maintenance or unreachable from this location at the moment'
                if (ddosProtection)
                    error = DDoSProtection
                throw new error ([ this.id, method, url, details ].join (' '))
            }

            if (this.verbose)
                console.log (this.id, method, url, 'error', e, "response body:\n'" + body + "'")

            throw e
        }
    }

    this.set_markets =
    this.setMarkets = function (markets) {
        let values = Object.values (markets)
        this.markets = indexBy (values, 'symbol')
        this.marketsById = indexBy (markets, 'id')
        this.markets_by_id = this.marketsById
        this.symbols = Object.keys (this.markets)
        let base = this.pluck (values.filter (market => 'base' in market), 'base')
        let quote = this.pluck (values.filter (market => 'quote' in market), 'quote')
        this.currencies = this.unique (base.concat (quote))
        return this.markets
    }

    this.load_markets =
    this.loadMarkets = function (reload = false) {
        if (!reload && this.markets) {
            if (!this.marketsById) {
                return new Promise ((resolve, reject) => resolve (this.setMarkets (this.markets)))
            }
            return new Promise ((resolve, reject) => resolve (this.markets))
        }
        return this.fetchMarkets ().then (markets => {
            return this.setMarkets (markets)
        })
    }

    this.fetch_tickers = function () {
        return this.fetchTickers ()
    }

    this.fetchTickers = function () {
        throw new ExchangeError (this.id + ' API does not allow to fetch all tickers at once with a single call to fetch_tickers () for now')
    }

    this.fetch_markets = function () {
        return this.fetchMarkets ()
    }

    this.fetchMarkets = function () {
        return new Promise ((resolve, reject) => resolve (this.markets))
    }

    this.commonCurrencyCode = function (currency) {
        if (!this.substituteCommonCurrencyCodes)
            return currency
        if (currency == 'XBT')
            return 'BTC'
        if (currency == 'BCC')
            return 'BCH'
        if (currency == 'DRK')
            return 'DASH'
        return currency
    }

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

    this.market_id =
    this.marketId = function (market) {
        return this.market (market).id || market
    }

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

    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.url = function (path, params = {}) {
        let result = this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (Object.keys (query).length)
            result += '?' + this.urlencode (query);
        return result;
    }

    this.create_limit_buy_order =
    this.createLimitBuyOrder = function (market, amount, price, params = {}) {
        return this.createOrder  (market, 'limit', 'buy', amount, price, params)
    }

    this.create_limit_sell_order =
    this.createLimitSellOrder = function (market, amount, price, params = {}) {
        return this.createOrder (market, 'limit', 'sell', amount, price, params)
    }

    this.create_market_buy_order =
    this.createMarketBuyOrder = function (market, amount, params = {}) {
        return this.createOrder (market, 'market', 'buy', amount, undefined, params)
    }

    this.create_market_sell_order =
    this.createMarketSellOrder = function (market, amount, params = {}) {
        return this.createOrder (market, 'market', 'sell', amount, undefined, params)
    }

    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  // milliseconds = seconds * 1000
    this.timeout        = 10000 // milliseconds = seconds * 1000
    this.verbose        = false
    this.userAgent      = false
    this.twofa          = false // two-factor authentication
    this.substituteCommonCurrencyCodes = true
    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
    }

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

    // prepended to URL, like https://proxy.com/https://exchange.com/api...
    this.proxy = ''

    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.get_market_url   = this.getMarketURL

    this.init ()
}

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

var _1broker = {

    'id': '_1broker',
    'name': '1Broker',
    'countries': 'US',
    'rateLimit': 1500,
    'version': 'v2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766021-420bd9fc-5ecb-11e7-8ed6-56d0081efed2.jpg',
        'api': 'https://1broker.com/api',
        'www': 'https://1broker.com',
        'market': 'https://1broker.com/?c=en/content/markets',
        '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 fetchMarkets () {
        let this_ = this; // workaround for Babel bug (not passing `this` to _recursive() call)
        let categories = await this.fetchCategories ();
        let result = [];
        for (let c = 0; c < categories.length; c++) {
            let category = categories[c];
            let markets = await this_.privateGetMarketList ({
                'category': category.toLowerCase (),
            });
            for (let p = 0; p < markets['response'].length; p++) {
                let market = markets['response'][p];
                let id = market['symbol'];
                let symbol = undefined;
                let base = undefined;
                let quote = undefined;
                if ((category == 'FOREX') || (category == 'CRYPTO')) {
                    symbol = market['name'];
                    let parts = symbol.split ('/');
                    base = parts[0];
                    quote = parts[1];
                } else {
                    base = id;
                    quote = 'USD';
                    symbol = base + '/' + quote;
                }
                base = this_.commonCurrencyCode (base);
                quote = this_.commonCurrencyCode (quote);
                result.push ({
                    'id': id,
                    'symbol': symbol,
                    'base': base,
                    'quote': quote,
                    'info': market,
                });
            }
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balance = await this.privateGetUserOverview ();
        let response = balance['response'];
        let result = {
            'info': response,
        };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            result[currency] = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
        }
        result['BTC']['free'] = parseFloat (response['balance']);
        result['BTC']['total'] = result['BTC']['free'];
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.privateGetMarketQuotes (this.extend ({
            'symbols': this.marketId (market),
        }, params));
        let orderbook = response['response'][0];
        let timestamp = this.parse8601 (orderbook['updated']);
        let bidPrice = parseFloat (orderbook['bid']);
        let askPrice = parseFloat (orderbook['ask']);
        let bid = [ bidPrice, undefined ];
        let ask = [ askPrice, undefined ];
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'bids': [ bid ],
            'asks': [ ask ],
        };
    },

    async fetchTrades (market) {
        throw new ExchangeError (this.id + ' fetchTrades () method not implemented yet');
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let result = await this.privateGetMarketBars ({
            'symbol': this.marketId (market),
            'resolution': 60,
            'limit': 1,
        });
        let orderbook = await this.fetchOrderBook (market);
        let ticker = result['response'][0];
        let timestamp = this.parse8601 (ticker['date']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['h']),
            'low': parseFloat (ticker['l']),
            'bid': orderbook['bids'][0][0],
            'ask': orderbook['asks'][0][0],
            'vwap': undefined,
            'open': parseFloat (ticker['o']),
            'close': parseFloat (ticker['c']),
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': undefined,
        };
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'symbol': this.marketId (market),
            'margin': amount,
            'direction': (side == 'sell') ? 'short' : 'long',
            'leverage': 1,
            'type': side,
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['type'] += '_market';
        let result = await this.privateGetOrderCreate (this.extend (order, params));
        return {
            'info': result,
            'id': result['response']['order_id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostOrderCancel ({ 'order_id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        if (!this.apiKey)
            throw new AuthenticationError (this.id + ' requires apiKey for all requests');
        let url = this.urls['api'] + '/' + this.version + '/' + path + '.php';
        let query = this.extend ({ 'token': this.apiKey }, params);
        url += '?' + this.urlencode (query);
        let response = await this.fetch (url, method);
        if ('warning' in response)
            if (response['warning'])
                throw new ExchangeError (this.id + ' Warning: ' + response['warning_message']);
        if ('error' in response)
            if (response['error'])
                throw new ExchangeError (this.id + ' Error: ' + response['error_code'] + response['error_message']);
        return response;
    },
}

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

var cryptocapital = {

    'id': 'cryptocapital',
    'name': 'Crypto Capital',
    'comment': 'Crypto Capital API',
    'countries': 'PA', // Panama
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27993158-7a13f140-64ac-11e7-89cc-a3b441f0b0f8.jpg',
        'www': 'https://cryptocapital.co',
        'doc': 'https://github.com/cryptocap',
    },
    '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',
            ],
        },
    },

    async fetchBalance () {
        let response = await this.privatePostBalancesAndInfo ();
        let balance = response['balances-and-info'];
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance['available'])
                account['free'] = parseFloat (balance['available'][currency]);
            if (currency in balance['on_hold'])
                account['used'] = parseFloat (balance['on_hold'][currency]);
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let response = await this.publicGetOrderBook (this.extend ({
            'currency': this.marketId (market),
        }, params));
        let orderbook = response['order-book'];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'bid', 'asks': 'ask' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let timestamp = parseInt (order['timestamp']) * 1000;
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['order_amount']);
                result[key].push ([ price, amount, timestamp ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetStats ({
            'currency': this.marketId (market),
        });
        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']),
        };
    },

    async fetchTrades (market) {
        return this.publicGetTransactions ({
            'currency': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'side': side,
            'type': type,
            'currency': this.marketId (market),
            'amount': amount,
        };
        if (type == 'limit')
            order['limit_price'] = price;
        let result = await this.privatePostOrdersNew (this.extend (order, params));
        return {
            'info': result,
            'id': result,
        };
    },

    async cancelOrder (id) {
        return this.privatePostOrdersCancel ({ 'id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        if (this.id == 'cryptocapital')
            throw new ExchangeError (this.id + ' is an abstract base API for _1btcxe');
        let url = this.urls['api'] + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let query = this.extend ({
                'api_key': this.apiKey,
                'nonce': this.nonce (),
            }, params);
            let request = this.json (query);
            query['signature'] = this.hmac (this.encode (request), this.encode (this.secret));
            body = this.json (query);
            headers = { 'Content-Type': 'application/json' };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('errors' in response) {
            let errors = [];
            for (let e = 0; e < response['errors'].length; e++) {
                let error = response['errors'][e];
                errors.push (error['code'] + ': ' + error['message']);
            }
            errors = errors.join (' ');
            throw new ExchangeError (this.id + ' ' + errors);
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var _1btcxe = extend (cryptocapital, {

    'id': '_1btcxe',
    'name': '1BTCXE',
    'countries': 'PA', // Panama
    'comment': 'Crypto Capital API',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766049-2b294408-5ecc-11e7-85cc-adaff013dc1a.jpg',
        'api': 'https://1btcxe.com/api',
        'www': 'https://1btcxe.com',
        'market': 'https://1btcxe.com/order-book.php?currency=rub',
        'doc': 'https://1btcxe.com/api-docs.php',
    },
    'markets': {
        '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 anxpro = {

    'id': 'anxpro',
    'name': 'ANXPro',
    'countries': [ 'JP', 'SG', 'HK', 'NZ' ],
    'version': '2',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27765983-fd8595da-5ec9-11e7-82e3-adb3ab8c2612.jpg',
        'api': 'https://anxpro.com/api',
        'www': 'https://anxpro.com',
        'doc': [
            'http://docs.anxv2.apiary.io',
            'https://anxpro.com/pages/api',
        ],
    },
    'api': {
        'public': {
            'get': [
                '{currency_pair}/money/ticker',
                '{currency_pair}/money/depth/full',
                '{currency_pair}/money/trade/fetch', // disabled by ANXPro
            ],
        },
        'private': {
            'post': [
                '{currency_pair}/money/order/add',
                '{currency_pair}/money/order/cancel',
                '{currency_pair}/money/order/quote',
                '{currency_pair}/money/order/result',
                '{currency_pair}/money/orders',
                'money/{currency}/address',
                'money/{currency}/send_simple',
                'money/info',
                'money/trade/list',
                'money/wallet/history',
            ],
        },
    },
    'markets': {
        'BTC/USD': { 'id': 'BTCUSD', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/HKD': { 'id': 'BTCHKD', 'symbol': 'BTC/HKD', 'base': 'BTC', 'quote': 'HKD' },
        'BTC/EUR': { 'id': 'BTCEUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'BTC/CAD': { 'id': 'BTCCAD', 'symbol': 'BTC/CAD', 'base': 'BTC', 'quote': 'CAD' },
        'BTC/AUD': { 'id': 'BTCAUD', 'symbol': 'BTC/AUD', 'base': 'BTC', 'quote': 'AUD' },
        'BTC/SGD': { 'id': 'BTCSGD', 'symbol': 'BTC/SGD', 'base': 'BTC', 'quote': 'SGD' },
        'BTC/JPY': { 'id': 'BTCJPY', 'symbol': 'BTC/JPY', 'base': 'BTC', 'quote': 'JPY' },
        'BTC/GBP': { 'id': 'BTCGBP', 'symbol': 'BTC/GBP', 'base': 'BTC', 'quote': 'GBP' },
        'BTC/NZD': { 'id': 'BTCNZD', 'symbol': 'BTC/NZD', 'base': 'BTC', 'quote': 'NZD' },
        'LTC/BTC': { 'id': 'LTCBTC', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'DOGE/BTC': { 'id': 'DOGEBTC', 'symbol': 'DOGE/BTC', 'base': 'DOGE', 'quote': 'BTC' },
        'STR/BTC': { 'id': 'STRBTC', 'symbol': 'STR/BTC', 'base': 'STR', 'quote': 'BTC' },
        'XRP/BTC': { 'id': 'XRPBTC', 'symbol': 'XRP/BTC', 'base': 'XRP', 'quote': 'BTC' },
    },

    async fetchBalance () {
        let response = await this.privatePostMoneyInfo ();
        let balance = response['data'];
        let currencies = Object.keys (balance['Wallets']);
        let result = { 'info': balance };
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance['Wallets']) {
                let wallet = balance['Wallets'][currency];
                account['free'] = parseFloat (wallet['Available_Balance']['value']);
                account['total'] = parseFloat (wallet['Balance']['value']);
                account['used'] = account['total'] - account['free'];
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let response = await this.publicGetCurrencyPairMoneyDepthFull (this.extend ({
            'currency_pair': this.marketId (market),
        }, params));
        let orderbook = response['data'];
        let t = parseInt (orderbook['dataUpdateTime']);
        let timestamp = parseInt (t / 1000);
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['amount']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetCurrencyPairMoneyTicker ({
            'currency_pair': this.marketId (market),
        });
        let ticker = response['data'];
        let t = parseInt (ticker['dataUpdateTime']);
        let timestamp = parseInt (t / 1000);
        let bid = undefined;
        let ask = undefined;
        if (ticker['buy']['value'])
            bid = parseFloat (ticker['buy']['value']);
        if (ticker['sell']['value'])
            ask = parseFloat (ticker['sell']['value']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']['value']),
            'low': parseFloat (ticker['low']['value']),
            'bid': bid,
            'ask': ask,
            'vwap': parseFloat (ticker['vwap']['value']),
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']['value']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['avg']['value']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['vol']['value']),
        };
    },

    async fetchTrades (market) {
        let error = this.id + ' switched off the trades endpoint, see their docs at http://docs.anxv2.apiary.io/reference/market-data/currencypairmoneytradefetch-disabled';
        throw new ExchangeError (error);
        return this.publicGetCurrencyPairMoneyTradeFetch ({
            'currency_pair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'currency_pair': this.marketId (market),
            'amount_int': amount,
            'type': side,
        };
        if (type == 'limit')
            order['price_int'] = price;
        let result = await this.privatePostCurrencyPairOrderAdd (this.extend (order, params));
        return {
            'info': result,
            'id': result['data']
        };
    },

    async cancelOrder (id) {
        return this.privatePostCurrencyPairOrderCancel ({ 'oid': id });
    },

    nonce () {
        return this.milliseconds ();
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        let url = this.urls['api'] + '/' + this.version + '/' + request;
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({ 'nonce': nonce }, query));
            let secret = this.base64ToBinary (this.secret);
            let auth = request + "\0" + body;
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Rest-Key': this.apiKey,
                'Rest-Sign': this.hmac (this.encode (auth), secret, 'sha512', 'base64'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response)
            if (response['result'] == 'success')
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var bit2c = {

    'id': 'bit2c',
    'name': 'Bit2C',
    'countries': 'IL', // Israel
    'rateLimit': 3000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766119-3593220e-5ece-11e7-8b3a-5a041f6bcc3f.jpg',
        'api': 'https://www.bit2c.co.il',
        'www': 'https://www.bit2c.co.il',
        'market': 'https://www.bit2c.co.il/order/index?pair=LtcBtc',
        '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',
            ],
        },
    },
    'markets': {
        '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' },
    },

    async fetchBalance () {
        let balance = await this.privatePostAccountBalanceV2 ();
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance) {
                let available = 'AVAILABLE_' + currency;
                account['free'] = balance[available];
                account['total'] = balance[currency];
                account['used'] = account['total'] - account['free'];
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetExchangesPairOrderbook (this.extend ({
            'pair': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order[0];
                let amount = order[1];
                let timestamp = order[2] * 1000;
                result[side].push ([ price, amount, timestamp ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetExchangesPairTicker ({
            'pair': this.marketId (market),
        });
        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']),
        };
    },

    async fetchTrades (market) {
        return this.publicGetExchangesPairTrades ({
            'pair': this.marketId (market),
        });
    },

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

    async cancelOrder (id) {
        return this.privatePostOrderCancelOrder ({ 'id': id });
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.implodeParams (path, params);
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512', 'base64'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var bitbay = {

    'id': 'bitbay',
    'name': 'BitBay',
    'countries': [ 'PL', 'EU' ], // Poland
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766132-978a7bd8-5ece-11e7-9540-bc96d1e9bbb8.jpg',
        'www': 'https://bitbay.net',
        'market': 'https://bitbay.net/market',
        'api': {
            'public': 'https://bitbay.net/API/Public',
            'private': 'https://bitbay.net/API/Trading/tradingApi.php',
        },
        'doc': [
            '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',
            ],
        },
    },
    'markets': {
        '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' },
    },

    async fetchBalance () {
        let response = await this.privatePostInfo ();
        let balance = response['balances'];
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance) {
                account['free'] = parseFloat (balance[currency]['available']);
                account['used'] = parseFloat (balance[currency]['locked']);
                account['total'] = this.sum (account['free'], account['used']);
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetIdOrderbook (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetIdTicker ({
            'id': this.marketId (market),
        });
        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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetIdTrades ({
            'id': this.marketId (market),
        });
    },

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

    async cancelOrder (id) {
        return this.privatePostCancel ({ 'id': id });
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var bitbays = {

    'id': 'bitbays',
    'name': 'BitBays',
    'countries': [ 'CN', 'GB', 'HK', 'AU', 'CA' ],
    'rateLimit': 1500,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27808599-983687d2-6051-11e7-8d95-80dfcbe5cbb4.jpg',
        'api': 'https://bitbays.com/api',
        'www': 'https://bitbays.com',
        'market': 'https://bitbays.com/trade/?market=btc_usd',
        'doc': 'https://bitbays.com/help/api/',
    },
    'api': {
        'public': {
            'get': [
                'ticker',
                'trades',
                'depth',
            ],
        },
        'private': {
            'post': [
                'cancel',
                'info',
                'orders',
                'order',
                'transactions',
                'trade',
            ],
        },
    },
    'markets': {
        'BTC/USD': { 'id': 'btc_usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/CNY': { 'id': 'btc_cny', 'symbol': 'BTC/CNY', 'base': 'BTC', 'quote': 'CNY' },
        'ODS/BTC': { 'id': 'ods_btc', 'symbol': 'ODS/BTC', 'base': 'ODS', 'quote': 'BTC' },
        'LSK/BTC': { 'id': 'lsk_btc', 'symbol': 'LSK/BTC', 'base': 'LSK', 'quote': 'BTC' },
        'LSK/CNY': { 'id': 'lsk_cny', 'symbol': 'LSK/CNY', 'base': 'LSK', 'quote': 'CNY' },
    },

    async fetchBalance () {
        let response = await this.privatePostInfo ();
        let balance = response['result']['wallet'];
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balance) {
                account['free'] = parseFloat (balance[lowercase]['avail']);
                account['used'] = parseFloat (balance[lowercase]['lock']);
                account['total'] = this.sum (account['free'], account['used']);
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let response = await this.publicGetDepth (this.extend ({
            'market': this.marketId (market),
        }, params));
        let orderbook = response['result'];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetTicker ({
            'market': this.marketId (market),
        });
        let ticker = response['result'];
        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': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTrades ({
            'market': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'market': this.marketId (market),
            'op': side,
            'amount': amount,
        };
        if (type == 'market') {
            order['order_type'] = 1;
            order['price'] = price;
        } else {
            order['order_type'] = 0;
        }
        let response = await this.privatePostTrade (this.extend (order, params));
        return {
            'info': response,
            'id': response['result']['id'].toString (),
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancel ({ 'id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == '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 (this.encode (body), this.secret, 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('status' in response)
            if (response['status'] == 200)
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var bitcoincoid = {

    'id': 'bitcoincoid',
    'name': 'Bitcoin.co.id',
    'countries': 'ID', // Indonesia
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766138-043c7786-5ecf-11e7-882b-809c14f38b53.jpg',
        'api': {
            'public': 'https://vip.bitcoin.co.id/api',
            'private': 'https://vip.bitcoin.co.id/tapi',
        },
        'www': 'https://www.bitcoin.co.id',
        'doc': [
            'https://vip.bitcoin.co.id/downloads/BITCOINCOID-API-DOCUMENTATION.pdf',
            'https://vip.bitcoin.co.id/trade_api',
        ],
    },
    'api': {
        'public': {
            'get': [
                '{pair}/ticker',
                '{pair}/trades',
                '{pair}/depth',
            ],
        },
        'private': {
            'post': [
                'getInfo',
                'transHistory',
                'trade',
                'tradeHistory',
                'openOrders',
                'cancelOrder',
            ],
        },
    },
    'markets': {
        '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' },
    },

    async fetchBalance () {
        let response = await this.privatePostGetInfo ();
        let balance = response['return']['balance'];
        let frozen = response['return']['balance_hold'];
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balance) {
                account['free'] = parseFloat (balance[lowercase]);
            }
            if (lowercase in frozen) {
                account['used'] = parseFloat (frozen[lowercase]);
            }
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetPairDepth (this.extend ({
            'pair': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buy', 'asks': 'sell' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let pair = this.market (market);
        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': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker[baseVolume]),
            'quoteVolume': parseFloat (ticker[quoteVolume]),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetPairTrades ({
            'pair': this.marketId (market),
        });
    },

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

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

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + response['error']);
        return response;
    },
}

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

var bitfinex = {

    'id': 'bitfinex',
    'name': 'Bitfinex',
    'countries': 'US',
    'version': 'v1',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766244-e328a50c-5ed2-11e7-947b-041416579bb3.jpg',
        'api': 'https://api.bitfinex.com',
        'www': 'https://www.bitfinex.com',
        'market': 'https://www.bitfinex.com/trading/DSHBTC',
        'doc': [
            '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 fetchMarkets () {
        let markets = await this.publicGetSymbolsDetails ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['pair'].toUpperCase ();
            let baseId = id.slice (0, 3);
            let quoteId = id.slice (3, 6);
            let base = baseId;
            let quote = quoteId;
            // issue #4 Bitfinex names Dash as DSH, instead of DASH
            if (base == 'DSH')
                base = 'DASH';
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'baseId': baseId,
                'quoteId': quoteId,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostBalances ();
        let balances = {};
        for (let b = 0; b < response.length; b++) {
            let account = response[b];
            if (account['type'] == 'exchange') {
                let currency = account['currency'];
                // issue #4 Bitfinex names Dash as DSH, instead of DASH
                if (currency == 'DSH')
                    currency = 'DASH';
                let uppercase = currency.toUpperCase ();
                balances[uppercase] = account;
            }
        }
        let result = { 'info': response };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balances) {
                account['free'] = parseFloat (balances[currency]['available']);
                account['total'] = parseFloat (balances[currency]['amount']);
                account['used'] = account['total'] - account['free'];
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetBookSymbol (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['amount']);
                let timestamp = parseInt (parseFloat (order['timestamp']));
                result[side].push ([ price, amount, timestamp ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let ticker = await this.publicGetPubtickerSymbol ({
            'symbol': this.marketId (market),
        });
        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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradesSymbol ({
            'symbol': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'symbol': this.marketId (market),
            'amount': amount.toString (),
            'side': side,
            'type': 'exchange ' + type,
            'ocoorder': false,
            'buy_price_oco': 0,
            'sell_price_oco': 0,
        };
        if (type == 'market') {
            order['price'] = this.nonce ().toString ();
        } else {
            order['price'] = price;
        }
        let result = await this.privatePostOrderNew (this.extend (order, params));
        return {
            'info': result,
            'id': result['order_id'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostOrderCancel ({ 'order_id': id });
    },

    nonce () {
        return this.milliseconds ();
    },

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            query = this.extend ({
                'nonce': nonce.toString (),
                'request': request,
            }, query);
            query = this.json (query);
            query = this.encode (query);
            let payload = this.stringToBase64 (query);
            let secret = this.encode (this.secret);
            headers = {
                'X-BFX-APIKEY': this.apiKey,
                'X-BFX-PAYLOAD': payload,
                'X-BFX-SIGNATURE': this.hmac (payload, secret, 'sha384'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('message' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var bitflyer = {

    'id': 'bitflyer',
    'name': 'bitFlyer',
    'countries': 'JP',
    'version': 'v1',
    'rateLimit': 500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28051642-56154182-660e-11e7-9b0d-6042d1e6edd8.jpg',
        'api': 'https://api.bitflyer.jp',
        'www': 'https://bitflyer.jp',
        'doc': 'https://bitflyer.jp/API',
    },
    'api': {
        'public': {
            'get': [
                'getmarkets',    // or 'markets'
                'getboard',      // or 'board'
                'getticker',     // or 'ticker'
                'getexecutions', // or 'executions'
                'gethealth',
                'getchats',
            ],
        },
        'private': {
            'get': [
                'getpermissions',
                'getbalance',
                'getcollateral',
                'getcollateralaccounts',
                'getaddresses',
                'getcoinins',
                'getcoinouts',
                'getbankaccounts',
                'getdeposits',
                'getwithdrawals',
                'getchildorders',
                'getparentorders',
                'getparentorder',
                'getexecutions',
                'getpositions',
                'gettradingcommission',
            ],
            'post': [
                'sendcoin',
                'withdraw',
                'sendchildorder',
                'cancelchildorder',
                'sendparentorder',
                'cancelparentorder',
                'cancelallchildorders',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['product_code'];
            let currencies = id.split ('_');
            let base = undefined;
            let quote = undefined;
            let symbol = id;
            let numCurrencies = currencies.length;
            if (numCurrencies == 2) {
                base = currencies[0];
                quote = currencies[1];
                symbol = base + '/' + quote;
            }
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalance ();
        let balances = {};
        for (let b = 0; b < response.length; b++) {
            let account = response[b];
            let currency = account['currency_code'];
            balances[currency] = account;
        }
        let result = { 'info': response };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balances) {
                account['total'] = balances[currency]['amount'];
                account['free'] = balances[currency]['available'];
                account['used'] = account['total'] - account['free'];
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetBoard (this.extend ({
            'product_code': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['size']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let ticker = await this.publicGetTicker ({
            'product_code': this.marketId (market),
        });
        let timestamp = this.parse8601 (ticker['timestamp']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': parseFloat (ticker['best_bid']),
            'ask': parseFloat (ticker['best_ask']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['ltp']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['volume_by_product']),
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetExecutions ({
            'product_code': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'product_code': this.marketId (market),
            'child_order_type': type.toUpperCase (),
            'side': side.toUpperCase (),
            'price': price,
            'size': amount,
        };
        let result = await this.privatePostSendchildorder (this.extend (order, params));
        return {
            'info': result,
            'id': result['child_order_acceptance_id'],
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privatePostCancelchildorder (this.extend ({
            'parent_order_id': id,
        }, params));
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = '/' + this.version + '/' + path;
        if (api == 'private')
            request = '/me' + request;
        let url = this.urls['api'] + request;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString ();
            body = this.json (params);
            let auth = [ nonce, method, request, body ].join ('');
            headers = {
                'ACCESS-KEY': this.apiKey,
                'ACCESS-TIMESTAMP': nonce,
                'ACCESS-SIGN': this.hmac (this.encode (auth), this.secret),
                'Content-Type': 'application/json',
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var bitlish = {

    'id': 'bitlish',
    'name': 'bitlish',
    'countries': [ 'GB', 'EU', 'RU' ],
    'rateLimit': 1500,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766275-dcfc6c30-5ed3-11e7-839d-00a846385d0b.jpg',
        'api': 'https://bitlish.com/api',
        'www': 'https://bitlish.com',
        'market': 'https://bitlish.com/trade/btceur',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetPairs ();
        let result = [];
        let keys = Object.keys (markets);
        for (let p = 0; p < keys.length; p++) {
            let market = markets[keys[p]];
            let id = market['id'];
            let symbol = market['name'];
            let [ base, quote ] = symbol.split ('/');
            // issue #4 bitlish names Dash as DSH, instead of DASH
            if (base == 'DSH')
                base = 'DASH';
            symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetTickers ();
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let tickers = await this.publicGetTickers ();
        let ticker = tickers[p['id']];
        return this.parseTicker (ticker, p);
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetTradesDepth (this.extend ({
            'pair_id': this.marketId (market),
        }, params));
        let timestamp = parseInt (parseInt (orderbook['last']) / 1000);
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'bid', 'asks': 'ask' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['volume']);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradesHistory ({
            'pair_id': this.marketId (market),
        });
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostBalance ();
        let result = { 'info': response };
        let currencies = Object.keys (response);
        let balance = {};
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let account = response[currency];
            currency = currency.toUpperCase ();
            // issue #4 bitlish names Dash as DSH, instead of DASH
            if (currency == 'DSH')
                currency = 'DASH';
            balance[currency] = account;
        }
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance) {
                account['free'] = parseFloat (balance[currency]['funds']);
                account['used'] = parseFloat (balance[currency]['holded']);
                account['total'] = this.sum (account['free'], account['used']);
            }
            result[currency] = account;
        }
        return result;
    },

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

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'pair_id': this.marketId (market),
            'dir': (side == 'buy') ? 'bid' : 'ask',
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let result = await this.privatePostCreateTrade (this.extend (order, params));
        return {
            'info': result,
            'id': result['id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelTrade ({ 'id': id });
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            body = this.json (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': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27767256-a8555200-5ef9-11e7-96fd-469a65e2b0bd.jpg',
        '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',
        ],
        'market': 'https://www.bitmarket.net/market.php?market=BTCEUR',
        'doc': [
            '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',
            ],
        },
    },
    'markets': {
        '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' },
        'LiteMineX/BTC': { 'id': 'LiteMineXBTC', 'symbol': 'LiteMineX/BTC', 'base': 'LiteMineX', 'quote': 'BTC' },
        'PlnX/BTC': { 'id': 'PlnxBTC', 'symbol': 'PlnX/BTC', 'base': 'PlnX', 'quote': 'BTC' },
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostInfo ();
        let data = response['data'];
        let balance = data['balances'];
        let result = { 'info': data };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance['available'])
                account['free'] = balance['available'][currency];
            if (currency in balance['blocked'])
                account['used'] = balance['blocked'][currency];
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetJsonMarketOrderbook (this.extend ({
            'market': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;

    },

    async fetchTicker (market) {
        let ticker = await this.publicGetJsonMarketTicker ({
            'market': this.marketId (market),
        });
        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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetJsonMarketTrades ({
            'market': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let response = await this.privatePostTrade (this.extend ({
            'market': this.marketId (market),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
        let result = {
            'info': response,
        };
        if ('id' in response['order'])
            result['id'] = response['id'];
        return result;
    },

    async cancelOrder (id) {
        return this.privatePostCancel ({ 'id': id });
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var bitmex = {

    'id': 'bitmex',
    'name': 'BitMEX',
    'countries': 'SC', // Seychelles
    'version': 'v1',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766319-f653c6e6-5ed4-11e7-933d-f0bc3699ae8f.jpg',
        'api': 'https://www.bitmex.com',
        'www': 'https://www.bitmex.com',
        'market': 'https://www.bitmex.com/app/trade/XBTUSD',
        'doc': [
            '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 fetchMarkets () {
        let markets = await this.publicGetInstrumentActive ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['symbol'];
            let base = market['underlying'];
            let quote = market['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': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetUserMargin ({ 'currency': 'all' });
        let result = { 'info': response };
        for (let b = 0; b < response.length; b++) {
            let balance = response[b];
            let currency = balance['currency'].toUpperCase ();
            currency = this.commonCurrencyCode (currency);
            let account = {
                'free': balance['availableMargin'],
                'used': undefined,
                'total': balance['amount'],
            };
            if (currency == 'BTC') {
                account['free'] = account['free'] * 0.00000001;
                account['total'] = account['total'] * 0.00000001;
            }
            account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetOrderBookL2 (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        for (let o = 0; o < orderbook.length; o++) {
            let order = orderbook[o];
            let side = (order['side'] == 'Sell') ? 'asks' : 'bids';
            let amount = order['size'];
            let price = order['price'];
            result[side].push ([ price, amount ]);
        }
        result['bids'] = this.sortBy (result['bids'], 0, true);
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let request = {
            'symbol': this.marketId (market),
            '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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrade ({
            'symbol': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'symbol': this.marketId (market),
            'side': this.capitalize (side),
            'orderQty': amount,
            'ordType': this.capitalize (type),
        };
        if (type == 'limit')
            order['rate'] = price;
        let response = await this.privatePostOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response['orderID'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privateDeleteOrder ({ 'orderID': id });
    },

    request (path, api = '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 (api == 'private') {
            let nonce = this.nonce ().toString ();
            if (method == 'POST')
                if (Object.keys (params).length)
                    body = this.json (params);
            let request = [ method, query, nonce, body || ''].join ('');
            headers = {
                'Content-Type': 'application/json',
                'api-nonce': nonce,
                'api-key': this.apiKey,
                'api-signature': this.hmac (this.encode (request), this.encode (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': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766335-715ce7aa-5ed5-11e7-88a8-173a27bb30fe.jpg',
        'api': 'https://api.bitso.com',
        'www': 'https://bitso.com',
        'market': 'https://bitso.com/trade/market/btc/mxn',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetAvailableBooks ();
        let result = [];
        for (let p = 0; p < markets['payload'].length; p++) {
            let market = markets['payload'][p];
            let id = market['book'];
            let symbol = id.toUpperCase ().replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalance ();
        let balances = response['payload']['balances'];
        let result = { 'info': response };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'].toUpperCase ();
            let account = {
                'free': parseFloat (balance['available']),
                'used': parseFloat (balance['locked']),
                'total': parseFloat (balance['total']),
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.publicGetOrderBook (this.extend ({
            'book': this.marketId (market),
        }, params));
        let orderbook = response['payload'];
        let timestamp = this.parse8601 (orderbook['updated_at']);
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['amount']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },


    async fetchTicker (market) {
        await this.loadMarkets ();
        let response = await this.publicGetTicker ({
            'book': this.marketId (market),
        });
        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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrades ({
            'book': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'book': this.marketId (market),
            'side': side,
            'type': type,
            'major': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this.privatePostOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['payload']['oid'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privateDeleteOrders ({ 'oid': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let query = '/' + this.version + '/' + this.implodeParams (path, params);
        let url = this.urls['api'] + query;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            if (Object.keys (params).length)
                body = this.json (params);
            let nonce = this.nonce ().toString ();
            let request = [ nonce, method, query, body || '' ].join ('');
            let signature = this.hmac (this.encode (request), this.encode (this.secret));
            let auth = this.apiKey + ':' + nonce + ':' + signature;
            headers = { 'Authorization': "Bitso " + auth };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var bitstamp = {

    'id': 'bitstamp',
    'name': 'Bitstamp',
    'countries': 'GB',
    'rateLimit': 1000,
    'version': 'v2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27786377-8c8ab57e-5fe9-11e7-8ea4-2b05b6bcceec.jpg',
        'api': 'https://www.bitstamp.net/api',
        'www': 'https://www.bitstamp.net',
        'market': 'https://www.bitstamp.net/market/tradeview/',
        'doc': 'https://www.bitstamp.net/api',
    },
    'api': {
        'public': {
            'get': [
                'order_book/{id}/',
                'ticker_hour/{id}/',
                'ticker/{id}/',
                'transactions/{id}/',
            ],
        },
        'private': {
            'post': [
                'balance/',
                'balance/{id}/',
                'buy/{id}/',
                'buy/market/{id}/',
                'cancel_order/',
                'liquidation_address/info/',
                'liquidation_address/new/',
                'open_orders/all/',
                'open_orders/{id}/',
                'sell/{id}/',
                'sell/market/{id}/',
                'transfer-from-main/',
                'transfer-to-main/',
                'user_transactions/',
                'user_transactions/{id}/',
                'withdrawal/cancel/',
                'withdrawal/open/',
                'withdrawal/status/',
                'xrp_address/',
                'xrp_withdrawal/',
            ],
        },
    },
    'markets': {
        'BTC/USD': { 'id': 'btcusd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/EUR': { 'id': 'btceur', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'EUR/USD': { 'id': 'eurusd', 'symbol': 'EUR/USD', 'base': 'EUR', 'quote': 'USD' },
        'XRP/USD': { 'id': 'xrpusd', 'symbol': 'XRP/USD', 'base': 'XRP', 'quote': 'USD' },
        'XRP/EUR': { 'id': 'xrpeur', 'symbol': 'XRP/EUR', 'base': 'XRP', 'quote': 'EUR' },
        'XRP/BTC': { 'id': 'xrpbtc', 'symbol': 'XRP/BTC', 'base': 'XRP', 'quote': 'BTC' },
        'LTC/USD': { 'id': 'ltcusd', 'symbol': 'LTC/USD', 'base': 'LTC', 'quote': 'USD' },
        'LTC/EUR': { 'id': 'ltceur', 'symbol': 'LTC/EUR', 'base': 'LTC', 'quote': 'EUR' },
        'LTC/BTC': { 'id': 'ltcbtc', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetOrderBookId (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = parseInt (orderbook['timestamp']) * 1000;
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetTickerId ({
            'id': this.marketId (market),
        });
        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': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTransactionsId ({
            'id': this.marketId (market),
        });
    },

    async fetchBalance () {
        let balance = await this.privatePostBalance ();
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let total = lowercase + '_balance';
            let free = lowercase + '_available';
            let used = lowercase + '_reserved';
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (free in balance)
                account['free'] = parseFloat (balance[free]);
            if (used in balance)
                account['used'] = parseFloat (balance[used]);
            if (total in balance)
                account['total'] = parseFloat (balance[total]);
            result[currency] = account;
        }
        return result;
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side);
        let order = {
            'id': this.marketId (market),
            'amount': amount,
        };
        if (type == 'market')
            method += 'Market';
        else
            order['price'] = price;
        method += 'Id';
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancelOrder ({ 'id': id });
    },

    request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            if (!this.uid)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.uid` property for authentication');
            let nonce = this.nonce ().toString ();
            let auth = nonce + this.uid + this.apiKey;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret));
            query = this.extend ({
                'key': this.apiKey,
                'signature': signature.toUpperCase (),
                'nonce': nonce,
            }, query);
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var bittrex = {

    'id': 'bittrex',
    'name': 'Bittrex',
    'countries': 'US',
    'version': 'v1.1',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766352-cf0b3c26-5ed5-11e7-82b7-f3826b7a97d8.jpg',
        'api': 'https://bittrex.com/api',
        'www': 'https://bittrex.com',
        'market': 'https://bittrex.com/Market/Index',
        'doc': [
            '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 getMarketURL (market, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        return this.url (this.urls['market'], this.extend ({
            'MarketName': m['id'],
        }, params));
    },

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

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.accountGetBalances ();
        let balances = response['result'];
        let result = { 'info': balances };
        let indexed = this.indexBy (balances, 'Currency');
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in indexed) {
                let balance = indexed[currency];
                account['free'] = balance['Available'];
                account['used'] = balance['Balance'] - balance['Available'];
                account['total'] = balance['Balance'];
            }
            result[currency] = account;
        }
        return result;
    },

    parseBidAsk (bidask) {
        let price = parseFloat (bidask['Rate']);
        let amount = parseFloat (bidask['Quantity']);
        return [ price, amount ];
    },

    parseBidAsks (bidasks) {
        let result = [];
        for (let i = 0; i < bidasks.length; i++) {
            result.push (this.parseBidAsk (bidasks[i]));
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.publicGetOrderbook (this.extend ({
            'market': this.marketId (market),
            'type': 'both',
            'depth': 50,
        }, params));
        let orderbook = response['result'];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buy', 'asks': 'sell' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            result[key] = this.parseBidAsks (orderbook[side]);
        }
        return result;
    },

    parseTicker (ticker, market) {
        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': parseFloat (ticker['BaseVolume']),
            'quoteVolume': parseFloat (ticker['Volume']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetMarketsummaries ();
        let tickers = response['result'];
        let result = {};
        for (let t = 0; t < tickers.length; t++) {
            let ticker = tickers[t];
            let id = ticker['MarketName'];
            let market = undefined;
            let symbol = id;
            if (id in this.markets_by_id) {
                market = this.markets_by_id[id];
                symbol = market['symbol'];
            } else {
                let [ quote, base ] = id.split ('-');
                base = this.commonCurrencyCode (base);
                quote = this.commonCurrencyCode (quote);
                symbol = base + '/' + quote;
            }
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let m = this.market (market);
        let response = await this.publicGetMarketsummary ({
            'market': m['id'],
        });
        let ticker = response['result'][0];
        return this.parseTicker (ticker, m);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetMarkethistory ({
            'market': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let method = 'marketGet' + this.capitalize (side) + type;
        let order = {
            'market': this.marketId (market),
            'quantity': amount,
        };
        if (type == 'limit')
            order['rate'] = price;
        let response = await this[method] (this.extend (order, params));
        let result = {
            'info': response,
            'id': response['result']['uuid'],
        };
        return result;
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.marketGetCancel ({ 'uuid': id });
    },

    async fetchOrder (id) {
        await this.loadMarkets ();
        let response = await this.accountGetOrder ({ 'uuid': id });
        let orderInfo = response['result'];
        let orderType = (orderInfo['Type'] == 'LIMIT_BUY') ? 'buy' : 'sell';
        let result = {
            'info': response,
            'type': orderType,
            'rate': orderInfo['PricePerUnit'],
            'startingAmount': orderInfo['Quantity'],
            'remaining': orderInfo['QuantityRemaining'],
            'isOpen': orderInfo['IsOpen'],
            'isCanceled': orderInfo['CancelInitiated'],
        };
        return result;
    },

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

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

var blinktrade = {

    'id': 'blinktrade',
    'name': 'BlinkTrade',
    'countries': [ 'US', 'VE', 'VN', 'BR', 'PK', 'CL' ],
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27990968-75d9c884-6470-11e7-9073-46756c8e7e8c.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://blinktrade.com',
        'doc': 'https://blinktrade.com/docs',
    },
    'api': {
        'public': {
            'get': [
                '{currency}/ticker',    // ?crypto_currency=BTC
                '{currency}/orderbook', // ?crypto_currency=BTC
                '{currency}/trades',    // ?crypto_currency=BTC&since=<TIMESTAMP>&limit=<NUMBER>
            ],
        },
        'private': {
            'post': [
                'D',   // order
                'F',   // cancel order
                'U2',  // balance
                'U4',  // my orders
                'U6',  // withdraw
                'U18', // deposit
                'U24', // confirm withdrawal
                'U26', // list withdrawals
                'U30', // list deposits
                'U34', // ledger
                'U70', // cancel withdrawal
            ],
        },
    },
    'markets': {
        'BTC/VEF': { 'id': 'BTCVEF', 'symbol': 'BTC/VEF', 'base': 'BTC', 'quote': 'VEF', 'brokerId': 1, 'broker': 'SurBitcoin' },
        'BTC/VND': { 'id': 'BTCVND', 'symbol': 'BTC/VND', 'base': 'BTC', 'quote': 'VND', 'brokerId': 3, 'broker': 'VBTC' },
        'BTC/BRL': { 'id': 'BTCBRL', 'symbol': 'BTC/BRL', 'base': 'BTC', 'quote': 'BRL', 'brokerId': 4, 'broker': 'FoxBit' },
        'BTC/PKR': { 'id': 'BTCPKR', 'symbol': 'BTC/PKR', 'base': 'BTC', 'quote': 'PKR', 'brokerId': 8, 'broker': 'UrduBit' },
        'BTC/CLP': { 'id': 'BTCCLP', 'symbol': 'BTC/CLP', 'base': 'BTC', 'quote': 'CLP', 'brokerId': 9, 'broker': 'ChileBit' },
    },

    async fetchBalance () {
        return this.privatePostU2 ({
            'BalanceReqID': this.nonce (),
        });
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let orderbook = await this.publicGetCurrencyOrderbook (this.extend ({
            'currency': p['quote'],
            'crypto_currency': p['base'],
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let p = this.market (market);
        let ticker = await this.publicGetCurrencyTicker ({
            'currency': p['quote'],
            'crypto_currency': p['base'],
        });
        let timestamp = this.milliseconds ();
        let lowercaseQuote = p['quote'].toLowerCase ();
        let quoteVolume = 'vol_' + lowercaseQuote;
        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[quoteVolume]),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        let p = this.market (market);
        return this.publicGetCurrencyTrades ({
            'currency': p['quote'],
            'crypto_currency': p['base'],
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let p = this.market (market);
        let order = {
            'ClOrdID': this.nonce (),
            'Symbol': p['id'],
            'Side': this.capitalize (side),
            'OrdType': 2,
            'Price': price,
            'OrderQty': amount,
            'BrokerID': p['brokerId'],
        };
        let response = await this.privatePostD (this.extend (order, params));
        return {
            'info': response,
            'id': response['OrderID'],
        };
    },

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

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

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

var bl3p = {

    'id': 'bl3p',
    'name': 'BL3P',
    'countries': [ 'NL', 'EU' ], // Netherlands, EU
    'rateLimit': 1000,
    'version': '1',
    'comment': 'An exchange market by BitonicNL',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28501752-60c21b82-6feb-11e7-818b-055ee6d0e754.jpg',
        'api': 'https://api.bl3p.eu',
        'www': [
            'https://bl3p.eu',
            'https://bitonic.nl',
        ],
        'doc': [
            'https://github.com/BitonicNL/bl3p-api/tree/master/docs',
            'https://bl3p.eu/api',
            'https://bitonic.nl/en/api',
        ],
    },
    'api': {
        'public': {
            'get': [
                '{market}/ticker',
                '{market}/orderbook',
                '{market}/trades',
            ],
        },
        'private': {
            'post': [
                '{market}/money/depth/full',
                '{market}/money/order/add',
                '{market}/money/order/cancel',
                '{market}/money/order/result',
                '{market}/money/orders',
                '{market}/money/orders/history',
                '{market}/money/trades/fetch',
                'GENMKT/money/info',
                'GENMKT/money/deposit_address',
                'GENMKT/money/new_deposit_address',
                'GENMKT/money/wallet/history',
                'GENMKT/money/withdraw',
            ],
        },
    },
    'markets': {
        'BTC/EUR': { 'id': 'BTCEUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'LTC/EUR': { 'id': 'LTCEUR', 'symbol': 'LTC/EUR', 'base': 'LTC', 'quote': 'EUR' },
    },

    async fetchBalance () {
        let response = await this.privatePostGENMKTMoneyInfo ();
        let data = response['data'];
        let balance = data['wallets'];
        let result = { 'info': data };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balance) {
                if ('available' in balance[currency]) {
                    account['free'] = parseFloat (balance[currency]['available']['value']);
                }
            }
            if (currency in balance) {
                if ('balance' in balance[currency]) {
                    account['total'] = parseFloat (balance[currency]['balance']['value']);
                }
            }
            if (account['total']) {
                if (account['free']) {
                    account['used'] = account['total'] - account['free'];
                }
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let response = await this.publicGetMarketOrderbook (this.extend ({
            'market': p['id'],
        }, params));
        let orderbook = response['data'];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['price_int'] / 100000;
                let amount = order['amount_int'] / 100000000;
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetMarketTicker ({
            'market': this.marketId (market),
        });
        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']['24h']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetMarketTrades ({
            'market': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let p = this.market (market);
        let order = {
            'market': p['id'],
            'amount_int': amount,
            'fee_currency': p['quote'],
            'type': (side == 'buy') ? 'bid' : 'ask',
        };
        if (type == 'limit')
            order['price_int'] = price;
        let response = await this.privatePostMarketMoneyOrderAdd (this.extend (order, params));
        return {
            'info': response,
            'id': response['order_id'].toString (),
        };
    },

    async cancelOrder (id) {
        return this.privatePostMarketMoneyOrderCancel ({ 'order_id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = this.implodeParams (path, params);
        let url = this.urls['api'] + '/' + this.version + '/' + request;
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({ 'nonce': nonce }, query));
            let secret = this.base64ToBinary (this.secret);
            let auth = request + "\0" + body;
            let signature = this.hmac (this.encode (auth), secret, 'sha512', 'base64');
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Rest-Key': this.apiKey,
                'Rest-Sign': signature,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var btcchina = {

    'id': 'btcchina',
    'name': 'BTCChina',
    'countries': 'CN',
    'rateLimit': 1500,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766368-465b3286-5ed6-11e7-9a11-0f6467e1d82b.jpg',
        'api': {
            'public': 'https://data.btcchina.com/data',
            'private': 'https://api.btcchina.com/api_trade_v1.php',
        },
        'www': 'https://www.btcchina.com',
        'market': 'https://www.btcchina.com/exc/trade/cnybtc',
        'doc': 'https://www.btcchina.com/apidocs'
    },
    'api': {
        'public': {
            'get': [
                'historydata',
                'orderbook',
                'ticker',
                'trades',
            ],
        },
        'private': {
            'post': [
                'BuyIcebergOrder',
                'BuyOrder',
                'BuyOrder2',
                'BuyStopOrder',
                'CancelIcebergOrder',
                'CancelOrder',
                'CancelStopOrder',
                'GetAccountInfo',
                'getArchivedOrder',
                'getArchivedOrders',
                'GetDeposits',
                'GetIcebergOrder',
                'GetIcebergOrders',
                'GetMarketDepth',
                'GetMarketDepth2',
                'GetOrder',
                'GetOrders',
                'GetStopOrder',
                'GetStopOrders',
                'GetTransactions',
                'GetWithdrawal',
                'GetWithdrawals',
                'RequestWithdrawal',
                'SellIcebergOrder',
                'SellOrder',
                'SellOrder2',
                'SellStopOrder',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetTicker ({
            'market': 'all',
        });
        let result = [];
        let keys = Object.keys (markets);
        for (let p = 0; p < keys.length; p++) {
            let key = keys[p];
            let market = markets[key];
            let parts = key.split ('_');
            let id = parts[1];
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            base = base.toUpperCase ();
            quote = quote.toUpperCase ();
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostGetAccountInfo ();
        let balances = response['result'];
        let result = { 'info': balances };

        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balances['balance'])
                account['total'] = parseFloat (balances['balance'][lowercase]['amount']);
            if (lowercase in balances['frozen'])
                account['used'] = parseFloat (balances['frozen'][lowercase]['amount']);
            account['free'] = account['total'] - account['used'];
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetOrderbook (this.extend ({
            'market': this.marketId (market),
        }, params));
        let timestamp = orderbook['date'] * 1000;;
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let tickers = await this.publicGetTicker ({
            'market': p['id'],
        });
        let ticker = tickers['ticker'];
        let timestamp = ticker['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': parseFloat (ticker['vwap']),
            'open': parseFloat (ticker['open']),
            'close': parseFloat (ticker['prev_close']),
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrades ({
            'market': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let method = 'privatePost' + this.capitalize (side) + 'Order2';
        let order = {};
        let id = p['id'].toUpperCase ();
        if (type == 'market') {
            order['params'] = [ undefined, amount, id ];
        } else {
            order['params'] = [ price, amount, id ];
        }
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        let market = params['market']; // TODO fixme
        return this.privatePostCancelOrder (this.extend ({
            'params': [ id, market ],
        }, params));
    },

    nonce () {
        return this.microseconds ();
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api] + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            if (!this.apiKey)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.apiKey` property for authentication');
            if (!this.secret)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.secret` property for authentication');
            let p = [];
            if ('params' in params)
                p = params['params'];
            let nonce = this.nonce ();
            let request = {
                'method': path,
                'id': nonce,
                'params': p,
            };
            p = p.join (',');
            body = this.json (request);
            let query = (
                'tonce=' + nonce +
                '&accesskey=' + this.apiKey +
                '&requestmethod=' + method.toLowerCase () +
                '&id=' + nonce +
                '&method=' + path +
                '&params=' + p
            );
            let signature = this.hmac (this.encode (query), this.encode (this.secret), 'sha1');
            let auth = this.apiKey + ':' + signature;
            headers = {
                'Content-Length': body.length,
                'Authorization': 'Basic ' + this.stringToBase64 (auth),
                'Json-Rpc-Tonce': nonce,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var btce = {

    'id': 'btce',
    'name': 'BTC-e',
    'countries': [ 'BG', 'RU' ], // Bulgaria, Russia
    'version': '3',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27843225-1b571514-611a-11e7-9208-2641a560b561.jpg',
        'api': {
            'public': 'https://btc-e.com/api',
            'private': 'https://btc-e.com/tapi',
        },
        'www': 'https://btc-e.com',
        'doc': [
            'https://btc-e.com/api/3/docs',
            'https://btc-e.com/tapi/docs',
        ],
    },
    'api': {
        'public': {
            'get': [
                'info',
                'ticker/{pair}',
                'depth/{pair}',
                'trades/{pair}',
            ],
        },
        'private': {
            'post': [
                'getInfo',
                'Trade',
                'ActiveOrders',
                'OrderInfo',
                'CancelOrder',
                'TradeHistory',
                'TransHistory',
                'CoinDepositAddress',
                'WithdrawCoin',
                'CreateCoupon',
                'RedeemCoupon',
            ],
        }
    },

    async fetchMarkets () {
        let response = await this.publicGetInfo ();
        let markets = response['pairs'];
        let keys = Object.keys (markets);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let market = markets[id];
            let [ base, quote ] = id.split ('_');
            base = base.toUpperCase ();
            quote = quote.toUpperCase ();
            if (base == 'DSH')
                base = 'DASH';
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostGetInfo ();
        let balances = response['return'];
        let result = { 'info': balances };
        let funds = balances['funds'];
        let currencies = Object.keys (funds);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let uppercase = currency.toUpperCase ();
            // they misspell DASH as dsh :/
            if (uppercase == 'DSH')
                uppercase = 'DASH';
            let account = {
                'free': funds[currency],
                'used': undefined,
                'total': funds[currency],
            };
            result[uppercase] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.publicGetDepthPair (this.extend ({
            'pair': p['id'],
        }, params));
        if (p['id'] in response) {
            let orderbook = response[p['id']];
            let timestamp = this.milliseconds ();
            let result = {
                'bids': orderbook['bids'],
                'asks': orderbook['asks'],
                'timestamp': timestamp,
                'datetime': this.iso8601 (timestamp),
            };
            result['bids'] = this.sortBy (result['bids'], 0, true);
            result['asks'] = this.sortBy (result['asks'], 0);
            return result;
        }
        throw new ExchangeError (this.id + ' ' + p['symbol'] + ' order book is empty or not available');
    },

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

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradesPair ({
            'pair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'pair': this.marketId (market),
            'type': side,
            'amount': amount,
            'rate': price,
        };
        let response = await this.privatePostTrade (this.extend (order, params));
        return {
            'info': response,
            'id': response['return']['order_id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'order_id': id });
    },

    async fetchOrder (id) {
        await this.loadMarkets ();
        let response = await this.privatePostOrderInfo ({ 'order_id': id });
        let orderInfo = response['return'][id];
        let isCanceled = false;
        if ((orderInfo['status'] == 2) || (orderInfo['status'] == 3))
            isCanceled = true;
        let result = {
            'info': response,
            'type': orderInfo['type'],
            'rate': orderInfo['rate'],
            'startingAmount': orderInfo['start_amount'],
            'remaining': orderInfo['amount'],
            'isOpen': orderInfo['status'] == 0,
            'isCanceled': isCanceled,
        };
        return result;
    },

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

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

var btcmarkets = {

    'id': 'btcmarkets',
    'name': 'BTC Markets',
    'countries': 'AU', // Australia
    'rateLimit': 1000, // market data cached for 1 second (trades cached for 2 seconds)
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/29142911-0e1acfc2-7d5c-11e7-98c4-07d9532b29d7.jpg',
        'api': 'https://api.btcmarkets.net',
        'www': 'https://btcmarkets.net/',
        'doc': 'https://github.com/BTCMarkets/API',
    },
    'api': {
        'public': {
            'get': [
                'market/{id}/tick',
                'market/{id}/orderbook',
                'market/{id}/trades',
            ],
        },
        'private': {
            'get': [
                'account/balance',
                'account/{id}/tradingfee',
            ],
            'post': [
                'fundtransfer/withdrawCrypto',
                'fundtransfer/withdrawEFT',
                'order/create',
                'order/cancel',
                'order/history',
                'order/open',
                'order/trade/history',
                'order/createBatch', // they promise it's coming soon...
                'order/detail',
            ],
        },
    },
    'markets': {
        'BTC/AUD': { 'id': 'BTC/AUD', 'symbol': 'BTC/AUD', 'base': 'BTC', 'quote': 'AUD' },
        'LTC/AUD': { 'id': 'LTC/AUD', 'symbol': 'LTC/AUD', 'base': 'LTC', 'quote': 'AUD' },
        'ETH/AUD': { 'id': 'ETH/AUD', 'symbol': 'ETH/AUD', 'base': 'ETH', 'quote': 'AUD' },
        'ETC/AUD': { 'id': 'ETC/AUD', 'symbol': 'ETC/AUD', 'base': 'ETC', 'quote': 'AUD' },
        'XRP/AUD': { 'id': 'XRP/AUD', 'symbol': 'XRP/AUD', 'base': 'XRP', 'quote': 'AUD' },
        'BCH/AUD': { 'id': 'BCH/AUD', 'symbol': 'BCH/AUD', 'base': 'BCH', 'quote': 'AUD' },
        'LTC/BTC': { 'id': 'LTC/BTC', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'ETH/BTC': { 'id': 'ETH/BTC', 'symbol': 'ETH/BTC', 'base': 'ETH', 'quote': 'BTC' },
        'ETC/BTC': { 'id': 'ETC/BTC', 'symbol': 'ETC/BTC', 'base': 'ETC', 'quote': 'BTC' },
        'XRP/BTC': { 'id': 'XRP/BTC', 'symbol': 'XRP/BTC', 'base': 'XRP', 'quote': 'BTC' },
        'BCH/BTC': { 'id': 'BCH/BTC', 'symbol': 'BCH/BTC', 'base': 'BCH', 'quote': 'BTC' },
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privateGetAccountBalance ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let multiplier = 100000000;
            let free = parseFloat (balance['balance'] / multiplier);
            let used = parseFloat (balance['pendingFunds'] / multiplier);
            let account = {
                'free': free,
                'used': used,
                'total': this.sum (free, used),
            };
            result[currency] = account;
        }
        return result;
    },

    parseBidAsk (bidask) {
        let price = bidask[0];
        let amount = bidask[1];
        return [ price, amount ];
    },

    parseBidAsks (bidasks) {
        let result = [];
        for (let i = 0; i < bidasks.length; i++) {
            result.push (this.parseBidAsk (bidasks[i]));
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        let orderbook = await this.publicGetMarketIdOrderbook (this.extend ({
            'id': m['id'],
        }, params));
        let timestamp = orderbook['timestamp'] * 1000;
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            result[side] = this.parseBidAsks (orderbook[side]);
        }
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = ticker['timestamp'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': parseFloat (ticker['bestBid']),
            'ask': parseFloat (ticker['bestAsk']),
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['lastPrice']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume24h']),
            'info': ticker,
        };
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let m = this.market (market);
        let ticker = await this.publicGetMarketIdTick ({
            'id': m['id'],
        });
        return this.parseTicker (ticker, m);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetMarketIdTrades ({
            // 'since': 59868345231,
            'id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        let multiplier = 100000000; // for price and volume
        // does BTC Markets support market orders at all?
        let orderSide = (side == 'buy') ? 'Bid' : 'Ask';
        let order = this.ordered ({
            'currency': m['quote'],
            'instrument': m['base'],
            'price': price * multiplier,
            'volume': amount * multiplier,
            'orderSide': orderSide,
            'ordertype': this.capitalize (type),
            'clientRequestId': this.nonce ().toString (),
        });
        let response = await this.privatePostOrderCreate (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrders (ids) {
        await this.loadMarkets ();
        return this.privatePostOrderCancel ({ 'order_ids': ids });
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.cancelOrders ([ id ]);
    },

    nonce () {
        return this.milliseconds ();
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let uri = '/' + this.implodeParams (path, params);
        let url = this.urls['api'] + uri;
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString ();
            let auth = uri + "\n" + nonce + "\n";
            headers = {
                'Content-Type': 'application/json',
                'apikey': this.apiKey,
                'timestamp': nonce,
            };
            if (method == 'POST') {
                body = this.urlencode (query);
                headers['Content-Length'] = body.length;
                auth += body;
            }
            let secret = this.base64ToBinary (this.secret);
            let signature = this.hmac (this.encode (auth), secret, 'sha512', 'base64');
            headers['signature'] = signature;
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'private') {
            if ('success' in response)
                if (!response['success'])
                    throw new ExchangeError (this.id + ' ' + this.json (response));
            return response;
        }
        return response;
    },
}

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

var btctrader = {

    'id': 'btctrader',
    'name': 'BTCTrader',
    'countries': [ 'TR', 'GR', 'PH' ], // Turkey, Greece, Philippines
    'rateLimit': 1000,
    'comment': 'base API for BTCExchange, BTCTurk',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27992404-cda1e386-649c-11e7-8dc1-40bbd2897768.jpg',
        'api': 'https://www.btctrader.com/api',
        'www': 'https://www.btctrader.com',
        'doc': 'https://github.com/BTCTrader/broker-api-docs',
    },
    'api': {
        'public': {
            'get': [
                'ohlcdata', // ?last=COUNT
                'orderbook',
                'ticker',
                'trades',   // ?last=COUNT (max 50)
            ],
        },
        'private': {
            'get': [
                'balance',
                'openOrders',
                'userTransactions', // ?offset=0&limit=25&sort=asc
            ],
            'post': [
                'buy',
                'cancelOrder',
                'sell',
            ],
        },
    },

    async fetchBalance () {
        let response = await this.privateGetBalance ();
        let result = { 'info': response };
        let base = {
            'free': response['bitcoin_available'],
            'used': response['bitcoin_reserved'],
            'total': response['bitcoin_balance'],
        };
        let quote = {
            'free': response['money_available'],
            'used': response['money_reserved'],
            'total': response['money_balance'],
        };
        let symbol = this.symbols[0];
        let market = this.markets[symbol];
        result[market['base']] = base;
        result[market['quote']] = quote;
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetOrderbook (params);
        let timestamp = parseInt (orderbook['timestamp'] * 1000);
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetTicker ();
        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': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': parseFloat (ticker['average']),
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        let maxCount = 50;
        return this.publicGetTrades ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side);
        let order = {
            'Type': (side == 'buy') ? 'BuyBtc' : 'SelBtc',
            'IsMarketOrder': (type == 'market') ? 1 : 0,
        };
        if (type == 'market') {
            if (side == 'buy')
                order['Total'] = amount;
            else
                order['Amount'] = amount;
        } else {
            order['Price'] = price;
            order['Amount'] = amount;
        }
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancelOrder ({ 'id': id });
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        if (this.id == 'btctrader')
            throw new ExchangeError (this.id + ' is an abstract base API for BTCExchange, BTCTurk');
        let url = this.urls['api'] + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString;
            body = this.urlencode (params);
            let secret = this.base64ToString (this.secret);
            let auth = this.apiKey + nonce;
            headers = {
                'X-PCK': this.apiKey,
                'X-Stamp': nonce.toString (),
                'X-Signature': this.hmac (this.encode (auth), secret, 'sha256', 'base64'),
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var btcexchange = extend (btctrader, {

    'id': 'btcexchange',
    'name': 'BTCExchange',
    'countries': 'PH', // Philippines
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27993052-4c92911a-64aa-11e7-96d8-ec6ac3435757.jpg',
        'api': 'https://www.btcexchange.ph/api',
        'www': 'https://www.btcexchange.ph',
        'doc': 'https://github.com/BTCTrader/broker-api-docs',
    },
    'markets': {
        'BTC/PHP': { 'id': 'BTC/PHP', 'symbol': 'BTC/PHP', 'base': 'BTC', 'quote': 'PHP' },
    },
})

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

var btctradeua = {

    'id': 'btctradeua',
    'name': 'BTC Trade UA',
    'countries': 'UA', // Ukraine,
    'rateLimit': 3000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27941483-79fc7350-62d9-11e7-9f61-ac47f28fcd96.jpg',
        'api': 'https://btc-trade.com.ua/api',
        'www': 'https://btc-trade.com.ua',
        'market': 'https://btc-trade.com.ua/stock/btc_uah',
        'doc': 'https://docs.google.com/document/d/1ocYA0yMy_RXd561sfG3qEPZ80kyll36HUxvCRe5GbhE/edit',
    },
    'api': {
        'public': {
            'get': [
                'deals/{symbol}',
                'trades/sell/{symbol}',
                'trades/buy/{symbol}',
                'japan_stat/high/{symbol}',
            ],
        },
        'private': {
            'post': [
                'auth',
                'ask/{symbol}',
                'balance',
                'bid/{symbol}',
                'buy/{symbol}',
                'my_orders/{symbol}',
                'order/status/{id}',
                'remove/order/{id}',
                'sell/{symbol}',
            ],
        },
    },
    'markets': {
        'BTC/UAH': { 'id': 'btc_uah', 'symbol': 'BTC/UAH', 'base': 'BTC', 'quote': 'UAH' },
        'ETH/UAH': { 'id': 'eth_uah', 'symbol': 'ETH/UAH', 'base': 'ETH', 'quote': 'UAH' },
        'LTC/UAH': { 'id': 'ltc_uah', 'symbol': 'LTC/UAH', 'base': 'LTC', 'quote': 'UAH' },
        'DOGE/UAH': { 'id': 'doge_uah', 'symbol': 'DOGE/UAH', 'base': 'DOGE', 'quote': 'UAH' },
        'DASH/UAH': { 'id': 'dash_uah', 'symbol': 'DASH/UAH', 'base': 'DASH', 'quote': 'UAH' },
        'SIB/UAH': { 'id': 'sib_uah', 'symbol': 'SIB/UAH', 'base': 'SIB', 'quote': 'UAH' },
        'KRB/UAH': { 'id': 'krb_uah', 'symbol': 'KRB/UAH', 'base': 'KRB', 'quote': 'UAH' },
        'NVC/UAH': { 'id': 'nvc_uah', 'symbol': 'NVC/UAH', 'base': 'NVC', 'quote': 'UAH' },
        'LTC/BTC': { 'id': 'ltc_btc', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'NVC/BTC': { 'id': 'nvc_btc', 'symbol': 'NVC/BTC', 'base': 'NVC', 'quote': 'BTC' },
        'ITI/UAH': { 'id': 'iti_uah', 'symbol': 'ITI/UAH', 'base': 'ITI', 'quote': 'UAH' },
        'DOGE/BTC': { 'id': 'doge_btc', 'symbol': 'DOGE/BTC', 'base': 'DOGE', 'quote': 'BTC' },
        'DASH/BTC': { 'id': 'dash_btc', 'symbol': 'DASH/BTC', 'base': 'DASH', 'quote': 'BTC' },
    },

    signIn () {
        return this.privatePostAuth ();
    },

    async fetchBalance () {
        let response = await this.privatePostBalance ();
        let result = { 'info': response };
        if ('accounts' in result) {
            let accounts = response['accounts'];
            for (let b = 0; b < accounts.length; b++) {
                let account = accounts[b];
                let currency = account['currency'];
                let balance = parseFloat (account['balance']);
                result[currency] = {
                    'free': balance,
                    'used': undefined,
                    'total': balance,
                };
            }
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let bids = await this.publicGetTradesBuySymbol (this.extend ({
            'symbol': p['id'],
        }, params));
        let asks = await this.publicGetTradesSellSymbol (this.extend ({
            'symbol': p['id'],
        }, params));
        let orderbook = {
            'bids': [],
            'asks': [],
        };
        if (bids) {
            if ('list' in bids)
                orderbook['bids'] = bids['list'];
        }
        if (asks) {
            if ('list' in asks)
                orderbook['asks'] = asks['list'];
        }
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['currency_trade']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetJapanStatHighSymbol ({
            'symbol': this.marketId (market),
        });
        let ticker = response['trades'];
        let timestamp = this.milliseconds ();
        let result = {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': undefined,
            'ask': undefined,
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': undefined,
            'info': ticker,
        };
        let tickerLength = ticker.length;
        if (tickerLength > 0) {
            let start = Math.max (tickerLength - 48, 0);
            for (let t = start; t < ticker.length; t++) {
                let candle = ticker[t];
                if (typeof result['open'] == 'undefined')
                    result['open'] = candle[1];
                if ((typeof result['high'] == 'undefined') || (result['high'] < candle[2]))
                    result['high'] = candle[2];
                if ((typeof result['low'] == 'undefined') || (result['low'] > candle[3]))
                    result['low'] = candle[3];
                if (typeof result['quoteVolume'] == 'undefined')
                    result['quoteVolume'] = -candle[5];
                else
                    result['quoteVolume'] -= candle[5];
            }
            let last = tickerLength - 1;
            result['close'] = ticker[last][4];
            result['quoteVolume'] = -1 * result['quoteVolume'];
        }
        return result;
    },

    async fetchTrades (market) {
        return this.publicGetDealsSymbol ({
            'symbol': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let p = this.market (market);
        let method = 'privatePost' + this.capitalize (side) + 'Id';
        let order = {
            'count': amount,
            'currency1': p['quote'],
            'currency': p['base'],
            'price': price,
        };
        return this[method] (this.extend (order, params));
    },

    async cancelOrder (id) {
        return this.privatePostRemoveOrderId ({ 'id': id });
    },

    request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += this.implodeParams (path, query);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({
                'out_order_id': nonce,
                'nonce': nonce,
            }, query));
            let auth = body + this.secret;
            headers = {
                'public-key': this.apiKey,
                'api-sign': this.hash (this.encode (auth), 'sha256'),
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var btcturk = extend (btctrader, {

    'id': 'btcturk',
    'name': 'BTCTurk',
    'countries': 'TR', // Turkey
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27992709-18e15646-64a3-11e7-9fa2-b0950ec7712f.jpg',
        'api': 'https://www.btcturk.com/api',
        'www': 'https://www.btcturk.com',
        'doc': 'https://github.com/BTCTrader/broker-api-docs',
    },
    'markets': {
        'BTC/TRY': { 'id': 'BTC/TRY', 'symbol': 'BTC/TRY', 'base': 'BTC', 'quote': 'TRY' },
    },
})

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

var btcx = {

    'id': 'btcx',
    'name': 'BTCX',
    'countries': [ 'IS', 'US', 'EU' ],
    'rateLimit': 1500, // support in english is very poor, unable to tell rate limits
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766385-9fdcc98c-5ed6-11e7-8f14-66d5e5cd47e6.jpg',
        'api': 'https://btc-x.is/api',
        'www': 'https://btc-x.is',
        'market': 'https://btc-x.is/market/BTC/EUR',
        'doc': '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',
            ],
        },
    },
    'markets': {
        'BTC/USD': { 'id': 'btc/usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/EUR': { 'id': 'btc/eur', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
    },

    async fetchBalance () {
        let balances = await this.privatePostBalance ();
        let result = { 'info': balances };
        let currencies = Object.keys (balances);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let uppercase = currency.toUpperCase ();
            let account = {
                'free': balances[currency],
                'used': undefined,
                'total': balances[currency],
            };
            result[uppercase] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetDepthIdLimit (this.extend ({
            'id': this.marketId (market),
            'limit': 1000,
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['price'];
                let amount = order['amount'];
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetTickerId ({
            'id': this.marketId (market),
        });
        let timestamp = ticker['time'] * 1000;
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['sell']),
            'ask': parseFloat (ticker['buy']),
            '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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTradeIdLimit ({
            'id': this.marketId (market),
            'limit': 100,
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let response = await this.privatePostTrade (this.extend ({
            'type': side.toUpperCase (),
            'market': this.marketId (market),
            'amount': amount,
            'price': price,
        }, params));
        return {
            'info': response,
            'id': response['order']['id'],
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancel ({ 'order': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/';
        if (api == 'public') {
            url += this.implodeParams (path, params);
        } else {
            let nonce = this.nonce ();
            url += api;
            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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response['error']));
        return response;
    },
}

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

var bter = {
    'id': 'bter',
    'name': 'Bter',
    'countries': [ 'VG', 'CN' ], // British Virgin Islands, China
    'version': '2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27980479-cfa3188c-6387-11e7-8191-93fc4184ba5c.jpg',
        'api': {
            'public': 'https://data.bter.com/api',
            'private': 'https://api.bter.com/api',
        },
        'www': 'https://bter.com',
        'market': 'https://bter.com/trade/ltc_btc',
        'doc': 'https://bter.com/api2',
    },
    'api': {
        'public': {
            'get': [
                'pairs',
                'marketinfo',
                'marketlist',
                'tickers',
                'ticker/{id}',
                'orderBook/{id}',
                'trade/{id}',
                'tradeHistory/{id}',
                'tradeHistory/{id}/{tid}',
            ],
        },
        'private': {
            'post': [
                'balances',
                'depositAddress',
                'newAddress',
                'depositsWithdrawals',
                'buy',
                'sell',
                'cancelOrder',
                'cancelAllOrders',
                'getOrder',
                'openOrders',
                'tradeHistory',
                'withdraw',
            ],
        },
    },

    async fetchMarkets () {
        let response = await this.publicGetMarketlist ();
        let markets = response['data'];
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['pair'];
            let base = market['curr_a'];
            let quote = market['curr_b'];
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balance = await this.privatePostBalances ();
        let result = { 'info': balance };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let code = this.commonCurrencyCode (currency);
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if ('available' in balance) {
                if (currency in balance['available']) {
                    account['free'] = parseFloat (balance['available'][currency]);
                }
            }
            if ('locked' in balance) {
                if (currency in balance['locked']) {
                    account['used'] = parseFloat (balance['locked'][currency]);
                }
            }
            account['total'] = this.sum (account['free'], account['used']);
            result[code] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetOrderBookId (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    parseTicker (ticker, market) {
        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': parseFloat (ticker['last']),
            'change': parseFloat (ticker['percentChange']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['baseVolume']),
            'quoteVolume': parseFloat (ticker['quoteVolume']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetTickers ();
        let result = {};
        let ids = Object.keys (tickers);
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let [ baseId, quoteId ] = id.split ('_');
            let base = baseId.toUpperCase ();
            let quote = quoteId.toUpperCase ();
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            let symbol = base + '/' + quote;
            let ticker = tickers[id];
            let market = this.markets[symbol];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetTickerId ({
            'id': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradeHistoryId ({
            'id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let method = 'privatePost' + this.capitalize (side);
        let order = {
            'currencyPair': this.symbol (market),
            'rate': price,
            'amount': amount,
        };
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['orderNumber'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'orderNumber': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let prefix = (api == 'private') ? (api + '/') : '';
        let url = this.urls['api'][api] + this.version + '/1/' + prefix + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let request = { 'nonce': nonce };
            body = this.urlencode (this.extend (request, query));
            headers = {
                'Key': this.apiKey,
                'Sign': this.hmac (this.encode (body), this.encode (this.secret), 'sha512'),
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response)
            if (response['result'] != 'true')
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var bxinth = {

    'id': 'bxinth',
    'name': 'BX.in.th',
    'countries': 'TH', // Thailand
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766412-567b1eb4-5ed7-11e7-94a8-ff6a3884f6c5.jpg',
        'api': 'https://bx.in.th/api',
        'www': 'https://bx.in.th',
        'market': 'https://bx.in.th/THB/BTC/',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetPairing ();
        let keys = Object.keys (markets);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let market = markets[keys[p]];
            let id = market['pairing_id'];
            let base = market['primary_currency'];
            let quote = market['secondary_currency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    commonCurrencyCode (currency) {
        // why would they use three letters instead of four for currency codes
        if (currency == 'DAS')
            return 'DASH';
        if (currency == 'DOG')
            return 'DOGE';
        return currency;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostBalance ();
        let balance = response['balance'];
        let result = { 'info': balance };
        let currencies = Object.keys (balance);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let code = this.commonCurrencyCode (currency);
            let account = {
                'free': parseFloat (balance[currency]['available']),
                'used': undefined,
                'total': parseFloat (balance[currency]['total']),
            };
            account['used'] = account['total'] - account['free'];
            result[code] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetOrderbook (this.extend ({
            'pairing': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGet ();
        let result = {};
        let ids = Object.keys (tickers);
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let ticker = tickers[id];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let tickers = await this.publicGet ({ 'pairing': p['id'] });
        let id = p['id'].toString ();
        let ticker = tickers[id];
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrade ({
            'pairing': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let response = await this.privatePostOrder (this.extend ({
            'pairing': this.marketId (market),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
        return {
            'info': response,
            'id': response['order_id'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        let pairing = undefined; // TODO fixme
        return this.privatePostCancel ({
            'order_id': id,
            'pairing': pairing,
        });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/';
        if (path)
            url += path + '/';
        if (Object.keys (params).length)
            url += '?' + this.urlencode (params);
        if (api == 'private') {
            let nonce = this.nonce ();
            let auth = this.apiKey + nonce.toString () + this.secret;
            let signature = this.hash (this.encode (auth), '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,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'public')
            return response;
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var ccex = {

    'id': 'ccex',
    'name': 'C-CEX',
    'countries': [ 'DE', 'EU' ],
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766433-16881f90-5ed8-11e7-92f8-3d92cc747a6c.jpg',
        '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',
        'market': 'https://c-cex.com/?p=eth-usd',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < markets['result'].length; p++) {
            let market = markets['result'][p];
            let id = market['MarketName'];
            let base = market['MarketCurrency'];
            let quote = market['BaseCurrency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalances ();
        let balances = response['result'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['Currency'];
            let account = {
                'free': balance['Available'],
                'used': balance['Pending'],
                'total': balance['Balance'],
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.publicGetOrderbook (this.extend ({
            'market': this.marketId (market),
            'type': 'both',
            'depth': 100,
        }, params));
        let orderbook = response['result'];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buy', 'asks': 'sell' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['Rate']);
                let amount = parseFloat (order['Quantity']);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.tickersGetMarket ({
            'market': p['id'].toLowerCase (),
        });
        let ticker = response['ticker'];
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetMarkethistory ({
            'market': this.marketId (market),
            'type': 'both',
            'depth': 100,
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let method = 'privateGet' + this.capitalize (side) + type;
        let response = await this[method] (this.extend ({
            'market': this.marketId (market),
            'quantity': amount,
            'rate': price,
        }, params));
        return {
            'info': response,
            'id': response['result']['uuid'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privateGetCancel ({ 'uuid': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if (api == '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 (this.encode (url), this.encode (this.secret), 'sha512') };
        } else if (api == 'public') {
            url += '?' + this.urlencode (this.extend ({
                'a': 'get' + path,
            }, params));
        } else {
            url += '/' + this.implodeParams (path, params) + '.json';
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'tickers')
            return response;
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var cex = {

    'id': 'cex',
    'name': 'CEX.IO',
    'countries': [ 'GB', 'EU', 'CY', 'RU' ],
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766442-8ddc33b0-5ed8-11e7-8b98-f786aef0f3c9.jpg',
        'api': 'https://cex.io/api',
        'www': 'https://cex.io',
        'market': 'https://cex.io/btc-usd',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetCurrencyLimits ();
        let result = [];
        for (let p = 0; p < markets['data']['pairs'].length; p++) {
            let market = markets['data']['pairs'][p];
            let id = market['symbol1'] + '/' + market['symbol2'];
            let symbol = id;
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privatePostBalance ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': parseFloat (balances[currency]['available']),
                'used': parseFloat (balances[currency]['orders']),
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await  this.publicGetOrderBookPair (this.extend ({
            'pair': this.marketId (market),
        }, params));
        let timestamp = orderbook['timestamp'] * 1000;
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    parseTicker (ticker, market) {
        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': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let currencies = this.currencies.join ('/');
        let response = await this.publicGetTickersCurrencies ({
            'currencies': currencies,
        });
        let tickers = response['data'];
        let result = {};
        for (let t = 0; t < tickers.length; t++) {
            let ticker = tickers[t];
            let symbol = ticker['pair'].replace (':', '/');
            let market = this.markets[symbol];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetTickerPair ({
            'pair': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradeHistoryPair ({
            'pair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'pair': this.marketId (market),
            'type': side,
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['order_type'] = type;
        let response = await this.privatePostPlaceOrderPair (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'id': id });
    },

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            if (!this.uid)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.uid` property for authentication');
            let nonce = this.nonce ().toString ();
            let auth = nonce + this.uid + this.apiKey;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret));
            body = this.urlencode (this.extend ({
                'key': this.apiKey,
                'signature': signature.toUpperCase (),
                'nonce': nonce,
            }, query));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('e' in response) {
            if ('ok' in response)
                if (response['ok'] == 'ok')
                    return response;
            throw new ExchangeError (this.id + ' ' + this.json (response));
        }
        return response;
    },
}

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

var chbtc = {
    'id': 'chbtc',
    'name': 'CHBTC',
    'countries': 'CN',
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28555659-f0040dc2-7109-11e7-9d99-688a438bf9f4.jpg',
        'api': {
            'public': 'http://api.chbtc.com/data', // no https for public API
            'private': 'https://trade.chbtc.com/api',
        },
        'www': 'https://trade.chbtc.com/api',
        'doc': 'https://www.chbtc.com/i/developer',
    },
    'api': {
        'public': {
            'get': [
                'ticker',
                'depth',
                'trades',
                'kline',
            ],
        },
        'private': {
            'post': [
                'order',
                'cancelOrder',
                'getOrder',
                'getOrders',
                'getOrdersNew',
                'getOrdersIgnoreTradeType',
                'getUnfinishedOrdersIgnoreTradeType',
                'getAccountInfo',
                'getUserAddress',
                'getWithdrawAddress',
                'getWithdrawRecord',
                'getChargeRecord',
                'getCnyWithdrawRecord',
                'getCnyChargeRecord',
                'withdraw',
            ],
        },
    },
    'markets': {
        'BTC/CNY': { 'id': 'btc_cny', 'symbol': 'BTC/CNY', 'base': 'BTC', 'quote': 'CNY' },
        'LTC/CNY': { 'id': 'ltc_cny', 'symbol': 'LTC/CNY', 'base': 'LTC', 'quote': 'CNY' },
        'ETH/CNY': { 'id': 'eth_cny', 'symbol': 'ETH/CNY', 'base': 'ETH', 'quote': 'CNY' },
        'ETC/CNY': { 'id': 'etc_cny', 'symbol': 'ETC/CNY', 'base': 'ETC', 'quote': 'CNY' },
        'BTS/CNY': { 'id': 'bts_cny', 'symbol': 'BTS/CNY', 'base': 'BTS', 'quote': 'CNY' },
        'EOS/CNY': { 'id': 'eos_cny', 'symbol': 'EOS/CNY', 'base': 'EOS', 'quote': 'CNY' },
    },

    async fetchBalance () {
        let response = await this.privatePostGetAccountInfo ();
        let balances = response['result'];
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balances['balance'])
                account['free'] = balances['balance'][currency]['amount'];
            if (currency in balances['frozen'])
                account['used'] = balances['frozen'][currency]['amount'];
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let orderbook = await this.publicGetDepth (this.extend ({
            'currency': p['id'],
        }, params));
        let timestamp = this.milliseconds ();
        let bids = undefined;
        let asks = undefined;
        if ('bids' in orderbook)
            bids = orderbook['bids'];
        if ('asks' in orderbook)
            asks = orderbook['asks'];
        let result = {
            'bids': bids,
            'asks': asks,
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        if (result['bids'])
            result['bids'] = this.sortBy (result['bids'], 0, true);
        if (result['asks'])
            result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetTicker ({
            'currency': this.marketId (market),
        });
        let ticker = response['ticker'];
        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': undefined,
            'quoteVolume': parseFloat (ticker['vol']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTrades ({
            'currency': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let paramString = '&price=' + price.toString ();
        paramString += '&amount=' + amount.toString ();
        let tradeType = (side == 'buy') ? '1' : '0';
        paramString += '&tradeType=' + tradeType;
        paramString += '&currency=' + this.marketId (market);
        let response = await this.privatePostOrder (paramString);
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id, params = {}) {
        let paramString = '&id=' + id.toString ();
        if ('currency' in params)
            paramString += '&currency=' + params['currency'];
        return this.privatePostCancelOrder (paramString);
    },

    async fetchOrder (id, params = {}) {
        let paramString = '&id=' + id.toString ();
        if ('currency' in params)
            paramString += '&currency=' + params['currency'];
        return this.privatePostGetOrder (paramString);
    },

    nonce () {
        return this.milliseconds ();
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if (api == 'public') {
            url += '/' + this.version + '/' + path;
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let paramsLength = params.length; // params should be a string here
            let nonce = this.nonce ();
            let auth = 'method=' + path;
            auth += '&accesskey=' + this.apiKey;
            auth += paramsLength ? params : '';
            let secret = this.hash (this.encode (this.secret), 'sha1');
            let signature = this.hmac (this.encode (auth), this.encode (secret), 'md5');
            let suffix = 'sign=' + signature + '&reqTime=' + nonce.toString ();
            url += '/' + path + '?' + auth + '&' + suffix;
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'private')
            if ('code' in response)
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var chilebit = extend (blinktrade, {
    'id': 'chilebit',
    'name': 'ChileBit',
    'countries': 'CL',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27991414-1298f0d8-647f-11e7-9c40-d56409266336.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://chilebit.net',
        'doc': 'https://blinktrade.com/docs',
    },
    'comment': 'Blinktrade API',
    'markets': {
        'BTC/CLP': { 'id': 'BTCCLP', 'symbol': 'BTC/CLP', 'base': 'BTC', 'quote': 'CLP', 'brokerId': 9, 'broker': 'ChileBit' },
    },
})

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

var coincheck = {

    'id': 'coincheck',
    'name': 'coincheck',
    'countries': [ 'JP', 'ID' ],
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766464-3b5c3c74-5ed9-11e7-840e-31b32968e1da.jpg',
        'api': 'https://coincheck.com/api',
        'www': 'https://coincheck.com',
        'market': 'https://coincheck.com/exchange/tradeview',
        'doc': '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}',
            ],
        },
    },
    'markets': {
        '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' },
    },

    async fetchBalance () {
        let balances = await this.privateGetAccountsBalance ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balances)
                account['free'] = parseFloat (balances[lowercase]);
            let reserved = lowercase + '_reserved';
            if (reserved in balances)
                account['used'] = parseFloat (balances[reserved]);
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await  this.publicGetOrderBooks (params);
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTrades ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let prefix = '';
        let order = {
            'pair': this.marketId (market),
        };
        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;
        }
        let response = await this.privatePostExchangeOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrder (id) {
        return this.privateDeleteExchangeOrdersId ({ 'id': id });
    },

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ().toString ();
            let length = 0;
            if (Object.keys (query).length) {
                body = this.urlencode (this.keysort (query));
                length = body.length;
            }
            let auth = nonce + url + (body || '');
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': length,
                'ACCESS-KEY': this.apiKey,
                'ACCESS-NONCE': nonce,
                'ACCESS-SIGNATURE': this.hmac (this.encode (auth), this.encode (this.secret)),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'public')
            return response;
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var coingi = {

    'id': 'coingi',
    'name': 'Coingi',
    'rateLimit': 1000,
    'countries': [ 'PA', 'BG', 'CN', 'US' ], // Panama, Bulgaria, China, US
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28619707-5c9232a8-7212-11e7-86d6-98fe5d15cc6e.jpg',
        'api': 'https://api.coingi.com',
        'www': 'https://coingi.com',
        'market': 'https://coingi.com/?currencyPairSelector-currencyId=DASH%2FBTC&do=currencyPairSelector-selectCurrency',
        'doc': 'http://docs.coingi.apiary.io/',
    },
    'api': {
        'current': {
            'get': [
                'order-book/{pair}/{askCount}/{bidCount}/{depth}',
                'transactions/{pair}/{maxCount}',
                '24hour-rolling-aggregation',
            ],
        },
        'user': {
            'post': [
                'balance',
                'add-order',
                'cancel-order',
                'orders',
                'transactions',
                'create-crypto-withdrawal',
            ],
        },
    },
    'markets': {
        'LTC/BTC': { 'id': 'ltc-btc', 'symbol': 'LTC/BTC', 'base': 'LTC', 'quote': 'BTC' },
        'PPC/BTC': { 'id': 'ppc-btc', 'symbol': 'PPC/BTC', 'base': 'PPC', 'quote': 'BTC' },
        'DOGE/BTC': { 'id': 'doge-btc', 'symbol': 'DOGE/BTC', 'base': 'DOGE', 'quote': 'BTC' },
        'VTC/BTC': { 'id': 'vtc-btc', 'symbol': 'VTC/BTC', 'base': 'VTC', 'quote': 'BTC' },
        'FTC/BTC': { 'id': 'ftc-btc', 'symbol': 'FTC/BTC', 'base': 'FTC', 'quote': 'BTC' },
        'NMC/BTC': { 'id': 'nmc-btc', 'symbol': 'NMC/BTC', 'base': 'NMC', 'quote': 'BTC' },
        'DASH/BTC': { 'id': 'dash-btc', 'symbol': 'DASH/BTC', 'base': 'DASH', 'quote': 'BTC' },
    },

    async fetchBalance () {
        let currencies = [];
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c].toLowerCase ();
            currencies.push (currency);
        }
        let balances = await this.userPostBalance ({
            'currencies': currencies.join (',')
        });
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency']['name'];
            currency = currency.toUpperCase ();
            let account = {
                'free': balance['available'],
                'used': balance['blocked'] + balance['inOrders'] + balance['withdrawing'],
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let orderbook = await this.currentGetOrderBookPairAskCountBidCountDepth (this.extend ({
            'pair': p['id'],
            'askCount': 512, // maximum returned number of asks 1-512
            'bidCount': 512, // maximum returned number of bids 1-512
            'depth': 32, // maximum number of depth range steps 1-32
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['price'];
                let amount = order['baseAmount'];
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': ticker['high'],
            'low': ticker['low'],
            'bid': ticker['highestBid'],
            'ask': ticker['lowestAsk'],
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': undefined,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': ticker['baseVolume'],
            'quoteVolume': ticker['counterVolume'],
            'info': ticker,
        };
        return ticker;
    },

    async fetchTickers () {
        let response = await this.currentGet24hourRollingAggregation ();
        let result = {};
        for (let t = 0; t < response.length; t++) {
            let ticker = response[t];
            let base = ticker['currencyPair']['base'].toUpperCase ();
            let quote = ticker['currencyPair']['counter'].toUpperCase ();
            let symbol = base + '/' + quote;
            let market = this.markets[symbol];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.currentGet24hourRollingAggregation ();
        let tickers = {};
        for (let t = 0; t < response.length; t++) {
            let ticker = response[t];
            let base = ticker['currencyPair']['base'].toUpperCase ();
            let quote = ticker['currencyPair']['counter'].toUpperCase ();
            let symbol = base + '/' + quote;
            tickers[symbol] = ticker;
        }
        let p = this.market (market);
        let symbol = p['symbol'];
        if (symbol in tickers) {
            let ticker = tickers[symbol];
            return this.parseTicker (ticker, p);
        }
        throw new ExchangeError (this.id + ' ' + symbol + ' ticker not found');
    },

    async fetchTrades (market, params = {}) {
        return this.currentGetTransactionsPairMaxCount (this.extend ({
            'pair': this.marketId (market),
            'maxCount': 128,
        }, params));
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'currencyPair': this.marketId (market),
            'volume': amount,
            'price': price,
            'orderType': (side == 'buy') ? 0 : 1,
        };
        let response = await this.userPostAddOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response['result'],
        };
    },

    async cancelOrder (id) {
        return this.userPostCancelOrder ({ 'orderId': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + api + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == 'current') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let request = this.extend ({
                'token': this.apiKey,
                'nonce': nonce,
            }, query);
            let auth = nonce.toString () + '$' + this.apiKey;
            request['signature'] = this.hmac (this.encode (auth), this.encode (this.secret));
            body = this.json (request);
            headers = {
                'Content-Type': 'application/json',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('errors' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var coinmarketcap = {

    'id': 'coinmarketcap',
    'name': 'CoinMarketCap',
    'rateLimit': 10000,
    'version': 'v1',
    'countries': 'US',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28244244-9be6312a-69ed-11e7-99c1-7c1797275265.jpg',
        'api': 'https://api.coinmarketcap.com',
        'www': 'https://coinmarketcap.com',
        'doc': 'https://coinmarketcap.com/api',
    },
    'api': {
        'public': {
            'get': [
                'ticker/',
                'ticker/{id}/',
                'global/',
            ],
        },
    },
    'currencies': [
        'AUD',
        'BRL',
        'CAD',
        'CHF',
        'CNY',
        'EUR',
        'GBP',
        'HKD',
        'IDR',
        'INR',
        'JPY',
        'KRW',
        'MXN',
        'RUB',
        'USD',
    ],

    async fetchOrderBook (market, params = {}) {
        throw new ExchangeError ('Fetching order books is not supported by the API of ' + this.id);
    },

    async fetchMarkets () {
        let markets = await this.publicGetTicker ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            for (let c = 0; c < this.currencies.length; c++) {
                let base = market['symbol'];
                let baseId = market['id'];
                let quote = this.currencies[c];
                let quoteId = quote.toLowerCase ();
                let symbol = base + '/' + quote;
                let id = baseId + '/' + quote;
                result.push ({
                    'id': id,
                    'symbol': symbol,
                    'base': base,
                    'quote': quote,
                    'baseId': baseId,
                    'quoteId': quoteId,
                    'info': market,
                });
            }
        }
        return result;
    },

    async fetchGlobal (currency = 'USD') {
        await this.loadMarkets ();
        let request = {};
        if (currency)
            request['convert'] = currency;
        return this.publicGetGlobal (request);
    },

    parseTicker (ticker, market) {
        let timestamp = this.milliseconds ();
        if ('last_updated' in ticker)
            if (ticker['last_updated'])
                timestamp = parseInt (ticker['last_updated']) * 1000;
        let volume = undefined;
        let volumeKey = '24h_volume_' + market['quoteId'];
        if (ticker[volumeKey])
            volume = parseFloat (ticker[volumeKey]);
        let price = 'price_' + market['quoteId'];
        let change = undefined;
        let changeKey = 'percent_change_24h';
        if (ticker[changeKey])
            change = parseFloat (ticker[changeKey]);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': undefined,
            'low': undefined,
            'bid': undefined,
            'ask': undefined,
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker[price]),
            'change': change,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': volume,
            'info': ticker,
        };
    },

    async fetchTickers (currency = 'USD') {
        await this.loadMarkets ();
        let request = {};
        if (currency)
            request['convert'] = currency;
        let response = await this.publicGetTicker (request);
        let tickers = {};
        for (let t = 0; t < response.length; t++) {
            let ticker = response[t];
            let id = ticker['id'] + '/' + currency;
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            tickers[symbol] = this.parseTicker (ticker, market);
        }
        return tickers;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let request = {
            'convert': p['quote'],
            'id': p['baseId'],
        };
        let response = await this.publicGetTickerId (request);
        let ticker = response[0];
        return this.parseTicker (ticker, p);
    },

    request (path, api = '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);
        return this.fetch (url, method, headers, body);
    },
}

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

var coinmate = {

    'id': 'coinmate',
    'name': 'CoinMate',
    'countries': [ 'GB', 'CZ' ], // UK, Czech Republic
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27811229-c1efb510-606c-11e7-9a36-84ba2ce412d8.jpg',
        'api': 'https://coinmate.io/api',
        'www': 'https://coinmate.io',
        'doc': [
            'http://docs.coinmate.apiary.io',
            'https://coinmate.io/developers',
        ],
    },
    'api': {
        'public': {
            'get': [
                'orderBook',
                'ticker',
                'transactions',
            ],
        },
        'private': {
            'post': [
                'balances',
                'bitcoinWithdrawal',
                'bitcoinDepositAddresses',
                'buyInstant',
                'buyLimit',
                'cancelOrder',
                'cancelOrderWithInfo',
                'createVoucher',
                'openOrders',
                'redeemVoucher',
                'sellInstant',
                'sellLimit',
                'transactionHistory',
                'unconfirmedBitcoinDeposits',
            ],
        },
    },
    'markets': {
        'BTC/EUR': { 'id': 'BTC_EUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
        'BTC/CZK': { 'id': 'BTC_CZK', 'symbol': 'BTC/CZK', 'base': 'BTC', 'quote': 'CZK' },
    },

    async fetchBalance () {
        let response = await this.privatePostBalances ();
        let balances = response['data'];
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in balances) {
                account['free'] = balances[currency]['available'];
                account['used'] = balances[currency]['reserved'];
                account['total'] = balances[currency]['balance'];
            }
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let response = await this.publicGetOrderBook (this.extend ({
            'currencyPair': this.marketId (market),
            'groupByPriceLimit': 'False',
        }, params));
        let orderbook = response['data'];
        let timestamp = orderbook['timestamp'] * 1000;
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['price'];
                let amount = order['amount'];
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetTicker ({
            'currencyPair': this.marketId (market),
        });
        let ticker = response['data'];
        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['amount']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTransactions ({
            'currencyPair': this.marketId (market),
            'minutesIntoHistory': 10,
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side);
        let order = {
            'currencyPair': this.marketId (market),
        };
        if (type == 'market') {
            if (side == 'buy')
                order['total'] = amount; // amount in fiat
            else
                order['amount'] = amount; // amount in fiat
            method += 'Instant';
        } else {
            order['amount'] = amount; // amount in crypto
            order['price'] = price;
            method += this.capitalize (type);
        }
        let response = await this[method] (self.extend (order, params));
        return {
            'info': response,
            'id': response['data'].toString (),
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancelOrder ({ 'orderId': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            if (!this.uid)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.uid` property for authentication');
            let nonce = this.nonce ().toString ();
            let auth = nonce + this.uid + this.apiKey;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret));
            body = this.urlencode (this.extend ({
                'clientId': this.uid,
                'nonce': nonce,
                'publicKey': this.apiKey,
                'signature': signature.toUpperCase (),
            }, params));
            headers = {
                'Content-Type':  'application/x-www-form-urlencoded',
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            if (response['error'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var coinsecure = {

    'id': 'coinsecure',
    'name': 'Coinsecure',
    'countries': 'IN', // India
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766472-9cbd200a-5ed9-11e7-9551-2267ad7bac08.jpg',
        'api': 'https://api.coinsecure.in',
        'www': 'https://coinsecure.in',
        'market': 'https://coinsecure.in/exchange_data',
        'doc': [
            '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}',
            ],
        },
    },
    'markets': {
        'BTC/INR': { 'id': 'BTC/INR', 'symbol': 'BTC/INR', 'base': 'BTC', 'quote': 'INR' },
    },

    async fetchBalance () {
        let response = await this.privateGetUserExchangeBankSummary ();
        let balance = response['message'];
        let coin = {
            'free': balance['availableCoinBalance'],
            'used': balance['pendingCoinBalance'],
            'total': balance['totalCoinBalance'],
        };
        let fiat = {
            'free': balance['availableFiatBalance'],
            'used': balance['pendingFiatBalance'],
            'total': balance['totalFiatBalance'],
        };
        let result = {
            'info': balance,
            'BTC': coin,
            'INR': fiat,
        };
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let bids = await this.publicGetExchangeBidOrders (params);
        let asks = await this.publicGetExchangeAskOrders (params);
        let orderbook = {
            'bids': bids['message'],
            'asks': asks['message'],
        };
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['rate'];
                let amount = order['vol'];
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetExchangeTrades ();
    },

    async createOrder (market, 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;
        }
        let response = await this[method] (self.extend (order, params));
        return {
            'info': response,
            'id': response['message']['orderID'],
        };
    },

    async cancelOrder (id) {
        throw new ExchangeError (this.id + ' cancelOrder () is not fully implemented yet');
        let method = 'privateDeleteUserExchangeAskCancelOrderId'; // TODO fixme, have to specify order side here
        return this[method] ({ 'orderID': id });
    },

    async request (path, api = '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 (api == 'private') {
            headers = { 'Authorization': this.apiKey };
            if (Object.keys (query).length) {
                body = this.json (query);
                headers['Content-Type'] = 'application/json';
            }
        }
        let response = await this.fetch (url, method, headers, body);
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var coinspot = {

    'id': 'coinspot',
    'name': 'CoinSpot',
    'countries': 'AU', // Australia
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28208429-3cacdf9a-6896-11e7-854e-4c79a772a30f.jpg',
        'api': {
            'public': 'https://www.coinspot.com.au/pubapi',
            'private': 'https://www.coinspot.com.au/api',
        },
        'www': 'https://www.coinspot.com.au',
        'market': 'https://www.coinspot.com.au/trade/btc',
        'doc': 'https://www.coinspot.com.au/api',
    },
    'api': {
        'public': {
            'get': [
                'latest',
            ],
        },
        'private': {
            'post': [
                'orders',
                'orders/history',
                'my/coin/deposit',
                'my/coin/send',
                'quote/buy',
                'quote/sell',
                'my/balances',
                'my/orders',
                'my/buy',
                'my/sell',
                'my/buy/cancel',
                'my/sell/cancel',
            ],
        },
    },
    'markets': {
        'BTC/AUD': { 'id': 'BTC', 'symbol': 'BTC/AUD', 'base': 'BTC', 'quote': 'AUD' },
        'LTC/AUD': { 'id': 'LTC', 'symbol': 'LTC/AUD', 'base': 'LTC', 'quote': 'AUD' },
        'DOGE/AUD': { 'id': 'DOGE', 'symbol': 'DOGE/AUD', 'base': 'DOGE', 'quote': 'AUD' },
    },

    async fetchBalance () {
        let response = await this.privatePostMyBalances ();
        let result = { 'info': response };
        if ('balance' in response) {
            let balances = response['balance'];
            let currencies = Object.keys (balances);
            for (let c = 0; c < currencies.length; c++) {
                let currency = currencies[c];
                let uppercase = currency.toUpperCase ();
                let account = {
                    'free': balances[currency],
                    'used': undefined,
                    'total': balances[currency],
                };
                if (uppercase == 'DRK')
                    uppercase = 'DASH';
                result[uppercase] = account;
            }
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let orderbook = await this.privatePostOrders (this.extend ({
            'cointype': p['id'],
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buyorders', 'asks': 'sellorders' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['rate']);
                let amount = parseFloat (order['amount']);
                result[key].push ([ price, amount ]);
            }
        }
        result['bids'] = this.sortBy (result['bids'], 0, true);
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetLatest ();
        let id = this.marketId (market);
        id = id.toLowerCase ();
        let ticker = response['prices'][id];
        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': undefined,
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.privatePostOrdersHistory ({
            'cointype': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePostMy' + this.capitalize (side);
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let order = {
            'cointype': this.marketId (market),
            'amount': amount,
            'rate': price,
        };
        return this[method] (this.extend (order, params));
    },

    async cancelOrder (id, params = {}) {
        throw new ExchangeError (this.id + ' cancelOrder () is not fully implemented yet');
        let method = 'privatePostMyBuy';
        return this[method] ({ 'id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        if (!this.apiKey)
            throw new AuthenticationError (this.id + ' requires apiKey for all requests');
        let url = this.urls['api'][api] + '/' + path;
        if (api == 'private') {
            let nonce = this.nonce ();
            body = this.json (this.extend ({ 'nonce': nonce }, params));
            headers = {
                'Content-Type': 'application/json',
                'Content-Length': body.length,
                'key': this.apiKey,
                'sign': this.hmac (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var dsx = {

    'id': 'dsx',
    'name': 'DSX',
    'countries': 'UK',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27990275-1413158a-645a-11e7-931c-94717f7510e3.jpg',
        'api': {
            'mapi': 'https://dsx.uk/mapi',  // market data
            'tapi': 'https://dsx.uk/tapi',  // trading
            'dwapi': 'https://dsx.uk/dwapi', // deposit/withdraw
        },
        'www': 'https://dsx.uk',
        'doc': [
            'https://api.dsx.uk',
            'https://dsx.uk/api_docs/public',
            'https://dsx.uk/api_docs/private',
            '',
        ],
    },
    'api': {
        'mapi': { // market data (public)
            'get': [
                'barsFromMoment/{id}/{period}/{start}', // empty reply :\
                'depth/{id}',
                'info',
                'lastBars/{id}/{period}/{amount}', // period is (m, h or d)
                'periodBars/{id}/{period}/{start}/{end}',
                'ticker/{id}',
                'trades/{id}',
            ],
        },
        'tapi': { // trading (private)
            'post': [
                'getInfo',
                'TransHistory',
                'TradeHistory',
                'OrderHistory',
                'ActiveOrders',
                'Trade',
                'CancelOrder',
            ],
        },
        'dwapi': { // deposit / withdraw (private)
            'post': [
                'getCryptoDepositAddress',
                'cryptoWithdraw',
                'fiatWithdraw',
                'getTransactionStatus',
                'getTransactions',
            ],
        },
    },

    async fetchMarkets () {
        let response = await this.mapiGetInfo ();
        let keys = Object.keys (response['pairs']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let market = response['pairs'][id];
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            base = base.toUpperCase ();
            quote = quote.toUpperCase ();
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.tapiPostGetInfo ();
        let balances = response['return'];
        let result = { 'info': balances };
        let currencies = Object.keys (balances['total']);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let account = {
                'free': balances['funds'][currency],
                'used': undefined,
                'total': balances['total'][currency],
            };
            account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.mapiGetDepthId (this.extend ({
            'id': p['id'],
        }, params));
        let orderbook = response[p['id']];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order[0];
                let amount = order[1];
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.mapiGetTickerId ({
            'id': p['id'],
        });
        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']),
            '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']),
            'quoteVolume': parseFloat (ticker['vol_cur']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.mapiGetTradesId ({
            'id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let order = {
            'pair': this.marketId (market),
            'type': side,
            'rate': price,
            'amount': amount,
        };
        let response = await this.tapiPostTrade (this.extend (order, params));
        return {
            'info': response,
            'id': response['return']['orderId'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.tapiPostCancelOrder ({ 'orderId': id });
    },

    async request (path, api = 'mapi', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        if ((api == 'mapi') || (api == 'dwapi'))
            url += '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == 'mapi') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let method = path;
            body = this.urlencode (this.extend ({
                'method': path,
                'nonce': nonce,
            }, query));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Key': this.apiKey,
                'Sign': this.hmac (this.encode (body), this.encode (this.secret), 'sha512', 'base64'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'mapi')
            return response;
        if ('success' in response)
            if (response['success'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

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': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766491-1b0ea956-5eda-11e7-9225-40d67b481b8d.jpg',
        'api': 'https://api.exmo.com',
        'www': 'https://exmo.me',
        'markets': 'https://exmo.me/en/trade#?pair=BTC_USD',
        'doc': [
            '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 fetchMarkets () {
        let markets = await this.publicGetPairSettings ();
        let keys = Object.keys (markets);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let market = markets[id];
            let symbol = id.replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostUserInfo ();
        let result = { 'info': response };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (currency in response['balances'])
                account['free'] = parseFloat (response['balances'][currency]);
            if (currency in response['reserved'])
                account['used'] = parseFloat (response['reserved'][currency]);
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.publicGetOrderBook (this.extend ({
            'pair': p['id'],
        }, params));
        let orderbook = response[p['id']];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'bid', 'asks': 'ask' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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': undefined,
            '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,
        };
    },

    async fetchTickers (currency = 'USD') {
        await this.loadMarkets ();
        let response = await this.publicGetTicker ();
        let result = {};
        let ids = Object.keys (response);
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = response[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let response = await this.publicGetTicker ();
        let p = this.market (market);
        return this.parseTicker (response[p['id']], p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrades ({
            'pair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let prefix = '';
        if (type == 'market')
            prefix = 'market_';
        let order = {
            'pair': this.marketId (market),
            'quantity': amount,
            'price': price || 0,
            'type': prefix + side,
        };
        let response = await this.privatePostOrderCreate (this.extend (order, params));
        return {
            'info': response,
            'id': response['order_id'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostOrderCancel ({ 'order_id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response) {
            if (response['result'])
                return response;
            throw new ExchangeError (this.id + ' ' + this.json (response));
        }
        return response;
    },
}

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

var flowbtc = {

    'id': 'flowbtc',
    'name': 'flowBTC',
    'countries': 'BR', // Brazil
    'version': 'v1',
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28162465-cd815d4c-67cf-11e7-8e57-438bea0523a2.jpg',
        'api': 'https://api.flowbtc.com:8400/ajax',
        'www': 'https://trader.flowbtc.com',
        'doc': 'http://www.flowbtc.com.br/api/',
    },
    'api': {
        'public': {
            'post': [
                'GetTicker',
                'GetTrades',
                'GetTradesByDate',
                'GetOrderBook',
                'GetProductPairs',
                'GetProducts',
            ],
        },
        'private': {
            'post': [
                'CreateAccount',
                'GetUserInfo',
                'SetUserInfo',
                'GetAccountInfo',
                'GetAccountTrades',
                'GetDepositAddresses',
                'Withdraw',
                'CreateOrder',
                'ModifyOrder',
                'CancelOrder',
                'CancelAllOrders',
                'GetAccountOpenOrders',
                'GetOrderFee',
            ],
        },
    },

    async fetchMarkets () {
        let response = await this.publicPostGetProductPairs ();
        let markets = response['productPairs'];
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['name'];
            let base = market['product1Label'];
            let quote = market['product2Label'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostGetAccountInfo ();
        let balances = response['currencies'];
        let result = { 'info': response };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['name'];
            let account = {
                'free': balance['balance'],
                'used': balance['hold'],
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let orderbook = await this.publicPostGetOrderBook (this.extend ({
            'productPair': p['id'],
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['px']);
                let amount = parseFloat (order['qty']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicPostGetTicker ({
            'productPair': p['id'],
        });
        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': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['volume24hr']),
            'quoteVolume': parseFloat (ticker['volume24hrProduct2']),
            'info': ticker,
        };
    },

    async fetchTrades (market, params = {}) {
        await this.loadMarkets ();
        return this.publicPostGetTrades (this.extend ({
            'ins': this.marketId (market),
        }, params));
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let orderType = (type == 'market') ? 1 : 0;
        let order = {
            'ins': this.marketId (market),
            'side': side,
            'orderType': orderType,
            'qty': amount,
            'px': price,
        };
        let response = await this.privatePostCreateOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response['serverOrderId'],
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        if ('ins' in params) {
            return this.privatePostCancelOrder (this.extend ({
                'serverOrderId': id,
            }, params));
        }
        throw new ExchangeError (this.id + ' requires `ins` symbol parameter for cancelling an order');
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length) {
                body = this.json (params);
            }
        } else {
            if (!this.uid)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.uid` property for authentication');
            let nonce = this.nonce ();
            let auth = nonce.toString () + this.uid + this.apiKey;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret));
            body = this.json (this.extend ({
                'apiKey': this.apiKey,
                'apiNonce': nonce,
                'apiSig': signature.toUpperCase (),
            }, params));
            headers = {
                'Content-Type': 'application/json',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('isAccepted' in response)
            if (response['isAccepted'])
                return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var foxbit = extend (blinktrade, {
    'id': 'foxbit',
    'name': 'FoxBit',
    'countries': 'BR',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27991413-11b40d42-647f-11e7-91ee-78ced874dd09.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://foxbit.exchange',
        'doc': 'https://blinktrade.com/docs',
    },
    'comment': 'Blinktrade API',
    'markets': {
        'BTC/BRL': { 'id': 'BTCBRL', 'symbol': 'BTC/BRL', 'base': 'BTC', 'quote': 'BRL', 'brokerId': 4, 'broker': 'FoxBit' },
    },
})

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

var fyb = {

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

    async fetchBalance () {
        let balance = await this.privatePostGetaccinfo ();
        let btc = parseFloat (balance['btcBal']);
        let symbol = this.symbols[0];
        let quote = this.markets[symbol]['quote'];
        let lowercase = quote.toLowerCase () + 'Bal';
        let fiat = parseFloat (balance[lowercase]);
        let crypto = {
            'free': btc,
            'used': undefined,
            'total': btc,
        };
        let accounts = { 'BTC': crypto };
        accounts[quote] = {
            'free': fiat,
            'used': undefined,
            'total': fiat,
        };
        accounts['info'] = balance;
        return accounts;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetOrderbook (params);
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetTickerdetailed ();
        let timestamp = this.milliseconds ();
        let last = undefined;
        let volume = undefined;
        if ('last' in ticker)
            last = parseFloat (ticker['last']);
        if ('vol' in ticker)
            volume = parseFloat (ticker['vol']);
        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': last,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': volume,
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTrades ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let response = await this.privatePostPlaceorder (this.extend ({
            'qty': amount,
            'price': price,
            'type': side[0].toUpperCase ()
        }, params));
        return {
            'info': response,
            'id': response['pending_oid'],
        };
    },

    async cancelOrder (id) {
        return this.privatePostCancelpendingorder ({ 'orderNo': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path;
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha1')
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if (api == 'private')
            if ('error' in response)
                if (response['error'])
                    throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var fybse = extend (fyb, {
    'id': 'fybse',
    'name': 'FYB-SE',
    'countries': 'SE', // Sweden
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766512-31019772-5edb-11e7-8241-2e675e6797f1.jpg',
        'api': 'https://www.fybse.se/api/SEK',
        'www': 'https://www.fybse.se',
        'doc': 'http://docs.fyb.apiary.io',
    },
    'markets': {
        'BTC/SEK': { 'id': 'SEK', 'symbol': 'BTC/SEK', 'base': 'BTC', 'quote': 'SEK' },
    },
})

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

var fybsg = extend (fyb, {
    'id': 'fybsg',
    'name': 'FYB-SG',
    'countries': 'SG', // Singapore
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766513-3364d56a-5edb-11e7-9e6b-d5898bb89c81.jpg',
        'api': 'https://www.fybsg.com/api/SGD',
        'www': 'https://www.fybsg.com',
        'doc': 'http://docs.fyb.apiary.io',
    },
    'markets': {
        'BTC/SGD': { 'id': 'SGD', 'symbol': 'BTC/SGD', 'base': 'BTC', 'quote': 'SGD' },
    },
})

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

var gatecoin = {

    'id': 'gatecoin',
    'name': 'Gatecoin',
    'rateLimit': 2000,
    'countries': 'HK', // Hong Kong
    'comment': 'a regulated/licensed exchange',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28646817-508457f2-726c-11e7-9eeb-3528d2413a58.jpg',
        'api': 'https://api.gatecoin.com',
        'www': 'https://gatecoin.com',
        'market': 'https://gatecoin.com/marketData',
        'doc': [
            'https://gatecoin.com/api',
            'https://github.com/Gatecoin/RESTful-API-Implementation',
            'https://api.gatecoin.com/swagger-ui/index.html',
        ],
    },
    'api': {
        'public': {
            'get': [
                'Public/ExchangeRate', // Get the exchange rates
                'Public/LiveTicker', // Get live ticker for all currency
                'Public/LiveTicker/{CurrencyPair}', // Get live ticker by currency
                'Public/LiveTickers', // Get live ticker for all currency
                'Public/MarketDepth/{CurrencyPair}', // Gets prices and market depth for the currency pair.
                'Public/NetworkStatistics/{DigiCurrency}', // Get the network status of a specific digital currency
                'Public/StatisticHistory/{DigiCurrency}/{Typeofdata}', // Get the historical data of a specific digital currency
                'Public/TickerHistory/{CurrencyPair}/{Timeframe}', // Get ticker history
                'Public/Transactions/{CurrencyPair}', // Gets recent transactions
                'Public/TransactionsHistory/{CurrencyPair}', // Gets all transactions
                'Reference/BusinessNatureList', // Get the business nature list.
                'Reference/Countries', // Get the country list.
                'Reference/Currencies', // Get the currency list.
                'Reference/CurrencyPairs', // Get the currency pair list.
                'Reference/CurrentStatusList', // Get the current status list.
                'Reference/IdentydocumentTypes', // Get the different types of identity documents possible.
                'Reference/IncomeRangeList', // Get the income range list.
                'Reference/IncomeSourceList', // Get the income source list.
                'Reference/VerificationLevelList', // Get the verif level list.
                'Stream/PublicChannel', // Get the public pubnub channel list
            ],
            'post': [
                'Export/Transactions', // Request a export of all trades from based on currencypair, start date and end date
                'Ping', // Post a string, then get it back.
                'Public/Unsubscribe/{EmailCode}', // Lets the user unsubscribe from emails
                'RegisterUser', // Initial trader registration.
            ],
        },
        'private': {
            'get': [
                'Account/CorporateData', // Get corporate account data
                'Account/DocumentAddress', // Check if residence proof uploaded
                'Account/DocumentCorporation', // Check if registered document uploaded
                'Account/DocumentID', // Check if ID document copy uploaded
                'Account/DocumentInformation', // Get Step3 Data
                'Account/Email', // Get user email
                'Account/FeeRate', // Get fee rate of logged in user
                'Account/Level', // Get verif level of logged in user
                'Account/PersonalInformation', // Get Step1 Data
                'Account/Phone', // Get user phone number
                'Account/Profile', // Get trader profile
                'Account/Questionnaire', // Fill the questionnaire
                'Account/Referral', // Get referral information
                'Account/ReferralCode', // Get the referral code of the logged in user
                'Account/ReferralNames', // Get names of referred traders
                'Account/ReferralReward', // Get referral reward information
                'Account/ReferredCode', // Get referral code
                'Account/ResidentInformation', // Get Step2 Data
                'Account/SecuritySettings', // Get verif details of logged in user
                'Account/User', // Get all user info
                'APIKey/APIKey', // Get API Key for logged in user
                'Auth/ConnectionHistory', // Gets connection history of logged in user
                'Balance/Balances', // Gets the available balance for each currency for the logged in account.
                'Balance/Balances/{Currency}', // Gets the available balance for s currency for the logged in account.
                'Balance/Deposits', // Get all account deposits, including wire and digital currency, of the logged in user
                'Balance/Withdrawals', // Get all account withdrawals, including wire and digital currency, of the logged in user
                'Bank/Accounts/{Currency}/{Location}', // Get internal bank account for deposit
                'Bank/Transactions', // Get all account transactions of the logged in user
                'Bank/UserAccounts', // Gets all the bank accounts related to the logged in user.
                'Bank/UserAccounts/{Currency}', // Gets all the bank accounts related to the logged in user.
                'ElectronicWallet/DepositWallets', // Gets all crypto currency addresses related deposits to the logged in user.
                'ElectronicWallet/DepositWallets/{DigiCurrency}', // Gets all crypto currency addresses related deposits to the logged in user by currency.
                'ElectronicWallet/Transactions', // Get all digital currency transactions of the logged in user
                'ElectronicWallet/Transactions/{DigiCurrency}', // Get all digital currency transactions of the logged in user
                'ElectronicWallet/UserWallets', // Gets all external digital currency addresses related to the logged in user.
                'ElectronicWallet/UserWallets/{DigiCurrency}', // Gets all external digital currency addresses related to the logged in user by currency.
                'Info/ReferenceCurrency', // Get user's reference currency
                'Info/ReferenceLanguage', // Get user's reference language
                'Notification/Messages', // Get from oldest unread + 3 read message to newest messages
                'Trade/Orders', // Gets open orders for the logged in trader.
                'Trade/Orders/{OrderID}', // Gets an order for the logged in trader.
                'Trade/StopOrders', // Gets all stop orders for the logged in trader. Max 1000 record.
                'Trade/StopOrdersHistory', // Gets all stop orders for the logged in trader. Max 1000 record.
                'Trade/Trades', // Gets all transactions of logged in user
                'Trade/UserTrades', // Gets all transactions of logged in user
            ],
            'post': [
                'Account/DocumentAddress', // Upload address proof document
                'Account/DocumentCorporation', // Upload registered document document
                'Account/DocumentID', // Upload ID document copy
                'Account/Email/RequestVerify', // Request for verification email
                'Account/Email/Verify', // Verification email
                'Account/GoogleAuth', // Enable google auth
                'Account/Level', // Request verif level of logged in user
                'Account/Questionnaire', // Fill the questionnaire
                'Account/Referral', // Post a referral email
                'APIKey/APIKey', // Create a new API key for logged in user
                'Auth/ChangePassword', // Change password.
                'Auth/ForgotPassword', // Request reset password
                'Auth/ForgotUserID', // Request user id
                'Auth/Login', // Trader session log in.
                'Auth/Logout', // Logout from the current session.
                'Auth/LogoutOtherSessions', // Logout other sessions.
                'Auth/ResetPassword', // Reset password
                'Bank/Transactions', // Request a transfer from the traders account of the logged in user. This is only available for bank account
                'Bank/UserAccounts', // Add an account the logged in user
                'ElectronicWallet/DepositWallets/{DigiCurrency}', // Add an digital currency addresses to the logged in user.
                'ElectronicWallet/Transactions/Deposits/{DigiCurrency}', // Get all internal digital currency transactions of the logged in user
                'ElectronicWallet/Transactions/Withdrawals/{DigiCurrency}', // Get all external digital currency transactions of the logged in user
                'ElectronicWallet/UserWallets/{DigiCurrency}', // Add an external digital currency addresses to the logged in user.
                'ElectronicWallet/Withdrawals/{DigiCurrency}', // Request a transfer from the traders account to an external address. This is only available for crypto currencies.
                'Notification/Messages', // Mark all as read
                'Notification/Messages/{ID}', // Mark as read
                'Trade/Orders', // Place an order at the exchange.
                'Trade/StopOrders', // Place a stop order at the exchange.
            ],
            'put': [
                'Account/CorporateData', // Update user company data for corporate account
                'Account/DocumentID', // Update ID document meta data
                'Account/DocumentInformation', // Update Step3 Data
                'Account/Email', // Update user email
                'Account/PersonalInformation', // Update Step1 Data
                'Account/Phone', // Update user phone number
                'Account/Questionnaire', // update the questionnaire
                'Account/ReferredCode', // Update referral code
                'Account/ResidentInformation', // Update Step2 Data
                'Account/SecuritySettings', // Update verif details of logged in user
                'Account/User', // Update all user info
                'Bank/UserAccounts', // Update the label of existing user bank accounnt
                'ElectronicWallet/DepositWallets/{DigiCurrency}/{AddressName}', // Update the name of an address
                'ElectronicWallet/UserWallets/{DigiCurrency}', // Update the name of an external address
                'Info/ReferenceCurrency', // User's reference currency
                'Info/ReferenceLanguage', // Update user's reference language
            ],
            'delete': [
                'APIKey/APIKey/{PublicKey}', // Remove an API key
                'Bank/Transactions/{RequestID}', // Delete pending account withdraw of the logged in user
                'Bank/UserAccounts/{Currency}/{Label}', // Delete an account of the logged in user
                'ElectronicWallet/DepositWallets/{DigiCurrency}/{AddressName}', // Delete an digital currency addresses related to the logged in user.
                'ElectronicWallet/UserWallets/{DigiCurrency}/{AddressName}', // Delete an external digital currency addresses related to the logged in user.
                'Trade/Orders', // Cancels all existing order
                'Trade/Orders/{OrderID}', // Cancels an existing order
                'Trade/StopOrders', // Cancels all existing stop orders
                'Trade/StopOrders/{ID}', // Cancels an existing stop order
            ],
        },
    },

    async fetchMarkets () {
        let response = await this.publicGetPublicLiveTickers ();
        let markets = response['tickers'];
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['currencyPair'];
            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': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalanceBalances ();
        let balances = response['balances'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let account = {
                'free': balance['availableBalance'],
                'used': this.sum (
                    balance['pendingIncoming'],
                    balance['pendingOutgoing'],
                    balance['openOrder']),
                'total': balance['balance'],
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let orderbook = await this.publicGetPublicMarketDepthCurrencyPair (this.extend ({
            'CurrencyPair': p['id'],
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['volume']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = parseInt (ticker['createDateTime']) * 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': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetPublicLiveTickers ();
        let tickers = response['tickers'];
        let result = {};
        for (let t = 0; t < tickers.length; t++) {
            let ticker = tickers[t];
            let id = ticker['currencyPair'];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.publicGetPublicLiveTickerCurrencyPair ({
            'CurrencyPair': p['id'],
        });
        let ticker = response['ticker'];
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetPublicTransactionsCurrencyPair ({
            'CurrencyPair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'Code': this.marketId (market),
            'Way': (side == 'buy') ? 'Bid' : 'Ask',
            'Amount': amount,
        };
        if (type == 'limit')
            order['Price'] = price;
        if (this.twofa) {
            if ('ValidationCode' in params)
                order['ValidationCode'] = params['ValidationCode'];
            else
                throw new AuthenticationError (this.id + ' two-factor authentication requires a missing ValidationCode parameter');
        }
        let response = await this.privatePostTradeOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['clOrderId'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privateDeleteTradeOrdersOrderID ({ 'OrderID': id });
    },

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let contentType = (method == 'GET') ? '' : 'application/json';
            let auth = method + url + contentType + nonce.toString ();
            auth = auth.toLowerCase ();
            let signature = this.hmac (this.encode (auth), this.encode (this.secret), 'sha256', 'base64');
            headers = {
                'API_PUBLIC_KEY': this.apiKey,
                'API_REQUEST_SIGNATURE': signature,
                'API_REQUEST_DATE': nonce,
            };
            if (method != 'GET') {
                headers['Content-Type'] = contentType;
                body = this.json (this.extend ({ 'nonce': nonce }, params));
            }
        }
        let response = await this.fetch (url, method, headers, body);
        if ('responseStatus' in response)
            if ('message' in response['responseStatus'])
                if (response['responseStatus']['message'] == 'OK')
                    return response;
        throw new ExchangeError (this.id + ' ' + this.json (response));
    },
}

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

var gdax = {
    'id': 'gdax',
    'name': 'GDAX',
    'countries': 'US',
    'rateLimit': 1000,
    'urls': {
        'test': 'https://api-public.sandbox.gdax.com',
        'logo': 'https://user-images.githubusercontent.com/1294454/27766527-b1be41c6-5edb-11e7-95f6-5b496c469e2c.jpg',
        'api': 'https://api.gdax.com',
        'www': 'https://www.gdax.com',
        'market': 'https://www.gdax.com/trade/BTC-USD',
        'doc': 'https://docs.gdax.com',
    },
    'api': {
        'public': {
            'get': [
                'currencies',
                'products',
                'products/{id}/book',
                'products/{id}/candles',
                'products/{id}/stats',
                'products/{id}/ticker',
                'products/{id}/trades',
                'time',
            ],
        },
        'private': {
            'get': [
                'accounts',
                'accounts/{id}',
                'accounts/{id}/holds',
                'accounts/{id}/ledger',
                'coinbase-accounts',
                'fills',
                'funding',
                'orders',
                'orders/{id}',
                'payment-methods',
                'position',
                'reports/{id}',
                'users/self/trailing-volume',
            ],
            'post': [
                'deposits/coinbase-account',
                'deposits/payment-method',
                'funding/repay',
                'orders',
                'position/close',
                'profiles/margin-transfer',
                'reports',
                'withdrawals/coinbase',
                'withdrawals/crypto',
                'withdrawals/payment-method',
            ],
            'delete': [
                'orders',
                'orders/{id}',
            ],
        },
    },

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

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privateGetAccounts ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let account = {
                'free': parseFloat (balance['available']),
                'used': parseFloat (balance['hold']),
                'total': parseFloat (balance['balance']),
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetProductsIdBook (this.extend ({
            'id': this.marketId (market),
            'level': 2, // 1 best bidask, 2 aggregated, 3 full
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetProductsIdTicker ({
            'id': p['id'],
        });
        let quote = await this.publicGetProductsIdStats ({
            'id': p['id'],
        });
        let timestamp = this.parse8601 (ticker['time']);
        let bid = undefined;
        let ask = undefined;
        if ('bid' in ticker)
            bid = parseFloat (ticker['bid']);
        if ('ask' in ticker)
            ask = parseFloat (ticker['ask']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (quote['high']),
            'low': parseFloat (quote['low']),
            'bid': bid,
            'ask': ask,
            'vwap': undefined,
            'open': parseFloat (quote['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (quote['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetProductsIdTrades ({
            'id': this.marketId (market), // fixes issue #2
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let oid = this.nonce ().toString ();
        let order = {
            'product_id': this.marketId (market),
            'side': side,
            'size': amount,
            'type': type,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this.privatePostOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privateDeleteOrdersId ({ 'id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = '/' + this.implodeParams (path, params);
        let url = this.urls['api'] + request;
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            if (!this.apiKey)
                throw new AuthenticationError (this.id + ' requires apiKey property for authentication and trading');
            if (!this.secret)
                throw new AuthenticationError (this.id + ' requires secret property for authentication and trading');
            if (!this.password)
                throw new AuthenticationError (this.id + ' requires password property for authentication and trading');
            let nonce = this.nonce ().toString ();
            if (Object.keys (query).length)
                body = this.json (query);
            let what = nonce + method + request + (body || '');
            let secret = this.base64ToBinary (this.secret);
            let signature = this.hmac (this.encode (what), secret, 'sha256', 'base64');
            headers = {
                'CB-ACCESS-KEY': this.apiKey,
                'CB-ACCESS-SIGN': signature,
                'CB-ACCESS-TIMESTAMP': nonce,
                'CB-ACCESS-PASSPHRASE': this.password,
                'Content-Type': 'application/json',
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('message' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var gemini = {
    'id': 'gemini',
    'name': 'Gemini',
    'countries': 'US',
    'rateLimit': 1500, // 200 for private API
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27816857-ce7be644-6096-11e7-82d6-3c257263229c.jpg',
        'api': 'https://api.gemini.com',
        'www': 'https://gemini.com',
        'doc': 'https://docs.gemini.com/rest-api',
    },
    'api': {
        'public': {
            'get': [
                'symbols',
                'pubticker/{symbol}',
                'book/{symbol}',
                'trades/{symbol}',
                'auction/{symbol}',
                'auction/{symbol}/history',
            ],
        },
        'private': {
            'post': [
                'order/new',
                'order/cancel',
                'order/cancel/session',
                'order/cancel/all',
                'order/status',
                'orders',
                'mytrades',
                'tradevolume',
                'balances',
                'deposit/{currency}/newAddress',
                'withdraw/{currency}',
                'heartbeat',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetSymbols ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let id = markets[p];
            let market = id;
            let uppercase = market.toUpperCase ();
            let base = uppercase.slice (0, 3);
            let quote = uppercase.slice (3, 6);
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetBookSymbol (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['amount']);
                let timestamp = parseInt (order['timestamp']) * 1000;
                result[side].push ([ price, amount, timestamp ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetPubtickerSymbol ({
            'symbol': p['id'],
        });
        let timestamp = ticker['volume']['timestamp'];
        let baseVolume = p['base'];
        let quoteVolume = p['quote'];
        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': parseFloat (ticker['volume'][baseVolume]),
            'quoteVolume': parseFloat (ticker['volume'][quoteVolume]),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradesSymbol ({
            'symbol': this.marketId (market),
        });
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privatePostBalances ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let account = {
                'free': parseFloat (balance['available']),
                'used': undefined,
                'total': parseFloat (balance['amount']),
            };
            account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let order = {
            'client_order_id': this.nonce (),
            'symbol': this.marketId (market),
            'amount': amount.toString (),
            'price': price.toString (),
            'side': side,
            'type': 'exchange limit', // gemini allows limit orders only
        };
        let response = await this.privatePostOrderNew (this.extend (order, params));
        return {
            'info': response,
            'id': response['order_id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'order_id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/' + this.version + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            let request = this.extend ({
                'request': url,
                'nonce': nonce,
            }, query);
            let payload = this.json (request);
            payload = this.stringToBase64 (this.encode (payload));
            let signature = this.hmac (payload, this.encode (this.secret), 'sha384');
            headers = {
                'Content-Type': 'text/plain',
                'Content-Length': 0,
                'X-GEMINI-APIKEY': this.apiKey,
                'X-GEMINI-PAYLOAD': payload,
                'X-GEMINI-SIGNATURE': signature,
            };
        }
        url = this.urls['api'] + url;
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response)
            if (response['result'] == 'error')
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var hitbtc = {

    'id': 'hitbtc',
    'name': 'HitBTC',
    'countries': 'HK', // Hong Kong
    'rateLimit': 1500,
    'version': '1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766555-8eaec20e-5edc-11e7-9c5b-6dc69fc42f5e.jpg',
        'api': 'http://api.hitbtc.com',
        'www': 'https://hitbtc.com',
        'market': 'https://hitbtc.com/exchange/BTC-to-USD',
        'doc': [
            '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 fetchMarkets () {
        let markets = await this.publicGetSymbols ();
        let result = [];
        for (let p = 0; p < markets['symbols'].length; p++) {
            let market = markets['symbols'][p];
            let id = market['symbol'];
            let base = market['commodity'];
            let quote = market['currency'];
            let lot = parseFloat (market['lot']);
            let step = parseFloat (market['step']);
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            // looks like they now have it correct
            // if (base == 'DSH')
            //     base = 'DASH';
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'lot': lot,
                'step': step,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.tradingGetBalance ();
        let balances = response['balance'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency_code'];
            let account = {
                'free': parseFloat (balance['cash']),
                'used': parseFloat (balance['reserved']),
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetSymbolOrderbook (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetTicker ();
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetSymbolTicker ({
            'symbol': p['id'],
        });
        if ('message' in ticker)
            throw new ExchangeError (this.id + ' ' + ticker['message']);
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetSymbolTrades ({
            'symbol': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        // check if amount can be evenly divided into lots
        // they want integer quantity in lot units
        let quantity = parseFloat (amount) / p['lot'];
        let wholeLots = Math.round (quantity);
        let difference = quantity - wholeLots;
        if (Math.abs (difference) > p['step'])
            throw new ExchangeError (this.id + ' order amount should be evenly divisible by lot unit size of ' + p['lot'].toString ());
        let order = {
            'clientOrderId': this.nonce (),
            'symbol': p['id'],
            'side': side,
            'quantity': wholeLots.toString (), // quantity in integer lot units
            'type': type,
        };
        if (type == 'limit')
            order['price'] = this.decimal (price);
        let response = await this.tradingPostNewOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response['ExecutionReport']['orderId'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.tradingPostCancelOrder ({ 'clientOrderId': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/' + 'api' + '/' + this.version + '/' + api + '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == '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);
            let auth = url + (body || '');
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'X-Signature': this.hmac (this.encode (auth), this.encode (this.secret), 'sha512').toLowerCase (),
            };
        }
        url = this.urls['api'] + url;
        let response = await this.fetch (url, method, headers, body);
        if ('code' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var huobi = {

    'id': 'huobi',
    'name': 'Huobi',
    'countries': 'CN',
    'rateLimit': 2000,
    'version': 'v3',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766569-15aa7b9a-5edd-11e7-9e7f-44791f4ee49c.jpg',
        'api': 'http://api.huobi.com',
        'www': 'https://www.huobi.com',
        'doc': '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',
            ],
        },
    },
    'markets': {
        '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 },
    },

    async fetchBalance () {
        let balances = await this.tradePostGetAccountInfo ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            let available = 'available_' + lowercase + '_display';
            let frozen = 'frozen_' + lowercase + '_display';
            let loan = 'loan_' + lowercase + '_display';
            if (available in balances)
                account['free'] = parseFloat (balances[available]);
            if (frozen in balances)
                account['used'] = parseFloat (balances[frozen]);
            if (loan in balances)
                account['used'] = this.sum (account['used'], parseFloat (balances[loan]));
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let method = p['type'] + 'GetDepthId';
        let orderbook = await this[method] (this.extend ({ 'id': p['id'] }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    async fetchTicker (market) {
        let p = this.market (market);
        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,
        };
    },

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

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let p = this.market (market);
        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);
        let response = this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id) {
        return this.tradePostCancelOrder ({ 'id': id });
    },

    async request (path, api = 'trade', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'];
        if (api == '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 (this.encode (queryString));
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        } else {
            url += '/' + api + '/' + this.implodeParams (path, params) + '_json.js';
            let query = this.omit (params, this.extractParams (path));
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        }
        let response = await this.fetch (url, method, headers, body);
        if ('status' in response)
            if (response['status'] == 'error')
                throw new ExchangeError (this.id + ' ' + this.json (response));
        if ('code' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var itbit = {

    'id': 'itbit',
    'name': 'itBit',
    'countries': 'US',
    'rateLimit': 2000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27822159-66153620-60ad-11e7-89e7-005f6d7f3de0.jpg',
        'api': 'https://api.itbit.com',
        'www': 'https://www.itbit.com',
        'market': 'https://exchange.itbit.com/markets',
        'doc': [
            'https://api.itbit.com/docs',
            'https://www.itbit.com/api',
        ],
    },
    'api': {
        'public': {
            'get': [
                'markets/{symbol}/ticker',
                'markets/{symbol}/order_book',
                'markets/{symbol}/trades',
            ],
        },
        'private': {
            'get': [
                'wallets',
                'wallets/{walletId}',
                'wallets/{walletId}/balances/{currencyCode}',
                'wallets/{walletId}/funding_history',
                'wallets/{walletId}/trades',
                'wallets/{walletId}/orders/{id}',
            ],
            'post': [
                'wallet_transfers',
                'wallets',
                'wallets/{walletId}/cryptocurrency_deposits',
                'wallets/{walletId}/cryptocurrency_withdrawals',
                'wallets/{walletId}/orders',
                'wire_withdrawal',
            ],
            'delete': [
                'wallets/{walletId}/orders/{id}',
            ],
        },
    },
    'markets': {
        'BTC/USD': { 'id': 'XBTUSD', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'BTC/SGD': { 'id': 'XBTSGD', 'symbol': 'BTC/SGD', 'base': 'BTC', 'quote': 'SGD' },
        'BTC/EUR': { 'id': 'XBTEUR', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetMarketsSymbolOrderBook (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetMarketsSymbolTicker ({
            'symbol': this.marketId (market),
        });
        let timestamp = this.parse8601 (ticker['serverTimeUTC']);
        let bid = undefined;
        let ask = undefined;
        if ('bid' in ticker)
            if (ticker['bid'])
                bid = parseFloat (ticker['bid']);
        if ('ask' in ticker)
            if (ticker['ask'])
                ask = parseFloat (ticker['ask']);
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high24h']),
            'low': parseFloat (ticker['low24h']),
            'bid': bid,
            'ask': ask,
            'vwap': parseFloat (ticker['vwap24h']),
            'open': parseFloat (ticker['openToday']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['lastPrice']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume24h']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetMarketsSymbolTrades ({
            'symbol': this.marketId (market),
        });
    },

    async fetchBalance () {
        let response = await this.privateGetBalances ();
        let balances = response['balances'];
        let result = { 'info': response };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let account = {
                'free': parseFloat (balance['availableBalance']),
                'used': undefined,
                'total': parseFloat (balance['totalBalance']),
            };
            account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    fetchWallets () {
        return this.privateGetWallets ();
    },

    nonce () {
        return this.milliseconds ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        amount = amount.toString ();
        price = price.toString ();
        let p = this.market (market);
        let order = {
            'side': side,
            'type': type,
            'currency': p['base'],
            'amount': amount,
            'display': amount,
            'price': price,
            'instrument': p['id'],
        };
        let response = await this.privatePostTradeAdd (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

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

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            if (Object.keys (query).length)
                body = this.json (query);
            else
                body = '';
            let nonce = this.nonce ().toString ();
            let timestamp = nonce;
            let auth = [ method, url, body, nonce, timestamp ];
            let message = nonce + this.json (auth);
            let hash = this.hash (this.encode (message), 'sha256', 'binary');
            let binhash = this.binaryConcat (url, hash);
            let signature = this.hmac (binhash, this.encode (this.secret), 'sha512', 'base64');
            headers = {
                'Authorization': self.apiKey + ':' + signature,
                'Content-Type': 'application/json',
                'X-Auth-Timestamp': timestamp,
                'X-Auth-Nonce': nonce,
            };
        }
        let response = this.fetch (url, method, headers, body);
        if ('code' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var jubi = {

    'id': 'jubi',
    'name': 'jubi.com',
    'countries': 'CN',
    'rateLimit': 1500,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766581-9d397d9a-5edd-11e7-8fb9-5d8236c0e692.jpg',
        'api': 'https://www.jubi.com/api',
        'www': 'https://www.jubi.com',
        'market': 'https://www.jubi.com/coin/btc/',
        'doc': 'https://www.jubi.com/help/api.html',
    },
    'api': {
        'public': {
            'get': [
                'depth',
                'orders',
                'ticker',
                'allticker',
            ],
        },
        'private': {
            'post': [
                'balance',
                'trade_add',
                'trade_cancel',
                'trade_list',
                'trade_view',
                'wallet',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetAllticker ();
        let keys = Object.keys (markets);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let base = id.toUpperCase ();
            let quote = 'CNY';
            let symbol = base + '/' + quote;
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': id,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privatePostBalance ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            if (lowercase == 'dash')
                lowercase = 'drk';
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            let free = lowercase + '_balance';
            let used = lowercase + '_lock';
            if (free in balances)
                account['free'] = parseFloat (balances[free]);
            if (used in balances)
                account['used'] = parseFloat (balances[used]);
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetDepth (this.extend ({
            'coin': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetAllticker ();
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetTicker ({
            'coin': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetOrders ({
            'coin': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let response = await this.privatePostTradeAdd (this.extend ({
            'amount': amount,
            'price': price,
            'type': side,
            'coin': this.marketId (market),
        }, params));
        return {
            'info': response,
            'id': response['id'],
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privateDeleteWalletsWalletIdOrdersId (this.extend ({
            'id': id,
        }, params));
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == '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);
            let request = this.urlencode (query);
            let secret = this.hash (this.encode (this.secret));
            query['signature'] = this.hmac (this.encode (request), this.encode (secret));
            body = this.urlencode (query);
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response)
            if (!response['result'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var kraken = {

    'id': 'kraken',
    'name': 'Kraken',
    'countries': 'US',
    'version': '0',
    'rateLimit': 1500,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766599-22709304-5ede-11e7-9de1-9f33732e1509.jpg',
        'api': 'https://api.kraken.com',
        'www': 'https://www.kraken.com',
        'market': 'https://www.kraken.com/charts',
        'doc': [
            '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 fetchMarkets () {
        let markets = await this.publicGetAssetPairs ();
        let keys = Object.keys (markets['result']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let market = markets['result'][id];
            let base = market['base'];
            let quote = market['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 ? market['altname'] : (base + '/' + quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'darkpool': darkpool,
                'info': market,
            });
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let darkpool = market.indexOf ('.d') >= 0;
        if (darkpool)
            throw new ExchangeError (this.id + ' does not provide an order book for darkpool symbol ' + market);
        let p = this.market (market);
        let response = await this.publicGetDepth (this.extend ({
            'pair': p['id'],
        }, params));
        let orderbook = response['result'][p['id']];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                let timestamp = order[2] * 1000;
                result[side].push ([ price, amount, timestamp ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let pairs = [];
        for (let s = 0; s < this.symbols.length; s++) {
            let symbol = this.symbols[s];
            let market = this.markets[symbol];
            if (!market['darkpool'])
                pairs.push (market['id']);
        }
        let filter = pairs.join (',');
        let response = await this.publicGetTicker ({
            'pair': filter,
        });
        let tickers = response['result'];
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let darkpool = market.indexOf ('.d') >= 0;
        if (darkpool)
            throw new ExchangeError (this.id + ' does not provide a ticker for darkpool symbol ' + market);
        let p = this.market (market);
        let response = await this.publicGetTicker ({
            'pair': p['id'],
        });
        let ticker = response['result'][p['id']];
        return this.parseTicker (ticker, p);
    },

    parseTrade (trade, market) {
        let timestamp = parseInt (trade[2] * 1000);
        let side = (trade[3] == 's') ? 'sell' : 'buy';
        let type = (trade[4] == 'l') ? 'limit' : 'market';
        return {
            'info': trade,
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'symbol': market['symbol'],
            'type': type,
            'side': side,
            'price': parseFloat (trade[0]),
            'amount': parseFloat (trade[1]),
        };
    },

    parseTrades (trades, market) {
        let result = [];
        for (let t = 0; t < trades.length; t++) {
            result.push (this.parseTrade (trades[t], market));
        }
        return result;
    },

    async fetchTrades (market, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        let id = m['id'];
        let response = await this.publicGetTrades (this.extend ({
            'pair': id,
        }, params));
        let trades = response['result'][id];
        return this.parseTrades (trades, m);
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostBalance ();
        let balances = response['result'];
        let result = { 'info': balances };
        let currencies = Object.keys (balances);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let code = currency;
            // X-ISO4217-A3 standard currency codes
            if (code[0] == 'X') {
                code = code.slice (1);
            } else if (code[0] == 'Z') {
                code = code.slice (1);
            }
            code = this.commonCurrencyCode (code);
            let balance = parseFloat (balances[currency]);
            let account = {
                'free': balance,
                'used': undefined,
                'total': balance,
            };
            result[code] = account;
        }
        return result;
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'pair': this.marketId (market),
            'type': side,
            'ordertype': type,
            'volume': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this.privatePostAddOrder (this.extend (order, params));
        let length = response['txid'].length;
        let id = (length > 1) ? response['txid'] : response['txid'][0];
        return {
            'info': response,
            'id': id,
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'txid': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/' + this.version + '/' + api + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ().toString ();
            body = this.urlencode (this.extend ({ 'nonce': nonce }, params));
            let auth = this.encode (nonce + body);
            let hash = this.hash (auth, 'sha256', 'binary');
            let binary = this.stringToBinary (this.encode (url));
            let binhash = this.binaryConcat (binary, hash);
            let secret = this.base64ToBinary (this.secret);
            let signature = this.hmac (binhash, secret, 'sha512', 'base64');
            headers = {
                'API-Key': this.apiKey,
                'API-Sign': signature,
                'Content-Type': 'application/x-www-form-urlencoded',
            };
        }
        url = this.urls['api'] + url;
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response) {
            let numErrors = response['error'].length;
            if (numErrors)
                throw new ExchangeError (this.id + ' ' + this.json (response));
        }
        return response;
    },
}

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

var lakebtc = {

    'id': 'lakebtc',
    'name': 'LakeBTC',
    'countries': 'US',
    'version': 'api_v2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28074120-72b7c38a-6660-11e7-92d9-d9027502281d.jpg',
        'api': 'https://api.lakebtc.com',
        'www': 'https://www.lakebtc.com',
        'market': 'https://www.lakebtc.com/orders/bid?symbol=btcusd',
        'doc': [
            'https://www.lakebtc.com/s/api',
            'https://www.lakebtc.com/s/api_v2',
        ],
    },
    'api': {
        'public': {
            'get': [
                'bcorderbook',
                'bctrades',
                'ticker',
            ],
        },
        'private': {
            'post': [
                'buyOrder',
                'cancelOrders',
                'getAccountInfo',
                'getExternalAccounts',
                'getOrders',
                'getTrades',
                'openOrders',
                'sellOrder',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetTicker ();
        let result = [];
        let keys = Object.keys (markets);
        for (let k = 0; k < keys.length; k++) {
            let id = keys[k];
            let market = markets[id];
            let base = id.slice (0, 3);
            let quote = id.slice (3, 6);
            base = base.toUpperCase ();
            quote = quote.toUpperCase ();
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostGetAccountInfo ();
        let balances = response['balance'];
        let result = { 'info': response };
        let currencies = Object.keys (balances);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let balance = parseFloat (balances[currency]);
            let account = {
                'free': balance,
                'used': undefined,
                'total': balance,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetBcorderbook (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let tickers = await this.publicGetTicker ({
            'symbol': p['id'],
        });
        let ticker = tickers[p['id']];
        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': 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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetBctrades ({
            'symbol': this.marketId (market)
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let method = 'privatePost' + this.capitalize (side) + 'Order';
        let marketId = this.marketId (market);
        let order = {
            'params': [ price, amount, marketId ],
        };
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder ({ 'params': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version;
        if (api == 'public') {
            url += '/' + path;
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let nonce = this.nonce ();
            if (Object.keys (params).length)
                params = params.join (',');
            else
                params = '';
            let query = this.urlencode ({
                'tonce': nonce,
                'accesskey': this.apiKey,
                'requestmethod': method.toLowerCase (),
                'id': nonce,
                'method': path,
                'params': params,
            });
            body = this.json ({
                'method': path,
                'params': params,
                'id': nonce,
            });
            let signature = this.hmac (this.encode (query), this.secret, 'sha1', 'base64');
            headers = {
                'Json-Rpc-Tonce': nonce,
                'Authorization': "Basic " + this.apiKey + ':' + signature,
                'Content-Length': body.length,
                'Content-Type': 'application/json',
            };
        }
        let response = this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var livecoin = {

    'id': 'livecoin',
    'name': 'LiveCoin',
    'countries': [ 'US', 'UK', 'RU' ],
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27980768-f22fc424-638a-11e7-89c9-6010a54ff9be.jpg',
        'api': 'https://api.livecoin.net',
        'www': 'https://www.livecoin.net',
        'market': 'https://www.livecoin.net/en/trade/orderbook',
        'doc': 'https://www.livecoin.net/api?lang=en',
    },
    'api': {
        'public': {
            'get': [
                'exchange/all/order_book',
                'exchange/last_trades',
                'exchange/maxbid_minask',
                'exchange/order_book',
                'exchange/restrictions',
                'exchange/ticker', // omit params to get all tickers at once
                'info/coinInfo',
            ],
        },
        'private': {
            'get': [
                'exchange/client_orders',
                'exchange/order',
                'exchange/trades',
                'exchange/commission',
                'exchange/commissionCommonInfo',
                'payment/balances',
                'payment/balance',
                'payment/get/address',
                'payment/history/size',
                'payment/history/transactions',
            ],
            'post': [
                'exchange/buylimit',
                'exchange/buymarket',
                'exchange/cancellimit',
                'exchange/selllimit',
                'exchange/sellmarket',
                'payment/out/capitalist',
                'payment/out/card',
                'payment/out/coin',
                'payment/out/okpay',
                'payment/out/payeer',
                'payment/out/perfectmoney',
                'payment/voucher/amount',
                'payment/voucher/make',
                'payment/voucher/redeem',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetExchangeTicker ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['symbol'];
            let symbol = id;
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privateGetPaymentBalances ();
        let result = { 'info': balances };
        for (let b = 0; b < this.currencies.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let account = undefined;
            if (currency in result)
                account = result[currency];
            else
                account = {
                    'free': undefined,
                    'used': undefined,
                    'total': undefined,
                };
            if (balance['type'] == 'total')
                account['total'] = parseFloat (balance['value']);
            if (balance['type'] == 'available')
                account['free'] = parseFloat (balance['value']);
            if (balance['type'] == 'trade')
                account['used'] = parseFloat (balance['value']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetExchangeOrderBook (this.extend ({
            'currencyPair': this.marketId (market),
            'groupByPrice': 'false',
            'depth': 100,
        }, params));
        let timestamp = orderbook['timestamp'];
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': parseFloat (ticker['high']),
            'low': parseFloat (ticker['low']),
            'bid': parseFloat (ticker['best_bid']),
            'ask': parseFloat (ticker['best_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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetExchangeTicker ();
        let tickers = this.indexBy (response, 'symbol');
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetExchangeTicker ({
            'currencyPair': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetExchangeLastTrades ({
            'currencyPair': this.marketId (market)
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let method = 'privatePostExchange' + this.capitalize (side) + type;
        let order = {
            'currencyPair': this.marketId (market),
            'quantity': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privatePostExchangeCancellimit (this.extend ({
            'orderId': id,
        }, params));
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + path;
        if (api == 'public') {
            if (Object.keys (params).length)
                url += '?' + this.urlencode (params);
        } else {
            let query = this.urlencode (this.keysort (params));
            if (method == 'GET')
                if (query)
                    url += '?' + query;
            else
                if (query)
                    body = query;
            let signature = this.hmac (this.encode (query), this.encode (this.secret), 'sha256');
            headers = {
                'Api-Key': this.apiKey,
                'Sign': signature.toUpperCase (),
                'Content-Type': 'application/x-www-form-urlencoded',
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('success' in response)
            if (!response['success'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var liqui = extend (btce, {
    'id': 'liqui',
    'name': 'Liqui',
    'countries': 'UA',
    'rateLimit': 1000,
    'version': '3',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27982022-75aea828-63a0-11e7-9511-ca584a8edd74.jpg',
        'api': {
            'public': 'https://api.liqui.io/api',
            'private': 'https://api.liqui.io/tapi',
        },
        'www': 'https://liqui.io',
        'market': 'https://liqui.io/#/exchange/PAY_BTC',
        'doc': 'https://liqui.io/api',
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            url +=  '/' + this.version + '/' + this.implodeParams (path, params);
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({
                'nonce': nonce,
                'method': path,
            }, query));
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Content-Length': body.length,
                'Key': this.apiKey,
                'Sign': this.hmac (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('success' in response)
            if (!response['success'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
})

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

var luno = {

    'id': 'luno',
    'name': 'luno',
    'countries': [ 'GB', 'SG', 'ZA' ],
    'rateLimit': 3000,
    'version': '1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766607-8c1a69d8-5ede-11e7-930c-540b5eb9be24.jpg',
        'api': 'https://api.mybitx.com/api',
        'www': 'https://www.luno.com',
        'market': 'https://www.luno.com/trade/XBTMYR',
        'doc': [
            'https://www.luno.com/en/api',
            '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 fetchMarkets () {
        let markets = await this.publicGetTickers ();
        let result = [];
        for (let p = 0; p < markets['tickers'].length; p++) {
            let market = markets['tickers'][p];
            let id = market['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': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalance ();
        let balances = response['balance'];
        let result = { 'info': response };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = this.commonCurrencyCode (balance['asset']);
            let reserved = parseFloat (balance['reserved']);
            let unconfirmed = parseFloat (balance['unconfirmed']);
            let account = {
                'free': parseFloat (balance['balance']),
                'used': this.sum (reserved, unconfirmed),
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetOrderbook (this.extend ({
            'pair': this.marketId (market),
        }, params));
        let timestamp = orderbook['timestamp'];
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['volume']);
                // let timestamp = order[2] * 1000;
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetTickers ();
        let tickers = this.indexBy (response['tickers'], 'pair');
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetTicker ({
            'pair': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTrades ({
            'pair': this.marketId (market)
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let method = 'privatePost';
        let order = { 'pair': this.marketId (market) };
        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';
        }
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['order_id'],
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostStoporder ({ 'order_id': id });
    },

    async request (path, api = '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 (api == 'private') {
            let auth = this.encode (this.apiKey + ':' + this.secret);
            auth = this.stringToBase64 (auth);
            headers = { 'Authorization': 'Basic ' + this.decode (auth) };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var mercado = {

    'id': 'mercado',
    'name': 'Mercado Bitcoin',
    'countries': 'BR', // Brazil
    'rateLimit': 1000,
    'version': 'v3',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27837060-e7c58714-60ea-11e7-9192-f05e86adb83f.jpg',
        'api': {
            'public': 'https://www.mercadobitcoin.net/api',
            'private': 'https://www.mercadobitcoin.net/tapi',
        },
        'www': 'https://www.mercadobitcoin.com.br',
        'doc': [
            'https://www.mercadobitcoin.com.br/api-doc',
            'https://www.mercadobitcoin.com.br/trade-api',
        ],
    },
    'api': {
        'public': {
            'get': [ // last slash critical
                'orderbook/',
                'orderbook_litecoin/',
                'ticker/',
                'ticker_litecoin/',
                'trades/',
                'trades_litecoin/',
                'v2/ticker/',
                'v2/ticker_litecoin/',
            ],
        },
        'private': {
            'post': [
                'cancel_order',
                'get_account_info',
                'get_order',
                'get_withdrawal',
                'list_system_messages',
                'list_orders',
                'list_orderbook',
                'place_buy_order',
                'place_sell_order',
                'withdraw_coin',
            ],
        },
    },
    'markets': {
        'BTC/BRL': { 'id': 'BRLBTC', 'symbol': 'BTC/BRL', 'base': 'BTC', 'quote': 'BRL', 'suffix': '' },
        'LTC/BRL': { 'id': 'BRLLTC', 'symbol': 'LTC/BRL', 'base': 'LTC', 'quote': 'BRL', 'suffix': 'Litecoin' },
    },

    async fetchOrderBook (market, params = {}) {
        let p = this.market (market);
        let method = 'publicGetOrderbook' + this.capitalize (p['suffix']);
        let orderbook = await this[method] (params);
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    async fetchTicker (market) {
        let p = this.market (market);
        let method = 'publicGetV2Ticker' + this.capitalize (p['suffix']);
        let response = await this[method] ();
        let ticker = response['ticker'];
        let timestamp = parseInt (ticker['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,
        };
    },

    async fetchTrades (market) {
        let p = this.market (market);
        let method = 'publicGetTrades' + this.capitalize (p['suffix']);
        return this[method] ();
    },

    async fetchBalance () {
        let response = await this.privatePostGetAccountInfo ();
        let balances = response['balance'];
        let result = { 'info': response };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balances) {
                account['free'] = parseFloat (balances[lowercase]['available']);
                account['total'] = parseFloat (balances[lowercase]['total']);
                account['used'] = account['total'] - account['free'];
            }
            result[currency] = account;
        }
        return result;
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let method = 'privatePostPlace' + this.capitalize (side) + 'Order';
        let order = {
            'coin_pair': this.marketId (market),
            'quantity': amount,
            'limit_price': price,
        };
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['response_data']['order']['order_id'].toString (),
        };
    },

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

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api] + '/';
        if (api == 'public') {
            url += path;
        } else {
            url += this.version + '/';
            let nonce = this.nonce ();
            body = this.urlencode (this.extend ({
                'tapi_method': path,
                'tapi_nonce': nonce,
            }, params));
            let auth = '/tapi/' + this.version + '/' + '?' + body;
            headers = {
                'Content-Type': 'application/x-www-form-urlencoded',
                'TAPI-ID': this.apiKey,
                'TAPI-MAC': this.hmac (this.encode (auth), this.secret, 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error_message' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

//-----------------------------------------------------------------------------
// 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': 1000, // 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',
            ],
        },
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetDepth (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': this.sortBy (orderbook['asks'], 0),
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    async fetchTicker (market) {
        let response = await this.publicGetTicker ({
            'symbol': this.marketId (market),
        });
        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,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTrades ({
            'symbol': this.marketId (market),
        });
    },

    async fetchBalance () {
        let response = await this.privatePostUserinfo ();
        let balances = response['info']['funds'];
        let result = { 'info': response };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if (lowercase in balances['free'])
                account['free'] = parseFloat (balances['free'][lowercase]);
            if (lowercase in balances['freezed'])
                account['used'] = parseFloat (balances['freezed'][lowercase]);
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'symbol': this.marketId (market),
            'type': side,
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        else
            order['type'] += '_market';
        let response = await this.privatePostTrade (this.extend (order, params));
        return {
            'info': response,
            'id': response['order_id'].toString (),
        };
    },

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

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = '/api/' + this.version + '/' + path + '.do';
        if (api == '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 (this.encode (queryString)).toUpperCase ();
            body = this.urlencode (query);
            headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
        }
        url = this.urls['api'] + url;
        let response = await this.fetch (url, method, headers, body);
        if ('result' in response)
            if (!response['result'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var okcoincny = extend (okcoin, {
    'id': 'okcoincny',
    'name': 'OKCoin CNY',
    'countries': 'CN',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766792-8be9157a-5ee5-11e7-926c-6d69b8d3378d.jpg',
        'api': 'https://www.okcoin.cn',
        'www': 'https://www.okcoin.cn',
        'doc': 'https://www.okcoin.cn/rest_getStarted.html',
    },
    'markets': {
        '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': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766791-89ffb502-5ee5-11e7-8a5b-c5950b68ac65.jpg',
        'api': 'https://www.okcoin.com',
        'www': 'https://www.okcoin.com',
        'doc': [
            'https://www.okcoin.com/rest_getStarted.html',
            'https://www.npmjs.com/package/okcoin.com',
        ],
    },
    'markets': {
        'BTC/USD': { 'id': 'btc_usd', 'symbol': 'BTC/USD', 'base': 'BTC', 'quote': 'USD' },
        'LTC/USD': { 'id': 'ltc_usd', 'symbol': 'LTC/USD', 'base': 'LTC', 'quote': 'USD' },
        'ETH/USD': { 'id': 'eth_usd', 'symbol': 'ETH/USD', 'base': 'ETH', 'quote': 'USD' },
        'ETC/USD': { 'id': 'etc_usd', 'symbol': 'ETC/USD', 'base': 'ETC', 'quote': 'USD' },
    },
})

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

var paymium = {

    'id': 'paymium',
    'name': 'Paymium',
    'countries': [ 'FR', 'EU' ],
    'rateLimit': 2000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27790564-a945a9d4-5ff9-11e7-9d2d-b635763f2f24.jpg',
        'api': 'https://paymium.com/api',
        'www': 'https://www.paymium.com',
        'doc': [
            'https://github.com/Paymium/api-documentation',
            'https://www.paymium.com/page/developers',
        ],
    },
    'api': {
        'public': {
            'get': [
                'countries',
                'data/{id}/ticker',
                'data/{id}/trades',
                'data/{id}/depth',
                'bitcoin_charts/{id}/trades',
                'bitcoin_charts/{id}/depth',
            ],
        },
        'private': {
            'get': [
                'merchant/get_payment/{UUID}',
                'user',
                'user/addresses',
                'user/addresses/{btc_address}',
                'user/orders',
                'user/orders/{UUID}',
                'user/price_alerts',
            ],
            'post': [
                'user/orders',
                'user/addresses',
                'user/payment_requests',
                'user/price_alerts',
                'merchant/create_payment',
            ],
            'delete': [
                'user/orders/{UUID}/cancel',
                'user/price_alerts/{id}',
            ],
        },
    },
    'markets': {
        'BTC/EUR': { 'id': 'eur', 'symbol': 'BTC/EUR', 'base': 'BTC', 'quote': 'EUR' },
    },

    async fetchBalance () {
        let balances = await this.privateGetUser ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            let balance = 'balance_' + lowercase;
            let locked = 'locked_' + lowercase;
            if (balance in balances)
                account['free'] = balances[balance];
            if (locked in balances)
                account['used'] = balances[locked];
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetDataIdDepth (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['price'];
                let amount = order['amount'];
                let timestamp = order['timestamp'] * 1000;
                result[side].push ([ price, amount, timestamp ]);
            }
        }
        result['bids'] = this.sortBy (result['bids'], 0, true);
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetDataIdTicker ({
            'id': this.marketId (market),
        });
        let timestamp = ticker['at'] * 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': parseFloat (ticker['open']),
            'close': undefined,
            'first': undefined,
            'last': parseFloat (ticker['price']),
            'change': undefined,
            'percentage': parseFloat (ticker['variation']),
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetDataIdTrades ({
            'id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let order = {
            'type': this.capitalize (type) + 'Order',
            'currency': this.marketId (market),
            'direction': side,
            'amount': amount,
        };
        if (type == 'market')
            order['price'] = price;
        let response = await this.privatePostUserOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['uuid'],
        };
    },

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

    async request (path, api = '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 (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            body = this.json (params);
            let nonce = this.nonce ().toString ();
            let auth = nonce + url + body;
            headers = {
                'Api-Key': this.apiKey,
                'Api-Signature': this.hmac (this.encode (auth), this.secret),
                'Api-Nonce': nonce,
                'Content-Type': 'application/json',
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('errors' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var poloniex = {

    'id': 'poloniex',
    'name': 'Poloniex',
    'countries': 'US',
    'rateLimit': 500, // 6 calls per second
    'orderCache': { },
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766817-e9456312-5ee6-11e7-9b3c-b628ca5626a5.jpg',
        'api': {
            'public': 'https://poloniex.com/public',
            'private': 'https://poloniex.com/tradingApi',
        },
        'www': 'https://poloniex.com',
        'market': 'https://poloniex.com/exchange#{id}',
        'doc': [
            '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 getMarketURL (market, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        return this.url (this.urls['market'], this.extend ({
            'id': m['id'].toLowerCase (),
        }, params));
    },

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

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privatePostReturnCompleteBalances ({
            'account': 'all',
        });
        let result = { 'info': balances };
        let currencies = Object.keys (balances);
        for (let c = 0; c < currencies.length; c++) {
            let currency = currencies[c];
            let balance = balances[currency];
            let account = {
                'free': parseFloat (balance['available']),
                'used': parseFloat (balance['onOrders']),
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[currency] = account;
        }
        return result;
    },

    parseBidAsk (bidask) {
        let price = parseFloat (bidask[0]);
        let amount = parseFloat (bidask[1]);
        return [ price, amount ];
    },

    parseBidAsks (bidasks) {
        let result = [];
        for (let i = 0; i < bidasks.length; i++) {
            result.push (this.parseBidAsk (bidasks[i]));
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetReturnOrderBook (this.extend ({
            'currencyPair': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            result[side] = this.parseBidAsks (orderbook[side]);
        }
        return result;
    },

    parseTicker (ticker, market) {
        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': parseFloat (ticker['last']),
            'change': parseFloat (ticker['percentChange']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': parseFloat (ticker['baseVolume']),
            'quoteVolume': parseFloat (ticker['quoteVolume']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetReturnTicker ();
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let m = this.market (market);
        let tickers = await this.publicGetReturnTicker ();
        let ticker = tickers[m['id']];
        return this.parseTicker (ticker, m);
    },

    parseTrade (trade, market = undefined) {
        let timestamp = this.parse8601 (trade['date']);
        let id = undefined;
        let order = undefined;
        if ('tradeID' in trade)
            id = trade['tradeID'];
        if ('orderNumber' in trade)
            order = trade['orderNumber'];
        return {
            'info': trade,
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'symbol': market['symbol'],
            'id': id,
            'order': order,
            'type': 'limit',
            'side': trade['type'],
            'price': parseFloat (trade['rate']),
            'amount': parseFloat (trade['amount']),
        };
    },

    parseTrades (trades, market = undefined) {
        let result = [];
        for (let t = 0; t < trades.length; t++) {
            result.push (this.parseTrade (trades[t], market));
        }
        return result;
    },

    async fetchTrades (market, params = {}) {
        await this.loadMarkets ();
        let m = this.market (market);
        let trades = await this.publicGetReturnTradeHistory (this.extend ({
            'currencyPair': m['id'],
            'end': this.seconds (), // last 50000 trades by default
        }, params));
        return this.parseTrades (trades, m);
    },

    async fetchMyTrades (market = undefined, params = {}) {
        let now = this.seconds ();
        let request = this.extend ({
            'currencyPair': 'all',
            'end': this.seconds (), // last 50000 trades by default
        }, params);
        if (market) {
            let m = this.market (market);
            request['currencyPair'] = m['id'];
        }
        let trades = await this.privatePostReturnTradeHistory (request);
        if (market)
            return this.parseTrades (trades, m);
        let result = { 'info': trades };
        let ids = Object.keys (trades);
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let trades = trades[id];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            result[symbol] = this.parseTrades (trades, market);
        }
        return result;
    },

    parseOrder (order, market) {
        return {
            'id': order['orderNumber'],
            'timestamp': order['timestamp'],
            'datetime': this.iso8601 (order['timestamp']),
            'status': order['status'],
            'symbol': market['symbol'],
            'type': order['type'],
            'side': order['side'],
            'price': order['price'],
            'amount': order['amount'],
            'trades': this.parseTrades (order['resultingTrades'], market),
        };
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        await this.loadMarkets ();
        let method = 'privatePost' + this.capitalize (side);
        let m = this.market (market);
        let response = await this[method] (this.extend ({
            'currencyPair': m['id'],
            'rate': price,
            'amount': amount,
        }, params));
        let timestamp = this.milliseconds ();
        let order = this.parseOrder (this.extend ({
            'timestamp': timestamp,
            'status': 'open',
            'type': type,
            'side': side,
            'price': price,
            'amount': amount,
        }, response), m);
        let id = order['id'];
        this.orders[id] = order;
        return this.extend ({ 'info': response }, order);
    },

    async fetchOrder (id) {
        await this.loadMarkets ();
        let found = (id in this.orders);
        if (!found)
            throw new ExchangeError (this.id + ' order ' + id + ' not found');
        return this.orders[id];
    },

    async fetchOrderTrades (id, params = {}) {
        await this.loadMarkets ();
        let trades = await this.privatePostReturnOrderTrades (this.extend ({
            'orderNumber': id,
        }, params));
        return this.parseTrades (trades);
    },

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

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        let query = this.extend ({ 'command': path }, params);
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var quadrigacx = {

    'id': 'quadrigacx',
    'name': 'QuadrigaCX',
    'countries': 'CA',
    'rateLimit': 1000,
    'version': 'v2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766825-98a6d0de-5ee7-11e7-9fa4-38e11a2c6f52.jpg',
        'api': 'https://api.quadrigacx.com',
        'www': 'https://www.quadrigacx.com',
        'market': 'https://www.quadrigacx.com/market/btc/cad',
        'doc': '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',
            ],
        },
    },
    'markets': {
        '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' },
    },

    async fetchBalance () {
        let balances = await this.privatePostBalance ();
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': parseFloat (balances[lowercase + '_available']),
                'used': parseFloat (balances[lowercase + '_reserved']),
                'total': parseFloat (balances[lowercase + '_balance']),
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        let orderbook = await this.publicGetOrderBook (this.extend ({
            'book': this.marketId (market),
        }, params));
        let timestamp = parseInt (orderbook['timestamp']) * 1000;
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        let ticker = await this.publicGetTicker ({
            'book': this.marketId (market),
        });
        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': parseFloat (ticker['last']),
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['volume']),
            'info': ticker,
        };
    },

    async fetchTrades (market) {
        return this.publicGetTransactions ({
            'book': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        let method = 'privatePost' + this.capitalize (side);
        let order = {
            'amount': amount,
            'book': this.marketId (market),
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this[method] (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

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

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + this.version + '/' + path;
        if (api == 'public') {
            url += '?' + this.urlencode (params);
        } else {
            if (!this.uid)
                throw new AuthenticationError (this.id + ' requires `' + this.id + '.uid` property for authentication');
            let nonce = this.nonce ();
            let request = [ nonce.toString (), this.uid, this.apiKey ].join ('');
            let signature = this.hmac (this.encode (request), this.encode (this.secret));
            let query = this.extend ({
                'key': this.apiKey,
                'nonce': nonce,
                'signature': signature,
            }, params);
            body = this.json (query);
            headers = {
                'Content-Type': 'application/json',
                'Content-Length': body.length,
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var quoine = {

    'id': 'quoine',
    'name': 'QUOINE',
    'countries': [ 'JP', 'SG', 'VN' ],
    'version': '2',
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766844-9615a4e8-5ee8-11e7-8814-fcd004db8cdd.jpg',
        'api': 'https://api.quoine.com',
        'www': 'https://www.quoine.com',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetProducts ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['id'];
            let base = market['base_currency'];
            let quote = market['quoted_currency'];
            let symbol = base + '/' + quote;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privateGetAccountsBalance ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let total = parseFloat (balance['balance']);
            let account = {
                'free': total,
                'used': undefined,
                'total': total,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetProductsIdPriceLevels (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buy_price_levels', 'asks': 'sell_price_levels' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetProducts ();
        let result = {};
        for (let t = 0; t < tickers.length; t++) {
            let ticker = tickers[t];
            let base = ticker['base_currency'];
            let quote = ticker['quoted_currency'];
            let symbol = base + '/' + quote;
            let market = this.markets[symbol];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetProductsId ({
            'id': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetExecutions ({
            'product_id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'order_type': type,
            'product_id': this.marketId (market),
            'side': side,
            'quantity': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this.privatePostOrders (this.extend ({
            'order': order,
        }, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

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

    async request (path, api = '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 (api == '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 = this.json (query);
            headers['X-Quoine-Auth'] = this.jwt (request, this.secret);
        }
        let response = await this.fetch (this.urls['api'] + url, method, headers, body);
        if ('message' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var southxchange = {

    'id': 'southxchange',
    'name': 'SouthXchange',
    'countries': 'AR', // Argentina
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27838912-4f94ec8a-60f6-11e7-9e5d-bbf9bd50a559.jpg',
        'api': 'https://www.southxchange.com/api',
        'www': 'https://www.southxchange.com',
        'market': 'https://www.southxchange.com/Market/Book/ETH/BTC',
        'doc': 'https://www.southxchange.com/Home/Api',
    },
    'api': {
        'public': {
            'get': [
                'markets',
                'price/{symbol}',
                'prices',
                'book/{symbol}',
                'trades/{symbol}',
            ],
        },
        'private': {
            'post': [
                'cancelMarketOrders',
                'cancelOrder',
                'generatenewaddress',
                'listOrders',
                'listBalances',
                'placeOrder',
                'withdraw',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let base = market[0];
            let quote = market[1];
            let symbol = base + '/' + quote;
            let id = symbol;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privatePostListBalances ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['Currency'];
            let uppercase = currency.uppercase;
            let free = parseFloat (balance['Available']);
            let used = parseFloat (balance['Unconfirmed']);
            let total = this.sum (free, used);
            let account = {
                'free': free,
                'used': used,
                'total': total,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetBookSymbol (this.extend ({
            'symbol': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'BuyOrders', 'asks': 'SellOrders' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['Price']);
                let amount = parseFloat (order['Amount']);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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': parseFloat (ticker['Variation24Hr']),
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': parseFloat (ticker['Volume24Hr']),
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetPrices ();
        let tickers = this.indexBy (response, 'Market');
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetPriceSymbol ({
            'symbol': this.marketId (market),
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTradesSymbol ({
            'symbol': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let order = {
            'listingCurrency': p['base'],
            'referenceCurrency': p['quote'],
            'type': side,
            'amount': amount,
        };
        if (type == 'limit')
            order['limitPrice'] = price;
        let response = await this.privatePostPlaceOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response.toString (),
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder (this.extend ({
            'orderCode': id,
        }, params));
    },

    async request (path, api = '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 (api == 'private') {
            let nonce = this.nonce ();
            query = this.extend ({
                'key': this.apiKey,
                'nonce': nonce,
            }, query);
            body = this.json (query);
            headers = {
                'Content-Type': 'application/json',
                'Hash': this.hmac (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if (!response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var surbitcoin = extend (blinktrade, {
    'id': 'surbitcoin',
    'name': 'SurBitcoin',
    'countries': 'VE',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27991511-f0a50194-6481-11e7-99b5-8f02932424cc.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://surbitcoin.com',
        'doc': 'https://blinktrade.com/docs',
    },
    'comment': 'Blinktrade API',
    'markets': {
        'BTC/VEF': { 'id': 'BTCVEF', 'symbol': 'BTC/VEF', 'base': 'BTC', 'quote': 'VEF', 'brokerId': 1, 'broker': 'SurBitcoin' },
    },
})

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

var therock = {

    'id': 'therock',
    'name': 'TheRockTrading',
    'countries': 'MT',
    'rateLimit': 1000,
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766869-75057fa2-5ee9-11e7-9a6f-13e641fa4707.jpg',
        'api': 'https://api.therocktrading.com',
        'www': 'https://therocktrading.com',
        'market': 'https://therocktrading.com/en/offers/BTCUSD',
        'doc': [
            'https://api.therocktrading.com/doc/v1/index.html',
            '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 fetchMarkets () {
        let markets = await this.publicGetFundsTickers ();
        let result = [];
        for (let p = 0; p < markets['tickers'].length; p++) {
            let market = markets['tickers'][p];
            let id = market['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': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalances ();
        let balances = response['balances'];
        let result = { 'info': response };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let free = balance['trading_balance'];
            let total = balance['balance'];
            let used = total - free;
            let account = {
                'free': free,
                'used': used,
                'total': total,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.publicGetFundsIdOrderbook (this.extend ({
            'id': this.marketId (market),
        }, params));
        let timestamp = this.parse8601 (orderbook['date']);
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['amount']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let response = await this.publicGetFundsTickers ();
        let tickers = this.indexBy (response['tickers'], 'fund_id');
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = this.markets_by_id[id];
            let symbol = market['symbol'];
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let ticker = await this.publicGetFundsIdTicker ({
            'id': p['id'],
        });
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetFundsIdTrades ({
            'id': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let response = await this.privatePostFundsFundIdOrders (this.extend ({
            'fund_id': this.marketId (market),
            'side': side,
            'amount': amount,
            'price': price,
        }, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privateDeleteFundsFundIdOrdersId (this.extend ({
            'id': id,
        }, params));
    },

    async request (path, api = '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 (api == 'private') {
            let nonce = this.nonce ().toString ();
            let auth = nonce + url;
            headers = {
                'X-TRT-KEY': this.apiKey,
                'X-TRT-NONCE': nonce,
                'X-TRT-SIGN': this.hmac (this.encode (auth), this.encode (this.secret), 'sha512'),
            };
            if (Object.keys (query).length) {
                body = this.json (query);
                headers['Content-Type'] = 'application/json';
            }
        }
        let response = await this.fetch (url, method, headers, body);
        if ('errors' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var urdubit = extend (blinktrade, {
    'id': 'urdubit',
    'name': 'UrduBit',
    'countries': 'PK',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27991453-156bf3ae-6480-11e7-82eb-7295fe1b5bb4.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://urdubit.com',
        'doc': 'https://blinktrade.com/docs',
    },
    'comment': 'Blinktrade API',
    'markets': {
        'BTC/PKR': { 'id': 'BTCPKR', 'symbol': 'BTC/PKR', 'base': 'BTC', 'quote': 'PKR', 'brokerId': 8, 'broker': 'UrduBit' },
    },
})

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

var vaultoro = {

    'id': 'vaultoro',
    'name': 'Vaultoro',
    'countries': 'CH',
    'rateLimit': 1000,
    'version': '1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766880-f205e870-5ee9-11e7-8fe2-0d5b15880752.jpg',
        'api': 'https://api.vaultoro.com',
        'www': 'https://www.vaultoro.com',
        'doc': '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/{id}',
                'sell/{symbol}/{type}',
                'withdraw',
            ],
        },
    },

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

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetBalance ();
        let balances = response['data'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency_code'];
            let uppercase = currency.toUpperCase ();
            let free = balance['cash'];
            let used = balance['reserved'];
            let total = this.sum (free, used);
            let account = {
                'free': free,
                'used': used,
                'total': total,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.publicGetOrderbook (params);
        let orderbook = {
            'bids': response['data'][0]['b'],
            'asks': response['data'][1]['s'],
        };
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = order['Gold_Price'];
                let amount = order['Gold_Amount'];
                result[side].push ([ price, amount ]);
            }
        }
        result['bids'] = this.sortBy (result['bids'], 0, true);
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetTransactionsDay ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let method = 'privatePost' + this.capitalize (side) + 'SymbolType';
        let response = await this[method] (this.extend ({
            'symbol': p['quoteId'].toLowerCase (),
            'type': type,
            'gld': amount,
            'price': price || 1,
        }, params));
        return {
            'info': response,
            'id': response['data']['Order_ID'],
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privatePostCancelId (this.extend ({
            'id': id,
        }, params));
    },

    request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/';
        if (api == '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 (this.encode (url), this.encode (this.secret))
            };
        }
        return this.fetch (url, method, headers, body);
    },
}

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

var vbtc = extend (blinktrade, {
    'id': 'vbtc',
    'name': 'VBTC',
    'countries': 'VN',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27991481-1f53d1d8-6481-11e7-884e-21d17e7939db.jpg',
        'api': {
            'public': 'https://api.blinktrade.com/api',
            'private': 'https://api.blinktrade.com/tapi',
        },
        'www': 'https://vbtc.exchange',
        'doc': 'https://blinktrade.com/docs',
    },
    'comment': 'Blinktrade API',
    'markets': {
        'BTC/VND': { 'id': 'BTCVND', 'symbol': 'BTC/VND', 'base': 'BTC', 'quote': 'VND', 'brokerId': 3, 'broker': 'VBTC' },
    },
})


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

var virwox = {

    'id': 'virwox',
    'name': 'VirWoX',
    'countries': 'AT',
    'rateLimit': 1000,
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766894-6da9d360-5eea-11e7-90aa-41f2711b7405.jpg',
        'api': {
            'public': 'http://api.virwox.com/api/json.php',
            'private': 'https://www.virwox.com/api/trading.php',
        },
        'www': 'https://www.virwox.com',
        'doc': '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 fetchMarkets () {
        let markets = await this.publicGetInstruments ();
        let keys = Object.keys (markets['result']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let market = markets['result'][keys[p]];
            let id = market['instrumentID'];
            let symbol = market['symbol'];
            let base = market['longCurrency'];
            let quote = market['shortCurrency'];
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privatePostGetBalances ();
        let balances = response['result']['accountList'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let total = balance['balance'];
            let account = {
                'free': total,
                'used': undefined,
                'total': total,
            };
            result[currency] = account;
        }
        return result;
    },

    async fetchBestPrices (market) {
        await this.loadMarkets ();
        return this.publicPostGetBestPrices ({
            'symbols': [ this.symbol (market) ],
        });
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let response = await this.publicPostGetMarketDepth (this.extend ({
            'symbols': [ this.symbol (market) ],
            'buyDepth': 100,
            'sellDepth': 100,
        }, params));
        let orderbook = response['result'][0];
        let timestamp = this.milliseconds ();
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = { 'bids': 'buy', 'asks': 'sell' };
        let keys = Object.keys (sides);
        for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            let side = sides[key];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['price']);
                let amount = parseFloat (order['volume']);
                result[key].push ([ price, amount ]);
            }
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let end = this.milliseconds ();
        let start = end - 86400000;
        let response = await this.publicGetTradedPriceVolume ({
            'instrument': this.symbol (market),
            '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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.publicGetRawTradeData ({
            'instrument': this.symbol (market),
            'timespan': 3600,
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'instrument': this.symbol (market),
            'orderType': side.toUpperCase (),
            'amount': amount,
        };
        if (type == 'limit')
            order['price'] = price;
        let response = await this.privatePostPlaceOrder (this.extend (order, params));
        return {
            'info': response,
            'id': response['orderID'].toString (),
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privatePostCancelOrder (this.extend ({
            'orderID': id,
        }, params));
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'][api];
        let auth = {};
        if (api == 'private') {
            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 = this.json ({
                'method': path,
                'params': this.extend (auth, params),
                'id': nonce,
            });
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            if (response['error'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var xbtce = {

    'id': 'xbtce',
    'name': 'xBTCe',
    'countries': 'RU',
    'rateLimit': 2000, // responses are cached every 2 seconds
    'version': 'v1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28059414-e235970c-662c-11e7-8c3a-08e31f78684b.jpg',
        'api': 'https://cryptottlivewebapi.xbtce.net:8443/api',
        'www': 'https://www.xbtce.com',
        'doc': [
            'https://www.xbtce.com/tradeapi',
            'https://support.xbtce.info/Knowledgebase/Article/View/52/25/xbtce-exchange-api',
        ],
    },
    'api': {
        'public': {
            'get': [
                'currency',
                'currency/{filter}',
                'level2',
                'level2/{filter}',
                'quotehistory/{symbol}/{periodicity}/bars/ask',
                'quotehistory/{symbol}/{periodicity}/bars/bid',
                'quotehistory/{symbol}/level2',
                'quotehistory/{symbol}/ticks',
                'symbol',
                'symbol/{filter}',
                'tick',
                'tick/{filter}',
                'ticker',
                'ticker/{filter}',
                'tradesession',
            ],
        },
        'private': {
            'get': [
                'tradeserverinfo',
                'tradesession',
                'currency',
                'currency/{filter}',
                'level2',
                'level2/{filter}',
                'symbol',
                'symbol/{filter}',
                'tick',
                'tick/{filter}',
                'account',
                'asset',
                'asset/{id}',
                'position',
                'position/{id}',
                'trade',
                'trade/{id}',
                'quotehistory/{symbol}/{periodicity}/bars/ask',
                'quotehistory/{symbol}/{periodicity}/bars/ask/info',
                'quotehistory/{symbol}/{periodicity}/bars/bid',
                'quotehistory/{symbol}/{periodicity}/bars/bid/info',
                'quotehistory/{symbol}/level2',
                'quotehistory/{symbol}/level2/info',
                'quotehistory/{symbol}/periodicities',
                'quotehistory/{symbol}/ticks',
                'quotehistory/{symbol}/ticks/info',
                'quotehistory/cache/{symbol}/{periodicity}/bars/ask',
                'quotehistory/cache/{symbol}/{periodicity}/bars/bid',
                'quotehistory/cache/{symbol}/level2',
                'quotehistory/cache/{symbol}/ticks',
                'quotehistory/symbols',
                'quotehistory/version',
            ],
            'post': [
                'trade',
                'tradehistory',
            ],
            'put': [
                'trade',
            ],
            'delete': [
                'trade',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.privateGetSymbol ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['Symbol'];
            let base = market['MarginCurrency'];
            let quote = market['ProfitCurrency'];
            if (base == 'DSH')
                base = 'DASH';
            let symbol = base + '/' + quote;
            symbol = market['IsTradeAllowed'] ? symbol : id;
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let balances = await this.privateGetAsset ();
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['Currency'];
            let uppercase = currency.toUpperCase ();
            // xbtce names DASH incorrectly as DSH
            if (uppercase == 'DSH')
                uppercase = 'DASH';
            let total = balance['balance'];
            let account = {
                'free': balance['FreeAmount'],
                'used': balance['LockedAmount'],
                'total': balance['Amount'],
            };
            result[uppercase] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let orderbook = await this.privateGetLevel2Filter (this.extend ({
            'filter': p['id'],
        }, params));
        orderbook = orderbook[0];
        let timestamp = orderbook['Timestamp'];
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let Side = this.capitalize (side);
            let orders = orderbook[Side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order['Price']);
                let amount = parseFloat (order['Volume']);
                result[side].push ([ price, amount ]);
            }
        }
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = 0;
        let last = undefined;
        if ('LastBuyTimestamp' in ticker)
            if (timestamp < ticker['LastBuyTimestamp']) {
                timestamp = ticker['LastBuyTimestamp'];
                last = ticker['LastBuyPrice'];
            }
        if ('LastSellTimestamp' in ticker)
            if (timestamp < ticker['LastSellTimestamp']) {
                timestamp = ticker['LastSellTimestamp'];
                last = ticker['LastSellPrice'];
            }
        if (!timestamp)
            timestamp = this.milliseconds ();
        return {
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
            'high': ticker['DailyBestBuyPrice'],
            'low': ticker['DailyBestSellPrice'],
            'bid': ticker['BestBid'],
            'ask': ticker['BestAsk'],
            'vwap': undefined,
            'open': undefined,
            'close': undefined,
            'first': undefined,
            'last': last,
            'change': undefined,
            'percentage': undefined,
            'average': undefined,
            'baseVolume': undefined,
            'quoteVolume': ticker['DailyTradedTotalVolume'],
            'info': ticker,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetTicker ();
        tickers = this.indexBy (tickers, 'Symbol');
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = undefined;
            let symbol = undefined;
            if (id in this.markets_by_id) {
                market = this.markets_by_id[id];
                symbol = market['symbol'];
            } else {
                let base = id.slice (0, 3);
                let quote = id.slice (3, 6);
                if (base == 'DSH')
                    base = 'DASH';
                if (quote == 'DSH')
                    quote = 'DASH';
                symbol = base + '/' + quote;
            }
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let tickers = await this.publicGetTickerFilter ({
            'filter': p['id'],
        });
        let length = tickers.length;
        if (length < 1)
            throw new ExchangeError (this.id + ' fetchTicker returned empty response, xBTCe public API error');
        tickers = this.indexBy (tickers, 'Symbol');
        let ticker = tickers[p['id']];
        return this.parseTicker (ticker, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        // no method for trades?
        return this.privateGetTrade ();
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let response = await this.tapiPostTrade (this.extend ({
            'pair': this.marketId (market),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
        return {
            'info': response,
            'id': response['Id'].toString (),
        };
    },

    async cancelOrder (id, params = {}) {
        await this.loadMarkets ();
        return this.privateDeleteTrade (this.extend ({
            'Type': 'Cancel',
            'Id': id,
        }, params));
    },

    nonce () {
        return this.milliseconds ();
    },

    request (path, api = 'api', method = 'GET', params = {}, headers = undefined, body = undefined) {
        if (!this.apiKey)
            throw new AuthenticationError (this.id + ' requires apiKey for all requests, their public API is always busy');
        if (!this.uid)
            throw new AuthenticationError (this.id + ' requires uid property for authentication and trading');
        let url = this.urls['api'] + '/' + this.version;
        if (api == 'public')
            url += '/' + api;
        url += '/' + this.implodeParams (path, params);
        let query = this.omit (params, this.extractParams (path));
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            headers = { 'Accept-Encoding': 'gzip, deflate' };
            let nonce = this.nonce ().toString ();
            if (method == 'POST') {
                if (Object.keys (query).length) {
                    headers['Content-Type'] = 'application/json';
                    body = this.json (query);
                }
                else
                    url += '?' + this.urlencode (query);
            }
            let auth = nonce + this.uid + this.apiKey + method + url;
            if (body)
                auth += body;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret), 'sha256', 'base64');
            let credentials = this.uid + ':' + this.apiKey + ':' + nonce + ':' + this.binaryToString (signature);
            headers['Authorization'] = 'HMAC ' + credentials;
        }
        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': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766910-cdcbfdae-5eea-11e7-9859-03fea873272d.jpg',
        'api': 'https://yobit.net',
        'www': 'https://www.yobit.net',
        'market': 'https://www.yobit.net/en/trade/BTC/USD',
        'doc': '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 fetchMarkets () {
        let markets = await this.apiGetInfo ();
        let keys = Object.keys (markets['pairs']);
        let result = [];
        for (let p = 0; p < keys.length; p++) {
            let id = keys[p];
            let market = markets['pairs'][id];
            let symbol = id.toUpperCase ().replace ('_', '/');
            let [ base, quote ] = symbol.split ('/');
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.tapiPostGetInfo ();
        let balances = response['return'];
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if ('funds' in balances)
                if (lowercase in balances['funds'])
                    account['free'] = balances['funds'][lowercase];
            if ('funds_incl_orders' in balances)
                if (lowercase in balances['funds_incl_orders'])
                    account['total'] = balances['funds_incl_orders'][lowercase];
            if (account['total'] && account['free'])
                account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.apiGetDepthPairs (this.extend ({
            'pairs': p['id'],
        }, params));
        let orderbook = response[p['id']];
        let timestamp = this.milliseconds ();
        let bids = ('bids' in orderbook) ? orderbook['bids'] : [];
        let asks = ('asks' in orderbook) ? orderbook['asks'] : [];
        let result = {
            'bids': bids,
            'asks': asks,
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        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,
        };
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.apiGetTradesPairs ({
            'pairs': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let response = await this.tapiPostTrade (this.extend ({
            'pair': this.marketId (market),
            'type': side,
            'amount': amount,
            'rate': price,
        }, params));
        return {
            'info': response,
            'id': response['return']['order_id'].toString (),
        };
    },

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

    async request (path, api = 'api', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + api;
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var yunbi = {

    'id': 'yunbi',
    'name': 'YUNBI',
    'countries': 'CN',
    'rateLimit': 1000,
    'version': 'v2',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/28570548-4d646c40-7147-11e7-9cf6-839b93e6d622.jpg',
        'api': 'https://yunbi.com',
        'www': 'https://yunbi.com',
        'market': 'https://yunbi.com/markets/btccny',
        'doc': [
            'https://yunbi.com/documents/api/guide',
            'https://yunbi.com/swagger/',
        ],
    },
    'api': {
        'public': {
            'get': [
                'tickers',
                'tickers/{market}',
                'markets',
                'order_book',
                'k',
                'depth',
                'trades',
                'k_with_pending_trades',
                'timestamp',
                'addresses/{address}',
                'partners/orders/{id}/trades',
            ],
        },
        'private': {
            'get': [
                'deposits',
                'members/me',
                'deposit',
                'deposit_address',
                'order',
                'orders',
                'trades/my',
            ],
            'post': [
                'order/delete',
                'orders',
                'orders/multi',
                'orders/clear',
            ],
        },
    },

    async fetchMarkets () {
        let markets = await this.publicGetMarkets ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['id'];
            let symbol = market['name'];
            let [ base, quote ] = symbol.split ('/');
            base = this.commonCurrencyCode (base);
            quote = this.commonCurrencyCode (quote);
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.privateGetMembersMe ();
        let balances = response['accounts'];
        let result = { 'info': balances };
        for (let b = 0; b < balances.length; b++) {
            let balance = balances[b];
            let currency = balance['currency'];
            let uppercase = currency.toUpperCase ();
            let account = {
                'free': parseFloat (balance['balance']),
                'used': parseFloat (balance['locked']),
                'total': undefined,
            };
            account['total'] = this.sum (account['free'], account['used']);
            result[uppercase] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let p = this.market (market);
        let orderbook = await this.publicGetDepth (this.extend ({
            'market': p['id'],
            'limit': 300,
        }, params));
        let timestamp = orderbook['timestamp'] * 1000;
        let result = {
            'bids': [],
            'asks': [],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        let sides = [ 'bids', 'asks' ];
        for (let s = 0; s < sides.length; s++) {
            let side = sides[s];
            let orders = orderbook[side];
            for (let i = 0; i < orders.length; i++) {
                let order = orders[i];
                let price = parseFloat (order[0]);
                let amount = parseFloat (order[1]);
                result[side].push ([ price, amount ]);
            }
        }
        result['bids'] = this.sortBy (result['bids'], 0, true);
        result['asks'] = this.sortBy (result['asks'], 0);
        return result;
    },

    parseTicker (ticker, market) {
        let timestamp = ticker['at'] * 1000;
        ticker = ticker['ticker'];
        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,
        };
    },

    async fetchTickers () {
        await this.loadMarkets ();
        let tickers = await this.publicGetTickers ();
        let ids = Object.keys (tickers);
        let result = {};
        for (let i = 0; i < ids.length; i++) {
            let id = ids[i];
            let market = undefined;
            let symbol = id;
            if (id in this.markets_by_id) {
                market = this.markets_by_id[id];
                symbol = market['symbol'];
            } else {
                let base = id.slice (0, 3);
                let quote = id.slice (3, 6);
                base = base.toUpperCase ();
                quote = quote.toUpperCase ();
                base = this.commonCurrencyCode (base);
                quote = this.commonCurrencyCode (quote);
                let symbol = base + '/' + quote;
            }
            let ticker = tickers[id];
            result[symbol] = this.parseTicker (ticker, market);
        }
        return result;
    },

    async fetchTicker (market) {
        await this.loadMarkets ();
        let p = this.market (market);
        let response = await this.publicGetTickersMarket ({
            'market': p['id'],
        });
        return this.parseTicker (response, p);
    },

    async fetchTrades (market) {
        await this.loadMarkets ();
        let m = this.market (market);
        return this.publicGetTrades ({
            'market': m['id'],
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        let order = {
            'market': this.marketId (market),
            'side': side,
            'volume': amount.toString (),
            'ord_type': type,
        };
        if (type == 'limit') {
            order['price'] = price.toString ();
        }
        let response = await this.privatePostOrders (this.extend (order, params));
        return {
            'info': response,
            'id': response['id'].toString (),
        };
    },

    async cancelOrder (id) {
        await this.loadMarkets ();
        return this.privatePostOrderDelete ({ 'id': id });
    },

    async request (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let request = '/api/' + this.version + '/' + this.implodeParams (path, params) + '.json';
        let query = this.omit (params, this.extractParams (path));
        let url = this.urls['api'] + request;
        if (api == 'public') {
            if (Object.keys (query).length)
                url += '?' + this.urlencode (query);
        } else {
            let nonce = this.nonce ().toString ();
            let query = this.urlencode (this.keysort (this.extend ({
                'access_key': this.apiKey,
                'tonce': nonce,
            }, params)));
            let auth = method + '|' + request + '|' + query;
            let signature = this.hmac (this.encode (auth), this.encode (this.secret));
            let suffix = query + '&signature=' + signature;
            if (method == 'GET') {
                url += '?' + suffix;
            } else {
                body = suffix;
                headers = {
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Content-Length': body.length,
                };
            }
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var zaif = {

    'id': 'zaif',
    'name': 'Zaif',
    'countries': 'JP',
    'rateLimit': 2000,
    'version': '1',
    'urls': {
        'logo': 'https://user-images.githubusercontent.com/1294454/27766927-39ca2ada-5eeb-11e7-972f-1b4199518ca6.jpg',
        'api': 'https://api.zaif.jp',
        'www': 'https://zaif.jp',
        'market': 'https://zaif.jp/token_trade/xcp_jpy',
        'doc': [
            'http://techbureau-api-document.readthedocs.io/ja/latest/index.html',
            '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 fetchMarkets () {
        let markets = await this.apiGetCurrencyPairsAll ();
        let result = [];
        for (let p = 0; p < markets.length; p++) {
            let market = markets[p];
            let id = market['currency_pair'];
            let symbol = market['name'];
            let [ base, quote ] = symbol.split ('/');
            result.push ({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'info': market,
            });
        }
        return result;
    },

    async fetchBalance () {
        await this.loadMarkets ();
        let response = await this.tapiPostGetInfo ();
        let balances = response['return'];
        let result = { 'info': balances };
        for (let c = 0; c < this.currencies.length; c++) {
            let currency = this.currencies[c];
            let lowercase = currency.toLowerCase ();
            let account = {
                'free': undefined,
                'used': undefined,
                'total': undefined,
            };
            if ('funds' in balances)
                if (lowercase in balances['funds'])
                    account['free'] = balances['funds'][lowercase];
            if ('funds_incl_orders' in balances)
                if (lowercase in balances['funds_incl_orders'])
                    account['total'] = balances['funds_incl_orders'][lowercase];
            if (account['total'] && account['free'])
                account['used'] = account['total'] - account['free'];
            result[currency] = account;
        }
        return result;
    },

    async fetchOrderBook (market, params = {}) {
        await this.loadMarkets ();
        let orderbook = await this.apiGetDepthPair (this.extend ({
            'pair': this.marketId (market),
        }, params));
        let timestamp = this.milliseconds ();
        let result = {
            'bids': orderbook['bids'],
            'asks': orderbook['asks'],
            'timestamp': timestamp,
            'datetime': this.iso8601 (timestamp),
        };
        return result;
    },

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

    async fetchTrades (market) {
        await this.loadMarkets ();
        return this.apiGetTradesPair ({
            'pair': this.marketId (market),
        });
    },

    async createOrder (market, type, side, amount, price = undefined, params = {}) {
        await this.loadMarkets ();
        if (type == 'market')
            throw new ExchangeError (this.id + ' allows limit orders only');
        let response = await this.tapiPostTrade (this.extend ({
            'currency_pair': this.marketId (market),
            'action': (side == 'buy') ? 'bid' : 'ask',
            'amount': amount,
            'price': price,
        }, params));
        return {
            'info': response,
            'id': response['return']['order_id'].toString (),
        };
    },

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

    async request (path, api = 'api', method = 'GET', params = {}, headers = undefined, body = undefined) {
        let url = this.urls['api'] + '/' + api;
        if (api == '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 (this.encode (body), this.encode (this.secret), 'sha512'),
            };
        }
        let response = await this.fetch (url, method, headers, body);
        if ('error' in response)
            throw new ExchangeError (this.id + ' ' + response['error']);
        if ('success' in response)
            if (!response['success'])
                throw new ExchangeError (this.id + ' ' + this.json (response));
        return response;
    },
}

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

var exchanges = {

    '_1broker':      _1broker,
    '_1btcxe':       _1btcxe,
    'anxpro':        anxpro,
    'bit2c':         bit2c,
    'bitbay':        bitbay,
    'bitbays':       bitbays,
    'bitcoincoid':   bitcoincoid,
    'bitfinex':      bitfinex,
    'bitflyer':      bitflyer,
    'bitlish':       bitlish,
    'bitmarket':     bitmarket,
    'bitmex':        bitmex,
    'bitso':         bitso,
    'bitstamp':      bitstamp,
    'bittrex':       bittrex,
    'bl3p':          bl3p,
    'btcchina':      btcchina,
    'btce':          btce,
    'btcexchange':   btcexchange,
    'btcmarkets':    btcmarkets,
    'btctradeua':    btctradeua,
    'btcturk':       btcturk,
    'btcx':          btcx,
    'bter':          bter,
    'bxinth':        bxinth,
    'ccex':          ccex,
    'cex':           cex,
    'chbtc':         chbtc,
    'chilebit':      chilebit,
    'coincheck':     coincheck,
    'coingi':        coingi,
    'coinmarketcap': coinmarketcap,
    'coinmate':      coinmate,
    'coinsecure':    coinsecure,
    'coinspot':      coinspot,
    'dsx':           dsx,
    'exmo':          exmo,
    'flowbtc':       flowbtc,
    'foxbit':        foxbit,
    'fybse':         fybse,
    'fybsg':         fybsg,
    'gatecoin':      gatecoin,
    'gdax':          gdax,
    'gemini':        gemini,
    'hitbtc':        hitbtc,
    'huobi':         huobi,
    'itbit':         itbit,
    'jubi':          jubi,
    'kraken':        kraken,
    'lakebtc':       lakebtc,
    'livecoin':      livecoin,
    'liqui':         liqui,
    'luno':          luno,
    'mercado':       mercado,
    'okcoincny':     okcoincny,
    'okcoinusd':     okcoinusd,
    'paymium':       paymium,
    'poloniex':      poloniex,
    'quadrigacx':    quadrigacx,
    'quoine':        quoine,
    'southxchange':  southxchange,
    'surbitcoin':    surbitcoin,
    'therock':       therock,
    'urdubit':       urdubit,
    'vaultoro':      vaultoro,
    'vbtc':          vbtc,
    'virwox':        virwox,
    'xbtce':         xbtce,
    'yobit':         yobit,
    'yunbi':         yunbi,
    'zaif':          zaif,
}

let defineAllExchanges = function (exchanges) {
    let result = {}
    for (let id in exchanges)
        result[id] = function (params) {
            return new Exchange (extend (exchanges[id], params))
        }
    result.exchanges = Object.keys (exchanges)
    return result
}

if (isNode || isReactNative) {

    Object.assign (module.exports = defineAllExchanges (exchanges), {

        version,

        // exceptions

        CCXTError,
        ExchangeError,
        AuthenticationError,
        NetworkError,
        DDoSProtection,
        RequestTimeout,
        ExchangeNotAvailable,

        // common utility functions

        sleep,
        timeout,
        capitalize,
        keysort,
        extend,
        omit,
        indexBy,
        sortBy,
        flatten,
        unique,
        pluck,
        urlencode,
        sum,
        decimal,

        // underscore aliases

        index_by: indexBy,
        sort_by: sortBy,

        // crypto functions

        binaryConcat,
        stringToBinary,
        binaryToString,
        stringToBase64,
        utf16ToBase64,
        base64ToBinary,
        base64ToString,
        urlencodeBase64,
        hash,
        hmac,
        jwt,

    })

} else

    window.ccxt = defineAllExchanges (exchanges)

}) ()