@icgio/icg-exchanges 1.40.43 → 1.40.45

package/lib/exchanges/ascendex.js

@@ -112,9 +112,8 @@ module.exports = class Ascendex extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data.op === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
@@ -127,7 +126,7 @@ module.exports = class Ascendex extends ExchangeBase {
             for (let bid of data.data.bids) {
               this.ws.market.bids_dict[pair].insert(bid[0], bid[1])
             }
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks_s = this.ws.market.asks_dict[pair].entries()
             const bids_s = this.ws.market.bids_dict[pair].entries()
             if (asks_s.length > 0 && bids_s.length > 0) {
@@ -153,7 +152,7 @@ module.exports = class Ascendex extends ExchangeBase {
                 this.ws.market.bids_dict[pair].insert(parseFloat(bid[0]), parseFloat(bid[1]))
               }
             }
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks_u = this.ws.market.asks_dict[pair].entries()
             const bids_u = this.ws.market.bids_dict[pair].entries()
             if (asks_u.length > 0 && bids_u.length > 0) {

package/lib/exchanges/biconomy.js

@@ -109,9 +109,8 @@ module.exports = class Biconomy extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data && data.method === 'depth.update') {
           let pair = post_process_pair(data.params[2])
           this.ws.market.pair_status[pair] = 'opened'
@@ -148,7 +147,7 @@ module.exports = class Biconomy extends ExchangeBase {
               }
             }
           }
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
           const asks_e = this.ws.market.asks_dict[pair].entries()
           const bids_e = this.ws.market.bids_dict[pair].entries()
           if (asks_e.length > 0 && bids_e.length > 0) {

package/lib/exchanges/binance.js

@@ -73,9 +73,8 @@ module.exports = class Binance extends ExchangeBase {
       ;((this.rate_last_id = {}), (this.first_rate = {}))
       this.ws.market_socket = new websocket('wss://stream.binance.com:9443/stream?streams=' + streams.slice(0, -1))
       this.ws.market.on_open(() => {})
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data).data
-        const t_parsed = process.hrtime()
         if (data.e === 'depthUpdate') {
           let pair = post_process_pair(data.s, true)
           this.ws.market.pair_status[pair] = 'opened'
@@ -104,7 +103,7 @@ module.exports = class Binance extends ExchangeBase {
                 this.ws.market.bids_dict[pair].insert(parseFloat(bid[0]), parseFloat(bid[1]))
               }
             }
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.E, t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.E }
           } else if (this.first_rate[pair] && data.U > lastu[pair] + 1) {
             this.first_rate[pair] = false
           }
@@ -135,7 +134,7 @@ module.exports = class Binance extends ExchangeBase {
           if (options.depth === false) {
             this.ws.market.asks_dict[pair] = [[parseFloat(data.a), parseFloat(data.A)]]
             this.ws.market.bids_dict[pair] = [[parseFloat(data.b), parseFloat(data.B)]]
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.E || Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.E || Date.now() }
             this.ws.market.pair_status[pair] = 'opened'
           }
           this.ws.bbo_observable.notify()

package/lib/exchanges/bingx.js

@@ -136,21 +136,20 @@ module.exports = class Bingx extends ExchangeBase {
           this.ws.market.bids_dict[pair] = utils.ordered_dict(false)
         })
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         zlib.gunzip(data, (err, decompressedData) => {
           if (err) {
             console.error('Error decompressing data:', err)
           } else {
             let data = decompressedData.toString('utf8')
             data = JSON.parse(data)
-            const t_parsed = process.hrtime()
             if (data && _.includes(data.dataType, 'depth')) {
               let parts = data.dataType.split('@')
               let pair = post_process_pair(parts[0])
               this.ws.market.pair_status[pair] = 'opened'
               this.ws.market.asks_dict[pair] = data.data.asks.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])]).reverse()
               this.ws.market.bids_dict[pair] = data.data.bids.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp }
               const asks = this.ws.market.asks_dict[pair]
               const bids = this.ws.market.bids_dict[pair]
               if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/bitget.js

