@icgio/icg-exchanges 1.40.49 → 1.41.0

package/lib/exchanges/coinbase.js

@@ -2,9 +2,10 @@ const _ = require('lodash')
 
 const qs = require('qs')
 const websocket = require('ws')
-const { createHmac, randomBytes } = require('crypto')
+const { createHmac, randomBytes, randomUUID } = require('crypto')
 const needle = require('needle')
 
+const ExchangeFix = require('./exchange-fix.js')
 const ExchangeWs = require('./exchange-ws.js')
 const ExchangeBase = require('./exchange-base.js')
 const { filter_history_in_range, history_time_ms, sleep, sort_history_rows } = ExchangeBase.history_utils
@@ -15,6 +16,8 @@ const { error_codes } = require('../error_codes.json')
 const { utils, rate_limiter: Limiter } = require('@icgio/icg-utils')
 const { sign } = require('jsonwebtoken')
 
+const FIX_SOH = '\x01'
+
 // Detect key type: advanced keys start with "organizations/"
 function is_advanced_key(api_key) {
   return typeof api_key === 'string' && api_key.startsWith('organizations/')
@@ -54,6 +57,63 @@ function coinbase_taker_side(side) {
   return undefined
 }
 
+function build_fix_logon_fields(api_key, secret_key, passphrase, seq_num, sending_time, options = {}) {
+  const prehash = sending_time + FIX_SOH + 'A' + FIX_SOH + seq_num + FIX_SOH + api_key + FIX_SOH + 'Coinbase' + FIX_SOH + passphrase
+  const signature = createHmac('sha256', Buffer.from(secret_key, 'base64')).update(prehash).digest('base64')
+  const fields = [
+    [553, api_key], [554, passphrase],
+    [95, signature.length], [96, signature],
+    [98, 0], [108, 30], [141, 'Y'], [1137, 9],
+  ]
+  if (options.order_entry) fields.push([8013, 'S'])
+  return fields
+}
+
+function parse_fix_event_ts_ms(fix_time) {
+  if (!fix_time || fix_time.length < 17) return undefined
+  const iso = fix_time.slice(0, 4) + '-' + fix_time.slice(4, 6) + '-' + fix_time.slice(6, 8) + 'T' + fix_time.slice(9, 21) + 'Z'
+  const ms = Date.parse(iso)
+  return Number.isFinite(ms) ? ms : undefined
+}
+
+function parse_fix_md_entry(fields) {
+  const symbol = fields['55']
+  const entry_type = fields['269']
+  const action = fields['279']
+  const md_entry_id = fields['278']
+  const order_id = fields['37']
+  if (!symbol || entry_type === undefined || action === undefined) return null
+
+  const price = parseFloat(fields['270'])
+  const size = parseFloat(fields['271'])
+  if (!Number.isFinite(price)) return null
+
+  const rpt_seq = fields['83'] ? parseInt(fields['83'], 10) : undefined
+  if (entry_type === '2') {
+    return {
+      kind: 'trade', symbol, price, size,
+      time: fields['60'], trade_id: fields['1003'],
+      aggressor_side: fields['5797'], rpt_seq,
+    }
+  }
+  if (entry_type !== '0' && entry_type !== '1') return null
+  if (!md_entry_id && order_id) return null
+
+  let action_str
+  if (action === '0') action_str = 'new'
+  else if (action === '1') action_str = 'change'
+  else if (action === '2') action_str = 'delete'
+  else return null
+
+  return {
+    kind: 'l2', symbol,
+    side: entry_type === '0' ? 'bid' : 'offer',
+    action: action_str,
+    price, size,
+    time: fields['60'], md_entry_id, rpt_seq,
+  }
+}
+
 // --- Legacy auth (HMAC + passphrase) ---
 
 function get_signature_legacy(api_key, secret_key, timestamp, method, request_path, body) {
@@ -138,18 +198,57 @@ module.exports = class Coinbase extends ExchangeBase {
     })
 
     // FIX protocol — default for legacy keys
-    this.fix_ord = null
+    this.fix = null
     this._use_fix = false
+    this._fix_pending = new Map()
+    this._fix_md_pair_list = []
+    this._fix_md_symbols = []
+    this._fix_md_subscribed = false
+    this._fix_md_session_id = 0
     if (!this.advanced && this.passphrase && !this.settings.no_fix) {
-      const { CoinbaseFixOrd, CoinbaseFixMd } = require('./coinbase-fix.js')
-      this._CoinbaseFixMd = CoinbaseFixMd
-      this.fix_ord = new CoinbaseFixOrd(
-        Array.isArray(api_key) ? api_key[0] : api_key,
-        Array.isArray(secret_key) ? secret_key[0] : secret_key,
-        this.passphrase,
-        { error_codes, pre_process_pair },
-      )
-      this.fix_ord.connect()
+      const fix_api_key = Array.isArray(api_key) ? api_key[0] : api_key
+      const fix_secret_key = Array.isArray(secret_key) ? secret_key[0] : secret_key
+      this.fix = new ExchangeFix(this.name, {
+        market: {
+          host: 'fix-md.exchange.coinbase.com',
+          port: 6121,
+          sender_comp_id: fix_api_key,
+          target_comp_id: 'Coinbase',
+          heartbeat_interval: 30,
+          build_logon_fields: (seq, time) => build_fix_logon_fields(fix_api_key, fix_secret_key, this.passphrase, seq, time),
+          on_market_data_batch: (batch) => this._handle_fix_market_batch_fields(batch),
+          on_market_data_snapshot: (fields) => this._handle_fix_market_fields(fields),
+          on_market_data_request_reject: (fields) => {
+            console.log('[coinbase FIX md] request reject:', fields['58'] || '')
+          },
+          on_status_change: (status) => this._on_fix_market_status(status),
+        },
+        trading: {
+          host: 'fix-ord.exchange.coinbase.com',
+          port: 6121,
+          sender_comp_id: fix_api_key,
+          target_comp_id: 'Coinbase',
+          heartbeat_interval: 30,
+          build_logon_fields: (seq, time) => build_fix_logon_fields(fix_api_key, fix_secret_key, this.passphrase, seq, time, { order_entry: true }),
+          on_execution_report: (fields) => this._handle_fix_exec_report(fields),
+          on_cancel_reject: (fields) => this._handle_fix_cancel_reject(fields),
+          on_reject: (fields) => this._handle_fix_reject(fields),
+          on_status_change: (status) => this._on_fix_trading_status(status),
+        },
+      })
+      this.ws.market.end = () => {
+        if (this.fix && this.fix.market) this.fix.market.end()
+      }
+      this.ws.market.close = () => {
+        if (this.fix && this.fix.market) this.fix.market.close()
+      }
+      this.ws.trading.end = () => {
+        if (this.fix && this.fix.trading) this.fix.trading.end()
+      }
+      this.ws.trading.close = () => {
+        if (this.fix && this.fix.trading) this.fix.trading.close()
+      }
+      this.fix.trading.start()
       this._use_fix = true
     }
   }
