@icgio/icg-exchanges-wrapper 1.8.6

package/README.md

@@ -0,0 +1 @@
+# icg-exchanges-wrapper

package/functions/get-exchanges-balance.js

@@ -0,0 +1,32 @@
+const _ = require('lodash')
+
+let first_time = {}, balances = {}
+module.exports = function (Exchanges, cb) {
+  if (!Array.isArray(Exchanges)) {
+    console.error('Exchanges should be an array')
+    return
+  } else {
+    for (let Exchange of Exchanges) {
+      if (Exchange.balance_ws) {
+        if (Exchange.ws_status().trading === 'n-opened')
+          Exchange.ws_account()
+        Exchange.balance_ws(function (res) {
+          if (res.success) {
+            _.set(balances, Exchange.exchange_id, res.body)
+          } else {
+            delete balances[Exchange.exchange_id]
+          }
+        })
+      } else {
+        Exchange.balance(function (res) {
+          if (res.success) {
+            _.set(balances, Exchange.exchange_id, res.body)
+          } else {
+            delete balances[Exchange.exchange_id]
+          }
+        })
+      }
+    }
+  }
+  cb(balances)
+}

package/functions/get-exchanges-rates-market-history.js

@@ -0,0 +1,113 @@
+const _ = require('lodash')
+
+let first_time = {}, checked_rates = {}, exchange_pair_rates = {}, pair_exchange_rates = {}
+module.exports.get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb, ws_enabled=true) {
+  checked_rates = {}
+  if (!Array.isArray(Exchanges)) {
+    console.error('Exchanges should be an array')
+    return
+  } else {
+    for (let Exchange of Exchanges) {
+      let Exchange_name = _.upperFirst(Exchange.name)
+      if (checked_rates[Exchange_name])
+        continue
+      checked_rates[Exchange_name] = true
+      if (!exchange_pair_dict[Exchange_name]) continue
+      if (Exchange.ws_market && ws_enabled) {
+        if (!first_time[Exchange_name]) {
+          Exchange.ws_market(exchange_pair_dict[Exchange_name])
+          first_time[Exchange_name] = true
+        } else {
+          for (let pair of exchange_pair_dict[Exchange_name]) {
+            Exchange.rate_ws(pair, function (res) {
+              if (res.success) {
+                _.set(exchange_pair_rates, [Exchange_name, pair], res.body)
+                _.set(pair_exchange_rates, [pair, Exchange_name], res.body)
+              } else {
+                if (exchange_pair_rates[Exchange_name]) {
+                  delete exchange_pair_rates[Exchange_name][pair]
+                }
+                if (pair_exchange_rates[pair]) {
+                  delete pair_exchange_rates[pair][Exchange_name]
+                }
+              }
+            })
+          }
+        }
+      } else {
+        for (let pair of exchange_pair_dict[Exchange_name]) {
+          Exchange.rate(pair, 50, function (res) {
+            if (res.success) {
+              _.set(exchange_pair_rates, [Exchange_name, pair], res.body)
+              _.set(pair_exchange_rates, [pair, Exchange_name], res.body)
+            } else {
+              if (exchange_pair_rates[Exchange_name]) {
+                delete exchange_pair_rates[Exchange_name][pair]
+              }
+              if (pair_exchange_rates[pair]) {
+                delete pair_exchange_rates[pair][Exchange_name]
+              }
+            }
+          })
+        }
+      }
+    }
+  }
+  cb({ exchange_pair_rates, pair_exchange_rates })
+}
+
+let checked_market_history = {}, exchange_pair_market_history = {}, pair_exchange_market_history = {}
+module.exports.get_exchanges_market_history = function (Exchanges, exchange_pair_dict, timeframe_in_ms, cb) {
+  checked_market_history = {}
+  if (!Array.isArray(Exchanges)) {
+    console.error('Exchanges should be an array')
+    return
+  } else {
+    for (let Exchange of Exchanges) {
+      let Exchange_name = _.upperFirst(Exchange.name)
+      if (checked_market_history[Exchange_name])
+        continue
+      checked_market_history[Exchange_name] = true
+      if (!exchange_pair_dict[Exchange_name]) continue
+      if (Exchange.ws_market) {
+        if (!first_time[Exchange_name]) {
+          Exchange.ws_market(exchange_pair_dict[Exchange_name])
+          first_time[Exchange_name] = true
+        } else {
+          for (let pair of exchange_pair_dict[Exchange_name]) {
+            Exchange.market_history_ws(pair, timeframe_in_ms, function (res) {
+              if (res.success) {
+                _.set(exchange_pair_market_history, [Exchange_name, pair], res.body)
+                _.set(pair_exchange_market_history, [pair, Exchange_name], res.body)
+              } else {
+                if (exchange_pair_market_history[Exchange_name]) {
+                  delete exchange_pair_market_history[Exchange_name][pair]
+                }
+                if (pair_exchange_market_history[pair]) {
+                  delete pair_exchange_market_history[pair][Exchange_name]
+                }
+              }
+            })
+          }
+        }
+      } else if (Exchange.market_history) {
+        for (let pair of exchange_pair_dict[Exchange_name]) {
+          Exchange.market_history(pair, timeframe_in_ms, function (res) {
+            if (res.success) {
+              _.set(exchange_pair_market_history, [Exchange_name, pair], res.body)
+              _.set(pair_exchange_market_history, [pair, Exchange_name], res.body)
+            } else {
+              if (exchange_pair_market_history[Exchange_name]) {
+                delete exchange_pair_market_history[Exchange_name][pair]
+              }
+              if (pair_exchange_market_history[pair]) {
+                delete pair_exchange_market_history[pair][Exchange_name]
+              }
+            }
+          })
+        }
+      }
+    }
+  }
+  cb({ exchange_pair_market_history, pair_exchange_market_history })
+}

