@icgio/icg-exchanges-wrapper 1.9.63 → 1.9.64

package/middleware/orders.js

@@ -15,25 +15,25 @@ const STANDARD_LIMITS = {
   public_max_concurrent: 10,
   public_interval_concurrent: 1000,
   private_max_concurrent: 5,
-  private_interval_concurrent: 1000
+  private_interval_concurrent: 1000,
 }
 const MEDIUM_LIMITS = {
   public_max_concurrent: 7,
   public_interval_concurrent: 1000,
   private_max_concurrent: 4,
-  private_interval_concurrent: 1000
+  private_interval_concurrent: 1000,
 }
 const SMALL_LIMITS = {
   public_max_concurrent: 5,
   public_interval_concurrent: 1000,
   private_max_concurrent: 3,
-  private_interval_concurrent: 1000
+  private_interval_concurrent: 1000,
 }
 const MINIMUM_LIMITS = {
   public_max_concurrent: 2,
   public_interval_concurrent: 1000,
   private_max_concurrent: 1,
-  private_interval_concurrent: 3000
+  private_interval_concurrent: 3000,
 }
 
 const RATES_LENGTH_MAX = 100
@@ -42,11 +42,11 @@ const MARKET_HISTORY_DEFAULT_TIME = 10 * 60 * 1000
 const TRADES_DEFAULT_TIME = 12 * 60 * 60 * 1000
 
 module.exports = class Orders {
-  constructor (exchange_basecur_curs, cd, settings) {
+  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.pair_exchanges = pair_exchanges
     this.Exchanges = {}
     this.settings = settings || {}
     this.ws_enabled = settings.ws_enabled || false
@@ -63,7 +63,7 @@ module.exports = class Orders {
     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.bad_trades_no_arb_function_exchanges = settings.bad_trades_no_arb_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.99
@@ -92,12 +92,12 @@ module.exports = class Orders {
       }
       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,
+          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
@@ -108,30 +108,28 @@ module.exports = class Orders {
         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.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
+      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)
+      if (this.enabled.info_log) console.log(...args)
     }
     this.error_log = (...args) => {
-      if (this.enabled.info_log)
-        console.error(...args)
+      if (this.enabled.info_log) console.error(...args)
     }
     if (this.enabled.balances_check) {
       this.check_balances()
@@ -165,36 +163,50 @@ module.exports = class Orders {
     }
     this.ws_market_first_time = {}
   }
-  init_account (initial_balances) {
+  init_account(initial_balances) {
     this.account = new Account(initial_balances)
   }
-  set_exchange_assets_from_balances (balances) {
+  set_exchange_assets_from_balances(balances) {
     this.account.set_exchange_assets_from_balances(balances)
   }
-  limit_trade (exchange, pair, method, price, amount, id=uuid(), order_type='', limiter_on=true) {
+  limit_trade(exchange, pair, method, price, amount, id = uuid(), 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')
+    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')
+        this.update_order_info(
+          exchange,
+          pair,
+          method,
+          id,
+          {
+            status: 'N-OPENED-TIMEOUT',
+          },
+          order_type + ' n-opened-timeout-init'
+        )
       }
     }, 60 * 1000)
     let limit_trade = (cb) => {
@@ -208,26 +220,33 @@ module.exports = class Orders {
       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, 
+        this.update_order_info(
+          exchange,
+          pair,
+          method,
           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')
+          {
+            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'
@@ -238,7 +257,7 @@ module.exports = class Orders {
       clearTimeout(no_callback_timeout)
     })
   }
-  limit_trade_all (pair, method, price, total) {
+  limit_trade_all(pair, method, price, total) {
     if (!this.volumes[pair]) {
       this.error_log('%s volumes do not exist')
       return
@@ -246,20 +265,20 @@ module.exports = class Orders {
     let id = uuid()
     let sum = _.sum(_.values(this.volumes[pair]))
     for (let exchange of this.pair_exchanges[pair]) {
-      let amount = this.volumes[pair][exchange] / sum * total
+      let amount = (this.volumes[pair][exchange] / sum) * total
       this.limit_trade(exchange, pair, method, price, amount, id)
     }
   }
-  market_trade (exchange, pair, method, amount, id=uuid()) {
+  market_trade(exchange, pair, method, amount, id = uuid()) {
     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 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) {
+  market_trade_all(pair, method, total) {
     if (!this.rates_combined_all[pair]) {
       this.error_log('%s rates combined do not exist', pair)
       return
@@ -268,34 +287,54 @@ module.exports = class Orders {
     let { price_exchange, vol_exchange } = utils.vol_position_combined(this.rates_combined_all[pair][type], total)
     let id = uuid()
     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)
+      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) {
+  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.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')
+        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')
+        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)
@@ -304,11 +343,12 @@ module.exports = class Orders {
       }
     })
   }
-  get_order_info_all () {
+  get_order_info_all() {
     return this.order_info
   }
-  get_order_info_all_stats () {
-    let info_all = this.get_order_info_all(), info_all_stats = {}
+  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]) {
@@ -318,7 +358,7 @@ module.exports = class Orders {
     }
     return info_all_stats
   }
-  get_order_info_by_order_type (order_type) {
+  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]) {
@@ -333,73 +373,109 @@ module.exports = class Orders {
     }
     return order_info_temp
   }
-  get_order_info_status_all (exchange, pair, type, status) {
+  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) {
+      if (order_status === status || _.includes(status, order_status)) {
         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)
+  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) {
+  process_bot(balances, open_orders, trades) {
     for (let exchange in trades) {
       for (let pair in trades[exchange]) {
-        trades[exchange][pair].trades.map(trade => {
+        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
+              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')
+              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.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')
+              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) {
+            } 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')
+              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])
             }
@@ -412,22 +488,32 @@ module.exports = class Orders {
         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().getTime() - this.no_trades_function_f_filled_timeout) {
+            if (
+              (order_info_order.status === 'N-FILLED' || order_info_order.status === 'P-FILLED') &&
+              order_info_order.open_time < new Date().getTime() - this.no_trades_function_f_filled_timeout
+            ) {
               let exist = false
-              open_orders[exchange][pair].open_orders.map(o => {
+              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')
+                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)
@@ -439,50 +525,80 @@ module.exports = class Orders {
     }
     for (let exchange in open_orders) {
       for (let pair in open_orders[exchange]) {
-        open_orders[exchange][pair].open_orders.map(order => {
+        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')
+              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) {
+            } 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')
+              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 => {
+            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) {
+              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')
+                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'
+                )
               }
             })
           }
@@ -490,7 +606,7 @@ module.exports = class Orders {
       }
     }
   }
-  update_order_info (exchange, pair, type, order_id, dict, note) {
+  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
@@ -503,23 +619,23 @@ module.exports = class Orders {
     }
     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) {
+  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 () {
+  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 => {
+            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
+                buy: base_cur_balance * this.buy_sell_limits_threshold,
               })
             })
           }
@@ -534,35 +650,36 @@ module.exports = class Orders {
         this.buy_sell_limits = _.omit(this.buy_sell_limits, [exchange])
       }
     }
-    function get_balances (Exchanges, interval_dict) {
+    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) })
+            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) })
+            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) => {
-
-    }
+  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 => {
+          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)
+              buy: 1000 - _.get(res.body, ['total', pair], 0),
             })
           })
         }
