@icgio/icg-exchanges 1.40.42 → 1.40.43

package/lib/exchanges/bitmex.js

@@ -141,8 +141,9 @@ module.exports = class Bitmex extends ExchangeBase {
           this.ws.market.bids_dict[pair] = utils.ordered_dict(false)
         }
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         data = JSON.parse(data)
+        const t_parsed = process.hrtime()
         if (data.table === 'orderBookL2') {
           if (data.action === 'partial') {
             if (!data.data[0]) {
@@ -685,6 +686,75 @@ module.exports = class Bitmex extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let verb = 'GET'
+    let endpoint = '/api/v1/execution/tradeHistory'
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          count: 500,
+          symbol: pre_process_pair(pair),
+          startTime: new Date(window_start_ms).toISOString(),
+          endTime: new Date(window_stop_ms - 1).toISOString(),
+        }
+        let query = qs.stringify(params)
+        let nonce = Date.now() + 60 * 1000
+        let signature = get_signature_bitmex(verb, endpoint + '?' + query, nonce, null, secret_key)
+        let options = get_options(api_key, nonce, signature)
+        needle.get(base_url + endpoint + '?' + query, options, (err, res, body) => {
+          if (Array.isArray(body)) {
+            resolve(
+              body
+                .filter((trade) => trade.execType === 'Trade')
+                .map((trade) => {
+                  let price = parseFloat(trade.lastPx || trade.avgPx || trade.price)
+                  let amount = Math.abs(parseFloat(trade.homeNotional))
+                  if (!Number.isFinite(amount)) {
+                    let quantity = parseFloat(trade.lastQty || trade.cumQty || trade.foreignNotional)
+                    amount = Number.isFinite(quantity) && Number.isFinite(price) && price !== 0 ? Math.abs(quantity) / price : 0
+                  }
+                  let total = Math.abs(parseFloat(trade.foreignNotional))
+                  if (!Number.isFinite(total)) total = Math.abs(parseFloat(trade.lastQty || trade.cumQty || 0))
+                  let mapped_trade = {
+                    order_id: (trade.orderID || '').toString(),
+                    trade_id: (trade.execID || trade.trdMatchID || '').toString(),
+                    pair,
+                    type: (trade.side || '').toLowerCase(),
+                    price,
+                    amount,
+                    size: total,
+                    total,
+                    close_time: new Date(trade.transactTime || trade.timestamp),
+                  }
+                  if (trade.lastLiquidityInd === 'AddedLiquidity') mapped_trade.role = 'maker'
+                  if (trade.lastLiquidityInd === 'RemovedLiquidity') mapped_trade.role = 'taker'
+                  return mapped_trade
+                })
+            )
+          } else if (body && body.error && body.error.message === 'The system is currently overloaded. Please try again later.') {
+            reject({ success: false, error: error_codes.system_overloaded })
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 30 * 24 * 60 * 60 * 1000,
+        page_limit: 500,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   static get_precision(cb) {
     let price_precision = {},
       amount_precision = {}

package/lib/exchanges/bitrue.js

@@ -8,6 +8,7 @@ const zlib = require('zlib')
 const ExchangeBase = require('./exchange-base.js')
 const ExchangeWs = require('./exchange-ws.js')
 const JSONbig = require('json-bigint')
+const { fetch_split_windows, sort_history_rows } = ExchangeBase.history_utils
 
 const { error_codes } = require('../error_codes.json')
 
@@ -121,20 +122,21 @@ module.exports = class Bitrue extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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 }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
               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) {
@@ -512,6 +514,61 @@ module.exports = class Bitrue extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    const get_history_trades_base = (pair, start_time_in_ms, end_time_in_ms, cb) => {
+      let [api_key, secret_key] = this.api_secret_key
+      const options = get_options(api_key, false)
+      ;(async () => {
+        const rows = await fetch_split_windows({
+          start_ms: start_time_in_ms,
+          stop_ms: end_time_in_ms,
+          initial_window_ms: 60 * 60 * 1000,
+          page_limit: 1000,
+          fetch_window: async (window_start_ms, window_stop_ms) =>
+            await new Promise((resolve, reject) => {
+              let params = {
+                symbol: pre_process_pair(pair),
+                startTime: window_start_ms,
+                endTime: window_stop_ms - 1,
+                limit: 1000,
+                timestamp: parseInt(Date.now()),
+              }
+              let query = qs.stringify(params)
+              let sign = get_signature_bitrue(secret_key, query)
+              let url = 'https://openapi.bitrue.com/api/v2/myTrades?' + query + `&signature=${sign}`
+              needle.get(url, options, (err, res, body) => {
+                let parsed_body = typeof body === 'string' ? JSONbig.parse(body) : body
+                if (parsed_body && Array.isArray(parsed_body)) {
+                  resolve(
+                    parsed_body.map((trade) => ({
+                      order_id: trade.orderId != null ? trade.orderId.toString() : '',
+                      pair,
+                      type: trade.isBuyer ? 'buy' : 'sell',
+                      price: parseFloat(trade.price),
+                      amount: parseFloat(trade.qty),
+                      total: parseFloat(trade.price) * parseFloat(trade.qty),
+                      close_time: new Date(trade.time),
+                      fees: {
+                        [post_process_cur(trade.commissionAsset)]: parseFloat(trade.commission),
+                      },
+                      role: trade.isMaker ? 'maker' : 'taker',
+                    })),
+                  )
+                } else if (parsed_body) {
+                  reject({ error: error_codes.other, body: parsed_body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            }),
+        })
+        cb({ success: true, body: sort_history_rows(rows) })
+      })().catch((error) => {
+        cb({ success: false, error: error?.error || error_codes.other, body: error?.body })
+      })
+    }
+    this.private_limiter.process(get_history_trades_base, pair, start_time_in_ms, end_time_in_ms, cb)
+  }
   get_deposits(cur, timeframe_in_ms, cb) {
     let get_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key

package/lib/exchanges/bitstamp.js

@@ -370,6 +370,77 @@ module.exports = class Bitstamp extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { filter_history_in_range, sort_history_rows, sleep } = ExchangeBase.history_utils
+    let [base_cur, quote_cur] = utils.parse_pair(pair)
+    let base_key = base_cur.toLowerCase()
+    let quote_key = quote_cur.toLowerCase()
+    let price_key = base_key + '_' + quote_key
+    let parse_trade_time = (datetime) => {
+      let iso = datetime.replace(' ', 'T').replace(/(\.\d{3})\d+$/, '$1')
+      return new Date(iso + 'Z')
+    }
+    let fetch_page = (offset) =>
+      new Promise((resolve, reject) => {
+        let url = 'https://www.bitstamp.net/api/v2/user_transactions/' + pre_process_pair(pair) + '/'
+        let params = {
+          key: api_key,
+          nonce: Date.now(),
+          signature: get_signature_bitstamp(api_key, secret_key, this.account_id),
+          limit: 1000,
+          offset,
+          sort: 'desc',
+        }
+        needle.post(url, params, (err, res, body) => {
+          if (Array.isArray(body)) {
+            resolve(body)
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = []
+      let offset = 0
+      while (offset <= 200000) {
+        let rows = await fetch_page(offset)
+        if (rows.length === 0) break
+        trades.push(
+          ...rows
+            .filter((trade) => String(trade.type) === '2')
+            .map((trade) => {
+              let close_time = parse_trade_time(trade.datetime)
+              let price = parseFloat(trade[price_key])
+              let amount = Math.abs(parseFloat(trade[base_key]))
+              let total = Math.abs(parseFloat(trade[quote_key]))
+              return {
+                order_id: trade.order_id != null ? trade.order_id.toString() : '',
+                trade_id: (trade.id || trade.tid || '').toString(),
+                pair,
+                type: parseFloat(trade[base_key]) < 0 ? 'sell' : 'buy',
+                price,
+                amount,
+                total: Number.isFinite(total) ? total : price * amount,
+                close_time,
+              }
+            })
+        )
+        let oldest_seen_ms = Math.min(
+          ...rows
+            .map((trade) => parse_trade_time(trade.datetime).getTime())
+            .filter((time) => Number.isFinite(time))
+        )
+        if (rows.length < 1000 || (Number.isFinite(oldest_seen_ms) && oldest_seen_ms < start_time_in_ms)) break
+        offset += rows.length
+        await sleep(250)
+      }
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   static get_min_amount(cb) {
     let min_quote_cur_amount = {}
     needle.get('https://www.bitstamp.net/api/v2/trading-pairs-info/', (err, res, body) => {

package/lib/exchanges/blofin.js

@@ -150,9 +150,10 @@ module.exports = class Blofin extends ExchangeBase {
           }),
         )
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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)
@@ -168,7 +169,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() }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
               {
                 const _asks = this.ws.market.asks_dict[pair].entries()
                 const _bids = this.ws.market.bids_dict[pair].entries()
@@ -197,7 +198,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() }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
                 {
                   const _asks = this.ws.market.asks_dict[pair].entries()
                   const _bids = this.ws.market.bids_dict[pair].entries()
@@ -583,6 +584,78 @@ module.exports = class Blofin extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let [base_cur, quote_cur] = utils.parse_pair(pair)
+    let path = '/api/v1/spot/trade/fills-history'
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          instType: 'SPOT',
+          instId: pre_process_pair(pair),
+          begin: window_start_ms.toString(),
+          end: (window_stop_ms - 1).toString(),
+          limit: '100',
+        }
+        let query = qs.stringify(params)
+        let request_path = path + '?' + query
+        let timestamp = Date.now()
+        let nonce = generate_nonce()
+        let signature = get_signature_blofin(secret_key, 'GET', timestamp, request_path, nonce)
+        let options = get_options(api_key, signature, timestamp, nonce, this.passphrase)
+        let url = 'https://openapi.blofin.com' + request_path
+        needle.get(url, options, (err, res, body) => {
+          if (body && _.includes(['0', 0, 200], body.code) && Array.isArray(body.data)) {
+            resolve(
+              body.data.map((trade) => {
+                let price = parseFloat(trade.fillPrice || trade.trade_price)
+                let amount = parseFloat(trade.fillSize || trade.trade_quantity)
+                let total = price * amount
+                let fee = Math.abs(parseFloat(trade.fee || trade.trade_fee))
+                let fee_currency = trade.feeCurrency || trade.fee_currency
+                if (fee_currency === 'base_currency') fee_currency = base_cur
+                if (fee_currency === 'quote_currency') fee_currency = quote_cur
+                let mapped_trade = {
+                  order_id: (trade.orderId || trade.order_id || '').toString(),
+                  trade_id: (trade.tradeId || trade.trade_id || '').toString(),
+                  pair,
+                  type: (trade.side || trade.order_side || '').toLowerCase(),
+                  price,
+                  amount,
+                  total,
+                  close_time: new Date(parseInt(trade.ts || trade.create_time)),
+                }
+                if (Number.isFinite(fee) && fee_currency) {
+                  mapped_trade.fees = {
+                    [post_process_cur(fee_currency)]: fee,
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body && body.toString().startsWith('<html>')) {
+            reject({ success: false, error: error_codes.service_unavailable, body })
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 30 * 24 * 60 * 60 * 1000,
+        page_limit: 100,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   get_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key

package/lib/exchanges/btse.js

@@ -96,11 +96,12 @@ module.exports = class Btse extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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()
@@ -132,7 +133,7 @@ module.exports = class Btse extends ExchangeBase {
                   }
                 }
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
               {
                 const _asks = this.ws.market.asks_dict[pair].entries()
                 const _bids = this.ws.market.bids_dict[pair].entries()
@@ -488,6 +489,9 @@ module.exports = class Btse extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    this._get_history_trades_via_timeframe(pair, start_time_in_ms, end_time_in_ms, cb)
+  }
   get_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key

package/lib/exchanges/bybit.js

@@ -90,9 +90,10 @@ module.exports = class Bybit extends ExchangeBase {
         })
         this.ws.market.ping(JSON.stringify({ op: 'ping' }))
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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 {
@@ -131,7 +132,7 @@ module.exports = class Bybit extends ExchangeBase {
                   }
                 }
               }
-              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
               // 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

@@ -7,6 +7,7 @@ const needle = require('needle')
 
 const ExchangeWs = require('./exchange-ws.js')
 const ExchangeBase = require('./exchange-base.js')
+const { filter_history_in_range, history_time_ms, sleep, sort_history_rows } = ExchangeBase.history_utils
 
 const { sorted_book } = require('@icgio/icg-utils')
 
@@ -218,13 +219,14 @@ module.exports = class Coinbase extends ExchangeBase {
         }))
         console.log('coinbase ws-direct: subscribed channels:', channels.join(', '))
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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
@@ -251,7 +253,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() }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: Date.now(), t_recv, t_parsed }
           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) {
@@ -282,7 +284,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() }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parse_event_ts_ms(data.time) || Date.now(), t_recv, t_parsed }
           {
             const top_bid = this.ws.market.bids_dict[pair].top()
             const top_ask = this.ws.market.asks_dict[pair].top()
@@ -305,7 +307,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() }
+            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.pair_status[pair] = 'opened'
           } else {
             const bids = this.ws.market.bids_dict[pair]
@@ -322,7 +324,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() }
+            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.bbo_observable.notify()
         } else if (data.type === 'match' || data.type === 'last_match') {
@@ -405,13 +407,14 @@ 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) => {
+      this.ws.market.on_message((data, t_recv) => {
         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
@@ -485,6 +488,7 @@ 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()
@@ -531,7 +535,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() }
+                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.pair_status[pair] = 'opened'
               } else {
                 const bids = this.ws.market.bids_dict[pair]
@@ -549,7 +553,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() }
+                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.bbo_observable.notify()
             }
@@ -1572,6 +1576,107 @@ module.exports = class Coinbase extends ExchangeBase {
       cb({ success: true, body: [] })
     }
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    const get_history_trades_base = async (pair, start_time_in_ms, end_time_in_ms, cb) => {
+      try {
+        const results = []
+        if (this.advanced) {
+          let cursor = null
+          while (true) {
+            let path = '/api/v3/brokerage/orders/historical/fills'
+            let params = { product_id: pre_process_pair(pair) }
+            if (cursor) params.cursor = cursor
+            let options = this._get_auth('GET', path, params)
+            let url = this._base_url() + path + '?' + qs.stringify(params)
+            const response = await new Promise((resolve, reject) => {
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body.fills)) {
+                  resolve(body)
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            })
+            if (response.fills.length === 0) break
+            let oldest_ms = Infinity
+            for (const fill of response.fills) {
+              const close_time_ms = history_time_ms(fill.trade_time)
+              if (close_time_ms < oldest_ms) oldest_ms = close_time_ms
+              if (close_time_ms < start_time_in_ms || close_time_ms >= end_time_in_ms) continue
+              let quote_cur = (fill.product_id || '').split('-')[1] || ''
+              let trade = {
+                order_id: fill.order_id != null ? fill.order_id.toString() : '',
+                pair,
+                type: String(fill.side || '').toLowerCase(),
+                price: parseFloat(fill.price),
+                amount: parseFloat(fill.size),
+                total: parseFloat(fill.price) * parseFloat(fill.size),
+                close_time: new Date(close_time_ms),
+                fees: quote_cur && fill.commission != null ? { [post_process_cur(quote_cur)]: parseFloat(fill.commission) } : {},
+                role: fill.liquidity_indicator === 'MAKER' ? 'maker' : 'taker',
+              }
+              if (fill.trade_id != null) trade.trade_id = fill.trade_id.toString()
+              else if (fill.entry_id != null) trade.trade_id = fill.entry_id.toString()
+              results.push(trade)
+            }
+            if (!response.has_next || !response.cursor || oldest_ms < start_time_in_ms) break
+            cursor = response.cursor
+            await sleep(50)
+          }
+        } else {
+          let after = null
+          while (true) {
+            let path = '/fills'
+            let params = { product_id: pre_process_pair(pair) }
+            if (after) params.after = after
+            let options = this._get_auth('GET', path, params)
+            let url = this._base_url() + path + '?' + qs.stringify(params)
+            const response = await new Promise((resolve, reject) => {
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body)) {
+                  resolve({ res, body })
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            })
+            if (response.body.length === 0) break
+            let oldest_ms = Infinity
+            for (const fill of response.body) {
+              const close_time_ms = history_time_ms(fill.created_at)
+              if (close_time_ms < oldest_ms) oldest_ms = close_time_ms
+              if (close_time_ms < start_time_in_ms || close_time_ms >= end_time_in_ms) continue
+              let trade = {
+                order_id: fill.order_id != null ? fill.order_id.toString() : '',
+                pair,
+                type: String(fill.side || '').toLowerCase(),
+                price: parseFloat(fill.price),
+                amount: parseFloat(fill.size),
+                total: parseFloat(fill.price) * parseFloat(fill.size),
+                close_time: new Date(close_time_ms),
+                fees: fill.funding_currency && fill.fee != null ? { [post_process_cur(fill.funding_currency)]: parseFloat(fill.fee) } : {},
+                role: fill.liquidity === 'M' ? 'maker' : 'taker',
+              }
+              if (fill.trade_id != null) trade.trade_id = fill.trade_id.toString()
+              results.push(trade)
+            }
+            const next_after = response.res?.headers?.['cb-after']
+            if (!next_after || oldest_ms < start_time_in_ms) break
+            after = next_after
+            await sleep(50)
+          }
+        }
+        cb({ success: true, body: sort_history_rows(filter_history_in_range(results, start_time_in_ms, end_time_in_ms)) })
+      } catch (error) {
+        cb({ success: false, error: error?.error || error_codes.other, body: error?.body })
+      }
+    }
+    this.private_limiter.process(get_history_trades_base, pair, start_time_in_ms, end_time_in_ms, cb)
+  }
   _convert(from_cur, to_cur, amount, cb) {
     if (this.advanced) {
       cb({ success: false, error: error_codes.other, body: { message: 'Convert not supported on Advanced API' } })

package/lib/exchanges/coinstore.js

@@ -135,14 +135,15 @@ module.exports = class Coinstore extends ExchangeBase {
           false,
         )
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         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() }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
             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) {
@@ -476,6 +477,9 @@ module.exports = class Coinstore extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    this._get_history_trades_via_timeframe(pair, start_time_in_ms, end_time_in_ms, cb)
+  }
   static get_precision(cb) {
     const price_precision = {}
     const amount_precision = {}