package/index.js

@@ -0,0 +1,16 @@
+const get_exchanges_balance = require('./functions/get-exchanges-balance.js')
+const get_exchanges_open_orders = require('./functions/get-exchanges-open-orders.js')
+const get_exchanges_rates = require('./functions/get-exchanges-rates-market-history.js').get_exchanges_rates
+const get_exchanges_market_history = require('./functions/get-exchanges-rates-market-history.js').get_exchanges_market_history
+const get_exchanges_trades = require('./functions/get-exchanges-trades.js')
+
+module.exports.functions = {
+  get_exchanges_balance,
+  get_exchanges_open_orders,
+  get_exchanges_rates,
+  get_exchanges_market_history,
+  get_exchanges_trades
+}
+
+module.exports.orders = require('./middleware/orders.js')
+module.exports.websocket = require('./middleware/websocket.js')

package/middleware/account.js

@@ -0,0 +1,102 @@
+const _ = require('lodash')
+
+const USDCNY = 7.1, USDKRW = 1178, USDTHB = 30.3
+
+module.exports = class Account {
+  constructor (initial_balances) {
+    this.initial_exchange_assets_benchmark = {}
+    this.exchange_assets_benchmark = {}
+    this.initial_assets_benchmark = {}
+    this.assets_benchmark = {}
+    for (let exchange in initial_balances) {
+      for (let cur in initial_balances[exchange].total) {
+        _.set(this.initial_exchange_assets_benchmark, [exchange, cur], initial_balances[exchange].total[cur])
+        _.set(this.initial_assets_benchmark, cur, _.get(this.initial_assets_benchmark, cur, 0) + initial_balances[exchange].total[cur])
+      }
+    }
+    this.exchange_assets_benchmark = _.cloneDeep(this.initial_exchange_assets_benchmark)
+    this.assets_benchmark = _.cloneDeep(this.initial_assets_benchmark)
+  }
+  set_exchange_assets_from_balances (balances) {
+    for (let exchange in balances) {
+      for (let cur in balances[exchange].total) {
+        _.set(this.exchange_assets_benchmark, [exchange, cur], balances[exchange].total[cur])
+      }
+    }
+  }
+  get_exchange_position (balances, initial=true) {
+    let exchange_assets_benchmark = initial ? this.initial_exchange_assets_benchmark : this.exchange_assets_benchmark
+    let exchange_position = {}
+    for (let exchange in exchange_assets_benchmark) {
+      for (let cur in exchange_assets_benchmark[exchange]) {
+        if (!_.get(balances, [exchange, 'total'])) 
+          console.error('get_exchange_position error: ', exchange, balances[exchange])
+        if (_.get(balances, [exchange, 'total', cur])) {
+          let diff = balances[exchange].total[cur] - exchange_assets_benchmark[exchange][cur]
+          _.set(exchange_position, [exchange, cur, 'amount'], diff)
+          _.set(exchange_position, [exchange, cur, 'percentage'], diff / exchange_assets_benchmark[exchange][cur])
+        }
+      }
+    }
+    return exchange_position
+  }
+  get_position (balances, initial=true) {
+    let exchange_position = this.get_exchange_position(balances, initial)
+    let position = {}
+    for (let exchange in exchange_position) {
+      for (let cur in exchange_position[exchange]) {
+        if (!position[cur]) {
+          _.set(position, [cur, 'amount'], 0)
+          _.set(position, [cur, 'percentage'], 0)
+        }
+        position[cur].amount += exchange_position[exchange][cur].amount
+        position[cur].percentage = position[cur].amount / this.assets_benchmark[cur]
+      }
+    }
+    return position
+  }
+  get_exchange_profit (balances, cmc_rates, initial=true) {
+    let exchange_position = this.get_exchange_position(balances, initial)
+    let exchange_profit = {}
+    for (let exchange in exchange_position) {
+      let profit = {
+        BTC: 0
+      }
+      for (let cur in exchange_position[exchange]) {
+        if (!cmc_rates[cur]) {
+          // console.error('get_exchange_profit rates_cmc %s does not exist', cur)
+          continue
+        } else if (cmc_rates[cur].update_time < new Date() - 60 * 60 * 1000) {
+          console.error('get_exchange_profit rates_cmc %s expired', cur)
+          continue
+        }
+        let position = exchange_position[exchange][cur].amount
+        if (cur === 'BTC') {
+          profit.BTC += position
+        } else if (_.includes(['USD', 'USDT', 'USDC', 'BUSD', 'PAX', 'GUSD', 'HUSD'], cur)) {
+          profit.BTC += position / cmc_rates.BTC.USD
+        } else if (_.includes(['KRW'], cur)) {
+          profit.BTC += position / (cmc_rates.BTC.USD * USDKRW)
+        } else if (_.includes(['THB'], cur)) {
+          profit.BTC += position / (cmc_rates.BTC.USD * USDTHB)
+        } else if (_.includes(['CNYT'], cur)) {
+          profit.BTC += position / (cmc_rates.BTC.USD * USDCNY)
+        } else {
+          profit.BTC += position * cmc_rates[cur].BTC
+        }
+      }
+      _.set(exchange_profit, [exchange], profit)
+    }
+    return exchange_profit
+  }
+  get_profit (balances, cmc_rates, initial=true) {
+    let exchange_profit = this.get_exchange_profit(balances, cmc_rates, initial)
+    let profit =  {
+      BTC: 0,
+    }
+    for (let exchange in exchange_profit) {
+      profit.BTC += exchange_profit[exchange].BTC
+    }
+    return profit
+  }
+}