@icgio/icg-exchanges 1.40.49 → 1.41.0

package/lib/exchanges/digifinex.js

@@ -440,6 +440,7 @@ module.exports = class Digifinex extends ExchangeBase {
         delay_ms: 250,
       })
       trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      trades = utils.merge_trades_with_same_id(trades)
       cb({ success: true, body: trades })
     })().catch((error) => cb(error))
   }

package/lib/exchanges/exchange-base.js

@@ -450,9 +450,14 @@ class ExchangeBase {
   // ============================================
 
   /**
-   * Get trade history for a trading pair
+   * Get trade history for a trading pair within a relative time window.
+   *
+   * Implementations should call utils.merge_trades_with_same_id() before returning,
+   * which groups fills by order_id, aggregates amount/total/fees, recalculates price,
+   * and populates fill_history[] on every returned trade (even single-fill trades).
+   *
    * @param {string} pair - Trading pair
-   * @param {number} timeframe_in_ms - Time range in milliseconds
+   * @param {number} timeframe_in_ms - Time range in milliseconds (now - timeframe_in_ms .. now)
    * @param {function(ApiResponse<TradeResult[]>): void} cb - Callback with trades
    */
   get_trades(pair, timeframe_in_ms, cb) {
@@ -461,7 +466,11 @@ class ExchangeBase {
 
   /**
    * 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).
+   *
+   * Implementations should call utils.merge_trades_with_same_id() before
+   * returning, which groups fills by order_id, aggregates amount/total/fees,
+   * recalculates price, and populates fill_history[] on every returned trade.
+   *
    * @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
@@ -471,49 +480,6 @@ class ExchangeBase {
     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
   // ============================================

package/lib/exchanges/exchange-fix.js

@@ -1,8 +1,8 @@
-// Generic FIX 5.0 protocol handler over TLS.
+// Generic FIX 5.0 transport manager over TLS.
 //
-// Handles: TLS connection, message encode/decode, heartbeat, sequence numbers,
-// logon/logout lifecycle, auto-reconnect. Exchange-specific logic lives in
-// the caller (e.g. coinbase-fix.js).
+// Exposes `market` and `trading` channels that each own their own FIX session
+// lifecycle: connect, heartbeat, routine reconnect, disconnect, and restart.
+// Exchange-specific message handling lives in the caller.
 
 const tls = require('tls')
 
@@ -67,126 +67,231 @@ function parse_fix_messages(recv_buffer) {
 // --- ExchangeFix ---
 
 module.exports = class ExchangeFix {
-  constructor(name, options) {
+  constructor(name, options = {}) {
     this.name = name
-    this.host = options.host
-    this.port = options.port
-    this.sender_comp_id = options.sender_comp_id
-    this.target_comp_id = options.target_comp_id
-    this.heartbeat_interval = (options.heartbeat_interval || 30) * 1000
-    this.build_logon_fields = options.build_logon_fields
-    this.on_execution_report = options.on_execution_report
-    this.on_cancel_reject = options.on_cancel_reject
-    this.on_reject = options.on_reject
-    this.on_market_data_incremental = options.on_market_data_incremental
-    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_status_change = options.on_status_change || (() => {})
-
-    this.socket = null
-    this.status = 'disconnected'
-    this.seq_out = 1
-    this.recv_buffer = Buffer.alloc(0)
-    this.heartbeat_timer = null
-    this.reconnect_timer = null
+    this.market = this._create_channel('market', options.market)
+    this.trading = this._create_channel('trading', options.trading)
   }
 
-  connect() {
-    if (this.status !== 'disconnected') return
-    this._set_status('connecting')
-    this.socket = tls.connect({ host: this.host, port: this.port }, () => {
-      this._set_status('logging_in')
-      let sending_time = fix_timestamp()
-      let logon_fields = this.build_logon_fields(this.seq_out, sending_time)
-      this.send('A', logon_fields, sending_time)
+  _create_channel(kind, options) {
+    if (!options) return null
+    const channel = {
+      kind,
+      name: `${this.name}_${kind}`,
+      host: options.host,
+      port: options.port,
+      sender_comp_id: options.sender_comp_id,
+      target_comp_id: options.target_comp_id,
+      heartbeat_interval: (options.heartbeat_interval || 30) * 1000,
+      reconnecting_time: options.reconnecting_time || 2 * 60 * 60 * 1000,
+      restart_after_close_time: options.restart_after_close_time || 3 * 1000,
+      build_logon_fields: options.build_logon_fields,
+      on_execution_report: options.on_execution_report,
+      on_cancel_reject: options.on_cancel_reject,
+      on_reject: options.on_reject,
+      on_market_data_incremental: options.on_market_data_incremental,
+      on_market_data_batch: options.on_market_data_batch,
+      on_market_data_snapshot: options.on_market_data_snapshot,
+      on_market_data_request_reject: options.on_market_data_request_reject,
+      on_status_change: options.on_status_change || (() => {}),
+      status: 'n-opened',
+      session_status: 'disconnected',
+      socket: null,
+      seq_out: 1,
+      recv_buffer: Buffer.alloc(0),
+      heartbeat_timer: null,
+      restart_timeout: null,
+      reconnecting_timeout: null,
+      start: () => this._start_channel(channel),
+      end: () => this._end_channel(channel),
+      close: () => this._close_channel(channel),
+      send: (msg_type, fields, sending_time) => this._send(channel, msg_type, fields, sending_time),
+      is_ready: () => channel.status === 'opened' && channel.session_status === 'ready',
+    }
+    return channel
+  }
+
+  _start_channel(channel) {
+    if (!channel) return
+    if (channel.status !== 'n-opened' && channel.status !== 'closed' && channel.status !== 'stopped') return
+
+    clearTimeout(channel.restart_timeout)
+    channel.restart_timeout = null
+    clearTimeout(channel.reconnecting_timeout)
+    channel.reconnecting_timeout = null
+    this._clear_heartbeat(channel)
+
+    channel.status = 'opening'
+    this._set_session_status(channel, 'connecting')
+
+    const socket = tls.connect({ host: channel.host, port: channel.port }, () => {
+      if (socket !== channel.socket) return
+      this._set_session_status(channel, 'logging_in')
+      const sending_time = fix_timestamp()
+      const logon_fields = channel.build_logon_fields(channel.seq_out, sending_time)
+      this._send(channel, 'A', logon_fields, sending_time)
+    })
+
+    channel.socket = socket
+    socket.on('data', (chunk) => {
+      if (socket !== channel.socket) return
+      this._on_data(channel, chunk)
     })
-    this.socket.on('data', (chunk) => this._on_data(chunk))
-    this.socket.on('error', (err) => {
-      console.log('[FIX %s] error: %s', this.name, err.message)
-      this._reconnect()
+    socket.on('error', (err) => {
+      if (socket !== channel.socket) return
+      console.log('[FIX %s] error: %s', channel.name, err.message)
+      this._handle_disconnect(channel, { restart: channel.status !== 'stopped' })
     })
-    this.socket.on('close', () => {
-      if (this.status !== 'disconnected') this._reconnect()
+    socket.on('close', () => {
+      if (socket !== channel.socket) return
+      this._handle_disconnect(channel, { restart: channel.status !== 'stopped' })
     })
   }
 
-  disconnect() {
-    this._clear_timers()
-    this.status = 'disconnected'
-    if (this.socket) {
-      try { this.send('5', []) } catch (e) {}
-      this.socket.destroy()
-      this.socket = null
+  _end_channel(channel) {
+    if (!channel) return
+    if (channel.status !== 'opened' && channel.status !== 'opening' && !channel.socket) return
+    this._handle_disconnect(channel, { restart: true, graceful: true, next_status: 'closed' })
+  }
+
+  _close_channel(channel) {
+    if (!channel) return
+    clearTimeout(channel.restart_timeout)
+    channel.restart_timeout = null
+    clearTimeout(channel.reconnecting_timeout)
+    channel.reconnecting_timeout = null
+
+    if (channel.socket || channel.session_status !== 'disconnected') {
+      this._handle_disconnect(channel, { restart: false, graceful: true, next_status: 'stopped' })
+    } else {
+      channel.status = 'stopped'
+      channel.session_status = 'disconnected'
+      this._reset_session_state(channel)
     }
-    this.on_status_change('disconnected')
   }
 
-  send(msg_type, fields, sending_time) {
-    if (!this.socket || this.socket.destroyed) return false
-    this.socket.write(encode_fix_msg(msg_type, fields, this.seq_out, this.sender_comp_id, this.target_comp_id, sending_time))
-    this.seq_out++
+  _send(channel, msg_type, fields, sending_time) {
+    return this._send_on_socket(channel, channel.socket, msg_type, fields, sending_time)
+  }
+
+  _send_on_socket(channel, socket, msg_type, fields, sending_time) {
+    if (!socket || socket.destroyed) return false
+    socket.write(encode_fix_msg(msg_type, fields, channel.seq_out, channel.sender_comp_id, channel.target_comp_id, sending_time))
+    channel.seq_out++
     return true
   }
 
-  is_ready() { return this.status === 'ready' }
+  _set_session_status(channel, status) {
+    if (channel.session_status === status) return
+    channel.session_status = status
+    channel.on_status_change(status)
+  }
 
-  _set_status(s) { this.status = s; this.on_status_change(s) }
+  _mark_ready(channel) {
+    channel.status = 'opened'
+    this._start_heartbeat(channel)
+    clearTimeout(channel.reconnecting_timeout)
+    channel.reconnecting_timeout = setTimeout(() => {
+      channel.reconnecting_timeout = null
+      console.log('[FIX %s] routine reconnecting', channel.name)
+      channel.end()
+    }, channel.reconnecting_time)
+    this._set_session_status(channel, 'ready')
+  }
 
-  _on_data(chunk) {
-    this.recv_buffer = Buffer.concat([this.recv_buffer, chunk])
-    let { messages, remaining } = parse_fix_messages(this.recv_buffer)
-    this.recv_buffer = remaining
+  _on_data(channel, chunk) {
+    channel.recv_buffer = Buffer.concat([channel.recv_buffer, chunk])
+    const { messages, remaining } = parse_fix_messages(channel.recv_buffer)
+    channel.recv_buffer = remaining
     let md_batch = null
-    for (let msg of messages) {
-      let t = msg.msg_type
+
+    for (const msg of messages) {
+      const t = msg.msg_type
       if (t === 'A') {
-        this._set_status('ready')
-        this._start_heartbeat()
+        this._mark_ready(channel)
       } else if (t === '0') {
         // Heartbeat
       } else if (t === '1') {
-        this.send('0', [[112, msg.fields['112'] || '']])
+        channel.send('0', [[112, msg.fields['112'] || '']])
       } else if (t === '5') {
-        this._reconnect()
+        this._handle_disconnect(channel, { restart: channel.status !== 'stopped' })
       } else if (t === '8') {
-        if (this.on_execution_report) this.on_execution_report(msg.fields)
+        if (channel.on_execution_report) channel.on_execution_report(msg.fields)
       } else if (t === '9') {
-        if (this.on_cancel_reject) this.on_cancel_reject(msg.fields)
+        if (channel.on_cancel_reject) channel.on_cancel_reject(msg.fields)
       } else if (t === 'W') {
-        if (this.on_market_data_snapshot) this.on_market_data_snapshot(msg.fields)
+        if (channel.on_market_data_snapshot) channel.on_market_data_snapshot(msg.fields)
       } else if (t === 'X') {
-        if (this.on_market_data_batch) {
+        if (channel.on_market_data_batch) {
           if (!md_batch) md_batch = []
           md_batch.push(msg.fields)
-        } else if (this.on_market_data_incremental) {
-          this.on_market_data_incremental(msg.fields)
+        } else if (channel.on_market_data_incremental) {
+          channel.on_market_data_incremental(msg.fields)
         }
       } else if (t === 'Y') {
-        if (this.on_market_data_request_reject) this.on_market_data_request_reject(msg.fields)
+        if (channel.on_market_data_request_reject) channel.on_market_data_request_reject(msg.fields)
       } else if (t === '3' || t === 'j') {
-        if (this.on_reject) this.on_reject(msg.fields)
+        if (channel.on_reject) channel.on_reject(msg.fields)
       }
     }
-    if (md_batch) this.on_market_data_batch(md_batch)
+
+    if (md_batch && channel.on_market_data_batch) channel.on_market_data_batch(md_batch)
+  }
+
+  _start_heartbeat(channel) {
+    this._clear_heartbeat(channel)
+    channel.heartbeat_timer = setInterval(() => channel.send('0', []), channel.heartbeat_interval)
   }
 
-  _start_heartbeat() {
-    this._clear_timers()
-    this.heartbeat_timer = setInterval(() => this.send('0', []), this.heartbeat_interval)
+  _clear_heartbeat(channel) {
+    if (channel.heartbeat_timer) {
+      clearInterval(channel.heartbeat_timer)
+      channel.heartbeat_timer = null
+    }
   }
 
-  _clear_timers() {
-    if (this.heartbeat_timer) { clearInterval(this.heartbeat_timer); this.heartbeat_timer = null }
-    if (this.reconnect_timer) { clearTimeout(this.reconnect_timer); this.reconnect_timer = null }
+  _reset_session_state(channel) {
+    channel.recv_buffer = Buffer.alloc(0)
+    channel.seq_out = 1
   }
 
-  _reconnect() {
-    this._clear_timers()
-    if (this.socket) { this.socket.destroy(); this.socket = null }
-    this.recv_buffer = Buffer.alloc(0)
-    this.seq_out = 1
-    this._set_status('disconnected')
-    this.reconnect_timer = setTimeout(() => { this.reconnect_timer = null; this.connect() }, 3000)
+  _handle_disconnect(channel, options = {}) {
+    const restart = options.restart === true
+    const next_status = options.next_status || (restart ? 'closed' : 'stopped')
+    const socket = channel.socket
+    const should_notify = !!socket || channel.session_status !== 'disconnected'
+
+    if (!socket && !should_notify && channel.status === next_status) return
+
+    channel.socket = null
+
+    if (socket && options.graceful) {
+      try { this._send_on_socket(channel, socket, '5', []) } catch (e) {}
+    }
+
+    this._clear_heartbeat(channel)
+    clearTimeout(channel.reconnecting_timeout)
+    channel.reconnecting_timeout = null
+    clearTimeout(channel.restart_timeout)
+    channel.restart_timeout = null
+
+    this._reset_session_state(channel)
+    channel.status = next_status
+    channel.session_status = 'disconnected'
+
+    if (socket) {
+      try { socket.destroy() } catch (e) {}
+    }
+
+    if (should_notify) {
+      process.nextTick(() => channel.on_status_change('disconnected'))
+    }
+
+    if (restart && next_status !== 'stopped') {
+      channel.restart_timeout = setTimeout(() => {
+        channel.restart_timeout = null
+        channel.start()
+      }, channel.restart_after_close_time)
+    }
   }
 }

package/lib/exchanges/fastex.js

@@ -316,9 +316,7 @@ 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)
-  }
+  // get_history_trades — not implemented, no native absolute-window endpoint
   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

@@ -10,6 +10,7 @@ const ExchangeBase = require('./exchange-base.js')
 
 const { error_codes } = require('../error_codes.json')
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
+const { fetch_split_windows, sort_history_rows } = ExchangeBase.history_utils
 
 function pre_process_pair(pair) {
   let [cur, quote_cur] = utils.parse_pair(pair)
@@ -663,41 +664,55 @@ module.exports = class Gate extends ExchangeBase {
   }
   get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
     let get_history_trades_base = (pair, start_time_in_ms, end_time_in_ms, cb) => {
-      let params = {
-        currency_pair: pre_process_pair(pair),
-        from: parseInt(start_time_in_ms / 1000),
-        limit: 1000,
-        to: parseInt(end_time_in_ms / 1000),
-      }
       let [api_key, secret_key] = this.api_secret_key
-      let timestamp = parseInt(Date.now() / 1000)
-      let path = '/api/v4/spot/my_trades'
-      let sign = get_signature_gatev4('GET', path, params, secret_key, timestamp)
-      let options = get_options(api_key, timestamp, sign)
-      let url = 'https://api.gateio.ws' + path + '?' + qs.stringify(params)
-      needle.get(url, options, (err, res, body) => {
-        if (body && Array.isArray(body)) {
-          let trades = body.map((trade) => {
-            return {
-              order_id: trade.order_id,
-              pair,
-              type: trade.side,
-              price: parseFloat(trade.price),
-              amount: parseFloat(trade.amount),
-              total: parseFloat(trade.price) * parseFloat(trade.amount),
-              close_time: new Date(parseInt(trade.create_time_ms)),
-              fees: {
-                [post_process_cur(trade.fee_currency)]: parseFloat(trade.fee),
-              },
-            }
-          })
-
-          cb({ success: true, body: trades })
-        } else if (body) {
-          cb({ success: false, error: error_codes.other, body })
-        } else {
-          cb({ success: false, error: error_codes.timeout })
-        }
+      ;(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 = {
+                currency_pair: pre_process_pair(pair),
+                from: parseInt(window_start_ms / 1000),
+                limit: 1000,
+                to: parseInt(window_stop_ms / 1000),
+              }
+              let timestamp = parseInt(Date.now() / 1000)
+              let path = '/api/v4/spot/my_trades'
+              let sign = get_signature_gatev4('GET', path, params, secret_key, timestamp)
+              let options = get_options(api_key, timestamp, sign)
+              let url = 'https://api.gateio.ws' + path + '?' + qs.stringify(params)
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body)) {
+                  resolve(
+                    body.map((trade) => ({
+                      order_id: trade.order_id,
+                      pair,
+                      type: trade.side,
+                      price: parseFloat(trade.price),
+                      amount: parseFloat(trade.amount),
+                      total: parseFloat(trade.price) * parseFloat(trade.amount),
+                      close_time: new Date(parseInt(trade.create_time_ms)),
+                      fees: {
+                        [post_process_cur(trade.fee_currency)]: parseFloat(trade.fee),
+                      },
+                      role: trade.role,
+                    })),
+                  )
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            }),
+        })
+        const merged = utils.merge_trades_with_same_id(rows)
+        cb({ success: true, body: sort_history_rows(merged) })
+      })().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)

package/lib/exchanges/gemini.js

@@ -422,6 +422,7 @@ module.exports = class Gemini extends ExchangeBase {
         await sleep(250)
       }
       trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      trades = utils.merge_trades_with_same_id(trades)
       cb({ success: true, body: trades })
     })().catch((error) => cb(error))
   }

package/lib/exchanges/hashkey.js

@@ -532,6 +532,7 @@ module.exports = class Hashkey extends ExchangeBase {
         delay_ms: 250,
       })
       trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      trades = utils.merge_trades_with_same_id(trades)
       cb({ success: true, body: trades })
     })().catch((error) => cb(error))
   }

package/lib/exchanges/hashkeyglobal.js

@@ -520,6 +520,7 @@ module.exports = class Hashkeyglobal extends ExchangeBase {
         delay_ms: 250,
       })
       trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      trades = utils.merge_trades_with_same_id(trades)
       cb({ success: true, body: trades })
     })().catch((error) => cb(error))
   }

package/lib/exchanges/hitbtc.js

@@ -6,6 +6,7 @@ const needle = require('needle')
 const ExchangeWs = require('./exchange-ws.js')
 
 const ExchangeBase = require('./exchange-base.js')
+const { fetch_split_windows, sort_history_rows } = ExchangeBase.history_utils
 
 const { error_codes } = require('../error_codes.json')
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
@@ -651,34 +652,50 @@ module.exports = class Hitbtc extends ExchangeBase {
     })
   }
   get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
-    let from = new Date(start_time_in_ms).toISOString(),
-      end = new Date(end_time_in_ms).toISOString()
-    let params = {
-      from: from,
-      symbol: pre_process_pair(pair),
-      till: end,
-    }
-    let url = `https://api.hitbtc.com/api/3/spot/history/trade?` + qs.stringify(params)
-    this.private_limiter.process(needle.get, url, get_signature_hitbtc(this.api_secret_key), (err, res, body) => {
-      if (body && Array.isArray(body) && body[0]) {
-        let result = body.map((o) => {
-          return {
-            order_id: o.client_order_id.toString(),
-            pair: post_process_pair(o.symbol),
-            type: o.side,
-            price: parseFloat(o.price),
-            amount: parseFloat(o.quantity),
-            total: parseFloat(o.price) * parseFloat(o.quantity),
-            close_time: new Date(o.timestamp),
-          }
+    let get_history_trades_base = (pair, start_time_in_ms, end_time_in_ms, cb) => {
+      ;(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 = {
+                from: new Date(window_start_ms).toISOString(),
+                symbol: pre_process_pair(pair),
+                till: new Date(window_stop_ms).toISOString(),
+                limit: 1000,
+              }
+              let url = `https://api.hitbtc.com/api/3/spot/history/trade?` + qs.stringify(params)
+              needle.get(url, get_signature_hitbtc(this.api_secret_key), (err, res, body) => {
+                if (body && Array.isArray(body)) {
+                  resolve(
+                    body.map((o) => ({
+                      order_id: o.client_order_id.toString(),
+                      pair: post_process_pair(o.symbol),
+                      type: o.side,
+                      price: parseFloat(o.price),
+                      amount: parseFloat(o.quantity),
+                      total: parseFloat(o.price) * parseFloat(o.quantity),
+                      close_time: new Date(o.timestamp),
+                    })),
+                  )
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            }),
         })
-        cb({ success: true, body: result })
-      } else if (body) {
-        cb({ success: false, error: error_codes.other, body })
-      } else {
-        cb({ success: false, error: error_codes.timeout })
-      }
-    })
+        const merged = utils.merge_trades_with_same_id(rows)
+        cb({ success: true, body: sort_history_rows(merged) })
+      })().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_ws (timeframe_in_ms, cb) {
   //

package/lib/exchanges/hkbitex.js

@@ -557,9 +557,7 @@ 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)
-  }
+  // get_history_trades — not implemented, no native absolute-window endpoint
   static get_precision(cb) {
     let price_precision = {},
       amount_precision = {}