@@ -147,19 +147,18 @@ module.exports = class Bitget extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           let book = data.data
           if (data && data.arg && data.arg.channel === depth_val && Array.isArray(book) && book) {
             let pair = data.arg.instId
             this.ws.market.pair_status[pair] = 'opened'
             this.ws.market.asks_dict[pair] = book[0].asks.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
             this.ws.market.bids_dict[pair] = book[0].bids.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(book[0].ts), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(book[0].ts) }
           } else if (data && data.arg && data.arg.channel === ticker_val && Array.isArray(book) && book) {
             let pair = data.arg.instId
             let t = book[0]
@@ -176,7 +175,7 @@ module.exports = class Bitget extends ExchangeBase {
             if (options.depth === false) {
               this.ws.market.asks_dict[pair] = [[ask_1_price, ask_1_amount]]
               this.ws.market.bids_dict[pair] = [[bid_1_price, bid_1_amount]]
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(t.ts || data.ts) || Date.now(), t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(t.ts || data.ts) || Date.now() }
               this.ws.market.pair_status[pair] = 'opened'
             }
             this.ws.bbo_observable.notify()

package/lib/exchanges/bitmart.js

@@ -165,12 +165,11 @@ module.exports = class Bitmart extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           let book = data.data
           // Get the pair from the message's symbol field
           const msg_symbol = data.symbol
@@ -179,7 +178,7 @@ module.exports = class Bitmart extends ExchangeBase {
             this.ws.market.pair_status[target_pair] = 'opened'
             this.ws.market.asks_dict[target_pair] = book.sells.map((ask) => [parseFloat(ask.price), parseFloat(ask.amount)])
             this.ws.market.bids_dict[target_pair] = book.buys.map((bid) => [parseFloat(bid.price), parseFloat(bid.amount)])
-            this.ws.market.ts_dict[target_pair] = { received_ts: Date.now(), event_ts: parseInt(data.timeStamp) || undefined, t_recv, t_parsed }
+            this.ws.market.ts_dict[target_pair] = { received_ts: Date.now(), event_ts: parseInt(data.timeStamp) || undefined }
             const asks = this.ws.market.asks_dict[target_pair]
             const bids = this.ws.market.bids_dict[target_pair]
             if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/bitmex.js

@@ -141,9 +141,8 @@ module.exports = class Bitmex extends ExchangeBase {
           this.ws.market.bids_dict[pair] = utils.ordered_dict(false)
         }
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data.table === 'orderBookL2') {
           if (data.action === 'partial') {
             if (!data.data[0]) {

package/lib/exchanges/bitrue.js

@@ -122,21 +122,20 @@ module.exports = class Bitrue extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         zlib.gunzip(data, (err, decompressedData) => {
           if (err) {
             console.error('Error decompressing data:', err)
           } else {
             let data = decompressedData.toString('utf8')
             data = JSON.parse(data)
-            const t_parsed = process.hrtime()
             if (data && _.includes(data.channel, 'depth_step0') && data.tick) {
               let parts = data.channel.split('_')
               let pair = post_process_pair(parts[1])
               this.ws.market.pair_status[pair] = 'opened'
               this.ws.market.asks_dict[pair] = data.tick.asks.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
               this.ws.market.bids_dict[pair] = data.tick.buys.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts }
               const asks = this.ws.market.asks_dict[pair]
               const bids = this.ws.market.bids_dict[pair]
               if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/blofin.js

@@ -150,10 +150,9 @@ module.exports = class Blofin extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         try {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           if (data.channel === 'DEPTH') {
             const action = data.data_type
             const pair = post_process_pair(data.symbol)
@@ -169,7 +168,7 @@ module.exports = class Blofin extends ExchangeBase {
                 const [price, size] = bid
                 this.ws.market.bids_dict[pair].insert(parseFloat(price), parseFloat(size))
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
               {
                 const _asks = this.ws.market.asks_dict[pair].entries()
                 const _bids = this.ws.market.bids_dict[pair].entries()
@@ -198,7 +197,7 @@ module.exports = class Blofin extends ExchangeBase {
                     this.ws.market.bids_dict[pair].insert(parseFloat(price), parseFloat(size))
                   }
                 }
-                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
                 {
                   const _asks = this.ws.market.asks_dict[pair].entries()
                   const _bids = this.ws.market.bids_dict[pair].entries()

package/lib/exchanges/btse.js

@@ -96,12 +96,11 @@ module.exports = class Btse extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           if (data && data.topic && data.topic.includes('snapshot:' || 'update:') && data.data) {
             let pair = post_process_pair(data.data.symbol)
             let current_timestamp = new Date().getTime()
@@ -133,7 +132,7 @@ module.exports = class Btse extends ExchangeBase {
                   }
                 }
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp }
               {
                 const _asks = this.ws.market.asks_dict[pair].entries()
                 const _bids = this.ws.market.bids_dict[pair].entries()

package/lib/exchanges/bybit.js

@@ -90,10 +90,9 @@ module.exports = class Bybit extends ExchangeBase {
         })
         this.ws.market.ping(JSON.stringify({ op: 'ping' }))
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         try {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           if (data.success && data.ret_msg === 'pong') {
             this.ws.market.last_pong = new Date()
           } else {
@@ -132,7 +131,7 @@ module.exports = class Bybit extends ExchangeBase {
                   }
                 }
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts }
               // Populate BBO from orderbook data
               if (options.bbo !== false && data.data.a && data.data.a.length > 0 && data.data.b && data.data.b.length > 0) {
                 const best_ask = data.data.a[0]

package/lib/exchanges/coinbase.js

@@ -219,14 +219,13 @@ module.exports = class Coinbase extends ExchangeBase {
         }))
         console.log('coinbase ws-direct: subscribed channels:', channels.join(', '))
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         try {
           data = JSON.parse(data)
         } catch (err) {
           console.error('coinbase', 'ws-direct', 'JSON parse error:', err.message)
           return
         }
-        const t_parsed = process.hrtime()
         if (data.type === 'snapshot') {
           const pair = post_process_pair(data.product_id)
           if (!this.ws.market.asks_dict[pair]) return
@@ -253,7 +252,7 @@ module.exports = class Coinbase extends ExchangeBase {
             if (price >= lo && price <= hi) this.ws.market.asks_dict[pair].insert(price, qty)
           }
           this.ws.market.pair_status[pair] = 'opened'
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: Date.now(), t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: Date.now() }
           const top_bid = this.ws.market.bids_dict[pair].top()
           const top_ask = this.ws.market.asks_dict[pair].top()
           if (top_bid != null && top_ask != null) {
@@ -284,7 +283,7 @@ module.exports = class Coinbase extends ExchangeBase {
               }
             }
           }
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now(), t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now() }
           {
             const top_bid = this.ws.market.bids_dict[pair].top()
             const top_ask = this.ws.market.asks_dict[pair].top()
@@ -307,7 +306,7 @@ module.exports = class Coinbase extends ExchangeBase {
           if (options.depth === false) {
             this.ws.market.asks_dict[pair] = [[best_ask, best_ask_qty]]
             this.ws.market.bids_dict[pair] = [[best_bid, best_bid_qty]]
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now() }
             this.ws.market.pair_status[pair] = 'opened'
           } else {
             const bids = this.ws.market.bids_dict[pair]
@@ -324,7 +323,7 @@ module.exports = class Coinbase extends ExchangeBase {
             for (const k of prune_bids) bids.del(k)
             const prune_asks = asks.keys().filter((k) => k > hi)
             for (const k of prune_asks) asks.del(k)
-            if (bbo_changed) this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now(), t_recv, t_parsed }
+            if (bbo_changed) this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now() }
           }
           if (bbo_changed) this.ws.bbo_observable.notify()
         } else if (data.type === 'match' || data.type === 'last_match') {
@@ -407,14 +406,13 @@ module.exports = class Coinbase extends ExchangeBase {
           this.ws.market.send(JSON.stringify({ type: 'subscribe', product_ids, channel: 'market_trades' }))
         }
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         try {
           data = JSON.parse(data)
         } catch (err) {
           console.error('coinbase', 'websocket', 'JSON parse error:', err.message)
           return
         }
-        const t_parsed = process.hrtime()
         const seq = data.sequence_num
         if (seq !== undefined) {
           const gap = (this._ws_last_seq !== undefined && seq > this._ws_last_seq + 1) ? seq - this._ws_last_seq - 1 : 0
@@ -488,7 +486,6 @@ module.exports = class Coinbase extends ExchangeBase {
             this.ws.market.ts_dict[pair] = {
               received_ts: Date.now(),
               event_ts: parse_event_ts_ms(data.timestamp) || Date.now(),
-              t_recv, t_parsed,
             }
             {
               const top_bid = this.ws.market.bids_dict[pair].top()
@@ -535,7 +532,7 @@ module.exports = class Coinbase extends ExchangeBase {
               if (options.depth === false) {
                 this.ws.market.asks_dict[pair] = [[best_ask, best_ask_qty]]
                 this.ws.market.bids_dict[pair] = [[best_bid, best_bid_qty]]
-                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.timestamp) || Date.now(), t_recv, t_parsed }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.timestamp) || Date.now() }
                 this.ws.market.pair_status[pair] = 'opened'
               } else {
                 const bids = this.ws.market.bids_dict[pair]
@@ -553,7 +550,7 @@ module.exports = class Coinbase extends ExchangeBase {
                 for (const k of prune_bids) bids.del(k)
                 const prune_asks = asks.keys().filter((k) => k > hi)
                 for (const k of prune_asks) asks.del(k)
-                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.timestamp) || Date.now(), t_recv, t_parsed }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.timestamp) || Date.now() }
               }
               this.ws.bbo_observable.notify()
             }
@@ -1156,7 +1153,19 @@ module.exports = class Coinbase extends ExchangeBase {
       return
     }
     if (this.fix_ord && this.fix_ord.is_ready()) {
-      this.fix_ord.send_new_order(pair, method, price, amount, order_options, cb)
+      const normalized = this.normalize_order_options(order_options)
+      const t_order_sent = process.hrtime()
+      if (normalized.on_sent) {
+        normalized.on_sent({ t_order_sent })
+      }
+      this.fix_ord.send_new_order(pair, method, price, amount, normalized.order_options, (res = {}) => {
+        res.meta = {
+          ...(res.meta || {}),
+          t_order_sent,
+          t_ack_recv: process.hrtime(),
+        }
+        cb(res)
+      })
       return
     }
     this.private_limiter.process(this.limit_trade_base.bind(this), pair, method, price, amount, order_options, cb)
@@ -1201,7 +1210,15 @@ module.exports = class Coinbase extends ExchangeBase {
   }
   cancel_order_by_order(order, cb) {
     if (this.fix_ord && this.fix_ord.is_ready()) {
-      this.fix_ord.send_cancel(order.pair, order.order_id, order.type, cb)
+      const t_cancel_sent = process.hrtime()
+      this.fix_ord.send_cancel(order.pair, order.order_id, order.type, (res = {}) => {
+        res.meta = {
+          ...(res.meta || {}),
+          t_cancel_sent,
+          t_cancel_ack: process.hrtime(),
+        }
+        cb(res)
+      })
       return
     }
     this.cancel_order(order.pair, order.order_id, cb)

package/lib/exchanges/coinstore.js

@@ -135,15 +135,14 @@ module.exports = class Coinstore extends ExchangeBase {
           false,
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data && data.T === 'depth') {
             let pair = post_process_pair(data.symbol)
             this.ws.market.pair_status[pair] = 'opened'
             this.ws.market.asks_dict[pair] = data.a.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
             this.ws.market.bids_dict[pair] = data.b.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks = this.ws.market.asks_dict[pair]
             const bids = this.ws.market.bids_dict[pair]
             if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/cryptocom.js

@@ -109,7 +109,7 @@ module.exports = class Cryptocom extends ExchangeBase {
           )
         }
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         let parsed
         try {
           parsed = JSON.parse(data)
@@ -125,13 +125,12 @@ module.exports = class Cryptocom extends ExchangeBase {
           )
           return
         }
-        const t_parsed = process.hrtime()
         let result = parsed.result
         if (result) {
           let pair = post_process_pair(result.instrument_name, true)
           if (result.channel === 'book') {
             this.ws.market.pair_status[pair] = 'opened'
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             let { asks, bids } = result.data[0]
             this.ws.market.asks_dict[pair] = asks.map((e) => [parseFloat(e[0]), parseFloat(e[1])])
             this.ws.market.bids_dict[pair] = bids.map((e) => [parseFloat(e[0]), parseFloat(e[1])])

package/lib/exchanges/exchange-base.js

@@ -154,6 +154,59 @@ class ExchangeBase {
     }
     /** @type {boolean} Whether deposits/withdrawals go directly to the spot account */
     this.deposits_to_spot = true
+    this._wrap_transport_methods()
+  }
+
+  _wrap_transport_methods() {
+    if (typeof this.limit_trade_base === 'function') {
+      const original_limit_trade_base = this.limit_trade_base.bind(this)
+      this.limit_trade_base = (pair, method, price, amount, order_options, cb) => {
+        if (typeof order_options === 'function') {
+          cb = order_options
+          order_options = {}
+        }
+        const normalized = this.normalize_order_options(order_options)
+        if (parseFloat(amount) === 0) {
+          return original_limit_trade_base(pair, method, price, amount, normalized.order_options, cb)
+        }
+        const t_order_sent = process.hrtime()
+        if (normalized.on_sent) {
+          normalized.on_sent({ t_order_sent })
+        }
+        return original_limit_trade_base(pair, method, price, amount, normalized.order_options, (res = {}) => {
+          res.meta = {
+            ...(res.meta || {}),
+            t_order_sent,
+            t_ack_recv: process.hrtime(),
+          }
+          cb(res)
+        })
+      }
+    }
+
+    if (typeof this.cancel_order === 'function' && this.cancel_order !== ExchangeBase.prototype.cancel_order) {
+      const original_cancel_order = this.cancel_order.bind(this)
+      this.cancel_order = (pair, order_id, cb) => {
+        const t_cancel_sent = process.hrtime()
+        return original_cancel_order(pair, order_id, (res = {}) => {
+          res.meta = {
+            ...(res.meta || {}),
+            t_cancel_sent,
+            t_cancel_ack: process.hrtime(),
+          }
+          cb(res)
+        })
+      }
+    }
+
+    if (typeof this.rate_ws === 'function' && this.rate_ws !== ExchangeBase.prototype.rate_ws) {
+      const original_rate_ws = this.rate_ws.bind(this)
+      this.rate_ws = (pair, cb) => {
+        original_rate_ws(pair, (res) => {
+          cb(this.attach_market_ts(pair, res))
+        })
+      }
+    }
   }
 
   get api_secret_key() {
@@ -165,6 +218,45 @@ class ExchangeBase {
     return key
   }
 
+  normalize_order_options(order_options) {
+    if (!order_options || typeof order_options !== 'object') {
+      return { order_options: {}, on_sent: null }
+    }
+    const normalized = { ...order_options }
+    const on_sent = typeof normalized.on_sent === 'function' ? normalized.on_sent : null
+    delete normalized.on_sent
+    return { order_options: normalized, on_sent }
+  }
+
+  snapshot_market_ts(pair) {
+    const ticker_ts = _.get(this, ['ws', 'market', 'tickers', pair, '_ts'])
+    if (ticker_ts && typeof ticker_ts === 'object') {
+      return { ...ticker_ts }
+    }
+    const ts = _.get(this, ['ws', 'market', 'ts_dict', pair])
+    if (ts && typeof ts === 'object') {
+      return { ...ts }
+    }
+    return undefined
+  }
+
+  attach_market_ts(pair, res) {
+    if (!res || !res.success || !res.body || typeof res.body !== 'object') {
+      return res
+    }
+    const market_ts = this.snapshot_market_ts(pair)
+    if (!market_ts) {
+      return res
+    }
+    return {
+      ...res,
+      body: {
+        ...res.body,
+        _ts: res.body._ts && typeof res.body._ts === 'object' ? { ...res.body._ts } : market_ts,
+      },
+    }
+  }
+
   /**
    * Normalize a timestamp-like exchange value into a valid Date instance.
    * @param {Date|string|number|null|undefined} value
@@ -520,12 +612,12 @@ class ExchangeBase {
   bbo_ws(pair, cb) {
     const t = this.ws.market.tickers[pair]
     if (t && t.bid > 0 && t.ask > 0) {
-      cb({ success: true, body: { asks: [[t.ask, t.ask_size]], bids: [[t.bid, t.bid_size]] } })
+      cb({ success: true, body: { asks: [[t.ask, t.ask_size]], bids: [[t.bid, t.bid_size]], _ts: t._ts || this.snapshot_market_ts(pair) } })
     } else {
       // Fallback: derive from full orderbook
       this.rate_ws(pair, (res) => {
         if (res.success && res.body.bids.length > 0 && res.body.asks.length > 0) {
-          cb({ success: true, body: { asks: [res.body.asks[0]], bids: [res.body.bids[0]] } })
+          cb({ success: true, body: { asks: [res.body.asks[0]], bids: [res.body.bids[0]], _ts: res.body._ts || this.snapshot_market_ts(pair) } })
         } else {
           cb(res)
         }

package/lib/exchanges/exchange-ws.js

@@ -218,9 +218,8 @@ module.exports = class ExchangeWs {
         const boundSocket = this.market_socket
         let message_handler = (...args) => {
           if (boundSocket !== this.market_socket) return
-          const t_recv = process.hrtime()
           this.market.last_message_time = Date.now()
-          listener(...args, t_recv)
+          listener(...args)
           this.market_observable.notify()
         }
         if (this.market_socket.serviceHandlers) {

package/lib/exchanges/gate.js

@@ -159,9 +159,8 @@ module.exports = class Gate extends ExchangeBase {
         }),
       )
       const last_update_dict = {}
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data && data.channel === 'spot.pong') {
           this.ws.market.last_pong = new Date()
         } else if (data && data.channel === 'spot.order_book' && data.result && data.result.s && data.result.bids && data.result.asks) {
@@ -175,7 +174,6 @@ module.exports = class Gate extends ExchangeBase {
             this.ws.market.ts_dict[pair] = {
               received_ts: Date.now(),
               event_ts: parseInt(t),
-              t_recv, t_parsed,
             }
             last_update_dict[pair] = lastUpdateId
           }
@@ -191,7 +189,7 @@ module.exports = class Gate extends ExchangeBase {
           if (options.depth === false) {
             this.ws.market.asks_dict[pair] = [[parseFloat(ask_1_price), parseFloat(ask_1_amount)]]
             this.ws.market.bids_dict[pair] = [[parseFloat(bid_1_price), parseFloat(bid_1_amount)]]
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(data.result.t) || Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(data.result.t) || Date.now() }
             this.ws.market.pair_status[pair] = 'opened'
           } else {
             if (!this.ws.market.asks_dict[pair] || !this.ws.market.bids_dict[pair]) {

package/lib/exchanges/hashkey.js

@@ -108,10 +108,9 @@ module.exports = class Hashkey extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         try {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           if (data.pong) {
             this.ws.market.last_pong = new Date()
           } else {
@@ -121,7 +120,7 @@ module.exports = class Hashkey extends ExchangeBase {
               const { a, b } = data.data
               this.ws.market.asks_dict[pair] = a.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
               this.ws.market.bids_dict[pair] = b.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseFloat(data.data.t) || undefined, send_ts: parseFloat(data.sendTime) || undefined, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseFloat(data.data.t) || undefined, send_ts: parseFloat(data.sendTime) || undefined }
               const asks = this.ws.market.asks_dict[pair]
               const bids = this.ws.market.bids_dict[pair]
               if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/hashkeyglobal.js

@@ -110,9 +110,8 @@ module.exports = class Hashkeyglobal extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data.pong) {
           this.ws.market.last_pong = new Date()
         } else {
@@ -122,7 +121,7 @@ module.exports = class Hashkeyglobal extends ExchangeBase {
             this.ws.market.pair_status[pair] = 'opened'
             this.ws.market.asks_dict[pair] = book[0].a.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
             this.ws.market.bids_dict[pair] = book[0].b.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks = this.ws.market.asks_dict[pair]
             const bids = this.ws.market.bids_dict[pair]
             if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/hitbtc.js

@@ -80,9 +80,8 @@ module.exports = class Hitbtc extends ExchangeBase {
           }
         }
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data.method === 'snapshotOrderbook') {
           let pair = post_process_pair(data.params.symbol)
           this.ws.market.pair_status[pair] = 'opened'

package/lib/exchanges/hkbitex.js

@@ -142,12 +142,11 @@ module.exports = class Hkbitex extends ExchangeBase {
         }, 60 * 1000)
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
           data = JSON.parse(data)
-          const t_parsed = process.hrtime()
           if (data && data.data && data.data.e === 8) {
             let book = data.data
             let pair = post_process_pair(book.s)
@@ -158,7 +157,7 @@ module.exports = class Hkbitex extends ExchangeBase {
             if (book.d && book.d.b) {
               this.ws.market.bids_dict[pair] = book.d.b.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
             }
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks = this.ws.market.asks_dict[pair]
             const bids = this.ws.market.bids_dict[pair]
             if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/htx.js

@@ -120,13 +120,12 @@ module.exports = class Htx extends ExchangeBase {
       let depth_re = new RegExp('market.(.+).depth.step0'),
         bbo_re = new RegExp('market.(.+).bbo'),
         trade_re = new RegExp('market.(.+).trade.detail')
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = parse_body(pako.inflate(new Uint8Array(data), { to: 'string' }))
-        const t_parsed = process.hrtime()
         if (data.ch && depth_re.exec(data.ch)) {
           let pair = post_process_pair(depth_re.exec(data.ch)[1])
           this.ws.market.pair_status[pair] = 'opened'
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts }
           this.ws.market.asks_dict[pair] = data.tick.asks
           this.ws.market.bids_dict[pair] = data.tick.bids
         } else if (data.ch && bbo_re.exec(data.ch)) {
@@ -141,7 +140,7 @@ module.exports = class Htx extends ExchangeBase {
           if (options.depth === false) {
             this.ws.market.asks_dict[pair] = [[parseFloat(ask_1_price), parseFloat(ask_1_amount)]]
             this.ws.market.bids_dict[pair] = [[parseFloat(bid_1_price), parseFloat(bid_1_amount)]]
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts }
             this.ws.market.pair_status[pair] = 'opened'
           } else {
             if (!Array.isArray(this.ws.market.asks_dict[pair]) || !Array.isArray(this.ws.market.bids_dict[pair])) {

package/lib/exchanges/kucoin.js

@@ -121,9 +121,8 @@ module.exports = class Kucoin extends ExchangeBase {
               type: 'ping',
             }),
           )
-          this.ws.market.on_message((data, t_recv) => {
+          this.ws.market.on_message((data) => {
             data = JSON.parse(data)
-            const t_parsed = process.hrtime()
             let book = data.data
             if (data.type === 'pong') {
               this.ws.market.last_pong = new Date()
@@ -133,7 +132,7 @@ module.exports = class Kucoin extends ExchangeBase {
               this.ws.market.pair_status[pair] = 'opened'
               this.ws.market.asks_dict[pair] = book.asks.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
               this.ws.market.bids_dict[pair] = book.bids.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp }
             } else if (data && data.type === 'message' && data.topic && data.subject === 'level1' && book && book.timestamp && book.bids && book.asks) {
               let val = data.topic.split(':')
               let pair = post_process_pair(val[1])
@@ -149,7 +148,7 @@ module.exports = class Kucoin extends ExchangeBase {
               if (options.depth === false) {
                 this.ws.market.asks_dict[pair] = [[parseFloat(ask_1_price), parseFloat(ask_1_amount)]]
                 this.ws.market.bids_dict[pair] = [[parseFloat(bid_1_price), parseFloat(bid_1_amount)]]
-                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp }
                 this.ws.market.pair_status[pair] = 'opened'
               } else {
                 if (!Array.isArray(this.ws.market.asks_dict[pair]) || !Array.isArray(this.ws.market.bids_dict[pair])) {

package/lib/exchanges/lbank.js

@@ -157,9 +157,8 @@ module.exports = class Lbank extends ExchangeBase {
         })
         this.ws.market.ping(JSON.stringify({ action: 'ping', ping: 'keepalive' }))
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data.action === 'ping') {
           this.ws.market.send(
             JSON.stringify({
@@ -182,7 +181,7 @@ module.exports = class Lbank extends ExchangeBase {
           this.ws.market.pair_status[pair] = 'opened'
           this.ws.market.asks_dict[pair] = data.depth.asks.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
           this.ws.market.bids_dict[pair] = data.depth.bids.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
           const asks = this.ws.market.asks_dict[pair]
           const bids = this.ws.market.bids_dict[pair]
           if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/mexc.js

@@ -131,7 +131,7 @@ module.exports = class Mexc extends ExchangeBase {
           return false
         }
       }
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (is_json(data)) {
           try {
             const json = JSON.parse(data.toString())
@@ -152,7 +152,6 @@ module.exports = class Mexc extends ExchangeBase {
         try {
           const message = PushDataV3ApiWrapper.decode(data)
           const obj = PushDataV3ApiWrapper.toObject(message, { enums: String, longs: String })
-          const t_parsed = process.hrtime()
           const pair = post_process_pair(obj.symbol)
           const channel = obj.channel
           if (channel.startsWith('spot@public.limit.depth.v3.api.pb@')) {
@@ -160,7 +159,7 @@ module.exports = class Mexc extends ExchangeBase {
             this.ws.market.pair_status[pair] = 'opened'
             this.ws.market.asks_dict[pair] = asks.map((ask) => [parseFloat(ask.price), parseFloat(ask.quantity)])
             this.ws.market.bids_dict[pair] = bids.map((bid) => [parseFloat(bid.price), parseFloat(bid.quantity)])
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(obj.sendTime) || undefined, t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(obj.sendTime) || undefined }
             // Derive BBO from depth data
             if (options.bbo !== false && this.ws.market.asks_dict[pair].length > 0 && this.ws.market.bids_dict[pair].length > 0) {
               this.ws.market.tickers[pair] = {

package/lib/exchanges/okx.js

@@ -217,14 +217,13 @@ module.exports = class Okx extends ExchangeBase {
         this.ws.market.ping('ping')
         start_market_history_socket()
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         }
         if (data.toString() !== 'pong') {
           try {
             data = JSON.parse(data)
-            const t_parsed = process.hrtime()
             if (data && data.arg && data.arg.channel === 'books' && data.data && data.data[0]) {
               const action = data.action
               const pair = post_process_pair(data.arg.instId, true)
@@ -263,7 +262,7 @@ module.exports = class Okx extends ExchangeBase {
                 } else {
                 }
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(data.data[0].ts), t_recv, t_parsed }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(data.data[0].ts) }
             } else if (data && data.data && data.arg && (data.arg.channel === 'trades' || data.arg.channel === 'trades-all')) {
               for (let datum of data.data) {
                 let pair = post_process_pair(datum.instId)
@@ -300,7 +299,7 @@ module.exports = class Okx extends ExchangeBase {
               if (options.depth === false) {
                 this.ws.market.asks_dict[pair] = [[askPrice, askSize]]
                 this.ws.market.bids_dict[pair] = [[bidPrice, bidSize]]
-                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(bbo.ts), t_recv, t_parsed }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(bbo.ts) }
                 this.ws.market.pair_status[pair] = 'opened'
               }
               this.ws.bbo_observable.notify()

package/lib/exchanges/phemex.js

@@ -773,9 +773,8 @@ module.exports = class Phemex extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         data = JSON.parse(data)
-        const t_parsed = process.hrtime()
         if (data && data.book && data.type === 'snapshot') {
           let pair = post_process_pair(data.symbol)
           this.ws.market.pair_status[pair] = 'opened'
@@ -785,7 +784,7 @@ module.exports = class Phemex extends ExchangeBase {
           for (let bid of data.book.bids) {
             this.ws.market.bids_dict[pair].insert(bid[0], bid[1])
           }
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp ? Math.floor(data.timestamp / 1e6) : undefined, t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp ? Math.floor(data.timestamp / 1e6) : undefined }
           {
             const _asks = this.ws.market.asks_dict[pair].entries()
             const _bids = this.ws.market.bids_dict[pair].entries()
@@ -813,7 +812,7 @@ module.exports = class Phemex extends ExchangeBase {
               this.ws.market.bids_dict[pair].insert(parseFloat(bid[0]), parseFloat(bid[1]))
             }
           }
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp ? Math.floor(data.timestamp / 1e6) : undefined, t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp ? Math.floor(data.timestamp / 1e6) : undefined }
           {
             const _asks = this.ws.market.asks_dict[pair].entries()
             const _bids = this.ws.market.bids_dict[pair].entries()

package/lib/exchanges/swft.js

@@ -81,7 +81,7 @@ module.exports = class Swft extends ExchangeBase {
   // }
   rate(pair, orderbook_depth, cb) {
     let [api_key, secret_key] = this.public_api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       depth: '1',
@@ -110,7 +110,7 @@ module.exports = class Swft extends ExchangeBase {
   }
   market_history(pair, timeframe_in_ms, cb) {
     let [api_key, secret_key] = this.public_api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       symbol: pre_process_pair(pair),
@@ -166,7 +166,7 @@ module.exports = class Swft extends ExchangeBase {
       return filled_data
     }
     let [api_key, secret_key] = this.public_api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       period: '60min',
@@ -206,7 +206,7 @@ module.exports = class Swft extends ExchangeBase {
       return
     }
     let [api_key, secret_key] = this.api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       amount,
       channelId: api_key,
@@ -241,7 +241,7 @@ module.exports = class Swft extends ExchangeBase {
   }
   balance(cb) {
     let [api_key, secret_key] = this.api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       timestamp,
@@ -272,7 +272,7 @@ module.exports = class Swft extends ExchangeBase {
   get_open_orders(pair, cb) {
     let get_open_orders_base = (pair, cb) => {
       let [api_key, secret_key] = this.api_secret_key
-      let timestamp = (Date.now() + 8 * 3_600_000).toString()
+      let timestamp = new Date().addHours(8).getTime().toString()
       let params = {
         channelId: api_key,
         timestamp,
@@ -304,7 +304,7 @@ module.exports = class Swft extends ExchangeBase {
   }
   cancel_order(pair, id, cb) {
     let [api_key, secret_key] = this.api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       orderId: id,
@@ -329,7 +329,7 @@ module.exports = class Swft extends ExchangeBase {
   }
   query_order_base(pair, order_id, cb) {
     let [api_key, secret_key] = this.api_secret_key
-    let timestamp = (Date.now() + 8 * 3_600_000).toString()
+    let timestamp = new Date().addHours(8).getTime().toString()
     let params = {
       channelId: api_key,
       orderId: order_id,
@@ -376,7 +376,7 @@ module.exports = class Swft extends ExchangeBase {
   get_trades(pair, timeframe_in_ms, cb) {
     let get_trades_base = (pair, timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key
-      let timestamp = (Date.now() + 8 * 3_600_000).toString()
+      let timestamp = new Date().addHours(8).getTime().toString()
       let params = {
         channelId: api_key,
         timestamp,

package/lib/exchanges/upbit.js

@@ -97,7 +97,7 @@ module.exports = class Upbit extends ExchangeBase {
         let message = JSON.stringify([JSON.stringify(sub_channels).toString()])
         this.ws.market.send(message)
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.startsWith('a')) {
           data = _.trim(data, 'a')
           data = JSON.parse(JSON.parse(data)[0])
@@ -107,8 +107,7 @@ module.exports = class Upbit extends ExchangeBase {
           this.ws.market.pair_status[pair] = 'opened'
           this.ws.market.asks_dict[pair] = data.orderbookUnits.map((o) => [parseFloat(o.askPrice), parseFloat(o.askSize)])
           this.ws.market.bids_dict[pair] = data.orderbookUnits.map((o) => [parseFloat(o.bidPrice), parseFloat(o.bidSize)])
-          const t_parsed = process.hrtime()
-          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp, t_recv, t_parsed }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.timestamp }
           const asks = this.ws.market.asks_dict[pair]
           const bids = this.ws.market.bids_dict[pair]
           if (asks && asks.length > 0 && bids && bids.length > 0) {

package/lib/exchanges/xt.js

@@ -122,7 +122,7 @@ module.exports = class Xt extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data, t_recv) => {
+      this.ws.market.on_message((data) => {
         if (data.toString() === 'pong') {
           this.ws.market.last_pong = new Date()
         } else {
@@ -131,14 +131,13 @@ module.exports = class Xt extends ExchangeBase {
           } catch (err) {
             console.error('xt websocket', data.toString(), err)
           }
-          const t_parsed = process.hrtime()
           let book = data.data
           if (data && data.topic === 'depth' && book) {
             let pair = post_process_pair(data.data.s)
             this.ws.market.pair_status[pair] = 'opened'
             this.ws.market.asks_dict[pair] = data.data.a.map((ask) => [parseFloat(ask[0]), parseFloat(ask[1])])
             this.ws.market.bids_dict[pair] = data.data.b.map((bid) => [parseFloat(bid[0]), parseFloat(bid[1])])
-            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now() }
             const asks = this.ws.market.asks_dict[pair]
             const bids = this.ws.market.bids_dict[pair]
             if (asks && asks.length > 0 && bids && bids.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges",
-  "version": "1.40.43",
+  "version": "1.40.45",
   "description": "icgio exchanges package",
   "main": "./exchanges.js",
   "scripts": {
@@ -18,7 +18,7 @@
   },
   "homepage": "https://github.com/icgio/icg-exchanges#readme",
   "dependencies": {
-    "@icgio/icg-utils": "^1.9.60",
+    "@icgio/icg-utils": "^1.9.58",
     "json-bigint": "^1.0.0",
     "jsonwebtoken": "^9.0.3",
     "lodash": "^4.17.20",