@icgio/icg-exchanges-wrapper 1.17.14 → 1.17.16

package/functions/get-exchanges-rates-market-history-ohlcv.js

@@ -374,26 +374,6 @@ const get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enab
         })
 
         promises = promises.concat(rate_promises) // Add all rate promises
-      } else if (Exchange.rate_with_routes) {
-        let pairs_to_fetch = exchange_pair_dict[Exchange_name] || all_pairs
-        let rate_with_routes_promises = pairs_to_fetch.map((pair) => {
-          return new Promise((resolve, reject) => {
-            Exchange.rate_with_routes(pair, function (res) {
-              if (res.success) {
-                let { asks, bids } = res.body
-                asks = asks.map((ask) => ask.slice(0, 2))
-                bids = bids.map((bid) => bid.slice(0, 2))
-                set_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair, { asks, bids })
-              } else {
-                console.error(`getting rate with routes failed for ${Exchange_name} ${pair}:`, res)
-                delete_pair_data(exchange_pair_rates, pair_exchange_rates, Exchange_name, pair)
-              }
-              resolve()
-            })
-          })
-        })
-
-        promises = promises.concat(rate_with_routes_promises) // Add all rate_with_routes promises
       }
     }
   }

package/middleware/orders.js

@@ -200,7 +200,6 @@ module.exports = class Orders {
     this.trades = {}
     this.query_order = {}
     this.rates = {}
-    this.rates_with_routes = {}
     this.rates_observable = new Observable()
     this.market_history = {}
     this.ohlcv = {}
@@ -209,7 +208,8 @@ module.exports = class Orders {
     this.buy_sell_limits_against_reserve_balance = {}
     this.order_info = {}
     this.fill_records = [] // { side, usdt_amount, timestamp, order_type }
-    this.order_info_status = {}
+    this.order_status_index = {}
+    this.order_info_by_type = {}
     this.function_enabled = settings.function_enabled || {
       balances_check: true,
       positions_check: false,
@@ -319,39 +319,7 @@ module.exports = class Orders {
       }
     }, NO_CALLBACK_TIMEOUT_MS)
     let limit_trade = (cb) => {
-      if (this.Exchanges[exchange].exchange_type === 'dex') {
-        let rates_with_routes = this.rates_with_routes[exchange][pair]
-        let routes
-        if (method === 'buy') {
-          let closest_level = _.minBy(rates_with_routes.asks, (ask) => {
-            return Math.abs(ask[0] - price)
-          })
-          routes = [closest_level[2]]
-          // for (let ask of rates_with_routes.asks) {
-          //   if (ask[0] === price) {
-          //     routes = [ask[2]]
-          //   }
-          // }
-        } else {
-          let closest_level = _.minBy(rates_with_routes.bids, (bid) => {
-            return Math.abs(bid[0] - price)
-          })
-          routes = [closest_level[2]]
-          // for (let bid of rates_with_routes.bids) {
-          //   if (bid[0] === price) {
-          //     routes = [bid[2]]
-          //   }
-          // }
-        }
-        if (routes) {
-          if (this.Exchanges[exchange].private_limiter) {
-            this.Exchanges[exchange].private_limiter.priority = getOrderPriority(order_type)
-          }
-          this.Exchanges[exchange].limit_trade_with_routes(pair, method, price, amount, routes, cb)
-        } else {
-          console.error('dex no routes:', rates_with_routes, price)
-        }
-      } else if (limiter_on) {
+      if (limiter_on) {
         if (this.Exchanges[exchange].private_limiter) {
           this.Exchanges[exchange].private_limiter.priority = getOrderPriority(order_type)
         }
@@ -493,34 +461,68 @@ module.exports = class Orders {
     }
     return stats
   }
+  has_orders_by_type(order_type, exchange, pair, side) {
+    const bucket = this.order_info_by_type[order_type]?.[exchange]?.[pair]?.[side]
+    if (!bucket) return false
+    for (const _ in bucket) return true
+    return false
+  }
   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]) {
-            const order_type_temp = _.get(this.order_info, [exchange, pair, type, order_id, 'order_type'])
-            if ((Array.isArray(order_type) && order_type.includes(order_type_temp)) || order_type_temp === order_type) {
-              _.setWith(order_info_temp, `${exchange}.${pair}.${type}.${order_id}`, _.get(this.order_info, `${exchange}.${pair}.${type}.${order_id}`), Object)
+    const types = Array.isArray(order_type) ? order_type : [order_type]
+    const result = {}
+    // Walk only the index sub-trees for the requested order_type(s). The
+    // returned dict is freshly built (preserving the original semantics that
+    // callers may add/remove top-level keys without affecting the canonical
+    // store) but the leaf order objects are still refs into this.order_info.
+    for (const t of types) {
+      const sub = this.order_info_by_type[t]
+      if (!sub) continue
+      for (const exchange in sub) {
+        const exch_sub = sub[exchange]
+        let result_exch = result[exchange]
+        if (!result_exch) {
+          result_exch = {}
+          result[exchange] = result_exch
+        }
+        for (const pair in exch_sub) {
+          const pair_sub = exch_sub[pair]
+          let result_pair = result_exch[pair]
+          if (!result_pair) {
+            result_pair = {}
+            result_exch[pair] = result_pair
+          }
+          for (const inner_type in pair_sub) {
+            const type_sub = pair_sub[inner_type]
+            let result_type = result_pair[inner_type]
+            if (!result_type) {
+              result_type = {}
+              result_pair[inner_type] = result_type
+            }
+            for (const order_id in type_sub) {
+              result_type[order_id] = type_sub[order_id]
             }
           }
         }
       }
     }
-    return order_info_temp
+    return result
   }
   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 || _.includes(status, order_status)) {
-        this.order_info_status[exchange][pair][type][status].push(this.order_info[exchange][pair][type][order_id])
+    const buckets_by_status = this.order_status_index[exchange]?.[pair]?.[type]
+    if (!buckets_by_status) return []
+    if (Array.isArray(status)) {
+      const result = []
+      for (const s of status) {
+        const bucket = buckets_by_status[s]
+        if (bucket) for (const order of bucket) result.push(order)
       }
+      return result
     }
-    return this.order_info_status[exchange][pair][type][status]
+    const bucket = buckets_by_status[status]
+    return bucket ? Array.from(bucket) : []
   }
   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)
