@icgio/icg-exchanges-wrapper 1.8.6

package/middleware/orders.js

@@ -0,0 +1,1024 @@
+const _ = require('lodash')
+
+const uuidv4 = require('uuid/v4')
+const Influx = require('influx')
+
+const icg_exchanges = require('@icgio/icg-exchanges')
+const utils = require('@icgio/icg-utils').utils
+const get_coinmarketcap_rates = require('@icgio/icg-utils').coinmarketcap
+
+const { round_price, round_amount } = require('@icgio/icg-exchanges-data')
+
+const Account = require('./account.js')
+
+const limits = {
+  public_max_concurrent: 10,
+  public_interval_concurrent: 1000,
+  private_max_concurrent: 5,
+  private_interval_concurrent: 1000
+}
+const small_limits = {
+  public_max_concurrent: 5,
+  public_interval_concurrent: 1000,
+  private_max_concurrent: 3,
+  private_interval_concurrent: 1000
+}
+const mimimum_limits = {
+  public_max_concurrent: 2,
+  public_interval_concurrent: 1000,
+  private_max_concurrent: 1,
+  private_interval_concurrent: 3000
+}
+
+const rates_length = 10
+
+module.exports = class Orders {
+  constructor (exchange_basecur_curs, cd, settings) {
+    this.exchange_basecur_curs = exchange_basecur_curs
+    let { exchange_pairs, exchange_curs, pair_exchanges } = utils.exchange_basecur_curs_converter(exchange_basecur_curs)
+    this.exchange_pairs = exchange_pairs
+    this.pair_exchanges = pair_exchanges    
+    this.Exchanges = {}
+    this.settings = settings || {}
+    this.ws_enabled = settings.ws_enabled || false
+    this.interval_dict = settings.interval_dict || {}
+    this.influx_url_check_volume = settings.influx_url_check_volume
+    this.check_init_order_opened = settings.check_init_order_opened || true
+    this.check_init_order_opened_timeout = settings.check_init_order_opened_timeout || 5 * 1000
+    this.cancel_previous_orders = settings.cancel_previous_orders || false
+    this.cancel_range_orders = settings.cancel_range_orders || false
+    this.delete_finished_orders_timeout = settings.delete_finished_orders_timeout || 30 * 1000 // CANCELED or F-FILLED
+    this.interval_dict = settings.interval_dict || {}
+    this.major_exchanges = settings.major_exchanges || []
+    this.no_cancel_range_exchanges = settings.no_cancel_range_exchanges || []
+    this.no_trades_function_exchanges = settings.no_trades_function_exchanges || []
+    this.no_trades_function_f_filled_timeout = settings.no_trades_function_f_filled_timeout || 30 * 1000
+    this.bad_trades_function_exchanges = settings.bad_trades_function_exchanges || []
+    this.buy_sell_limits_threshold = settings.buy_sell_limits_threshold || 0.95
+    this.p_filled_threshold = settings.p_filled_threshold || 0
+    this.f_filled_threshold = settings.f_filled_threshold || 0.95
+    this.previous_orders_canceled = false
+    this.previous_orders_canceled_exchange_pair = {}
+    this.init_account_from_first_balances = settings.init_account_from_first_balances || true
+    this.account_init = false
+    for (let exchange in exchange_pairs) {
+      if (exchange === 'bitfinex') {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_keys'], cd[exchange]['secret_keys'], _.assign(small_limits, cd[exchange]))
+      } else if (exchange === 'okex' || exchange === 'bgogo') {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_key'], cd[exchange]['secret_key'], _.assign(small_limits, cd[exchange]))
+      } else if (exchange === 'bitforex' || exchange === 'bitkub' || exchange === 'coinbene') {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_key'], cd[exchange]['secret_key'], _.assign(mimimum_limits, cd[exchange]))
+      } else if (cd[exchange]['api_keys'] || exchange === 'kucoin') {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_keys'], cd[exchange]['secret_keys'], _.assign(small_limits, cd[exchange]))
+      } else if (cd[exchange]['api_keys']) {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_keys'], cd[exchange]['secret_keys'], _.assign(limits, cd[exchange]))
+      } else {
+        this.Exchanges[exchange] = new icg_exchanges[_.upperFirst(exchange)](cd[exchange]['api_key'], cd[exchange]['secret_key'], _.assign(limits, cd[exchange]))
+      }
+      if (!this.interval_dict || !this.interval_dict[exchange]) {
+        this.interval_dict[exchange] = {
+          'balances': 10 * 1000,
+          'positions': 10 * 1000,
+          'open_orders': 10 * 1000,
+          'trades': 10 * 1000,
+          'rates': 1 * 1000,
+          'market_history': 2 * 1000,
+        }
+      } else {
+        this.interval_dict[exchange].balances = this.interval_dict[exchange].balances || 10 * 1000
+        this.interval_dict[exchange].positions = this.interval_dict[exchange].positions || 10 * 1000
+        this.interval_dict[exchange].open_orders = this.interval_dict[exchange].open_orders || 10 * 1000
+        this.interval_dict[exchange].trades = this.interval_dict[exchange].trades || 10 * 1000
+        this.interval_dict[exchange].rates = this.interval_dict[exchange].rates || 1 * 1000
+        this.interval_dict[exchange].market_history = this.interval_dict[exchange].market_history || 2 * 1000
+      }
+    }
+    this.balances = {}, this.open_orders = {}, this.trades = {}, this.rates = {}, this.market_history = {}, this.volumes = {}, this.cmc_rates = {}
+    this.rates_combined_all = {}, this.rates_combined_all_with_buy_sell_limits = {}, this.rates_combined_major = {}, this.rates_combined_good_with_buy_sell_limits = {}
+    this.buy_sell_limits = {}
+    this.order_info = {}
+    this.order_info_status = {}
+    this.enabled = settings.enabled || {
+      'info_log': true,
+      'error_log': true,
+      'balances_check': true,
+      'positions_check': false,
+      'open_orders_check': true,
+      'trades_check': true,
+      'rates_check': true,
+      'market_history_check': true,
+      'volumes_check': false,
+      'cmc_rates_check': true
+    }
+    this.info_log = (...args) => {
+      if (this.enabled.info_log)
+        console.log(...args)
+    }
+    this.error_log = (...args) => {
+      if (this.enabled.info_log)
+        console.error(...args)
+    }
+    if (this.enabled.balances_check) {
+      this.check_balances()
+    }
+    if (this.enabled.positions_check) {
+      this.check_positions()
+    }
+    if (this.enabled.open_orders_check) {
+      this.check_open_orders()
+    }
+    if (this.enabled.trades_check) {
+      this.trades_amount_past_hour = {}
+      this.check_trades()
+    }
+    if (this.enabled.rates_check) {
+      this.check_rates()
+    }
+    if (this.enabled.market_history_check) {
+      this.check_market_history()
+    }
+    if (this.enabled.volumes_check) {
+      this.check_volumes()
+    }
+    if (this.enabled.cmc_rates_check) {
+      this.check_cmc_rates()
+    }
+    if (this.enabled.balances_check && this.enabled.open_orders_check && this.enabled.trades_check) {
+      setInterval(() => {
+        this.process_bot(this.balances, this.open_orders, this.trades)
+      }, 1000)
+    }
+    this.ws_market_first_time = {}
+  }
+  init_account (initial_balances) {
+    this.account = new Account(initial_balances)
+  }
+  set_exchange_assets_from_balances (balances) {
+    this.account.set_exchange_assets_from_balances(balances)
+  }
+  limit_trade (exchange, pair, method, price, amount, id=uuidv4().slice(0, 13), order_type='', limiter_on=true) {
+    price = round_price(_.upperFirst(exchange), pair, price)
+    amount = round_amount(_.upperFirst(exchange), pair, amount)
+    this.info_log('%s %s %s %s %s %s at %s', limiter_on, order_type, exchange, pair, method, amount, price)
+    this.update_order_info(exchange, pair, method, id, {
+      order_type,
+      status: 'INIT',
+      id, 
+      order_id: id,
+      type: method,
+      price, 
+      amount,
+      f_amount: 0,
+      f_percentage: 0,
+      t_amount: amount,
+      open_time: new Date(),
+      close_time: null
+    }, order_type + ' init')
+    let no_callback_timeout = setTimeout(() => {
+      if (_.get(this.order_info, [exchange, pair, method, id, 'status']) === 'INIT') {
+        console.log('no callback: %s %s %s %s %s', exchange, pair, method, id, order_type)
+        this.update_order_info(exchange, pair, method, id, {
+          status: 'N-OPENED-TIMEOUT'
+        }, order_type + ' n-opened-timeout-init')
+      }
+    }, 60 * 1000)
+    let limit_trade = (cb) => {
+      if (limiter_on) {
+        this.Exchanges[exchange].limit_trade(pair, method, price, amount, cb)
+      } else {
+        this.Exchanges[exchange].limit_trade_base(pair, method, price, amount, cb)
+      }
+    }
+    limit_trade((res) => {
+      if (res.success) {
+        let order_id = res.body
+        this.delete_order_info(exchange, pair, method, id, 'limit-trade-success')
+        this.update_order_info(exchange, pair, method, order_id, {
+          order_type,
+          status: 'N-FILLED',
+          id, 
+          order_id,
+          type: method,
+          price, 
+          amount,
+          f_amount: 0,
+          f_percentage: 0,
+          t_amount: amount,
+          open_time: new Date(),
+          close_time: null
+        }, order_type + ' n-filled')
+      } else if (res.error === 'amount-too-small' || res.error === 'insufficient-funds') {
+        this.delete_order_info(exchange, pair, method, id, 'limit-trade-' + res.error)
+      } else {
+        if (order_type.startsWith('self') || order_type.startsWith('maker_2')) {
+          this.delete_order_info(exchange, pair, method, id, 'limit-trade-timeout-' + order_type)
+        } 
+        // else if (_.get(this.order_info, [exchange, pair, method, id, 'status']) === 'INIT') { // make sure no_callback_timeout is NOT running zero
+        //   this.update_order_info(exchange, pair, method, id, {
+        //     status: 'N-OPENED-TIMEOUT'
+        //   }, order_type + ' n-opened-timeout-callback')
+        // }
+        this.error_log('limit trade error: %s %s %s %s %s %s %s %j', order_type, id, exchange, pair, method, price, amount, res)
+      }
+      clearTimeout(no_callback_timeout)
+    })
+  }
+  limit_trade_all (pair, method, price, total) {
+    if (!this.volumes[pair]) {
+      this.error_log('%s volumes do not exist')
+      return
+    }
+    let id = uuidv4().slice(0, 13)
+    let sum = _.sum(_.values(this.volumes[pair]))
+    for (let exchange of this.pair_exchanges[pair]) {
+      let amount = this.volumes[pair][exchange] / sum * total
+      this.limit_trade(exchange, pair, method, price, amount, id)
+    }
+  }
+  market_trade (exchange, pair, method, amount, id=uuidv4().slice(0, 13)) {
+    if (!this.rates[exchange][pair]) {
+      this.info_log('%s %s rates do not exist', exchange, pair)
+      return
+    }
+    let input_array = (method === 'sell') ? this.rates[exchange][pair].bids : this.rates[exchange][pair].asks
+    let { price } = utils.vol_position(input_array, amount)
+    this.limit_trade(exchange, pair, method, price, amount, id)
+  }
+  market_trade_all (pair, method, total) {
+    if (!this.rates_combined_all[pair]) {
+      this.error_log('%s rates combined do not exist', pair)
+      return
+    }
+    let type = method === 'buy' ? 'asks' : 'bids' // reverse because it is market order
+    let { price_exchange, vol_exchange } = utils.vol_position_combined(this.rates_combined_all[pair][type], total)
+    let id = uuidv4().slice(0, 13)
+    for (let exchange of this.pair_exchanges[pair]) {
+      if (price_exchange[exchange] && vol_exchange[exchange])
+        this.limit_trade(exchange, pair, method, price_exchange[exchange], vol_exchange[exchange], id)
+    }
+  }
+  cancel_order (exchange, pair, order) {
+    let original_status = order.status
+    this.update_order_info(exchange, pair, order.type, order.order_id, {
+      status: 'CANCELING'
+    }, order.order_type + ' canceling')
+    order.exchange = exchange, order.pair = pair
+    this.Exchanges[exchange].cancel_order_by_order(order, (res) => {
+      if (res.success || (!res.success && res.error === 'order-not-open' && original_status === 'CANCELING')) {
+        this.update_order_info(exchange, pair, order.type, order.order_id, {
+          status: 'CANCELED',
+          close_time: new Date()
+        }, order.order_type + ' canceled')
+        setTimeout(() => {
+          this.delete_order_info(exchange, pair, order.type, order.order_id, 'cancel-order-success')
+        }, this.delete_finished_orders_timeout)
+      } else if (!res.success && res.error === 'order-not-open' && original_status !== 'CANCELED') {
+        // this.info_log('%s ORDER CANNOT BE CANCELED: %j', original_status, order)
+        this.update_order_info(exchange, pair, order.type, order.order_id, {
+          status: 'F-FILLED',
+          amount: 0,
+          f_amount: order.amount,
+          f_percentage: 1,
+          close_time: new Date()
+        }, order.order_type + ' cannot-be-canceled')
+        setTimeout(() => {
+          this.delete_order_info(exchange, pair, order.type, order.order_id, 'cannot-be-canceled')
+        }, this.delete_finished_orders_timeout)
+      } else {
+        console.error('cancel order:', exchange, pair, order, res)
+      }
+    })
+  }
+  get_order_info_all () {
+    return this.order_info
+  }
+  get_order_info_all_stats () {
+    let info_all = this.get_order_info_all(), info_all_stats = {}
+    for (let exchange in info_all) {
+      for (let pair in info_all[exchange]) {
+        for (let type in info_all[exchange][pair]) {
+          _.set(info_all_stats, [exchange, pair, type], _.keys(info_all[exchange][pair][type]).length)
+        }
+      }
+    }
+    return info_all_stats
+  }
+  get_order_info_by_order_type (order_type) {
+    let order_info_temp = {}
+    for (let exchange in this.order_info) {
+      for (let pair in this.order_info[exchange]) {
+        for (let type in this.order_info[exchange][pair]) {
+          for (let order_id in this.order_info[exchange][pair][type]) {
+            if (_.get(this.order_info, [exchange, pair, type, order_id, 'order_type']) === order_type) {
+              _.setWith(order_info_temp, `${exchange}.${pair}.${type}.${order_id}`, _.get(this.order_info, `${exchange}.${pair}.${type}.${order_id}`), Object)
+            }
+          }
+        }
+      }
+    }
+    return order_info_temp
+  }
+  get_order_info_status_all (exchange, pair, type, status) {
+    if (type === 'both') {
+      return this.get_order_info_status_all(exchange, pair, 'sell', status).concat(this.get_order_info_status_all(exchange, pair, 'buy', status))
+    }
+    _.set(this.order_info_status, [exchange, pair, type, status], [])
+    for (let order_id in _.get(this.order_info, [exchange, pair, type], {})) {
+      let order_status = _.get(this.order_info, [exchange, pair, type, order_id, 'status'])
+      if (order_status === status || status.indexOf(order_status) > -1) {
+        this.order_info_status[exchange][pair][type][status].push(this.order_info[exchange][pair][type][order_id])
+      }
+    }
+    return this.order_info_status[exchange][pair][type][status]
+  }
+  get_order_info_status_by_order_type (exchange, pair, type, status, order_type) {
+    return this.get_order_info_status_all(exchange, pair, type, status).filter(o => o.order_type === order_type)
+  }
+  process_bot (balances, open_orders, trades) {
+    for (let exchange in trades) {
+      for (let pair in trades[exchange]) {
+        trades[exchange][pair].trades.map(trade => {
+          if (_.get(this.order_info, [exchange, pair, trade.type, trade.order_id])) {
+            let order_info = this.order_info[exchange][pair][trade.type][trade.order_id]
+            if (order_info.status === 'CANCELED' || order_info.status === 'CANCELING') {
+              let type = trade.type, order_id = trade.order_id
+              // this.info_log('TRADES: %s ORDER FILLED', order_info.status, trade, order_info)
+              this.update_order_info(exchange, pair, type, order_id, {
+                status: 'F-FILLED',
+                price: trade.price,
+                amount: 0,
+                f_amount: trade.amount,
+                t_amount: trade.amount,
+                f_percentage: 1,
+                close_time: trade.close_time || new Date()
+              }, order_info.order_type + ' canceled-order-filled')
+              setTimeout(() => {
+                this.delete_order_info(exchange, pair, type, order_id, 'canceled-order-filled')
+              }, this.delete_finished_orders_timeout)
+            } else if (order_info.status === 'F-FILLED' && trade.amount > order_info.f_amount) {
+              // this.info_log('TRADES: FILLED ORDER FILLED MORE', trade, order_info)
+              this.update_order_info(exchange, pair, order_info.type, order_info.order_id, {
+                f_amount: trade.amount,
+                t_amount: trade.amount,
+                f_percentage: 1
+              }, order_info.order_type + ' filled-order-filled-more')
+            } else if (_.includes(['N-FILLED', 'P-FILLED'], order_info.status) && trade.amount > order_info.f_amount && trade.amount / order_info.t_amount > this.f_filled_threshold) {
+              // this.info_log('TRADES: %s %s ORDER F-FILLED', exchange, pair, trade)
+              this.update_order_info(exchange, pair, order_info.type, order_info.order_id, {
+                status: 'F-FILLED',
+                price: trade.price,
+                amount: order_info.t_amount - trade.amount,
+                f_amount: trade.amount,
+                f_percentage: trade.amount / order_info.t_amount,
+                close_time: trade.close_time || new Date()
+              }, order_info.order_type + ' order-f-filled-1')
+              setTimeout(() => {
+                this.delete_order_info(exchange, pair, order_info.type, order_info.order_id, 'f-filled-trades')
+              }, this.delete_finished_orders_timeout)
+            } else if (_.includes(['N-FILLED', 'P-FILLED'], order_info.status) && trade.amount > order_info.f_amount && trade.amount / order_info.t_amount > this.p_filled_threshold) {
+              // this.info_log('TRADES: %s %s ORDER P-FILLED', exchange, pair, trade)
+              this.update_order_info(exchange, pair, order_info.type, order_info.order_id, {
+                status: 'P-FILLED',
+                amount: order_info.t_amount - trade.amount,
+                f_amount: trade.amount,
+                f_percentage: trade.amount / order_info.t_amount
+              }, order_info.order_type + ' order-p-filled-1')
+            } else if (_.includes(['F-FILLED', 'P-FILLED'], order_info.status)) {
+
+            } else {
+              this.info_log('TRADES: UNKNOWN %j', trade, this.order_info[exchange][pair])
+            }
+          }
+        })
+      }
+    }
+    for (let exchange of this.no_trades_function_exchanges) {
+      for (let pair in _.get(this.order_info, [exchange], {})) {
+        for (let type in _.get(this.order_info, [exchange, pair], {})) {
+          for (let order_id in _.get(this.order_info, [exchange, pair, type], {})) {
+            let order_info_order = this.order_info[exchange][pair][type][order_id]
+            if ((order_info_order.status === 'N-FILLED' || order_info_order.status === 'P-FILLED') && order_info_order.open_time < new Date() - this.no_trades_function_f_filled_timeout) {
+              let exist = false
+              open_orders[exchange][pair].open_orders.map(o => {
+                if (o.order_id === order_info_order.order_id) {
+                  exist = true
+                }
+              })
+              if (!exist) {
+                // this.info_log('ORDERS: %s %s ORDER F-FILLED NO TRADES FUNCTION EXCHANGES', exchange, pair)
+                this.update_order_info(exchange, pair, order_info_order.type, order_info_order.order_id, {
+                  status: 'F-FILLED',
+                  amount: 0,
+                  f_amount: order_info_order.t_amount,
+                  f_percentage: 1,
+                  close_time: new Date()
+                }, order_info_order.order_type + ' order-f-filled-2')
+                setTimeout(() => {
+                  this.delete_order_info(exchange, pair, order_info_order.type, order_info_order.order_id, 'f-filled-no-trades-function')
+                }, this.delete_finished_orders_timeout)
+              }
+            }
+          }
+        }
+      }
+    }
+    for (let exchange in open_orders) {
+      for (let pair in open_orders[exchange]) {
+        open_orders[exchange][pair].open_orders.map(order => {
+          if (_.get(this.order_info, [exchange, pair, order.type, order.order_id])) {
+            let order_info = this.order_info[exchange][pair][order.type][order.order_id]
+            if (_.includes(['N-FILLED', 'P-FILLED'], order_info.status) && order.f_amount > order_info.f_amount && order.f_amount / order_info.t_amount > this.f_filled_threshold) {
+              // this.info_log('ORDERS: %s %s ORDER F-FILLED', exchange, pair)
+              this.update_order_info(exchange, pair, order_info.type, order_info.order_id, {
+                status: 'F-FILLED',
+                amount: order.amount,
+                f_amount: order.f_amount,
+                f_percentage: order.f_amount / order_info.t_amount,
+                close_time: order.close_time || new Date()
+              }, order_info.order_type + ' order-f-filled-3')
+              setTimeout(() => {
+                this.delete_order_info(exchange, pair, order_info.type, order_info.order_id, 'f-filled-open-orders')
+              }, this.delete_finished_orders_timeout)
+            } else if (_.includes(['N-FILLED', 'P-FILLED'], order_info.status) && order.f_amount > order_info.f_amount && order.f_amount / order_info.t_amount > this.p_filled_threshold) {
+              // this.info_log('ORDERS: %s %s ORDER P-FILLED', exchange, pair)
+              this.update_order_info(exchange, pair, order_info.type, order_info.order_id, {
+                status: 'P-FILLED',
+                amount: order.amount,
+                f_amount: order.f_amount,
+                f_percentage: order.f_amount / order_info.t_amount
+              }, order_info.order_type + ' order-p-filled-2')
+            }
+          } else if (this.get_order_info_status_all(exchange, pair, 'both', 'INIT') && this.check_init_order_opened) {
+            this.get_order_info_status_all(exchange, pair, 'both', 'INIT').map(init_order => {
+              let init_order_price = round_price(exchange, pair, init_order.price)
+              let order_price = round_price(exchange, pair, order.price)
+              let init_order_time = init_order.open_time.getTime()
+              let order_time = order.open_time.getTime()
+              if (init_order.type === order.type && init_order_price === order_price && order_time - init_order_time > 0 && order_time - init_order_time < this.check_init_order_opened_timeout) {
+                // this.info_log('ORDERS: %s %s %s %s INIT ORDER OPENED', init_order.order_id, order.order_id, exchange, pair)
+                this.delete_order_info(exchange, pair, init_order.type, init_order.order_id, 'init-order-opened')
+                this.update_order_info(exchange, pair, order.type, order.order_id, {
+                  status: 'N-FILLED',
+                  order_id: order.order_id,
+                  type: order.type,
+                  price: order.price, 
+                  amount: order.amount,
+                  f_amount: 0,
+                  t_amount: order.amount,
+                  open_time: order.open_time || new Date(),
+                  close_time: null
+                }, init_order.order_type + ' init-order-opened')
+              }
+            })
+          }
+        })
+      }
+    }
+  }
+  update_order_info (exchange, pair, type, order_id, dict, note) {
+    if (!order_id) {
+      this.error_log('UPDATE %s: order_id invalid %s %s %s %s %j', note, exchange, pair, type, order_id, dict)
+      return
+    }
+    for (let key in dict) {
+      if (key === 'f_percentage') {
+        dict[key] = Math.round(dict[key] * 100) / 100
+      }
+      _.setWith(this.order_info, `${exchange}.${pair}.${type}.${order_id}.${key}`, dict[key], Object)
+    }
+    this.info_log('UPDATE %s: %s %s %s %s %j', note, exchange, pair, type, order_id, dict)
+  }
+  delete_order_info (exchange, pair, type, order_id, note) {
+    this.order_info[exchange][pair][type] = _.omit(this.order_info[exchange][pair][type], [order_id])
+    this.info_log('DELETE %s: %s %s %s %s', note, exchange, pair, type, order_id)
+  }
+  check_balances () {
+    let balances_handler = (exchange, res) => {
+      if (res.success) {
+        _.set(this.balances, [exchange], Object.assign(res.body, { update_time: new Date() }))
+        for (let exchange in this.exchange_basecur_curs) {
+          for (let base_cur in this.exchange_basecur_curs[exchange]) {
+            this.exchange_basecur_curs[exchange][base_cur].map(cur => {
+              let cur_balance = _.get(this.balances, [exchange, 'available', cur], 0)
+              let base_cur_balance = _.get(this.balances, [exchange, 'available', base_cur], 0)
+              let pair = cur + base_cur
+              _.set(this.buy_sell_limits, [exchange, pair], {
+                sell: cur_balance * this.buy_sell_limits_threshold,
+                buy: base_cur_balance * this.buy_sell_limits_threshold
+              })
+            })
+          }
+        }
+        if (!this.account_init && _.keys(this.balances).length === _.keys(this.exchange_pairs).length) {
+          this.account_init = true
+          this.init_account(this.balances)
+        }
+      } else if (_.get(this.balances, [exchange, 'update_time']) < new Date() - this.interval_dict[exchange].balances) {
+        this.error_log('%s balances expired: %j', exchange, res)
+        this.balances = _.omit(this.balances, [exchange])
+        this.buy_sell_limits = _.omit(this.buy_sell_limits, [exchange])
+      }
+    }
+    function get_balances (Exchanges, interval_dict) {
+      for (let exchange in Exchanges) {
+        if (Exchanges[exchange].balance_ws) {
+          setInterval(() => {
+            if (Exchanges[exchange].ws_status().trading === 'n-opened')
+              Exchanges[exchange].ws_account()
+            Exchanges[exchange].balance_ws((res) => { balances_handler (exchange, res) })
+          }, interval_dict[exchange].balances)
+        } else {
+          setInterval(() => {
+            Exchanges[exchange].balance((res) => { balances_handler (exchange, res) })
+          }, interval_dict[exchange].balances)
+        }
+      }
+    }
+    get_balances(this.Exchanges, this.interval_dict)
+  }
+  check_positions () {
+    let position_handler = (exchange, pair, res) => {
+
+    }
+    let position_all_handler = (exchange, res) => {
+      if (res.success) {
+        _.set(this.positions, [exchange], Object.assign(res.body, { update_time: new Date() }))
+        for (let exchange in this.exchange_pairs) {
+          this.exchange_pairs[exchange].map(pair => {
+            _.set(this.buy_sell_limits, [exchange, pair], {
+              sell: 1000 + _.get(res.body, ['total', pair], 0),
+              buy: 1000 - _.get(res.body, ['total', pair], 0)
+            })
+          })
+        }
+      } else if (_.get(this.positions, [exchange, 'update_time']) < new Date() - this.interval_dict[exchange].positions) {
+        this.error_log('%s positions expired: %j', exchange, res)
+        this.positions = _.omit(this.positions, [exchange])
+        this.buy_sell_limits = _.omit(this.buy_sell_limits, [exchange])
+      }
+    }
+    function get_positions (Exchanges, interval_dict) {
+      for (let exchange in Exchanges) {
+        if (Exchanges[exchange].position_all_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          setInterval(() => {
+            Exchanges[exchange].position_all_ws((res) => { position_all_handler (exchange, res) })
+          }, interval_dict[exchange].positions)
+        } else if (Exchanges[exchange].position_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          setInterval(() => {
+            for (let pair of this.exchange_pairs[exchange]) {
+              Exchanges[exchange].position_ws(pair, (res) => { position_handler (exchange, pair, res) })
+            }
+          }, interval_dict[exchange].positions)
+        } else if (Exchanges[exchange].position_all) {
+          setInterval(() => {
+            Exchanges[exchange].position_all((res) => { position_all_handler (exchange, res) })
+          }, interval_dict[exchange].positions)
+        } else if (Exchanges[exchange].position) {
+          setInterval(() => {
+            for (let pair of this.exchange_pairs[exchange]) {
+              Exchanges[exchange].position_ws(pair, (res) => { position_handler (exchange, pair, res) })
+            }
+          }, interval_dict[exchange].positions)
+        }
+      }
+    }
+    get_positions(this.Exchanges, this.interval_dict)
+  }
+  check_open_orders () {
+    const open_orders_timeframe = 12 * 60 * 60 * 1000
+    let previous_orders_processer = (exchange, pair, orders) => {
+      if (this.cancel_previous_orders && !this.previous_orders_canceled) {
+        orders.map(order => {
+          this.info_log('cancel original order: %s %s %j', exchange, pair, order)
+          this.Exchanges[exchange].cancel_order_by_order(order, (res) => {})
+        })
+        if (orders.length === 0) {
+          _.set(this.previous_orders_canceled_exchange_pair, [exchange, pair], true)
+        }
+        if (!this.previous_orders_canceled) {
+          let previous_orders_canceled = true
+          for (let exchange in this.exchange_pairs) {
+            this.exchange_pairs[exchange].map(pair => {
+              if (!_.get(this.previous_orders_canceled_exchange_pair, [exchange, pair])) {
+                previous_orders_canceled = false
+              }
+            })
+          }
+          if (previous_orders_canceled)
+            this.info_log('original order canceled')
+          this.previous_orders_canceled = previous_orders_canceled
+        }
+      }
+      let rate_major = _.get(this.rates_combined_major, [pair])
+      if (this.cancel_range_orders && this.major_exchanges[pair].indexOf(exchange) === -1 && this.no_cancel_range_exchanges.indexOf(exchange) === -1 && rate_major) {
+//         console.log(exchange, pair, rate_major, orders)
+        orders.map(order => {
+          if (order.type === 'sell' && order.price < rate_major.asks[0][0] && order.order_status !== 'F-FILLED' && order.order_type !== 'arb') {
+            this.info_log('cancel range order: %s %s %j', exchange, pair, order)
+            order.order_type = 'range-order'
+            this.cancel_order(exchange, pair, order)
+          }
+          if (order.type === 'buy' && order.price > rate_major.bids[0][0] && order.order_status !== 'F-FILLED' && order.order_type !== 'arb') {
+            this.info_log('cancel range order: %s %s %j', exchange, pair, order)
+            order.order_type = 'range-order'
+            this.cancel_order(exchange, pair, order)
+          }
+        })
+      }
+    }
+    let open_orders_handler = (exchange, pair, res) => {
+      if (res.success) {
+        _.set(this.open_orders, [exchange, pair], { open_orders: res.body, update_time: new Date() })
+        previous_orders_processer(exchange, pair, res.body)
+      } else if (_.get(this.open_orders, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].open_orders) {
+        this.error_log('%s %s open orders expired: %j', exchange, pair, res)
+        this.open_orders[exchange] = _.omit(this.open_orders[exchange], [pair])
+      } else if (res.error !== 'opening') {
+        this.error_log('%s %s open orders: %j', exchange, pair, res)
+      }
+    }
+    let all_open_orders_handler = (exchange, res) => {
+      if (res.success) {
+        for (let pair of this.exchange_pairs[exchange]) {
+          let open_orders = res.body.filter(o => o.pair === pair)
+          _.set(this.open_orders, [exchange, pair], { open_orders: open_orders, update_time: new Date() })
+          previous_orders_processer(exchange, pair, open_orders)
+        }
+      } else {
+        let error_logged = false
+        for (let pair of this.exchange_pairs[exchange]) {
+          if (_.get(this.open_orders, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].open_orders) {
+            if (!error_logged) {
+              this.error_log('%s all open orders expired: %j', exchange, res)
+              error_logged = true
+            }
+            this.open_orders[exchange] = _.omit(this.open_orders[exchange], [pair])
+          } else if (res.error !== 'opening' && !error_logged) {
+            this.error_log('%s all open orders: %j', exchange, res)
+            error_logged = true
+          }
+        }
+      }
+    }
+    let get_open_orders_all = (Exchanges, exchange_pairs, interval_dict) => {
+      function get_all_open_orders_ws (exchange) {
+        if (Exchanges[exchange].ws_status().trading === 'n-opened')
+          Exchanges[exchange].ws_account()
+        Exchanges[exchange].get_all_open_orders_ws((res) => {
+          all_open_orders_handler(exchange, res)
+          setTimeout(() => {
+            get_all_open_orders_ws(exchange)
+          }, interval_dict[exchange].open_orders)
+        })
+      }
+      function get_open_orders_ws (exchange, pair) {
+        Exchanges[exchange].get_open_orders_ws(pair, (res) => {
+          open_orders_handler(exchange, pair, res)
+          setTimeout(() => {
+            get_open_orders_ws(exchange, pair)
+          }, interval_dict[exchange].open_orders)
+        })
+      }
+      function get_all_open_orders (exchange) {
+        Exchanges[exchange].get_all_open_orders((res) => {
+          all_open_orders_handler(exchange, res)
+          setTimeout(() => {
+            get_all_open_orders(exchange)
+          }, interval_dict[exchange].open_orders)
+        })
+      }
+      function get_open_orders (exchange, pair) {
+        Exchanges[exchange].get_open_orders(pair, (res) => {
+          open_orders_handler(exchange, pair, res)
+          setTimeout(() => {
+            get_open_orders(exchange, pair)
+          }, interval_dict[exchange].open_orders)
+        })
+      }
+      for (let exchange in Exchanges) {
+        if (Exchanges[exchange].get_all_open_orders_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          get_all_open_orders_ws(exchange)
+        } else if (Exchanges[exchange].get_open_orders_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          for (let pair of exchange_pairs[exchange]) {
+            get_open_orders_ws(exchange, pair)
+          }
+        } else if (Exchanges[exchange].get_all_open_orders) {
+          get_all_open_orders(exchange)
+        } else if (Exchanges[exchange].get_open_orders) {
+          for (let pair of exchange_pairs[exchange]) {
+            get_open_orders(exchange, pair)
+          }
+        }
+      }
+    }
+    get_open_orders_all(this.Exchanges, this.exchange_pairs, this.interval_dict)
+  }
+  check_trades () {
+    const trades_timeframe = 12 * 60 * 60 * 1000
+    let trades_handler = (exchange, pair, res) => {
+      if (res.success) {
+        _.set(this.trades, [exchange, pair], { trades: res.body, update_time: new Date() })
+        _.set(this.trades_amount_past_hour, [exchange, pair], _.sumBy(res.body.filter(t => t.close_time > new Date() - 60 * 60 * 1000 || t.open_time > new Date() - 60 * 60 * 1000), t => t.amount) || 0)
+      } else if (_.get(this.trades, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].trades) {
+        this.error_log('%s %s trades expired: %j', exchange, pair, res)
+        this.trades[exchange] = _.omit(this.trades[exchange], [pair])
+      } else if (res.error !== 'opening') {
+        this.error_log('%s %s trades: %j', exchange, pair, res)
+      }
+    }
+    let all_trades_handler = (exchange, res) => {
+      if (res.success) {
+        for (let pair of this.exchange_pairs[exchange]) {
+          let trades = res.body.filter(o => o.pair === pair)
+          _.set(this.trades, [exchange, pair], { trades: trades, update_time: new Date() })
+          _.set(this.trades_amount_past_hour, [exchange, pair], _.sumBy(trades.filter(t => t.close_time > new Date() - 60 * 60 * 1000 || t.open_time > new Date() - 60 * 60 * 1000), t => t.amount) || 0)
+        }
+      } else if (res.error !== 'opening') {
+        let error_logged = false
+        for (let pair of this.exchange_pairs[exchange]) {
+          if (_.get(this.trades, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].trades) {
+            if (!error_logged) {
+              this.error_log('%s all trades expired: %j', exchange, res)
+              error_logged = true
+            }
+            this.trades[exchange] = _.omit(this.trades[exchange], [pair])
+          } else if (res.error !== 'opening' && !error_logged) {
+            this.error_log('%s all trades: %j', exchange, res)
+            error_logged = true
+          }
+        }
+      }
+    }
+    let get_trades_all = (Exchanges, exchange_pairs, interval_dict) => {
+      let get_all_trades_ws = (exchange) => {
+        if (Exchanges[exchange].ws_status().trading === 'n-opened')
+          Exchanges[exchange].ws_account()
+        Exchanges[exchange].get_all_trades_ws(trades_timeframe, (res) => {
+          all_trades_handler(exchange, res)
+          setTimeout(() => {
+            get_all_trades_ws(exchange)
+          }, interval_dict[exchange].trades)
+        })
+      }
+      let get_trades_ws = (exchange, pair) => {
+        Exchanges[exchange].get_trades_ws(pair, trades_timeframe, (res) => {
+          trades_handler(exchange, pair, res)
+          setTimeout(() => {
+            get_trades_ws(exchange, pair)
+          }, interval_dict[exchange].trades)
+        })
+      }
+      let get_all_trades = (exchange) => {
+        Exchanges[exchange].get_all_trades(trades_timeframe, (res) => {
+          all_trades_handler(exchange, res)
+          setTimeout(() => {
+            get_all_trades(exchange)
+          }, interval_dict[exchange].trades)
+        })
+      }
+      let get_trades = (exchange, pair) => {
+        Exchanges[exchange].get_trades(pair, trades_timeframe, (res) => {
+          trades_handler(exchange, pair, res)
+          setTimeout(() => {
+            get_trades(exchange, pair)
+          }, interval_dict[exchange].trades)
+        })
+      }
+      let get_trades_id = (exchange, pair) => {
+        let order_info = _.get(this.order_info, [exchange, pair], {})
+        let timeout = setTimeout(() => {
+          get_trades_id(exchange, pair)
+        }, interval_dict[exchange].trades)
+        let order_number = _.keys(order_info['sell']).length + _.keys(order_info['buy']).length, count = 0, result = []
+        for (let type in order_info) {
+          for (let order_id in order_info[type]) {
+            Exchanges[exchange].get_trades_id(pair, order_id, trades_timeframe, (res) => {
+              count++
+              if (res.success) {
+                result = res.body.concat(result)
+              }
+              if (count === order_number) {
+                trades_handler(exchange, pair, { success: true, body: result })
+                clearTimeout(timeout)
+                setTimeout(() => {
+                  get_trades_id(exchange, pair)
+                }, interval_dict[exchange].trades)
+              }
+            })
+          }
+        }
+      }
+      for (let exchange in Exchanges) {
+        if (this.no_trades_function_exchanges.indexOf(exchange) > -1) {
+
+        } else if (Exchanges[exchange].get_all_trades_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          get_all_trades_ws(exchange)
+        } else if (Exchanges[exchange].get_trades_ws) {
+          if (Exchanges[exchange].ws_status().trading === 'n-opened')
+            Exchanges[exchange].ws_account()
+          for (let pair of exchange_pairs[exchange]) {
+            get_trades_ws(exchange, pair)
+          }
+        } else if (Exchanges[exchange].get_all_trades) {
+          get_all_trades(exchange)
+        } else if (Exchanges[exchange].get_trades) {
+          for (let pair of exchange_pairs[exchange]) {
+            get_trades(exchange, pair)
+          }
+        } else if (Exchanges[exchange].get_trades_id) {
+          for (let pair of exchange_pairs[exchange]) {
+            get_trades_id(exchange, pair)
+          }
+        }
+      }
+    }
+    get_trades_all (this.Exchanges, this.exchange_pairs, this.interval_dict)
+  }
+  check_rates () {
+    let rates_handler = (exchange, pair, res) => {
+      if (res.success) {
+        res.body.asks = res.body.asks.slice(0, rates_length)
+        res.body.bids = res.body.bids.slice(0, rates_length)
+        _.set(this.rates, [exchange, pair], Object.assign(res.body, { update_time: new Date() }))
+        for (let pair in this.pair_exchanges) {
+          let orderbook_all = {}, orderbook_all_with_buy_sell_limits = {}, 
+              orderbook_major = {}, orderbook_major_temp = {},
+              orderbook_good_with_buy_sell_limits = {}, orderbook_good_temp = {}
+          for (let exchange of this.pair_exchanges[pair]) {
+
+            if (_.get(this.rates, [exchange, pair, 'asks'], []).length > 0 && _.get(this.rates, [exchange, pair, 'bids'], []).length > 0) {
+              orderbook_all[exchange] = this.rates[exchange][pair]
+            } else {
+              orderbook_all = _.omit(orderbook_all, [exchange])
+            }
+
+            if (_.get(this.rates, [exchange, pair, 'asks'], []).length > 0 
+              && _.get(this.rates, [exchange, pair, 'bids'], []).length > 0 
+              && _.get(this.buy_sell_limits, [exchange, pair, 'buy']) 
+              && _.get(this.buy_sell_limits, [exchange, pair, 'sell'])
+            ) {
+              let rates = JSON.parse(JSON.stringify(this.rates[exchange][pair]))
+              let rates_with_buy_sell_limits = {
+                asks: utils.sum_position_orderbook(rates.asks, this.buy_sell_limits[exchange][pair].buy),
+                bids: utils.vol_position_orderbook(rates.bids, this.buy_sell_limits[exchange][pair].sell)
+              }
+              orderbook_all_with_buy_sell_limits[exchange] = rates_with_buy_sell_limits
+              if (this.major_exchanges[pair] && this.major_exchanges[pair].indexOf(exchange) > -1) {
+                orderbook_major_temp[exchange] = rates
+                if (_.keys(orderbook_major_temp).length === this.major_exchanges[pair].length) {
+                  orderbook_major = orderbook_major_temp
+                }
+              }
+              if (this.bad_trades_function_exchanges && this.bad_trades_function_exchanges.indexOf(exchange) === -1) {
+                orderbook_good_temp[exchange] = rates_with_buy_sell_limits
+                if (_.keys(orderbook_good_temp).length === this.pair_exchanges[pair].length - this.bad_trades_function_exchanges.length) {
+                  orderbook_good_with_buy_sell_limits = orderbook_good_temp
+                }
+              }
+            } else {
+              orderbook_all_with_buy_sell_limits = _.omit(orderbook_all_with_buy_sell_limits, [exchange])
+              orderbook_major = _.omit(orderbook_major, [exchange])
+              orderbook_major_temp = _.omit(orderbook_major_temp, [exchange])
+              orderbook_good_with_buy_sell_limits = _.omit(orderbook_good_with_buy_sell_limits, [exchange])
+              orderbook_good_temp = _.omit(orderbook_good_temp, [exchange])
+            }
+          }
+          if (_.keys(orderbook_all).length > 0) {
+            let o = utils.combine_orderbooks(orderbook_all, 100)
+            if (o.asks.length > 0 && o.bids.length > 0) {
+              _.set(this.rates_combined_all, [pair], o)
+            } else {
+              this.rates_combined_all = _.omit(this.rates_combined_all, [pair])
+            }
+          }
+          if (_.keys(orderbook_all_with_buy_sell_limits).length > 0) {
+            let o = utils.combine_orderbooks(orderbook_all_with_buy_sell_limits, 100)
+            if (o.asks.length > 0 && o.bids.length > 0) {
+              _.set(this.rates_combined_all_with_buy_sell_limits, [pair], o)
+            } else {
+              this.rates_combined_all_with_buy_sell_limits = _.omit(this.rates_combined_all_with_buy_sell_limits, [pair])
+            }
+          }
+          if (_.keys(orderbook_major).length > 0) {
+            let o = utils.combine_orderbooks(orderbook_major, 100)
+            if (o.asks.length > 0 && o.bids.length > 0) {
+              _.set(this.rates_combined_major, [pair], o)
+            } else {
+              this.rates_combined_major = _.omit(this.rates_combined_major, [pair])
+            }
+          }
+          if (_.keys(orderbook_good_with_buy_sell_limits).length > 0) {
+            let o = utils.combine_orderbooks(orderbook_good_with_buy_sell_limits, 100)
+            if (o.asks.length > 0 && o.bids.length > 0) {
+              _.set(this.rates_combined_good_with_buy_sell_limits, [pair], o)
+            } else {
+              this.rates_combined_good_with_buy_sell_limits = _.omit(this.rates_combined_good_with_buy_sell_limits, [pair])
+            }
+          }
+        }
+      } else if (_.get(this.rates, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].rates) {
+        this.error_log('%s %s rates expired: %j', exchange, pair, res)
+        this.rates[exchange] = _.omit(this.rates[exchange], [pair])
+      }
+    }
+    let get_rates = (Exchanges, exchange_pairs, interval_dict) => {
+      for (let exchange in Exchanges) {
+        if (Exchanges[exchange].ws_market) {
+          setInterval(() => {
+            if (!this.ws_market_first_time[exchange]) {
+              Exchanges[exchange].ws_market(exchange_pairs[exchange])
+              this.ws_market_first_time[exchange] = true
+            } else {
+              for (let pair of exchange_pairs[exchange]) {
+                Exchanges[exchange].rate_ws(pair, (res) => { rates_handler(exchange, pair, res) })
+              }
+            }
+          }, interval_dict[exchange].rates)
+        } else {
+          for (let pair of exchange_pairs[exchange]) {
+            setInterval(() => {
+              Exchanges[exchange].rate(pair, 30, (res) => { rates_handler(exchange, pair, res) })
+            }, interval_dict[exchange].rates)
+          }
+        }
+      }
+    }
+    get_rates (this.Exchanges, this.exchange_pairs, this.interval_dict)
+  }
+  check_market_history () {
+    let market_history_handler = (exchange, pair, res) => {
+      if (res.success) {
+        _.set(this.market_history, [exchange, pair], Object.assign(res.body, { update_time: new Date() }))
+      } else if (_.get(this.market_history, [exchange, pair, 'update_time']) < new Date() - this.interval_dict[exchange].market_history) {
+        this.error_log('%s %s market_history expired: %j', exchange, pair, res)
+        this.market_history[exchange] = _.omit(this.market_history[exchange], [pair])
+      }
+    }
+    let get_market_history = (Exchanges, exchange_pairs, interval_dict) => {
+      for (let exchange in Exchanges) {
+        const market_history_timeframe = (exchange === 'coinbene') ? 30 * 24 * 60 * 60 * 1000 : 10 * 60 * 1000
+        if (Exchanges[exchange].ws_market) {
+          setInterval(() => {
+            if (!this.ws_market_first_time[exchange]) {
+              Exchanges[exchange].ws_market(exchange_pairs[exchange])
+              this.ws_market_first_time[exchange] = true
+            } else {
+              for (let pair of exchange_pairs[exchange]) {
+                Exchanges[exchange].market_history_ws(pair, market_history_timeframe, (res) => { market_history_handler(exchange, pair, res) })
+              }
+            }
+          }, interval_dict[exchange].market_history)
+        } else {
+          for (let pair of exchange_pairs[exchange]) {
+            setInterval(() => {
+              Exchanges[exchange].market_history(pair, market_history_timeframe, (res) => { market_history_handler(exchange, pair, res) })
+            }, interval_dict[exchange].market_history)
+          }
+        }
+      }
+    }
+    get_market_history (this.Exchanges, this.exchange_pairs, this.interval_dict)
+  }
+  check_volumes () {
+    const influx_client = new Influx.InfluxDB(this.influx_url_check_volume)
+    let check_volumes_base = () => {
+      for (let pair in this.pair_exchanges) {
+        for (let exchange of this.pair_exchanges[pair]) {
+          let query_string = `SELECT sum("vol") FROM "${pair}" WHERE ("exchange" = '${_.upperFirst(exchange)}') AND time > now() - 12h`        
+          influx_client.query(query_string).then(res => {       
+            res.map(e => {            
+              if (e.time && e.sum) {
+                _.set(this.volumes, [pair, exchange], e.sum)
+              }
+            })
+          })
+        }
+      }
+    }
+    check_volumes_base()
+    setInterval(() => {
+      check_volumes_base()
+    }, 15 * 60 * 1000)    
+  }
+  check_cmc_rates () {
+    let check_cmc_rates_base = () => {
+      get_coinmarketcap_rates(rates => {
+        this.cmc_rates = rates
+      })
+    }
+    check_cmc_rates_base()
+    setInterval(() => {
+      check_cmc_rates_base()
+    }, 15 * 60 * 1000)    
+  }
+}