@icgio/icg-exchanges 1.40.42 → 1.40.43

package/lib/exchanges/hashkeyglobal.js

@@ -44,6 +44,15 @@ function get_options(api_key) {
   return options
 }
 
+function get_trade_fees_hashkey(trade) {
+  let fee_coin = trade.commissionAsset || trade.feeCoinId || _.get(trade, 'fee.feeCoinName')
+  let fee = parseFloat(trade.commission ?? trade.feeAmount ?? _.get(trade, 'fee.fee'))
+  if (!fee_coin || !Number.isFinite(fee)) return {}
+  return {
+    [post_process_cur(fee_coin)]: Math.abs(fee),
+  }
+}
+
 module.exports = class Hashkeyglobal extends ExchangeBase {
   constructor(api_key, secret_key, settings) {
     super('hashkey', settings.id, api_key, secret_key)
@@ -101,8 +110,9 @@ module.exports = class Hashkeyglobal extends ExchangeBase {
         })
         this.ws.market.ping('ping')
       })
-      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.pong) {
           this.ws.market.last_pong = new Date()
         } else {
@@ -112,7 +122,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() }
+            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) {
@@ -455,6 +465,64 @@ module.exports = class Hashkeyglobal 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 path = '/api/v1/account/trades'
+    let options = get_options(api_key)
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          symbol: pre_process_pair(pair),
+          startTime: window_start_ms,
+          endTime: window_stop_ms - 1,
+          limit: 1000,
+          timestamp: Date.now(),
+        }
+        params.signature = get_signature_hashkey(params, secret_key)
+        let url = base_url + path + '?' + qs.stringify(params)
+        this.private_limiter.process(needle.get, url, options, (err, res, body) => {
+          if (Array.isArray(body)) {
+            resolve(
+              body.map((trade) => {
+                let price = parseFloat(trade.price)
+                let amount = parseFloat(trade.qty)
+                let mapped_trade = {
+                  order_id: (trade.orderId || '').toString(),
+                  trade_id: (trade.id || trade.tradeId || '').toString(),
+                  pair: post_process_pair(trade.symbol),
+                  type: trade.isBuyer ? 'buy' : 'sell',
+                  price,
+                  amount,
+                  total: Number.isFinite(parseFloat(trade.quoteQty)) ? parseFloat(trade.quoteQty) : price * amount,
+                  close_time: new Date(parseInt(trade.time)),
+                  role: trade.isMaker ? 'maker' : 'taker',
+                }
+                let fees = get_trade_fees_hashkey(trade)
+                if (_.keys(fees).length > 0) mapped_trade.fees = fees
+                return mapped_trade
+              })
+            )
+          } 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: 24 * 60 * 60 * 1000,
+        page_limit: 1000,
+        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 [api_key, secret_key] = this.api_secret_key
     let params = {

package/lib/exchanges/hitbtc.js

@@ -80,8 +80,9 @@ module.exports = class Hitbtc extends ExchangeBase {
           }
         }
       })
