@icgio/icg-exchanges 1.40.48 → 1.40.50

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)
       }
-      this._fix_md_orders = {}
-      this._fix_md_snapshot_mid = {}
-      this._fix_md_snapshot_seq = {}
-      this._fix_md_event_buffer = {}
-      this._fix_md_cross_pending = {}
+      return
     }
-    this.ws.market.start(pair_list)
+    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)
+      }
+    }
+  }
+
+  _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,

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/kucoin.js

@@ -560,6 +560,7 @@ module.exports = class Kucoin extends ExchangeBase {
           fees: {
             [post_process_cur(fill.feeCurrency)]: parseFloat(fill.fee),
           },
+          role: fill.liquidity,
         }
       }
       let dedupe_history_trades = (trades) => {
@@ -567,9 +568,18 @@ module.exports = class Kucoin extends ExchangeBase {
         trades.forEach((trade) => {
           let time = trade.open_time instanceof Date ? trade.open_time.getTime() : new Date(trade.open_time).getTime()
           let fees = trade.fees && typeof trade.fees === 'object' ? JSON.stringify(trade.fees) : ''
-          let key =
-            trade.trade_id ||
-            [trade.order_id || '', pair, trade.type || '', trade.price || 0, trade.amount || 0, trade.total || 0, Number.isFinite(time) ? time : 0, fees].join('|')
+          let key = [
+            trade.trade_id || '',
+            trade.order_id || '',
+            pair,
+            trade.type || '',
+            trade.role || '',
+            trade.price || 0,
+            trade.amount || 0,
+            trade.total || 0,
+            Number.isFinite(time) ? time : 0,
+            fees,
+          ].join('|')
           if (!by_fill_identity.has(key)) by_fill_identity.set(key, trade)
         })
         return [...by_fill_identity.values()]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges",
-  "version": "1.40.48",
+  "version": "1.40.50",
   "description": "icgio exchanges package",
   "main": "./exchanges.js",
   "scripts": {

package/lib/exchanges/coinbase-fix.js

@@ -1,267 +0,0 @@
-// Coinbase FIX session wrappers.
-//
-// CoinbaseFixOrd  — order entry (fix-ord.exchange.coinbase.com:6121)
-// CoinbaseFixMd   — market data (fix-md.exchange.coinbase.com:6121)
-
-const { createHmac, randomUUID } = require('crypto')
-const ExchangeFix = require('./exchange-fix.js')
-
-const SOH = '\x01'
-
-// --- Shared helpers ---
-
-function build_logon_fields(api_key, secret_key, passphrase, seq_num, sending_time) {
-  let prehash = sending_time + SOH + 'A' + SOH + seq_num + SOH + api_key + SOH + 'Coinbase' + SOH + passphrase
-  let signature = createHmac('sha256', Buffer.from(secret_key, 'base64')).update(prehash).digest('base64')
-  return [
-    [553, api_key], [554, passphrase],
-    [95, signature.length], [96, signature],
-    [98, 0], [108, 30], [141, 'Y'], [1137, 9],
-  ]
-}
-
-function parse_event_ts_ms(fix_time) {
-  if (!fix_time || fix_time.length < 17) return undefined
-  let iso = fix_time.slice(0, 4) + '-' + fix_time.slice(4, 6) + '-' + fix_time.slice(6, 8) + 'T' + fix_time.slice(9, 21) + 'Z'
-  let ms = Date.parse(iso)
-  return Number.isFinite(ms) ? ms : undefined
-}
-
-function parse_md_entry(fields) {
-  let symbol = fields['55']
-  let entry_type = fields['269']
-  let action = fields['279']
-  let md_entry_id = fields['278']
-  let order_id = fields['37']
-  if (!symbol || entry_type === undefined || action === undefined) return null
-  let price = parseFloat(fields['270'])
-  let size = parseFloat(fields['271'])
-  if (!Number.isFinite(price)) return null
-  let 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,
-  }
-}
-
-// --- CoinbaseFixOrd ---
-
-class CoinbaseFixOrd {
-  constructor(api_key, secret_key, passphrase, options = {}) {
-    this.error_codes = options.error_codes || {}
-    this.pre_process_pair = options.pre_process_pair || ((p) => p)
-    this.pending = new Map()
-
-    this.fix = new ExchangeFix('coinbase_ord', {
-      host: options.host || 'fix-ord.exchange.coinbase.com',
-      port: options.port || 6121,
-      sender_comp_id: api_key,
-      target_comp_id: 'Coinbase',
-      heartbeat_interval: 30,
-      build_logon_fields: (seq, time) => {
-        let fields = build_logon_fields(api_key, secret_key, passphrase, seq, time)
-        fields.push([8013, 'S'])
-        return fields
-      },
-      on_execution_report: (fields) => this._handle_exec_report(fields),
-      on_cancel_reject: (fields) => this._handle_cancel_reject(fields),
-      on_reject: (fields) => this._handle_reject(fields),
-      on_status_change: (status) => {
-        console.log('[coinbase FIX ord] status:', status)
-        if (status === 'disconnected') this._flush_pending()
-      },
-    })
-  }
-
-  connect() { this.fix.connect() }
-  disconnect() { this.fix.disconnect() }
-  is_ready() { return this.fix.is_ready() }
-
-  send_new_order(pair, method, price, amount, order_options, cb) {
-    if (typeof order_options === 'function') { cb = order_options; order_options = {} }
-    let cl_ord_id = randomUUID()
-    let 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'
-    let fields = [
-      [11, cl_ord_id], [55, this.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'])
-    let timeout_id = setTimeout(() => this._resolve_pending(cl_ord_id, { success: false, error: this.error_codes.timeout }), 15000)
-    this.pending.set(cl_ord_id, { cb, timeout_id, type: 'new' })
-    this.fix.send('D', fields)
-  }
-
-  send_cancel(pair, order_id, side, cb) {
-    let cl_ord_id = randomUUID()
-    let fix_side = side === 'buy' ? '1' : '2'
-    let fields = [
-      [11, cl_ord_id], [41, cl_ord_id], [37, order_id],
-      [55, this.pre_process_pair(pair)], [54, fix_side],
-    ]
-    let timeout_id = setTimeout(() => this._resolve_pending(cl_ord_id, { success: false, error: this.error_codes.timeout }), 15000)
-    this.pending.set(cl_ord_id, { cb, timeout_id, type: 'cancel', order_id })
-    this.fix.send('F', fields)
-  }
-
-  _handle_exec_report(fields) {
-    let cl_ord_id = fields['11'], ord_status = fields['39'], order_id = fields['37'] || '', ec = this.error_codes
-    if (ord_status === '0') {
-      this._resolve_pending(cl_ord_id, { success: true, body: order_id })
-    } else if (ord_status === '8') {
-      let text = fields['58'] || '', error = ec.other
-      if (text.includes('nsufficient') || text.includes('NSUFFICIENT')) error = ec.insufficient_funds
-      else if (fields['103'] === '2' || text.includes('too small') || text.includes('TOO_SMALL')) error = ec.amount_too_small
-      this._resolve_pending(cl_ord_id, { success: false, error, body: text })
-    } else if (ord_status === '4') {
-      if (this.pending.has(cl_ord_id)) this._resolve_pending(cl_ord_id, { success: true, body: order_id })
-      else this._resolve_pending_by_order_id(order_id, { success: true, body: order_id })
-    } else if (ord_status === '1' || ord_status === '2') {
-      if (this.pending.has(cl_ord_id) && this.pending.get(cl_ord_id).type === 'cancel')
-        this._resolve_pending(cl_ord_id, { success: false, error: ec.order_not_open, body: order_id })
-      else this._resolve_pending_by_order_id(order_id, { success: false, error: ec.order_not_open, body: order_id }, 'cancel')
-    }
-  }
-
-  _handle_cancel_reject(fields) {
-    let error = this.error_codes.other
-    if (fields['102'] === '1') error = this.error_codes.order_not_open
-    this._resolve_pending(fields['11'], { success: false, error, body: fields['58'] || '' })
-  }
-
-  _handle_reject(fields) {
-    let cl_ord_id = fields['379'] || fields['11'] || ''
-    if (cl_ord_id && this.pending.has(cl_ord_id))
-      this._resolve_pending(cl_ord_id, { success: false, error: this.error_codes.other, body: fields['58'] || '' })
-  }
-
-  _resolve_pending(cl_ord_id, result) {
-    let p = this.pending.get(cl_ord_id)
-    if (!p) return
-    clearTimeout(p.timeout_id)
-    this.pending.delete(cl_ord_id)
-    p.cb(result)
-  }
-
-  _resolve_pending_by_order_id(order_id, result, type_filter) {
-    for (let [id, p] of this.pending) {
-      if (p.order_id === order_id && (!type_filter || p.type === type_filter)) {
-        this._resolve_pending(id, result)
-        return
-      }
-    }
-  }
-
-  _flush_pending() {
-    for (let [id, p] of this.pending) { clearTimeout(p.timeout_id); p.cb({ success: false, error: this.error_codes.timeout }) }
-    this.pending.clear()
-  }
-}
-
-// --- CoinbaseFixMd ---
-
-class CoinbaseFixMd {
-  constructor(options) {
-    this.symbols = options.symbols || []
-    this.on_event = options.on_event || (() => {})
-    this.on_batch = options.on_batch || null  // called with array of parsed entries per data chunk
-    this.on_status = options.on_status || (() => {})
-    this.subscribed = false
-
-    this.fix = new ExchangeFix('coinbase_md', {
-      host: options.host || 'fix-md.exchange.coinbase.com',
-      port: options.port || 6121,
-      sender_comp_id: options.api_key,
-      target_comp_id: 'Coinbase',
-      heartbeat_interval: 30,
-      build_logon_fields: (seq, time) => build_logon_fields(options.api_key, options.secret_key, options.passphrase, seq, time),
-      on_market_data_batch: this.on_batch ? (batch) => this._handle_md_batch(batch) : undefined,
-      on_market_data_incremental: this.on_batch ? undefined : (fields) => this._handle_md(fields),
-      on_market_data_snapshot: (fields) => this._handle_md(fields),
-      on_market_data_request_reject: (fields) => {
-        console.log('[coinbase FIX md] request reject:', fields['58'] || '')
-      },
-      on_status_change: (status) => {
-        if (status === 'ready' && !this.subscribed) this._send_subscribe()
-        if (status === 'disconnected') this.subscribed = false
-        this.on_status(status)
-      },
-    })
-  }
-
-  connect() { this.fix.connect() }
-  disconnect() { this.fix.disconnect() }
-  is_ready() { return this.fix.is_ready() }
-
-  _send_subscribe() {
-    if (!this.symbols.length) return
-    let fields = [
-      [262, 'icg-md-' + Date.now()], [263, 1], [264, 0], [265, 1],
-      [267, 3], [269, 0], [269, 1], [269, 2],
-      [146, this.symbols.length],
-    ]
-    for (let s of this.symbols) fields.push([55, s])
-    this.fix.send('V', fields)
-    this.subscribed = true
-    console.log('[coinbase FIX md] subscribed:', this.symbols.join(','))
-  }
-
-  _handle_md(fields) {
-    const hr_recv = process.hrtime()
-    let entry = parse_md_entry(fields)
-    if (!entry) return
-    const hr_parsed = process.hrtime()
-    entry.ts_ms_venue_event = parse_event_ts_ms(entry.time)
-    entry.ts_ms_local_received = Date.now()
-    entry.hr_recv = hr_recv
-    entry.hr_parsed = hr_parsed
-    this.on_event(entry)
-  }
-
-  _handle_md_batch(batch) {
-    let entries = []
-    let now = Date.now()
-    for (let fields of batch) {
-      const hr_recv = process.hrtime()
-      let entry = parse_md_entry(fields)
-      if (!entry) continue
-      const hr_parsed = process.hrtime()
-      entry.ts_ms_venue_event = parse_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.on_batch(entries)
-  }
-}
-
-module.exports = {
-  CoinbaseFixOrd,
-  CoinbaseFixMd,
-  build_logon_fields,
-  parse_md_entry,
-  parse_event_ts_ms,
-}