@@ -580,65 +679,250 @@ module.exports = class Coinbase extends ExchangeBase {
     this.ws.market.start(pair_list)
   }
 
-  // FIX market data — L3 incremental with REST L3 snapshot bootstrap.
-  _fix_market_data(pair_list, options = {}) {
-    this.ws.ws_market_options = options
-    const OB_WINDOW = options.fix_ob_window || 0.05
-    const RESNAPSHOT_DRIFT = options.fix_resnapshot_drift || 0.03
-    const CROSS_GRACE_MS = options.fix_cross_grace_ms || 500
-    const [api_key, secret_key] = this.api_secret_key
+  _fix_trading_ready() {
+    return !!(this.fix && this.fix.trading && this.fix.trading.is_ready())
+  }
+
+  _send_fix_new_order(pair, method, price, amount, order_options, cb) {
+    if (typeof order_options === 'function') { cb = order_options; order_options = {} }
+    const cl_ord_id = randomUUID()
+    const side = method === 'buy' ? '1' : '2'
+    let tif = '1'
+    if (order_options && order_options.ioc) tif = '3'
+    else if (order_options && order_options.fok) tif = '4'
+    const fields = [
+      [11, cl_ord_id], [55, pre_process_pair(pair)], [54, side],
+      [44, price.toString()], [38, amount.toString()], [40, 2], [59, tif], [21, 1],
+    ]
+    if (order_options && order_options.post_only) fields.push([18, 'A'])
+    const timeout_id = setTimeout(() => this._resolve_fix_pending(cl_ord_id, { success: false, error: error_codes.timeout }), 15000)
+    this._fix_pending.set(cl_ord_id, { cb, timeout_id, type: 'new' })
+    this.fix.trading.send('D', fields)
+  }
+
+  _send_fix_cancel(pair, order_id, side, cb) {
+    const cl_ord_id = randomUUID()
+    const fix_side = side === 'buy' ? '1' : '2'
+    const fields = [
+      [11, cl_ord_id], [41, cl_ord_id], [37, order_id],
+      [55, pre_process_pair(pair)], [54, fix_side],
+    ]
+    const timeout_id = setTimeout(() => this._resolve_fix_pending(cl_ord_id, { success: false, error: error_codes.timeout }), 15000)
+    this._fix_pending.set(cl_ord_id, { cb, timeout_id, type: 'cancel', order_id })
+    this.fix.trading.send('F', fields)
+  }
+
+  _on_fix_trading_status(status) {
+    console.log('[coinbase FIX ord] status:', status)
+    if (status === 'connecting' || status === 'logging_in') {
+      this.ws.trading.status = 'opening'
+    } else if (status === 'ready') {
+      this.ws.trading.status = 'opened'
+    } else if (status === 'disconnected') {
+      this.ws.trading.status = this.fix && this.fix.trading && this.fix.trading.status === 'stopped' ? 'stopped' : 'closed'
+      this._flush_fix_pending()
+    }
+  }
+
+  _handle_fix_exec_report(fields) {
+    const cl_ord_id = fields['11']
+    const ord_status = fields['39']
+    const order_id = fields['37'] || ''
+    if (ord_status === '0') {
+      this._resolve_fix_pending(cl_ord_id, { success: true, body: order_id })
+    } else if (ord_status === '8') {
+      const text = fields['58'] || ''
+      let error = error_codes.other
+      if (text.includes('nsufficient') || text.includes('NSUFFICIENT')) error = error_codes.insufficient_funds
+      else if (fields['103'] === '2' || text.includes('too small') || text.includes('TOO_SMALL')) error = error_codes.amount_too_small
+      this._resolve_fix_pending(cl_ord_id, { success: false, error, body: text })
+    } else if (ord_status === '4') {
+      if (this._fix_pending.has(cl_ord_id)) this._resolve_fix_pending(cl_ord_id, { success: true, body: order_id })
+      else this._resolve_fix_pending_by_order_id(order_id, { success: true, body: order_id })
+    } else if (ord_status === '1' || ord_status === '2') {
+      if (this._fix_pending.has(cl_ord_id) && this._fix_pending.get(cl_ord_id).type === 'cancel') {
+        this._resolve_fix_pending(cl_ord_id, { success: false, error: error_codes.order_not_open, body: order_id })
+      } else {
+        this._resolve_fix_pending_by_order_id(order_id, { success: false, error: error_codes.order_not_open, body: order_id }, 'cancel')
+      }
+    }
+  }
+
+  _handle_fix_cancel_reject(fields) {
+    let error = error_codes.other
+    if (fields['102'] === '1') error = error_codes.order_not_open
+    this._resolve_fix_pending(fields['11'], { success: false, error, body: fields['58'] || '' })
+  }
+
+  _handle_fix_reject(fields) {
+    const cl_ord_id = fields['379'] || fields['11'] || ''
+    if (cl_ord_id && this._fix_pending.has(cl_ord_id)) {
+      this._resolve_fix_pending(cl_ord_id, { success: false, error: error_codes.other, body: fields['58'] || '' })
+    }
+  }
+
+  _resolve_fix_pending(cl_ord_id, result) {
+    const pending = this._fix_pending.get(cl_ord_id)
+    if (!pending) return
+    clearTimeout(pending.timeout_id)
+    this._fix_pending.delete(cl_ord_id)
+    pending.cb(result)
+  }
+
+  _resolve_fix_pending_by_order_id(order_id, result, type_filter) {
+    for (const [id, pending] of this._fix_pending) {
+      if (pending.order_id === order_id && (!type_filter || pending.type === type_filter)) {
+        this._resolve_fix_pending(id, result)
+        return
+      }
+    }
+  }
+
+  _flush_fix_pending() {
+    for (const [id, pending] of this._fix_pending) {
+      clearTimeout(pending.timeout_id)
+      pending.cb({ success: false, error: error_codes.timeout })
+    }
+    this._fix_pending.clear()
+  }
 
+  _prepare_fix_market_session() {
+    this._fix_md_session_id++
+    this._fix_md_subscribed = false
     this._fix_md_orders = {}
     this._fix_md_snapshot_mid = {}
     this._fix_md_snapshot_seq = {}
     this._fix_md_event_buffer = {}
     this._fix_md_pair_by_symbol = {}
     this._fix_md_cross_pending = {}
-    this._fix_md_cross_grace_ms = CROSS_GRACE_MS
+    this._fix_md_resnapshot_pending = {}
+    this._fix_md_resnapshot_buffer = {}
+    this._fix_md_notify_pending = false
+    this.ws.market.status = 'opening'
+    this.ws.market.last_message_time = undefined
+
+    for (const pair of this._fix_md_pair_list) {
+      this.ws.market.pair_status[pair] = 'opening'
+      this.ws.market.asks_dict[pair] = sorted_book(true)
+      this.ws.market.bids_dict[pair] = sorted_book(false)
+      this.ws.market.market_history_dict[pair] = []
+      delete this.ws.market.market_ts_by_pair[pair]
+      delete this.ws.market.tickers[pair]
+      this._fix_md_orders[pair] = {}
+      this._fix_md_snapshot_mid[pair] = null
+      this._fix_md_snapshot_seq[pair] = null
+      this._fix_md_event_buffer[pair] = []
+      this._fix_md_pair_by_symbol[pre_process_pair(pair)] = pair
+    }
+  }
 
-    this.ws.market.start_base = () => {
-      pair_list.map((pair) => {
-        this.ws.market.pair_status[pair] = 'opening'
-        this.ws.market.asks_dict[pair] = sorted_book(true)
-        this.ws.market.bids_dict[pair] = sorted_book(false)
-        this.ws.market.market_history_dict[pair] = []
-        this._fix_md_orders[pair] = {}
-        this._fix_md_snapshot_seq[pair] = null
-        this._fix_md_event_buffer[pair] = []
-        this._fix_md_pair_by_symbol[pre_process_pair(pair)] = pair
-      })
+  _send_fix_market_subscribe() {
+    if (!this.fix || !this.fix.market || !this._fix_md_symbols.length) return
+    const fields = [
+      [262, 'icg-md-' + Date.now()], [263, 1], [264, 0], [265, 1],
+      [267, 3], [269, 0], [269, 1], [269, 2],
+      [146, this._fix_md_symbols.length],
+    ]
+    for (const symbol of this._fix_md_symbols) fields.push([55, symbol])
+    if (this.fix.market.send('V', fields)) {
+      this._fix_md_subscribed = true
+      console.log('[coinbase FIX md] subscribed:', this._fix_md_symbols.join(','))
+    }
+  }
 
-      const symbols = pair_list.map((pair) => pre_process_pair(pair))
-
-      this.fix_md = new this._CoinbaseFixMd({
-        api_key: Array.isArray(api_key) ? api_key[0] : api_key,
-        secret_key: Array.isArray(secret_key) ? secret_key[0] : secret_key,
-        passphrase: this.passphrase,
-        symbols,
-        on_status: (status) => {
-          console.log('[coinbase FIX MD] status:', status)
-          if (status === 'ready') {
-            this.ws.market.status = 'opened'
-            this.ws.market.last_message_time = Date.now()
-            for (const pair of pair_list) this._fix_md_load_snapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT)
-          }
-        },
-        on_batch: (entries) => this._fix_md_handle_batch(entries, OB_WINDOW, RESNAPSHOT_DRIFT),
-      })
-      this.fix_md.connect()
+  _on_fix_market_status(status) {
+    console.log('[coinbase FIX md] status:', status)
+    if (!this._fix_md_pair_list.length) return
+
+    if (status === 'connecting') {
+      this._prepare_fix_market_session()
+      return
     }
-    this.ws.market.end_base = () => {
-      if (this.fix_md) {
-        try { this.fix_md.disconnect() } catch (e) {}
-        this.fix_md = null
+    if (status === 'logging_in') {
+      this.ws.market.status = 'opening'
+      return
+    }
+    if (status === 'ready') {
+      if (!this._fix_md_subscribed) this._send_fix_market_subscribe()
+      this.ws.market.status = 'opened'
+      this.ws.market.last_message_time = Date.now()
+      const session_id = this._fix_md_session_id
+      for (const pair of this._fix_md_pair_list) {
+        this._fix_md_load_snapshot(pair, this._fix_md_ob_window, this._fix_md_resnapshot_drift, session_id)
+      }
+      return
+    }
+    if (status === 'disconnected') {
+      const final_status = this.fix && this.fix.market && this.fix.market.status === 'stopped' ? 'stopped' : 'closed'
+      this._fix_md_session_id++
+      this._fix_md_subscribed = false
+      this.ws.market.status = final_status
+      this.ws.market.last_message_time = undefined
+      for (const pair of this._fix_md_pair_list) this.ws.market.pair_status[pair] = final_status
+      if (final_status === 'stopped') {
+        clearInterval(this.ws.market.notify_heartbeat_session)
+        clearInterval(this.ws.market.stale_check_session)
+        clearInterval(this.ws.market.ping_session)
+        clearTimeout(this.ws.market.restart_timeout)
+        clearTimeout(this.ws.market.reconnecting_timeout)
       }
-      this._fix_md_orders = {}
-      this._fix_md_snapshot_mid = {}
-      this._fix_md_snapshot_seq = {}
-      this._fix_md_event_buffer = {}
-      this._fix_md_cross_pending = {}
     }
-    this.ws.market.start(pair_list)
+  }
+
+  _handle_fix_market_fields(fields) {
+    const hr_recv = process.hrtime()
+    const entry = parse_fix_md_entry(fields)
+    if (!entry) return
+    const hr_parsed = process.hrtime()
+    entry.ts_ms_venue_event = parse_fix_event_ts_ms(entry.time)
+    entry.ts_ms_local_received = Date.now()
+    entry.hr_recv = hr_recv
+    entry.hr_parsed = hr_parsed
+    this._fix_md_handle_batch([entry], this._fix_md_ob_window, this._fix_md_resnapshot_drift)
+  }
+
+  _handle_fix_market_batch_fields(batch) {
+    const entries = []
+    const now = Date.now()
+    for (const fields of batch) {
+      const hr_recv = process.hrtime()
+      const entry = parse_fix_md_entry(fields)
+      if (!entry) continue
+      const hr_parsed = process.hrtime()
+      entry.ts_ms_venue_event = parse_fix_event_ts_ms(entry.time)
+      entry.ts_ms_local_received = now
+      entry.hr_recv = hr_recv
+      entry.hr_parsed = hr_parsed
+      entries.push(entry)
+    }
+    if (entries.length) this._fix_md_handle_batch(entries, this._fix_md_ob_window, this._fix_md_resnapshot_drift)
+  }
+
+  // FIX market data — L3 incremental with REST L3 snapshot bootstrap.
+  _fix_market_data(pair_list, options = {}) {
+    if (!this.fix || !this.fix.market) return
+    if (this.fix.market.status === 'opening' || this.fix.market.status === 'opened') return
+
+    this.ws.ws_market_options = options
+    this._fix_md_ob_window = options.fix_ob_window || 0.05
+    this._fix_md_resnapshot_drift = options.fix_resnapshot_drift || 0.03
+    this._fix_md_cross_grace_ms = options.fix_cross_grace_ms || 500
+    this._fix_md_pair_list = pair_list.slice()
+    this._fix_md_symbols = pair_list.map((pair) => pre_process_pair(pair))
+
+    clearInterval(this.ws.market.ping_session)
+    clearInterval(this.ws.market.notify_heartbeat_session)
+    clearInterval(this.ws.market.stale_check_session)
+    clearTimeout(this.ws.market.restart_timeout)
+    clearTimeout(this.ws.market.reconnecting_timeout)
+
+    this.ws.market.clear()
+    this.ws.market.pair_list = pair_list.slice()
+    this.ws.market.status = 'closed'
+    pair_list.map((pair) => (this.ws.market.pair_status[pair] = 'closed'))
+    this.ws.market.start_notify_heartbeat()
+    this.ws.market.start_stale_check()
+    this.fix.market.start()
   }
 
   // Build book from L3 snapshot, apply to pair, replay buffered events.
@@ -709,11 +993,12 @@ module.exports = class Coinbase extends ExchangeBase {
     return snap_seq
   }
 
-  _fix_md_load_snapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT) {
+  _fix_md_load_snapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT, session_id = this._fix_md_session_id) {
     this._fix_md_fetch_snapshot(pair, (res) => {
+      if (session_id !== this._fix_md_session_id) return
       if (!res.success) {
         console.log('[coinbase FIX MD] snapshot fetch failed for %s, retrying in 1s', pair)
-        setTimeout(() => this._fix_md_load_snapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT), 1000)
+        setTimeout(() => this._fix_md_load_snapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT, session_id), 1000)
         return
       }
       const buffered = this._fix_md_event_buffer[pair] || []
@@ -723,11 +1008,12 @@ module.exports = class Coinbase extends ExchangeBase {
   }
 
   // Background resnapshot: old book stays live while new one is built, then atomic swap.
-  _fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT) {
+  _fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT, session_id = this._fix_md_session_id) {
     this._fix_md_fetch_snapshot(pair, (res) => {
+      if (session_id !== this._fix_md_session_id) return
       if (!res.success) {
         console.log('[coinbase FIX MD] resnapshot fetch failed for %s, retrying in 1s', pair)
-        setTimeout(() => this._fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT), 1000)
+        setTimeout(() => this._fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT, session_id), 1000)
         return
       }
       const buffered = this._fix_md_resnapshot_buffer[pair] || []
@@ -931,7 +1217,7 @@ module.exports = class Coinbase extends ExchangeBase {
     this._fix_md_resnapshot_buffer[pair] = []
     console.log('[coinbase FIX MD] %s: %s snap_mid=%s cur_mid=%s bid=%s ask=%s, refetching',
       reason, pair, snap_mid.toFixed(2), cur_mid.toFixed(2), best_bid, best_ask)
-    this._fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT)
+    this._fix_md_resnapshot(pair, OB_WINDOW, RESNAPSHOT_DRIFT, this._fix_md_session_id)
   }
 
   _fix_md_update_bbo(pair, OB_WINDOW, RESNAPSHOT_DRIFT, options = {}) {
@@ -987,7 +1273,7 @@ module.exports = class Coinbase extends ExchangeBase {
   }
 
   ws_status() {
-    return { market: this.ws.market.pair_status, trading: 'n-opened' }
+    return { market: this.ws.market.pair_status, trading: this.ws.trading.status }
   }
   rate_ws(pair, cb) {
     if (this.ws.market.pair_status[pair] === 'opened') {
@@ -1106,8 +1392,8 @@ module.exports = class Coinbase extends ExchangeBase {
       cb({ success: false, error: error_codes.amount_too_small })
       return
     }
-    if (this.fix_ord && this.fix_ord.is_ready()) {
-      this.fix_ord.send_new_order(pair, method, price, amount, order_options, cb)
+    if (this._fix_trading_ready()) {
+      this._send_fix_new_order(pair, method, price, amount, order_options, cb)
       return
     }
     if (this.advanced) {
@@ -1173,13 +1459,13 @@ module.exports = class Coinbase extends ExchangeBase {
       cb({ success: false, error: error_codes.amount_too_small })
       return
     }
-    if (this.fix_ord && this.fix_ord.is_ready()) {
+    if (this._fix_trading_ready()) {
       const normalized = this.normalize_order_options(order_options)
       const t_order_sent = process.hrtime()
       if (normalized.on_sent) {
         normalized.on_sent({ t_order_sent })
       }
-      this.fix_ord.send_new_order(pair, method, price, amount, normalized.order_options, (res = {}) => {
+      this._send_fix_new_order(pair, method, price, amount, normalized.order_options, (res = {}) => {
         res.meta = {
           ...(res.meta || {}),
           t_order_sent,
@@ -1230,9 +1516,9 @@ module.exports = class Coinbase extends ExchangeBase {
     }
   }
   cancel_order_by_order(order, cb) {
-    if (this.fix_ord && this.fix_ord.is_ready()) {
+    if (this._fix_trading_ready()) {
       const t_cancel_sent = process.hrtime()
-      this.fix_ord.send_cancel(order.pair, order.order_id, order.type, (res = {}) => {
+      this._send_fix_cancel(order.pair, order.order_id, order.type, (res = {}) => {
         res.meta = {
           ...(res.meta || {}),
           t_cancel_sent,
@@ -1708,7 +1994,9 @@ module.exports = class Coinbase extends ExchangeBase {
             await sleep(50)
           }
         }
-        cb({ success: true, body: sort_history_rows(filter_history_in_range(results, start_time_in_ms, end_time_in_ms)) })
+        let trades = sort_history_rows(filter_history_in_range(results, start_time_in_ms, end_time_in_ms))
+        trades = utils.merge_trades_with_same_id(trades)
+        cb({ success: true, body: trades })
       } catch (error) {
         cb({ success: false, error: error?.error || error_codes.other, body: error?.body })
       }

package/lib/exchanges/coinstore.js

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

package/lib/exchanges/coinw.js

@@ -7,6 +7,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')
@@ -506,38 +507,53 @@ module.exports = class Coinw extends ExchangeBase {
   get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
     const [api_key, secret_key] = this.api_secret_key
     const get_trades_base = (pair, start_time_in_ms, end_time_in_ms, cb) => {
-      const params = {
-        api_key,
-        currencyPair: pre_process_pair(pair),
-        endAt: end_time_in_ms,
-        startAt: start_time_in_ms,
-      }
-      params.sign = get_signature_coinw(secret_key, params)
-      needle.post('https://api.coinw.com/api/v1/private?command=returnUTradeHistory', params, options, (_err, _res, body) => {
-        body = parse_body(body)
-        if (body && body.code === '200') {
-          if (!body.data) {
-            cb({ success: true, body: [] })
-          } else {
-            let trades = body.data
-              .filter((t) => t.status === '2' || t.status === '3')
-              .map((trade) => ({
-                order_id: trade.tradeID.toString(),
-                pair,
-                type: trade.type,
-                price: parseFloat(trade.prize), // exchange typo
-                amount: parseFloat(trade.success_count),
-                total: parseFloat(trade.success_amount),
-                close_time: new Date(parseInt(trade.date)),
-              }))
-            trades = utils.merge_trades_with_same_id(trades)
-            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: 100,
+          fetch_window: async (window_start_ms, window_stop_ms) =>
+            await new Promise((resolve, reject) => {
+              const params = {
+                api_key,
+                currencyPair: pre_process_pair(pair),
+                endAt: window_stop_ms,
+                startAt: window_start_ms,
+              }
+              params.sign = get_signature_coinw(secret_key, params)
+              needle.post('https://api.coinw.com/api/v1/private?command=returnUTradeHistory', params, options, (_err, _res, body) => {
+                body = parse_body(body)
+                if (body && body.code === '200') {
+                  if (!body.data) {
+                    resolve([])
+                  } else {
+                    resolve(
+                      body.data
+                        .filter((t) => t.status === '2' || t.status === '3')
+                        .map((trade) => ({
+                          order_id: trade.tradeID.toString(),
+                          pair,
+                          type: trade.type,
+                          price: parseFloat(trade.prize), // exchange typo
+                          amount: parseFloat(trade.success_count),
+                          total: parseFloat(trade.success_amount),
+                          close_time: new Date(parseInt(trade.date)),
+                        })),
+                    )
+                  }
+                } 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_trades_base, pair, start_time_in_ms, end_time_in_ms, cb)

package/lib/exchanges/cryptocom.js

@@ -558,6 +558,7 @@ module.exports = class Cryptocom 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/deepcoin.js

@@ -528,6 +528,7 @@ module.exports = class Deepcoin 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))
   }