@icgio/icg-exchanges 1.40.41 → 1.40.43

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 = {}

package/lib/exchanges/cryptocom.js

@@ -109,7 +109,7 @@ module.exports = class Cryptocom extends ExchangeBase {
           )
         }
       })
-      this.ws.market.on_message((data) => {
+      this.ws.market.on_message((data, t_recv) => {
         let parsed
         try {
           parsed = JSON.parse(data)
@@ -125,12 +125,13 @@ 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() }
+            this.ws.market.ts_dict[pair] = { received_ts: Date.now(), t_recv, t_parsed }
             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])])
@@ -493,6 +494,72 @@ module.exports = class Cryptocom extends ExchangeBase {
       }
     })
   }
+  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 fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let req = {
+          id: 11,
+          method: 'private/get-trades',
+          params: {
+            instrument_name: pre_process_pair(pair),
+            start_time: window_start_ms,
+            end_time: window_stop_ms - 1,
+            limit: 100,
+          },
+          api_key: api_key,
+          nonce: Date.now(),
+        }
+        req.sig = get_signature_crypto(req, secret_key)
+        needle.post('https://api.crypto.com/v2/private/get-trades', req, options, (err, res, body) => {
+          body = parse_body(body)
+          let rows = body?.result?.data || body?.result?.trade_list
+          if (body && body.code === 0 && Array.isArray(rows)) {
+            resolve(
+              rows.map((trade) => {
+                let price = parseFloat(trade.traded_price)
+                let amount = parseFloat(trade.traded_quantity)
+                let fee = Math.abs(parseFloat(trade.fees || trade.fee))
+                let mapped_trade = {
+                  order_id: (trade.order_id || '').toString(),
+                  trade_id: (trade.trade_id || trade.trade_match_id || '').toString(),
+                  pair,
+                  type: (trade.side || '').toLowerCase(),
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.create_time)),
+                }
+                if (trade.taker_side) mapped_trade.role = trade.taker_side.toLowerCase()
+                if (Number.isFinite(fee) && trade.fee_instrument_name) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.fee_instrument_name)]: fee,
+                  }
+                }
+                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: 7 * 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 [api_key, secret_key] = this.api_secret_key
     let req = {

package/lib/exchanges/deepcoin.js

@@ -467,6 +467,70 @@ module.exports = class Deepcoin extends ExchangeBase {
     }
     this.private_limiter.process(get_all_trades_base, timeframe_in_ms, cb, 2)
   }
