@icgio/icg-exchanges 1.40.42 → 1.40.44

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/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/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) {
   //
   // }

package/lib/exchanges/hashkey.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 Hashkey extends ExchangeBase {
   constructor(api_key, secret_key, settings) {
     super('hashkey', settings.id, api_key, secret_key)
@@ -462,6 +471,64 @@ module.exports = class Hashkey 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/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)
@@ -455,6 +464,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/hkbitex.js

@@ -556,6 +556,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')
@@ -539,6 +540,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 = {}