@@ -656,7 +658,7 @@ module.exports = class Orders {
             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
+              order_info_order.open_time < Date.now() - this.no_trades_function_f_filled_timeout
             ) {
               let exist = false
               open_orders[exchange][pair].open_orders.map((o) => {
@@ -803,6 +805,11 @@ module.exports = class Orders {
       console.error('UPDATE %s: order_id invalid %s %s %s %s %j', note, exchange, pair, type, order_id, dict)
       return
     }
+
+    const existing = this.order_info[exchange]?.[pair]?.[type]?.[order_id]
+    const old_status = existing && existing.status
+    const old_order_type = existing && existing.order_type
+
     for (let key in dict) {
       if (key === 'f_percentage') {
         dict[key] = Math.round(dict[key] * 100) / 100
@@ -814,15 +821,37 @@ module.exports = class Orders {
       _.setWith(this.order_info, `${exchange}.${pair}.${type}.${order_id}.${key}`, dict[key], Object)
     }
 
-    // Add trace entry for order history
-    const trace_entry = {
-      ts: Date.now(),
-      status: dict.status || _.get(this.order_info, [exchange, pair, type, order_id, 'status']),
-      note,
-      f_amount: dict.f_amount,
+    const order = this.order_info[exchange][pair][type][order_id]
+    order.last_update_ts = Date.now()
+
+    const new_status = order.status
+    if (old_status !== new_status) {
+      if (old_status) {
+        const old_bucket = this.order_status_index[exchange]?.[pair]?.[type]?.[old_status]
+        if (old_bucket) old_bucket.delete(order)
+      }
+      if (new_status) {
+        const by_exch = this.order_status_index[exchange] || (this.order_status_index[exchange] = {})
+        const by_pair = by_exch[pair] || (by_exch[pair] = {})
+        const by_type = by_pair[type] || (by_pair[type] = {})
+        const bucket = by_type[new_status] || (by_type[new_status] = new Set())
+        bucket.add(order)
+      }
+    }
+    const new_order_type = order.order_type
+    if (old_order_type !== new_order_type) {
+      if (old_order_type) {
+        const at = this.order_info_by_type[old_order_type]?.[exchange]?.[pair]?.[type]
+        if (at) delete at[order_id]
+      }
+      if (new_order_type) {
+        const by_type = this.order_info_by_type[new_order_type] || (this.order_info_by_type[new_order_type] = {})
+        const by_exch = by_type[exchange] || (by_type[exchange] = {})
+        const by_pair = by_exch[pair] || (by_exch[pair] = {})
+        const by_inner_type = by_pair[type] || (by_pair[type] = {})
+        by_inner_type[order_id] = order
+      }
     }
-    const existing_trace = _.get(this.order_info, [exchange, pair, type, order_id, 'trace'], [])
-    _.setWith(this.order_info, `${exchange}.${pair}.${type}.${order_id}.trace`, [...existing_trace, trace_entry], Object)
 
     console.log('UPDATE %s: %s %s %s %s %j', note, exchange, pair, type, order_id, dict)
     // start: log every f-filled trade for future analysis
@@ -865,7 +894,19 @@ module.exports = class Orders {
   }
   delete_order_info(exchange, pair, type, order_id, note) {
     const order_data = _.get(this.order_info, [exchange, pair, type, order_id], {})
-    this.order_info[exchange][pair][type] = _.omit(this.order_info[exchange][pair][type], [order_id])
+
+    if (order_data.status) {
+      const bucket = this.order_status_index[exchange]?.[pair]?.[type]?.[order_data.status]
+      if (bucket) bucket.delete(order_data)
+    }
+    if (order_data.order_type) {
+      const at = this.order_info_by_type[order_data.order_type]?.[exchange]?.[pair]?.[type]
+      if (at) delete at[order_id]
+    }
+
+    if (this.order_info[exchange]?.[pair]?.[type]) {
+      delete this.order_info[exchange][pair][type][order_id]
+    }
     console.log('DELETE %s: %s %s %s %s', note, exchange, pair, type, order_id)
 
     // Send delete event via WebSocket (only for non-INIT orders)
@@ -885,28 +926,17 @@ module.exports = class Orders {
     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_cur_quote_cur) {
-          for (let quote_cur in this.exchange_cur_quote_cur[exchange]) {
-            this.exchange_cur_quote_cur[exchange][quote_cur].map((cur) => {
-              let cur_balance = _.get(this.balances, [exchange, 'available', cur], 0)
-              let quote_cur_balance = _.get(this.balances, [exchange, 'available', quote_cur], 0)
-              let pair = cur + quote_cur
+        const cur_quote_cur = this.exchange_cur_quote_cur[exchange]
+        if (cur_quote_cur) {
+          for (let quote_cur in cur_quote_cur) {
+            cur_quote_cur[quote_cur].map((cur) => {
+              const cur_balance = _.get(this.balances, [exchange, 'available', cur], 0)
+              const quote_cur_balance = _.get(this.balances, [exchange, 'available', quote_cur], 0)
+              const pair = cur + quote_cur
               let max_cur_amount = cur_balance - _.get(this.min_reserve_balance, [exchange, cur], 0)
               let max_quote_cur_amount = quote_cur_balance - _.get(this.min_reserve_balance, [exchange, quote_cur], 0)
-              if (max_cur_amount > 0) {
-              } else {
-                // if (cur_balance > 0) {
-                //   console.log('balance low', exchange, cur, cur_balance, this.min_reserve_balance[exchange][cur])
-                // }
-                max_cur_amount = 0
-              }
-              if (max_quote_cur_amount > 0) {
-              } else {
-                // if (quote_cur_balance > 0) {
-                //   console.log('balance low', exchange, quote_cur, quote_cur_balance, this.min_reserve_balance[exchange][quote_cur])
-                // }
-                max_quote_cur_amount = 0
-              }
+              if (max_cur_amount < 0) max_cur_amount = 0
+              if (max_quote_cur_amount < 0) max_quote_cur_amount = 0
               _.set(this.buy_sell_limits_against_reserve_balance, [exchange, pair], {
                 sell: max_cur_amount,
                 buy: max_quote_cur_amount,
@@ -918,10 +948,10 @@ module.exports = class Orders {
           this.account_init = true
           this.init_account(this.balances, this.accounting_benchmark || this.balance_benchmark) // use accounting_benchmark if it exists
         }
-      } else if (_.get(this.balances, [exchange, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].balances) {
+      } else if (_.get(this.balances, [exchange, 'update_time']) < Date.now() - this.interval_dict[exchange].balances) {
         console.log('%s balances expired: %j', exchange, res)
-        this.balances = _.omit(this.balances, [exchange])
-        this.buy_sell_limits_against_reserve_balance = _.omit(this.buy_sell_limits_against_reserve_balance, [exchange])
+        delete this.balances[exchange]
+        delete this.buy_sell_limits_against_reserve_balance[exchange]
       }
     }
     function get_balances(Exchanges, interval_dict) {
@@ -949,9 +979,9 @@ module.exports = class Orders {
     let position_all_handler = (exchange, res) => {
       if (res.success) {
         _.set(this.positions, [exchange], Object.assign(res.body, { update_time: new Date() }))
-      } else if (_.get(this.positions, [exchange, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].positions) {
+      } else if (_.get(this.positions, [exchange, 'update_time']) < Date.now() - this.interval_dict[exchange].positions) {
         console.log('%s positions expired: %j', exchange, res)
-        this.positions = _.omit(this.positions, [exchange])
+        delete this.positions[exchange]
       }
     }
     function get_positions(Exchanges, interval_dict) {
@@ -1018,18 +1048,21 @@ 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) => {
-              if (!_.get(this.previous_orders_canceled_exchange_pair, [exchange, pair])) {
-                previous_orders_canceled = false
+          let all_canceled = true
+          outer: for (const exch of Object.keys(this.exchange_pairs)) {
+            const pairs = this.exchange_pairs[exch]
+            const exch_marks = this.previous_orders_canceled_exchange_pair[exch]
+            for (let i = 0; i < pairs.length; i++) {
+              if (!exch_marks || !exch_marks[pairs[i]]) {
+                all_canceled = false
+                break outer
               }
-            })
+            }
           }
-          if (previous_orders_canceled) {
+          if (all_canceled) {
             console.log('original order canceled')
           }
-          this.previous_orders_canceled = previous_orders_canceled
+          this.previous_orders_canceled = all_canceled
         }
       }
       let rate_major = _.get(this.rates_combined_major, [pair])
@@ -1053,9 +1086,9 @@ module.exports = class Orders {
       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().getTime() - this.interval_dict[exchange].open_orders) {
+      } else if (_.get(this.open_orders, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].open_orders) {
         console.log('%s %s open orders expired: %j', exchange, pair, res)
-        this.open_orders[exchange] = _.omit(this.open_orders[exchange], [pair])
+        if (this.open_orders[exchange]) delete this.open_orders[exchange][pair]
       } else if (res.error !== 'opening') {
         console.error('%s %s open orders: %j', exchange, pair, res)
       }
@@ -1070,12 +1103,12 @@ module.exports = class 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().getTime() - this.interval_dict[exchange].open_orders) {
+          if (_.get(this.open_orders, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].open_orders) {
             if (!error_logged) {
               console.log('%s all open orders expired: %j', exchange, res)
               error_logged = true
             }
-            this.open_orders[exchange] = _.omit(this.open_orders[exchange], [pair])
+            if (this.open_orders[exchange]) delete this.open_orders[exchange][pair]
           } else if (res.error !== 'opening' && !error_logged) {
             console.error('%s all open orders: %j', exchange, res)
             error_logged = true
@@ -1118,11 +1151,6 @@ module.exports = class Orders {
         })
       }
       for (let exchange in Exchanges) {
-        if (Exchanges[exchange].exchange_type === 'dex') {
-          for (let pair of exchange_pairs[exchange]) {
-            _.set(this.previous_orders_canceled_exchange_pair, [exchange, pair], true)
-          }
-        }
         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)
@@ -1151,13 +1179,13 @@ module.exports = class Orders {
           this.trades_amount_past_hour,
           [exchange, pair],
           _.sumBy(
-            res.body.filter((t) => t.close_time > new Date().getTime() - ONE_HOUR_IN_MS || t.open_time > new Date().getTime() - ONE_HOUR_IN_MS),
+            res.body.filter((t) => t.close_time > Date.now() - ONE_HOUR_IN_MS || t.open_time > Date.now() - ONE_HOUR_IN_MS),
             (t) => t.amount,
           ) || 0,
         )
-      } else if (_.get(this.trades, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].trades) {
+      } else if (_.get(this.trades, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].trades) {
         console.log('%s %s trades expired: %j', exchange, pair, res)
-        this.trades[exchange] = _.omit(this.trades[exchange], [pair])
+        if (this.trades[exchange]) delete this.trades[exchange][pair]
       } else if (res.error !== 'opening') {
         console.error('%s %s trades: %j', exchange, pair, res)
       }
@@ -1171,7 +1199,7 @@ module.exports = class Orders {
             this.trades_amount_past_hour,
             [exchange, pair],
             _.sumBy(
-              trades.filter((t) => t.close_time > new Date().getTime() - ONE_HOUR_IN_MS || t.open_time > new Date().getTime() - ONE_HOUR_IN_MS),
+              trades.filter((t) => t.close_time > Date.now() - ONE_HOUR_IN_MS || t.open_time > Date.now() - ONE_HOUR_IN_MS),
               (t) => t.amount,
             ) || 0,
           )
@@ -1179,12 +1207,12 @@ module.exports = class Orders {
       } 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().getTime() - this.interval_dict[exchange].trades) {
+          if (_.get(this.trades, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].trades) {
             if (!error_logged) {
               console.log('%s all trades expired: %j', exchange, res)
               error_logged = true
             }
-            this.trades[exchange] = _.omit(this.trades[exchange], [pair])
+            if (this.trades[exchange]) delete this.trades[exchange][pair]
           } else if (res.error !== 'opening' && !error_logged) {
             console.error('%s all trades: %j', exchange, res)
             error_logged = true
@@ -1283,9 +1311,9 @@ module.exports = class Orders {
     let query_order_handler = (exchange, pair, res) => {
       if (res.success) {
         _.set(this.query_order, [exchange, pair], { query_order: res.body, update_time: new Date() })
-      } else if (_.get(this.query_order, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].query_order) {
+      } else if (_.get(this.query_order, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].query_order) {
         console.log('%s %s query_order expired: %j', exchange, pair, res)
-        this.query_order[exchange] = _.omit(this.query_order[exchange], [pair])
+        if (this.query_order[exchange]) delete this.query_order[exchange][pair]
       } else if (res.error !== 'opening') {
         console.error('%s %s query_order: %j', exchange, pair, res)
       }
@@ -1341,7 +1369,7 @@ module.exports = class Orders {
         let exchanges_list = _.concat(this.pair_exchanges[pair] || [], this.pair_exchanges_rates_only[pair] || [])
         for (let exchange of exchanges_list) {
           if (_.get(this.rates, [exchange, pair, 'asks'], []).length > 0 && _.get(this.rates, [exchange, pair, 'bids'], []).length > 0) {
-            const rates = _.cloneDeep(this.rates[exchange][pair])
+            const rates = this.rates[exchange][pair]
 
             let major_rates_only_exchanges_length = _.get(this.major_exchanges, [pair], []).length + _.get(this.rates_only_exchanges, [pair], []).length
             if (this.major_exchanges[pair] && _.includes(this.major_exchanges[pair], exchange)) {
@@ -1356,8 +1384,8 @@ module.exports = class Orders {
               }
             }
           } else {
-            orderbook_major = _.omit(orderbook_major, [exchange])
-            orderbook_major_temp = _.omit(orderbook_major_temp, [exchange])
+            delete orderbook_major[exchange]
+            delete orderbook_major_temp[exchange]
           }
         }
 
@@ -1365,7 +1393,7 @@ module.exports = class Orders {
         if (o_3.asks.length > 0 && o_3.bids.length > 0) {
           _.set(this.rates_combined_major, [pair], o_3)
         } else {
-          this.rates_combined_major = _.omit(this.rates_combined_major, [pair])
+          delete this.rates_combined_major[pair]
         }
 
         const reference_pair = this.pair_map_rates_only[pair]
@@ -1376,14 +1404,9 @@ module.exports = class Orders {
       this.rates_observable.notify()
     }
     const throttled_process_rates = _.throttle(process_rates, PROCESS_RATES_THROTTLE_MS, { leading: true, trailing: true })
-    let rates_handler = (exchange, pair, res, rates_with_routes = false) => {
+    let rates_handler = (exchange, pair, res) => {
       if (res.success) {
         let { asks, bids } = res.body
-        if (rates_with_routes) {
-          _.set(this.rates_with_routes, [exchange, pair], { asks, bids, update_time: new Date() })
-          asks = asks.map((ask) => ask.slice(0, 2))
-          bids = bids.map((bid) => bid.slice(0, 2))
-        }
         asks = asks.slice(0, RATES_LENGTH_MAX)
         bids = bids.slice(0, RATES_LENGTH_MAX)
         _.set(this.rates, [exchange, pair], { asks, bids, update_time: new Date() })
@@ -1391,9 +1414,9 @@ module.exports = class Orders {
          * throttle to 20ms
          */
         throttled_process_rates()
-      } else if (_.get(this.rates, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].rates) {
+      } else if (_.get(this.rates, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].rates) {
         console.log('%s %s rates expired: %j', exchange, pair, res)
-        this.rates[exchange] = _.omit(this.rates[exchange], [pair])
+        if (this.rates[exchange]) delete this.rates[exchange][pair]
         this.rates_observable.notify()
       }
     }
@@ -1412,19 +1435,6 @@ module.exports = class Orders {
               rates_handler(exchange, pair, res)
             })
           }
-        } else if (Exchanges[exchange].ws_market && Exchanges[exchange].exchange_type === 'dex') {
-          setInterval(() => {
-            if (!this.ws_market_first_time[exchange]) {
-              Exchanges[exchange].ws_market(exchange_pairs[exchange], this.ws_market_options)
-              this.ws_market_first_time[exchange] = true
-            } else {
-              for (let pair of exchange_pairs[exchange]) {
-                Exchanges[exchange].rate_with_routes_ws(pair, (res) => {
-                  rates_handler(exchange, pair, res, true)
-                })
-              }
-            }
-          }, interval_dict[exchange].rates)
         } else if (Exchanges[exchange].exchange_type === 'spot') {
           for (let pair of exchange_pairs[exchange]) {
             setInterval(() => {
@@ -1433,14 +1443,6 @@ module.exports = class Orders {
               })
             }, interval_dict[exchange].rates)
           }
-        } else if (Exchanges[exchange].exchange_type === 'dex') {
-          for (let pair of exchange_pairs[exchange]) {
-            setInterval(() => {
-              Exchanges[exchange].rate_with_routes(pair, (res) => {
-                rates_handler(exchange, pair, res, true)
-              })
-            }, interval_dict[exchange].rates)
-          }
         }
       }
       for (let exchange in exchange_pairs_rates_only) {
@@ -1471,9 +1473,9 @@ module.exports = class Orders {
     let market_history_handler = (exchange, pair, res) => {
       if (res.success) {
         _.set(this.market_history, [exchange, pair], { data: res.body, update_time: new Date() })
-      } else if (_.get(this.market_history, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].market_history) {
+      } else if (_.get(this.market_history, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].market_history) {
         console.log('%s %s market_history expired: %j', exchange, pair, res)
-        this.market_history[exchange] = _.omit(this.market_history[exchange], [pair])
+        if (this.market_history[exchange]) delete this.market_history[exchange][pair]
       }
     }
     let get_market_history = (Exchanges, exchange_pairs, interval_dict) => {
@@ -1508,13 +1510,13 @@ module.exports = class Orders {
       if (res.success) {
         if (res.body.length < OHLCV_DEFAULT_PAST_HOURS) {
           console.error('ohlcv length should be:', OHLCV_DEFAULT_PAST_HOURS, exchange, pair, res.body.length, _.first(res.body), _.last(res.body))
-          this.ohlcv[exchange] = _.omit(this.ohlcv[exchange], [pair])
+          if (this.ohlcv[exchange]) delete this.ohlcv[exchange][pair]
         } else {
           _.set(this.ohlcv, [exchange, pair], { data: res.body, update_time: new Date() })
         }
-      } else if (_.get(this.ohlcv, [exchange, pair, 'update_time']) < new Date().getTime() - this.interval_dict[exchange].ohlcv) {
+      } else if (_.get(this.ohlcv, [exchange, pair, 'update_time']) < Date.now() - this.interval_dict[exchange].ohlcv) {
         console.log('%s %s ohlcv expired: %j', exchange, pair, res)
-        this.ohlcv[exchange] = _.omit(this.ohlcv[exchange], [pair])
+        if (this.ohlcv[exchange]) delete this.ohlcv[exchange][pair]
       }
     }
     let get_ohlcv = (Exchanges, exchange_pairs, interval_dict) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges-wrapper",
-  "version": "1.17.14",
+  "version": "1.17.16",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -18,7 +18,7 @@
   "homepage": "https://github.com/icgio/icg-exchanges-wrapper#readme",
   "dependencies": {
     "@icgio/icg-exchanges": "^1.40.29",
-    "@icgio/icg-utils": "^1.9.53",
+    "@icgio/icg-utils": "^1.9.55",
     "lodash": "^4.17.23",
     "pg": "^8.17.2"
   }