+  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 = '/deepcoin/trade/fills'
+    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,
+          end: window_stop_ms - 1,
+          limit: 100,
+        }
+        let query = qs.stringify(params)
+        let options = get_options(api_key, secret_key, this.passphrase, 'GET', path + '?' + query, '')
+        needle.get(base_url + path + '?' + query, options, (err, res, body) => {
+          body = parse_body(body)
+          if (body && body.code === '0' && Array.isArray(body.data)) {
+            resolve(
+              body.data.map((trade) => {
+                let price = parseFloat(trade.fillPx)
+                let amount = parseFloat(trade.fillSz)
+                let mapped_trade = {
+                  order_id: (trade.ordId || '').toString(),
+                  trade_id: (trade.tradeId || trade.billId || '').toString(),
+                  pair: post_process_pair(trade.instId),
+                  type: trade.side,
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.ts)),
+                }
+                if (trade.execType === 'M') mapped_trade.role = 'maker'
+                if (trade.execType === 'T') mapped_trade.role = 'taker'
+                if (trade.feeCcy && Number.isFinite(parseFloat(trade.fee))) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.feeCcy)]: Math.abs(parseFloat(trade.fee)),
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body && (body.code === '50026' || body.code === '50001')) {
+            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))
+  }
   static get_min_amount(cb) {
     let min_quote_cur_amount = {}
     needle.get('https://api.deepcoin.com/deepcoin/market/instruments?instType=SPOT', (err, res, body) => {

package/lib/exchanges/digifinex.js

@@ -381,6 +381,68 @@ module.exports = class Digifinex 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 fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          symbol: pre_process_pair(pair),
+          limit: 500,
+          start_time: Math.floor(window_start_ms / 1000),
+          end_time: Math.floor((window_stop_ms - 1) / 1000),
+        }
+        let signature = get_signature_digifinex(secret_key, params)
+        let options = get_options(api_key, signature)
+        let url = 'https://openapi.digifinex.com/v3/spot/mytrades?' + qs.stringify(params)
+        needle.get(url, options, (err, res, body) => {
+          if (body && body.code === 0 && Array.isArray(body.list)) {
+            resolve(
+              body.list.map((trade) => {
+                let price = parseFloat(trade.price)
+                let amount = parseFloat(trade.amount)
+                let is_maker = trade.is_maker === true || trade.is_maker === 1 || trade.is_maker === '1' || trade.is_maker === 'true'
+                let mapped_trade = {
+                  order_id: (trade.order_id || '').toString(),
+                  trade_id: (trade.id || trade.tid || '').toString(),
+                  pair,
+                  type: (trade.side || '').split('_')[0],
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.timestamp) * 1000),
+                  role: is_maker ? 'maker' : 'taker',
+                }
+                if (trade.fee_currency && Number.isFinite(parseFloat(trade.fee))) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.fee_currency)]: Math.abs(parseFloat(trade.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: 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))
+  }
   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/exchange-base.js

@@ -1,5 +1,6 @@
 const _ = require('lodash')
 const { randomUUID: uuid } = require('crypto')
+const qs = require('qs')
 
 function trim_orderbook_body(body, depth = 1) {
   if (!body || typeof body !== 'object') return body
@@ -18,6 +19,101 @@ function trim_orderbook_response(res, depth = 1) {
   return { ...res, body: trim_orderbook_body(res.body, depth) }
 }
 
+const DEFAULT_HISTORY_MIN_WINDOW_MS = 60 * 1000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function history_time_ms(value) {
+  if (value instanceof Date) return value.getTime()
+  if (typeof value === 'number') return value
+  if (typeof value === 'string' && /^\d+$/.test(value)) return parseInt(value, 10)
+  const parsed = new Date(value).getTime()
+  return Number.isFinite(parsed) ? parsed : NaN
+}
+
+function history_row_ts(row) {
+  return history_time_ms(row?.close_time || row?.open_time || row?.event_time || row?.time)
+}
+
+function filter_history_in_range(rows, start_ms, stop_ms) {
+  return (rows || []).filter((row) => {
+    const ts = history_row_ts(row)
+    return Number.isFinite(ts) && ts >= start_ms && ts < stop_ms
+  })
+}
+
+function sort_history_rows(rows) {
+  return (rows || []).slice().sort((left, right) => {
+    const left_ts = history_row_ts(left)
+    const right_ts = history_row_ts(right)
+    if (left_ts !== right_ts) return left_ts - right_ts
+    const left_trade_id = left?.trade_id != null ? String(left.trade_id) : ''
+    const right_trade_id = right?.trade_id != null ? String(right.trade_id) : ''
+    if (left_trade_id !== right_trade_id) return left_trade_id.localeCompare(right_trade_id)
+    const left_order_id = left?.order_id != null ? String(left.order_id) : ''
+    const right_order_id = right?.order_id != null ? String(right.order_id) : ''
+    return left_order_id.localeCompare(right_order_id)
+  })
+}
+
+function split_windows(start_ms, stop_ms, window_ms) {
+  const windows = []
+  for (let cursor = start_ms; cursor < stop_ms; cursor += window_ms) {
+    windows.push([cursor, Math.min(cursor + window_ms, stop_ms)])
+  }
+  return windows
+}
+
+async function fetch_split_windows({ start_ms, stop_ms, initial_window_ms, min_window_ms = DEFAULT_HISTORY_MIN_WINDOW_MS, page_limit, fetch_window, delay_ms = 0 }) {
+  async function fetch_recursive(window_start_ms, window_stop_ms) {
+    const rows = await fetch_window(window_start_ms, window_stop_ms)
+    if (rows.length >= page_limit && window_stop_ms - window_start_ms > min_window_ms) {
+      const midpoint = window_start_ms + Math.floor((window_stop_ms - window_start_ms) / 2)
+      const left = await fetch_recursive(window_start_ms, midpoint)
+      const right = await fetch_recursive(midpoint, window_stop_ms)
+      return left.concat(right)
+    }
+    return rows
+  }
+
+  const results = []
+  const windows = split_windows(start_ms, stop_ms, initial_window_ms)
+  for (const [window_start_ms, window_stop_ms] of windows) {
+    const rows = await fetch_recursive(window_start_ms, window_stop_ms)
+    results.push(...filter_history_in_range(rows, start_ms, stop_ms))
+    if (delay_ms > 0) await sleep(delay_ms)
+  }
+  return results
+}
+
+async function with_retry(fn, { retries = 4, should_retry = () => false, backoff_ms = (attempt) => attempt * 1000 } = {}) {
+  let last_error = null
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await fn(attempt)
+    } catch (error) {
+      last_error = error
+      if (attempt >= retries || !should_retry(error)) break
+      await sleep(backoff_ms(attempt, error))
+    }
+  }
+  throw last_error
+}
+
+function sort_query_params(params) {
+  const ordered = {}
+  for (const key of Object.keys(params).sort()) {
+    ordered[key] = params[key]
+  }
+  return ordered
+}
+
+function stringify_sorted(params) {
+  return qs.stringify(sort_query_params(params))
+}
+
 /**
  * @typedef {import('./types').BalanceEntry} BalanceEntry
  * @typedef {import('./types').OrderResult} OrderResult
@@ -37,7 +133,7 @@ function trim_orderbook_response(res, depth = 1) {
  * Subclasses must override methods to provide exchange-specific implementations.
  * Methods that are not overridden will throw "not implemented" errors.
  */
-module.exports = class ExchangeBase {
+class ExchangeBase {
   constructor(name, id = '', api_key, secret_key, exchange_type = 'spot') {
     this.name = name
     this.Name = _.upperFirst(name)
@@ -248,6 +344,61 @@ module.exports = class ExchangeBase {
     cb({ success: false, error: `${this.name}: get_trades not implemented` })
   }
 
+  /**
+   * Get trade history for a trading pair in an absolute time window.
+   * Implementations should return individual fills filtered to [start_time_in_ms, end_time_in_ms).
+   * @param {string} pair - Trading pair
+   * @param {number} start_time_in_ms - Inclusive start timestamp in milliseconds
+   * @param {number} end_time_in_ms - Exclusive end timestamp in milliseconds
+   * @param {function(ApiResponse<TradeResult[]>): void} cb - Callback with trades
+   */
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    cb({ success: false, error: `${this.name}: get_history_trades not implemented` })
+  }
+
+  /**
+   * Best-effort absolute-window history built from the exchange's existing recent trade endpoint.
+   * @param {string} pair
+   * @param {number} start_time_in_ms
+   * @param {number} end_time_in_ms
+   * @param {function(ApiResponse<TradeResult[]>): void} cb
+   * @param {{use_all_trades?: boolean}} options
+   */
+  _get_history_trades_via_timeframe(pair, start_time_in_ms, end_time_in_ms, cb, options = {}) {
+    if (!(start_time_in_ms < end_time_in_ms)) {
+      cb({ success: true, body: [] })
+      return
+    }
+
+    const use_all_trades = options.use_all_trades === true
+    const timeframe_in_ms = Math.max(end_time_in_ms - start_time_in_ms, Date.now() - start_time_in_ms, 0)
+    const handle = (res) => {
+      if (!res || !res.success) {
+        cb(res)
+        return
+      }
+      let trades = Array.isArray(res.body) ? res.body : []
+      if (pair) {
+        trades = trades.filter((trade) => !trade?.pair || trade.pair === pair)
+      }
+      cb({
+        success: true,
+        body: ExchangeBase.history_utils.sort_history_rows(ExchangeBase.history_utils.filter_history_in_range(trades, start_time_in_ms, end_time_in_ms)),
+      })
+    }
+
+    if (use_all_trades) {
+      if (typeof this.get_all_trades !== 'function') {
+        cb({ success: false, error: `${this.name}: get_all_trades not implemented` })
+        return
+      }
+      this.get_all_trades(timeframe_in_ms, handle)
+      return
+    }
+
+    this.get_trades(pair, timeframe_in_ms, handle)
+  }
+
   // ============================================
   // Deposit/Withdrawal Methods
   // ============================================
@@ -423,3 +574,18 @@ module.exports = class ExchangeBase {
     cb({ success: false, error: 'get_precision not implemented' })
   }
 }
+
+ExchangeBase.history_utils = {
+  DEFAULT_HISTORY_MIN_WINDOW_MS,
+  fetch_split_windows,
+  filter_history_in_range,
+  history_time_ms,
+  sleep,
+  sort_history_rows,
+  sort_query_params,
+  split_windows,
+  stringify_sorted,
+  with_retry,
+}
+
+module.exports = ExchangeBase

package/lib/exchanges/exchange-fix.js

@@ -82,7 +82,6 @@ module.exports = class ExchangeFix {
     this.on_market_data_batch = options.on_market_data_batch  // called once per data chunk with array of fields
     this.on_market_data_snapshot = options.on_market_data_snapshot
     this.on_market_data_request_reject = options.on_market_data_request_reject
-    this.on_inbound_message = options.on_inbound_message || (() => {})
     this.on_status_change = options.on_status_change || (() => {})
 
     this.socket = null
@@ -140,7 +139,6 @@ module.exports = class ExchangeFix {
     this.recv_buffer = remaining
     let md_batch = null
     for (let msg of messages) {
-      this.on_inbound_message(msg)
       let t = msg.msg_type
       if (t === 'A') {
         this._set_status('ready')

package/lib/exchanges/exchange-ws.js

@@ -218,8 +218,9 @@ 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)
+          listener(...args, t_recv)
           this.market_observable.notify()
         }
         if (this.market_socket.serviceHandlers) {

package/lib/exchanges/fastex.js

@@ -316,6 +316,9 @@ module.exports = class Fastex 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://exchange.fastex.com/api/v1/pair/list?items_per_page=100&page=1', (err, res, body) => {

package/lib/exchanges/gate.js

@@ -159,8 +159,9 @@ module.exports = class Gate extends ExchangeBase {
         }),
       )
       const last_update_dict = {}
-      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.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) {
@@ -174,6 +175,7 @@ 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
           }
@@ -189,7 +191,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() }
+            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.pair_status[pair] = 'opened'
           } else {
             if (!this.ws.market.asks_dict[pair] || !this.ws.market.bids_dict[pair]) {

package/lib/exchanges/gemini.js

@@ -355,6 +355,76 @@ module.exports = class Gemini extends ExchangeBase {
     }
     this.private_limiter.process(get_trade_base, pair, 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 fetch_page = (cursor_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          request: '/v1/mytrades',
+          nonce: Date.now(),
+          symbol: pre_process_pair(pair),
+          limit_trades: 500,
+          timestamp: cursor_ms,
+        }
+        let sign = get_signature_gemini(secret_key, params)
+        let request_options = get_options(api_key, secret_key, params, sign)
+        needle.post('https://api.gemini.com/v1/mytrades', {}, request_options, (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 cursor_ms = Math.max(0, end_time_in_ms - 1)
+      while (cursor_ms >= start_time_in_ms) {
+        let rows = await fetch_page(cursor_ms)
+        if (rows.length === 0) break
+        trades.push(
+          ...rows
+            .filter((trade) => trade.break !== 'full')
+            .map((trade) => {
+              let price = parseFloat(trade.price)
+              let amount = parseFloat(trade.amount)
+              let close_time_ms = trade.timestampms != null ? parseInt(trade.timestampms) : parseInt(trade.timestamp) * 1000
+              let is_aggressor = trade.aggressor === true || trade.aggressor === 1 || trade.aggressor === '1' || trade.aggressor === 'true'
+              let mapped_trade = {
+                order_id: (trade.order_id || '').toString(),
+                trade_id: (trade.tid || '').toString(),
+                pair,
+                type: (trade.type || '').toLowerCase(),
+                price,
+                amount,
+                total: price * amount,
+                close_time: new Date(close_time_ms),
+                role: is_aggressor ? 'taker' : 'maker',
+              }
+              if (trade.fee_currency && Number.isFinite(parseFloat(trade.fee_amount))) {
+                mapped_trade.fees = {
+                  [post_process_cur(trade.fee_currency)]: Math.abs(parseFloat(trade.fee_amount)),
+                }
+              }
+              return mapped_trade
+            })
+        )
+        let oldest_seen_ms = Math.min(
+          ...rows
+            .map((trade) => (trade.timestampms != null ? parseInt(trade.timestampms) : parseInt(trade.timestamp) * 1000))
+            .filter((time) => Number.isFinite(time))
+        )
+        if (rows.length < 500 || !Number.isFinite(oldest_seen_ms) || oldest_seen_ms < start_time_in_ms || oldest_seen_ms >= cursor_ms) break
+        cursor_ms = oldest_seen_ms - 1
+        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))
+  }
   // get_all_trades (timeframe_in_ms, cb) {
   //
   // }