@icgio/icg-exchanges 1.40.42 → 1.40.44

package/lib/exchanges/bitstamp.js

@@ -370,6 +370,77 @@ module.exports = class Bitstamp extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { filter_history_in_range, sort_history_rows, sleep } = ExchangeBase.history_utils
+    let [base_cur, quote_cur] = utils.parse_pair(pair)
+    let base_key = base_cur.toLowerCase()
+    let quote_key = quote_cur.toLowerCase()
+    let price_key = base_key + '_' + quote_key
+    let parse_trade_time = (datetime) => {
+      let iso = datetime.replace(' ', 'T').replace(/(\.\d{3})\d+$/, '$1')
+      return new Date(iso + 'Z')
+    }
+    let fetch_page = (offset) =>
+      new Promise((resolve, reject) => {
+        let url = 'https://www.bitstamp.net/api/v2/user_transactions/' + pre_process_pair(pair) + '/'
+        let params = {
+          key: api_key,
+          nonce: Date.now(),
+          signature: get_signature_bitstamp(api_key, secret_key, this.account_id),
+          limit: 1000,
+          offset,
+          sort: 'desc',
+        }
+        needle.post(url, params, (err, res, body) => {
+          if (Array.isArray(body)) {
+            resolve(body)
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = []
+      let offset = 0
+      while (offset <= 200000) {
+        let rows = await fetch_page(offset)
+        if (rows.length === 0) break
+        trades.push(
+          ...rows
+            .filter((trade) => String(trade.type) === '2')
+            .map((trade) => {
+              let close_time = parse_trade_time(trade.datetime)
+              let price = parseFloat(trade[price_key])
+              let amount = Math.abs(parseFloat(trade[base_key]))
+              let total = Math.abs(parseFloat(trade[quote_key]))
+              return {
+                order_id: trade.order_id != null ? trade.order_id.toString() : '',
+                trade_id: (trade.id || trade.tid || '').toString(),
+                pair,
+                type: parseFloat(trade[base_key]) < 0 ? 'sell' : 'buy',
+                price,
+                amount,
+                total: Number.isFinite(total) ? total : price * amount,
+                close_time,
+              }
+            })
+        )
+        let oldest_seen_ms = Math.min(
+          ...rows
+            .map((trade) => parse_trade_time(trade.datetime).getTime())
+            .filter((time) => Number.isFinite(time))
+        )
+        if (rows.length < 1000 || (Number.isFinite(oldest_seen_ms) && oldest_seen_ms < start_time_in_ms)) break
+        offset += rows.length
+        await sleep(250)
+      }
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   static get_min_amount(cb) {
     let min_quote_cur_amount = {}
     needle.get('https://www.bitstamp.net/api/v2/trading-pairs-info/', (err, res, body) => {

package/lib/exchanges/blofin.js

@@ -583,6 +583,78 @@ module.exports = class Blofin extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let [base_cur, quote_cur] = utils.parse_pair(pair)
+    let path = '/api/v1/spot/trade/fills-history'
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          instType: 'SPOT',
+          instId: pre_process_pair(pair),
+          begin: window_start_ms.toString(),
+          end: (window_stop_ms - 1).toString(),
+          limit: '100',
+        }
+        let query = qs.stringify(params)
+        let request_path = path + '?' + query
+        let timestamp = Date.now()
+        let nonce = generate_nonce()
+        let signature = get_signature_blofin(secret_key, 'GET', timestamp, request_path, nonce)
+        let options = get_options(api_key, signature, timestamp, nonce, this.passphrase)
+        let url = 'https://openapi.blofin.com' + request_path
+        needle.get(url, options, (err, res, body) => {
+          if (body && _.includes(['0', 0, 200], body.code) && Array.isArray(body.data)) {
+            resolve(
+              body.data.map((trade) => {
+                let price = parseFloat(trade.fillPrice || trade.trade_price)
+                let amount = parseFloat(trade.fillSize || trade.trade_quantity)
+                let total = price * amount
+                let fee = Math.abs(parseFloat(trade.fee || trade.trade_fee))
+                let fee_currency = trade.feeCurrency || trade.fee_currency
+                if (fee_currency === 'base_currency') fee_currency = base_cur
+                if (fee_currency === 'quote_currency') fee_currency = quote_cur
+                let mapped_trade = {
+                  order_id: (trade.orderId || trade.order_id || '').toString(),
+                  trade_id: (trade.tradeId || trade.trade_id || '').toString(),
+                  pair,
+                  type: (trade.side || trade.order_side || '').toLowerCase(),
+                  price,
+                  amount,
+                  total,
+                  close_time: new Date(parseInt(trade.ts || trade.create_time)),
+                }
+                if (Number.isFinite(fee) && fee_currency) {
+                  mapped_trade.fees = {
+                    [post_process_cur(fee_currency)]: fee,
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body && body.toString().startsWith('<html>')) {
+            reject({ success: false, error: error_codes.service_unavailable, body })
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 30 * 24 * 60 * 60 * 1000,
+        page_limit: 100,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   get_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key

package/lib/exchanges/btse.js

@@ -488,6 +488,9 @@ module.exports = class Btse 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_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key

package/lib/exchanges/coinbase.js

@@ -7,6 +7,7 @@ const needle = require('needle')
 
 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
 
 const { sorted_book } = require('@icgio/icg-utils')
 
@@ -1572,6 +1573,107 @@ module.exports = class Coinbase extends ExchangeBase {
       cb({ success: true, body: [] })
     }
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    const get_history_trades_base = async (pair, start_time_in_ms, end_time_in_ms, cb) => {
+      try {
+        const results = []
+        if (this.advanced) {
+          let cursor = null
+          while (true) {
+            let path = '/api/v3/brokerage/orders/historical/fills'
+            let params = { product_id: pre_process_pair(pair) }
+            if (cursor) params.cursor = cursor
+            let options = this._get_auth('GET', path, params)
+            let url = this._base_url() + path + '?' + qs.stringify(params)
+            const response = await new Promise((resolve, reject) => {
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body.fills)) {
+                  resolve(body)
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            })
+            if (response.fills.length === 0) break
+            let oldest_ms = Infinity
+            for (const fill of response.fills) {
+              const close_time_ms = history_time_ms(fill.trade_time)
+              if (close_time_ms < oldest_ms) oldest_ms = close_time_ms
+              if (close_time_ms < start_time_in_ms || close_time_ms >= end_time_in_ms) continue
+              let quote_cur = (fill.product_id || '').split('-')[1] || ''
+              let trade = {
+                order_id: fill.order_id != null ? fill.order_id.toString() : '',
+                pair,
+                type: String(fill.side || '').toLowerCase(),
+                price: parseFloat(fill.price),
+                amount: parseFloat(fill.size),
+                total: parseFloat(fill.price) * parseFloat(fill.size),
+                close_time: new Date(close_time_ms),
+                fees: quote_cur && fill.commission != null ? { [post_process_cur(quote_cur)]: parseFloat(fill.commission) } : {},
+                role: fill.liquidity_indicator === 'MAKER' ? 'maker' : 'taker',
+              }
+              if (fill.trade_id != null) trade.trade_id = fill.trade_id.toString()
+              else if (fill.entry_id != null) trade.trade_id = fill.entry_id.toString()
+              results.push(trade)
+            }
+            if (!response.has_next || !response.cursor || oldest_ms < start_time_in_ms) break
+            cursor = response.cursor
+            await sleep(50)
+          }
+        } else {
+          let after = null
+          while (true) {
+            let path = '/fills'
+            let params = { product_id: pre_process_pair(pair) }
+            if (after) params.after = after
+            let options = this._get_auth('GET', path, params)
+            let url = this._base_url() + path + '?' + qs.stringify(params)
+            const response = await new Promise((resolve, reject) => {
+              needle.get(url, options, (err, res, body) => {
+                if (body && Array.isArray(body)) {
+                  resolve({ res, body })
+                } else if (body) {
+                  reject({ error: error_codes.other, body })
+                } else {
+                  reject({ error: error_codes.timeout })
+                }
+              })
+            })
+            if (response.body.length === 0) break
+            let oldest_ms = Infinity
+            for (const fill of response.body) {
+              const close_time_ms = history_time_ms(fill.created_at)
+              if (close_time_ms < oldest_ms) oldest_ms = close_time_ms
+              if (close_time_ms < start_time_in_ms || close_time_ms >= end_time_in_ms) continue
+              let trade = {
+                order_id: fill.order_id != null ? fill.order_id.toString() : '',
+                pair,
+                type: String(fill.side || '').toLowerCase(),
+                price: parseFloat(fill.price),
+                amount: parseFloat(fill.size),
+                total: parseFloat(fill.price) * parseFloat(fill.size),
+                close_time: new Date(close_time_ms),
+                fees: fill.funding_currency && fill.fee != null ? { [post_process_cur(fill.funding_currency)]: parseFloat(fill.fee) } : {},
+                role: fill.liquidity === 'M' ? 'maker' : 'taker',
+              }
+              if (fill.trade_id != null) trade.trade_id = fill.trade_id.toString()
+              results.push(trade)
+            }
+            const next_after = response.res?.headers?.['cb-after']
+            if (!next_after || oldest_ms < start_time_in_ms) break
+            after = next_after
+            await sleep(50)
+          }
+        }
+        cb({ success: true, body: sort_history_rows(filter_history_in_range(results, start_time_in_ms, end_time_in_ms)) })
+      } 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)
+  }
   _convert(from_cur, to_cur, amount, cb) {
     if (this.advanced) {
       cb({ success: false, error: error_codes.other, body: { message: 'Convert not supported on Advanced API' } })

package/lib/exchanges/coinstore.js

@@ -476,6 +476,9 @@ module.exports = class Coinstore extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    this._get_history_trades_via_timeframe(pair, start_time_in_ms, end_time_in_ms, cb)
+  }
   static get_precision(cb) {
     const price_precision = {}
     const amount_precision = {}

package/lib/exchanges/cryptocom.js

@@ -493,6 +493,72 @@ module.exports = class Cryptocom extends ExchangeBase {
       }
     })
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let req = {
+          id: 11,
+          method: 'private/get-trades',
+          params: {
+            instrument_name: pre_process_pair(pair),
+            start_time: window_start_ms,
+            end_time: window_stop_ms - 1,
+            limit: 100,
+          },
+          api_key: api_key,
+          nonce: Date.now(),
+        }
+        req.sig = get_signature_crypto(req, secret_key)
+        needle.post('https://api.crypto.com/v2/private/get-trades', req, options, (err, res, body) => {
+          body = parse_body(body)
+          let rows = body?.result?.data || body?.result?.trade_list
+          if (body && body.code === 0 && Array.isArray(rows)) {
+            resolve(
+              rows.map((trade) => {
+                let price = parseFloat(trade.traded_price)
+                let amount = parseFloat(trade.traded_quantity)
+                let fee = Math.abs(parseFloat(trade.fees || trade.fee))
+                let mapped_trade = {
+                  order_id: (trade.order_id || '').toString(),
+                  trade_id: (trade.trade_id || trade.trade_match_id || '').toString(),
+                  pair,
+                  type: (trade.side || '').toLowerCase(),
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.create_time)),
+                }
+                if (trade.taker_side) mapped_trade.role = trade.taker_side.toLowerCase()
+                if (Number.isFinite(fee) && trade.fee_instrument_name) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.fee_instrument_name)]: fee,
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 7 * 24 * 60 * 60 * 1000,
+        page_limit: 100,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   get_all_deposits(timeframe_in_ms, cb) {
     let [api_key, secret_key] = this.api_secret_key
     let req = {

package/lib/exchanges/deepcoin.js

@@ -467,6 +467,70 @@ module.exports = class Deepcoin extends ExchangeBase {
     }
     this.private_limiter.process(get_all_trades_base, timeframe_in_ms, cb, 2)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let path = '/deepcoin/trade/fills'
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          instType: 'SPOT',
+          instId: pre_process_pair(pair),
+          begin: window_start_ms,
+          end: window_stop_ms - 1,
+          limit: 100,
+        }
+        let query = qs.stringify(params)
+        let options = get_options(api_key, secret_key, this.passphrase, 'GET', path + '?' + query, '')
+        needle.get(base_url + path + '?' + query, options, (err, res, body) => {
+          body = parse_body(body)
+          if (body && body.code === '0' && Array.isArray(body.data)) {
+            resolve(
+              body.data.map((trade) => {
+                let price = parseFloat(trade.fillPx)
+                let amount = parseFloat(trade.fillSz)
+                let mapped_trade = {
+                  order_id: (trade.ordId || '').toString(),
+                  trade_id: (trade.tradeId || trade.billId || '').toString(),
+                  pair: post_process_pair(trade.instId),
+                  type: trade.side,
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.ts)),
+                }
+                if (trade.execType === 'M') mapped_trade.role = 'maker'
+                if (trade.execType === 'T') mapped_trade.role = 'taker'
+                if (trade.feeCcy && Number.isFinite(parseFloat(trade.fee))) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.feeCcy)]: Math.abs(parseFloat(trade.fee)),
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body && (body.code === '50026' || body.code === '50001')) {
+            reject({ success: false, error: error_codes.service_unavailable, body })
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 30 * 24 * 60 * 60 * 1000,
+        page_limit: 100,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   static get_min_amount(cb) {
     let min_quote_cur_amount = {}
     needle.get('https://api.deepcoin.com/deepcoin/market/instruments?instType=SPOT', (err, res, body) => {

package/lib/exchanges/digifinex.js

@@ -381,6 +381,68 @@ module.exports = class Digifinex extends ExchangeBase {
     }
     this.private_limiter.process(get_trades_base, pair, timeframe_in_ms, cb)
   }
+  get_history_trades(pair, start_time_in_ms, end_time_in_ms, cb) {
+    let [api_key, secret_key] = this.api_secret_key
+    let { fetch_split_windows, filter_history_in_range, sort_history_rows } = ExchangeBase.history_utils
+    let fetch_window = (window_start_ms, window_stop_ms) =>
+      new Promise((resolve, reject) => {
+        let params = {
+          symbol: pre_process_pair(pair),
+          limit: 500,
+          start_time: Math.floor(window_start_ms / 1000),
+          end_time: Math.floor((window_stop_ms - 1) / 1000),
+        }
+        let signature = get_signature_digifinex(secret_key, params)
+        let options = get_options(api_key, signature)
+        let url = 'https://openapi.digifinex.com/v3/spot/mytrades?' + qs.stringify(params)
+        needle.get(url, options, (err, res, body) => {
+          if (body && body.code === 0 && Array.isArray(body.list)) {
+            resolve(
+              body.list.map((trade) => {
+                let price = parseFloat(trade.price)
+                let amount = parseFloat(trade.amount)
+                let is_maker = trade.is_maker === true || trade.is_maker === 1 || trade.is_maker === '1' || trade.is_maker === 'true'
+                let mapped_trade = {
+                  order_id: (trade.order_id || '').toString(),
+                  trade_id: (trade.id || trade.tid || '').toString(),
+                  pair,
+                  type: (trade.side || '').split('_')[0],
+                  price,
+                  amount,
+                  total: price * amount,
+                  close_time: new Date(parseInt(trade.timestamp) * 1000),
+                  role: is_maker ? 'maker' : 'taker',
+                }
+                if (trade.fee_currency && Number.isFinite(parseFloat(trade.fee))) {
+                  mapped_trade.fees = {
+                    [post_process_cur(trade.fee_currency)]: Math.abs(parseFloat(trade.fee)),
+                  }
+                }
+                return mapped_trade
+              })
+            )
+          } else if (body && body.toString().startsWith('<html>')) {
+            reject({ success: false, error: error_codes.service_unavailable, body })
+          } else if (body) {
+            reject({ success: false, error: error_codes.other, body })
+          } else {
+            reject({ success: false, error: error_codes.timeout })
+          }
+        })
+      })
+    ;(async () => {
+      let trades = await fetch_split_windows({
+        start_ms: start_time_in_ms,
+        stop_ms: end_time_in_ms,
+        initial_window_ms: 30 * 24 * 60 * 60 * 1000,
+        page_limit: 500,
+        fetch_window,
+        delay_ms: 250,
+      })
+      trades = sort_history_rows(filter_history_in_range(trades, start_time_in_ms, end_time_in_ms))
+      cb({ success: true, body: trades })
+    })().catch((error) => cb(error))
+  }
   get_all_deposits(timeframe_in_ms, cb) {
     let get_all_deposits_base = (timeframe_in_ms, cb) => {
       let [api_key, secret_key] = this.api_secret_key