-      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.method === 'snapshotOrderbook') {
           let pair = post_process_pair(data.params.symbol)
           this.ws.market.pair_status[pair] = 'opened'

package/lib/exchanges/hkbitex.js

@@ -142,11 +142,12 @@ module.exports = class Hkbitex extends ExchangeBase {
         }, 60 * 1000)
         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.data && data.data.e === 8) {
             let book = data.data
             let pair = post_process_pair(book.s)
@@ -157,7 +158,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() }
+            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) {
@@ -556,6 +557,9 @@ module.exports = class Hkbitex 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) {
     let price_precision = {},
       amount_precision = {}

package/lib/exchanges/htx.js

@@ -8,6 +8,7 @@ const pako = require('pako')
 const ExchangeWs = require('./exchange-ws.js')
 
 const ExchangeBase = require('./exchange-base.js')
+const { fetch_split_windows, sort_history_rows, stringify_sorted } = ExchangeBase.history_utils
 
 const { error_codes } = require('../error_codes.json')
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
@@ -119,12 +120,13 @@ 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) => {
+      this.ws.market.on_message((data, t_recv) => {
         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 }
+          this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
           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)) {
@@ -139,7 +141,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 }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: data.ts, t_recv, t_parsed }
             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])) {
@@ -539,6 +541,79 @@ module.exports = class Htx 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) => {
+      const account_id = this.account_id
+      if (!account_id) {
+        cb({ success: false, error: error_codes.other, body: { message: 'htx account_id missing' } })
+        return
+      }
+      const [api_key, secret_key] = this.api_secret_key
+      ;(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 base_url = 'api.huobi.pro'
+              let path = '/v1/order/matchresults'
+              let params = {
+                AccessKeyId: api_key,
+                SignatureMethod: 'HmacSHA256',
+                SignatureVersion: 2,
+                Timestamp: new Date().toISOString().slice(0, 19),
+                'account-id': account_id,
+                'start-time': window_start_ms,
+                'end-time': window_stop_ms - 1,
+                size: 1000,
+                symbol: pre_process_pair(pair),
+              }
+              const signature = crypto.createHmac('sha256', secret_key).update(`GET\n${base_url}\n${path}\n${stringify_sorted(params)}`).digest('base64')
+              params.Signature = signature
+              let url = 'https://' + base_url + path + '?' + stringify_sorted(params)
+              needle.get(url, (err, res, body) => {
+                if (body && Array.isArray(body.data)) {
+                  resolve(
+                    body.data.map((trade) => {
+                      let result = {
+                        order_id: trade['order-id'] != null ? trade['order-id'].toString() : '',
+                        pair: post_process_pair(trade.symbol),
+                        type: String(trade.type || '').startsWith('buy') ? 'buy' : 'sell',
+                        price: parseFloat(trade.price),
+                        amount: parseFloat(trade['filled-amount']),
+                        total: parseFloat(trade['filled-amount']) * parseFloat(trade.price),
+                        close_time: new Date(trade['created-at']),
+                        fees: {
+                          [post_process_cur(trade['fee-currency'])]: parseFloat(trade['filled-fees']),
+                        },
+                        role: String(trade.role || '').toLowerCase(),
+                      }
+                      let trade_id = trade['match-id'] || trade['trade-id'] || trade.id
+                      if (trade_id != null) result.trade_id = trade_id.toString()
+                      return result
+                    }),
+                  )
+                } else if (body && body.status === 'error' && body['err-code'] === 'api-signature-not-valid') {
+                  reject({ error: error_codes.invalid_key, body })
+                } else if (body && body.toString().startsWith('<html>')) {
+                  reject({ error: error_codes.service_unavailable, body })
+                } else if (body) {
+                  reject({ error: error_codes.other, 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_all_trades(timeframe_in_ms, cb) {
   //   let get_all_trades_base = (timeframe_in_ms, cb) => {
   //     let base_url = 'api.huobi.pro'

package/lib/exchanges/indodax.js

@@ -391,6 +391,9 @@ module.exports = class Indodax extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, 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_min_amount(cb) {
     let min_quote_cur_amount = {}
     needle.get('https://indodax.com/api/pairs', (err, res, body) => {

package/lib/exchanges/kraken.js

@@ -333,6 +333,69 @@ module.exports = class Kraken extends ExchangeBase {
       }
     })
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let api_secret_key = this.api_secret_key
+    let { filter_history_in_range, sort_history_rows, sleep } = ExchangeBase.history_utils
+    let path = '/0/private/TradesHistory'
+    let fetch_page = (ofs) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          nonce: Date.now() + ofs,
+          start: Math.floor(start_time_in_ms / 1000),
+          end: Math.floor((end_time_in_ms - 1) / 1000),
+          ofs,
+        }
+        let options = get_options(path, params, api_secret_key, params.nonce)
+        this.private_limiter.process(needle.post, 'https://api.kraken.com' + path, params, options, (err, res, body) => {
+          if (body && body.result && body.result.trades) {
+            let trades = []
+            for (let trade_id in body.result.trades) {
+              let trade = body.result.trades[trade_id]
+              let pair = post_process_pair(trade.pair)
+              let [, quote_cur] = utils.parse_pair(pair)
+              let mapped_trade = {
+                order_id: trade.ordertxid.toString(),
+                trade_id: (trade.trade_id || trade_id || trade.postxid).toString(),
+                pair,
+                type: trade.type,
+                price: parseFloat(trade.price),
+                amount: parseFloat(trade.vol),
+                total: parseFloat(trade.cost),
+                close_time: new Date(parseFloat(trade.time) * 1000),
+              }
+              if (trade.maker !== undefined) mapped_trade.role = trade.maker ? 'maker' : 'taker'
+              if (trade.fee !== undefined) {
+                mapped_trade.fees = {
+                  [quote_cur]: parseFloat(trade.fee),
+                }
+              }
+              trades.push({
+                ...mapped_trade,
+              })
+            }
+            resolve({ trades, count: parseInt(body.result.count || trades.length) })
+          } 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 (true) {
+        let page = await fetch_page(offset)
+        trades.push(...page.trades)
+        offset += page.trades.length
+        if (page.trades.length === 0 || offset >= page.count) break
+        await sleep(250)
+      }
+      trades = trades.filter((trade) => trade.pair === pair)
+      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/kucoin.js

@@ -121,8 +121,9 @@ module.exports = class Kucoin extends ExchangeBase {
               type: 'ping',
             }),
           )
-          this.ws.market.on_message((data) => {
+          this.ws.market.on_message((data, t_recv) => {
             data = JSON.parse(data)
+            const t_parsed = process.hrtime()
             let book = data.data
             if (data.type === 'pong') {
               this.ws.market.last_pong = new Date()
@@ -132,7 +133,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 }
+              this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
             } 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])
@@ -148,7 +149,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 }
+                this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: book.timestamp, t_recv, t_parsed }
                 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

@@ -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, sleep, sort_history_rows, split_windows } = ExchangeBase.history_utils
 
 const { error_codes } = require('../error_codes.json')
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
@@ -69,11 +70,29 @@ const uuid38 = () => uuid16() + uuid22()
 function get_signature_lbank(secret_key, request, timestamp, echostr) {
   request = _.extend(request, { timestamp, echostr, signature_method: 'HmacSHA256' })
   request = _.fromPairs(_.sortBy(_.toPairs(request), [0]))
-  let message = qs.stringify(request)
+  let message = qs.stringify(request, { encode: false })
   message = crypto.createHash('md5').update(message).digest('hex').toUpperCase()
   return crypto.createHmac('sha256', secret_key).update(message).digest('hex')
 }
 
+function format_history_time_utc8(ms) {
+  const date = new Date(ms + 8 * 60 * 60 * 1000)
+  const pad = (value) => String(value).padStart(2, '0')
+  return (
+    date.getUTCFullYear() +
+    '-' +
+    pad(date.getUTCMonth() + 1) +
+    '-' +
+    pad(date.getUTCDate()) +
+    ' ' +
+    pad(date.getUTCHours()) +
+    ':' +
+    pad(date.getUTCMinutes()) +
+    ':' +
+    pad(date.getUTCSeconds())
+  )
+}
+
 function parse_lbank_ws_timestamp(value) {
   if (value instanceof Date) return value
   if (typeof value === 'number') return new Date(value)
@@ -138,8 +157,9 @@ module.exports = class Lbank extends ExchangeBase {
         })
         this.ws.market.ping(JSON.stringify({ action: 'ping', ping: 'keepalive' }))
       })
-      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.action === 'ping') {
           this.ws.market.send(
             JSON.stringify({
@@ -162,7 +182,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() }
+          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) {
@@ -580,61 +600,77 @@ module.exports = class Lbank 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
-    const PAGE_SIZE = 100
-    let all_results = []
-
-    const fetch_page = (page_start) => {
-      let timestamp = new Date().getTime().toString()
-      let echostr = uuid38()
-      let params = {
-        api_key: api_key,
-        direct: 'next',
-        endTime: end_time_in_ms.toString(),
-        size: PAGE_SIZE,
-        startTime: page_start.toString(),
-        symbol: pre_process_pair(pair),
-      }
-      params.sign = get_signature_lbank(secret_key, params, timestamp, echostr)
-      let options = get_options(timestamp, echostr)
-      needle.post('https://api.lbank.info/v2/transaction_history.do', params, options, (err, res, body) => {
-        body = parse_body(body)
-        if (body && body.result && body.error_code === 0 && !body.data) {
-          cb({ success: true, body: all_results })
-        } else if (body && body.result && Array.isArray(body.data)) {
-          let result = body.data.map((order) => {
-            return {
-              order_id: order.orderUuid.toString(),
-              pair,
-              type: order.tradeType,
-              price: parseFloat(order.dealPrice),
-              amount: parseFloat(order.dealQuantity),
-              total: parseFloat(order.dealVolumePrice),
-              close_time: new Date(order.dealTime),
-              fees: {
-                [order.tradeType === 'buy' ? pair_to_base_cur(pair) : pair_to_quote_cur(pair)]: parseFloat(order.tradeFee),
-              },
-            }
-          })
-          all_results = all_results.concat(result)
-          // direct=next returns oldest first — advance startTime past the newest to get next page
-          if (result.length >= PAGE_SIZE) {
-            const newest_time = Math.max(...result.map(t => t.close_time.getTime()))
-            if (newest_time > page_start && newest_time < end_time_in_ms) {
-              fetch_page(newest_time + 1)
-              return
+    const get_history_trades_base = (pair, start_time_in_ms, end_time_in_ms, cb) => {
+      let [api_key, secret_key] = this.api_secret_key
+      ;(async () => {
+        const rows = []
+        const max_window_ms = 2 * 24 * 60 * 60 * 1000
+        const windows = split_windows(start_time_in_ms, end_time_in_ms, Math.min(max_window_ms, end_time_in_ms - start_time_in_ms))
+        for (const [window_start_ms, window_stop_ms] of windows) {
+          let last_trade_id = null
+          while (true) {
+            const raw_items = await new Promise((resolve, reject) => {
+              let timestamp = new Date().getTime().toString()
+              let echostr = uuid38()
+              let params = {
+                api_key: api_key,
+                endTime: format_history_time_utc8(window_stop_ms),
+                limit: '100',
+                startTime: format_history_time_utc8(window_start_ms),
+                symbol: pre_process_pair(pair),
+              }
+              if (last_trade_id) params.fromId = last_trade_id
+              params.sign = get_signature_lbank(secret_key, params, timestamp, echostr)
+              let options = get_options(timestamp, echostr)
+              needle.post('https://api.lbank.info/v2/supplement/transaction_history.do', params, options, (err, res, body) => {
+                body = parse_body(body)
+                if (body && body.result && body.error_code === 0 && !body.data) {
+                  resolve([])
+                } else if (body && body.result && Array.isArray(body.data)) {
+                  resolve(
+                    body.data.map((trade) => {
+                      let result = {
+                        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.quoteQty),
+                        close_time: new Date(trade.time),
+                        fees: {
+                          [trade.isBuyer ? pair_to_base_cur(pair) : pair_to_quote_cur(pair)]: parseFloat(trade.commission),
+                        },
+                        role: trade.isMaker ? 'maker' : 'taker',
+                      }
+                      if (trade.id != null) result.trade_id = trade.id.toString()
+                      return result
+                    }),
+                  )
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            })
+            if (raw_items.length === 0) break
+            let items = raw_items
+            if (last_trade_id && items[0] && items[0].trade_id === last_trade_id) {
+              items = items.slice(1)
             }
+            if (items.length === 0) break
+            rows.push(...items)
+            last_trade_id = raw_items[raw_items.length - 1]?.trade_id || null
+            if (raw_items.length < 100 || !last_trade_id) break
+            await sleep(50)
           }
-          cb({ success: true, body: all_results })
-        } else if (body) {
-          cb({ success: false, error: error_codes.other, body })
-        } else {
-          cb({ success: false, error: error_codes.timeout })
         }
+        cb({ success: true, body: sort_history_rows(filter_history_in_range(rows, 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(fetch_page, start_time_in_ms)
+    this.private_limiter.process(get_history_trades_base, pair, start_time_in_ms, end_time_in_ms, cb)
   }
   get_all_deposits(timeframe_in_ms, cb) {
     const get_all_deposits_base = (timeframe_in_ms, cb) => {

package/lib/exchanges/mexc.js

@@ -7,6 +7,7 @@ const needle = require('needle')
 
 const ExchangeBase = require('./exchange-base.js')
 const ExchangeWs = require('./exchange-ws.js')
+const { fetch_split_windows, sort_history_rows } = ExchangeBase.history_utils
 
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
 
@@ -130,7 +131,7 @@ module.exports = class Mexc extends ExchangeBase {
           return false
         }
       }
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         if (is_json(data)) {
           try {
             const json = JSON.parse(data.toString())
@@ -151,6 +152,7 @@ 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@')) {
@@ -158,7 +160,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 }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), event_ts: parseInt(obj.sendTime) || undefined, t_recv, t_parsed }
             // 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] = {
@@ -515,6 +517,63 @@ module.exports = class Mexc 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)
+      ;(async () => {
+        const rows = await fetch_split_windows({
+          start_ms: start_time_in_ms,
+          stop_ms: end_time_in_ms,
+          initial_window_ms: Math.max(end_time_in_ms - start_time_in_ms, 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 signature = get_signature_mexc(secret_key, params)
+              let url = 'https://api.mexc.com/api/v3/myTrades?' + qs.stringify(params) + '&signature=' + signature
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body)) {
+                  resolve(
+                    body.map((trade) => {
+                      let result = {
+                        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.quoteQty),
+                        close_time: new Date(parseInt(trade.time)),
+                        fees: {
+                          [post_process_cur(trade.commissionAsset)]: parseFloat(trade.commission),
+                        },
+                        role: trade.isMaker ? 'maker' : 'taker',
+                      }
+                      if (trade.id != null) result.trade_id = trade.id.toString()
+                      return result
+                    }),
+                  )
+                } else if (body) {
+                  reject({ error: error_codes.other, 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_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key