@@ -572,30 +689,36 @@ module.exports = class Orders {
         this.buy_sell_limits = _.omit(this.buy_sell_limits, [exchange])
       }
     }
-    function get_positions (Exchanges, interval_dict) {
+    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()
+          if (Exchanges[exchange].ws_status().trading === 'n-opened') Exchanges[exchange].ws_account()
           setInterval(() => {
-            Exchanges[exchange].position_all_ws((res) => { position_all_handler (exchange, res) })
+            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()
+          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) })
+              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) })
+            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) })
+              Exchanges[exchange].position_ws(pair, (res) => {
+                position_handler(exchange, pair, res)
+              })
             }
           }, interval_dict[exchange].positions)
         }
@@ -603,11 +726,11 @@ module.exports = class Orders {
     }
     get_positions(this.Exchanges, this.interval_dict)
   }
-  check_open_orders () {
+  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 && this.no_cancel_previous_exchanges.indexOf(exchange) === -1) {
-        orders.map(order => {
+      if (this.cancel_previous_orders && !this.previous_orders_canceled && !_.includes(this.no_cancel_previous_exchanges, exchange)) {
+        orders.map((order) => {
           this.info_log('cancel original order: %s %s %j', exchange, pair, order)
           this.Exchanges[exchange].cancel_order_by_order(order, (res) => {})
         })
@@ -617,21 +740,20 @@ module.exports = class Orders {
         if (!this.previous_orders_canceled) {
           let previous_orders_canceled = true
           for (let exchange in this.exchange_pairs) {
-            this.exchange_pairs[exchange].map(pair => {
+            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')
+          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 (this.cancel_range_orders && !_.includes(this.major_exchanges[pair], exchange) && !_.includes(this.no_cancel_range_exchanges, exchange) && 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'
@@ -659,7 +781,7 @@ module.exports = class Orders {
     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)
+          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)
         }
@@ -680,9 +802,8 @@ module.exports = class Orders {
       }
     }
     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()
+      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(() => {
@@ -690,7 +811,7 @@ module.exports = class Orders {
           }, interval_dict[exchange].open_orders)
         })
       }
-      function get_open_orders_ws (exchange, pair) {
+      function get_open_orders_ws(exchange, pair) {
         Exchanges[exchange].get_open_orders_ws(pair, (res) => {
           open_orders_handler(exchange, pair, res)
           setTimeout(() => {
@@ -698,7 +819,7 @@ module.exports = class Orders {
           }, interval_dict[exchange].open_orders)
         })
       }
-      function get_all_open_orders (exchange) {
+      function get_all_open_orders(exchange) {
         Exchanges[exchange].get_all_open_orders((res) => {
           all_open_orders_handler(exchange, res)
           setTimeout(() => {
@@ -706,7 +827,7 @@ module.exports = class Orders {
           }, interval_dict[exchange].open_orders)
         })
       }
-      function get_open_orders (exchange, pair) {
+      function get_open_orders(exchange, pair) {
         Exchanges[exchange].get_open_orders(pair, (res) => {
           open_orders_handler(exchange, pair, res)
           setTimeout(() => {
@@ -716,12 +837,10 @@ module.exports = class 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()
+          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()
+          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)
           }
@@ -736,11 +855,18 @@ module.exports = class Orders {
     }
     get_open_orders_all(this.Exchanges, this.exchange_pairs, this.interval_dict)
   }
-  check_trades () {
+  check_trades() {
     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().getTime() - 60 * 60 * 1000 || t.open_time > new Date().getTime() - 60 * 60 * 1000), t => t.amount) || 0)
+        _.set(
+          this.trades_amount_past_hour,
+          [exchange, pair],
+          _.sumBy(
+            res.body.filter((t) => t.close_time > new Date().getTime() - 60 * 60 * 1000 || t.open_time > new Date().getTime() - 60 * 60 * 1000),
+            (t) => t.amount
+          ) || 0
+        )
       } else if (_.get(this.trades, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].trades) {
         this.info_log('%s %s trades expired: %j', exchange, pair, res)
         this.trades[exchange] = _.omit(this.trades[exchange], [pair])
@@ -751,9 +877,16 @@ module.exports = class Orders {
     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)
+          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().getTime() - 60 * 60 * 1000 || t.open_time > new Date().getTime() - 60 * 60 * 1000), t => t.amount) || 0)
+          _.set(
+            this.trades_amount_past_hour,
+            [exchange, pair],
+            _.sumBy(
+              trades.filter((t) => t.close_time > new Date().getTime() - 60 * 60 * 1000 || t.open_time > new Date().getTime() - 60 * 60 * 1000),
+              (t) => t.amount
+            ) || 0
+          )
         }
       } else if (res.error !== 'opening') {
         let error_logged = false
@@ -773,8 +906,7 @@ module.exports = class Orders {
     }
     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()
+        if (Exchanges[exchange].ws_status().trading === 'n-opened') Exchanges[exchange].ws_account()
         Exchanges[exchange].get_all_trades_ws(TRADES_DEFAULT_TIME, (res) => {
           all_trades_handler(exchange, res)
           setTimeout(() => {
@@ -811,7 +943,9 @@ module.exports = class Orders {
         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 = []
+        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_DEFAULT_TIME, (res) => {
@@ -831,15 +965,12 @@ module.exports = class Orders {
         }
       }
       for (let exchange in Exchanges) {
-        if (this.no_trades_function_exchanges.indexOf(exchange) > -1) {
-
+        if (_.includes(this.no_trades_function_exchanges, exchange)) {
         } else if (Exchanges[exchange].get_all_trades_ws) {
-          if (Exchanges[exchange].ws_status().trading === 'n-opened')
-            Exchanges[exchange].ws_account()
+          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()
+          if (Exchanges[exchange].ws_status().trading === 'n-opened') Exchanges[exchange].ws_account()
           for (let pair of exchange_pairs[exchange]) {
             get_trades_ws(exchange, pair)
           }
@@ -856,46 +987,49 @@ module.exports = class Orders {
         }
       }
     }
-    get_trades_all (this.Exchanges, this.exchange_pairs, this.interval_dict)
+    get_trades_all(this.Exchanges, this.exchange_pairs, this.interval_dict)
   }
-  check_rates () {
+  check_rates() {
     let rates_handler = (exchange, pair, res) => {
       if (res.success) {
         res.body.asks = res.body.asks.slice(0, RATES_LENGTH_MAX)
         res.body.bids = res.body.bids.slice(0, RATES_LENGTH_MAX)
         _.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 = {}
+          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'])
+            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)
+                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) {
+              if (this.major_exchanges[pair] && _.includes(this.major_exchanges[pair], exchange)) {
                 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) {
+              if (this.bad_trades_no_arb_function_exchanges && !_.includes(this.bad_trades_no_arb_function_exchanges, exchange)) {
                 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) {
+                if (_.keys(orderbook_good_temp).length === this.pair_exchanges[pair].length - this.bad_trades_no_arb_function_exchanges.length) {
                   orderbook_good_with_buy_sell_limits = orderbook_good_temp
                 }
               }
@@ -954,22 +1088,26 @@ module.exports = class Orders {
               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) })
+                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, RATES_LENGTH_DEFAULT, (res) => { rates_handler(exchange, pair, res) })
+              Exchanges[exchange].rate(pair, RATES_LENGTH_DEFAULT, (res) => {
+                rates_handler(exchange, pair, res)
+              })
             }, interval_dict[exchange].rates)
           }
         }
       }
     }
-    get_rates (this.Exchanges, this.exchange_pairs, this.interval_dict)
+    get_rates(this.Exchanges, this.exchange_pairs, this.interval_dict)
   }
-  check_market_history () {
+  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() }))
@@ -980,7 +1118,7 @@ module.exports = class Orders {
     }
     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 : MARKET_HISTORY_DEFAULT_TIME
+        const market_history_timeframe = exchange === 'coinbene' ? 30 * 24 * 60 * 60 * 1000 : MARKET_HISTORY_DEFAULT_TIME
         if (Exchanges[exchange].ws_market) {
           setInterval(() => {
             if (!this.ws_market_first_time[exchange]) {
@@ -988,29 +1126,33 @@ module.exports = class Orders {
               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) })
+                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) })
+              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)
+    get_market_history(this.Exchanges, this.exchange_pairs, this.interval_dict)
   }
-  check_volumes () {
+  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 => {            
+          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)
               }
@@ -1022,17 +1164,21 @@ module.exports = class Orders {
     check_volumes_base()
     setInterval(() => {
       check_volumes_base()
-    }, 15 * 60 * 1000)    
+    }, 15 * 60 * 1000)
   }
-  check_cmc_rates (data, type) {
+  check_cmc_rates(data, type) {
     let check_cmc_rates_base = (data) => {
-      get_coinmarketcap_rates(rates => {
-        this.cmc_rates = rates
-      }, data, type)
+      get_coinmarketcap_rates(
+        (rates) => {
+          this.cmc_rates = rates
+        },
+        data,
+        type
+      )
     }
     check_cmc_rates_base(data, type)
     setInterval(() => {
       check_cmc_rates_base(data, type)
-    }, 15 * 60 * 1000)    
+    }, 15 * 60 * 1000)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges-wrapper",
-  "version": "1.9.63",
+  "version": "1.9.64",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -17,8 +17,8 @@
   },
   "homepage": "https://github.com/icgio/icg-exchanges-wrapper#readme",
   "dependencies": {
-    "@icgio/icg-exchanges": "^1.27.51",
-    "@icgio/icg-exchanges-data": "^1.6.26",
+    "@icgio/icg-exchanges": "^1.27.52",
+    "@icgio/icg-exchanges-data": "^1.6.27",
     "@icgio/icg-utils": "^1.7.12",
     "influx": "^5.7.0",
     "lodash": "^4.17.20",