@icgio/icg-exchanges-wrapper 1.12.172 → 1.12.174

package/functions/get-exchanges-balance.js

@@ -1,32 +1,46 @@
-const _ = require('lodash')
+const _ = require('lodash');
+let balances = {}
+module.exports = function (exchanges, cb) {
+  if (!Array.isArray(exchanges)) {
+    console.error('exchanges should be an array');
+    return;
+  }
 
-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) {
+  const promises = exchanges.map(exchange => {
+    return new Promise((resolve, reject) => {
+      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)
+            _.set(balances, exchange.settings.id, res.body);
+            resolve();
           } else {
-            delete balances[Exchange.exchange_id]
+            delete balances[exchange.name];
+            resolve();
           }
-        })
-      } else if (Exchange.balance) {
-        Exchange.balance(function (res) {
+        });
+      } else if (exchange.balance) {
+        exchange.balance(function (res) {
           if (res.success) {
-            _.set(balances, Exchange.exchange_id, res.body)
+            _.set(balances, exchange.settings.id, res.body);
+            resolve();
           } else {
-            delete balances[Exchange.exchange_id]
+            delete balances[exchange.name];
+            resolve();
           }
-        })
+        });
+      } else {
+        resolve();
       }
-    }
-  }
-  cb(balances)
-}
+    });
+  });
+
+  Promise.all(promises)
+    .then(() => {
+      cb(balances);
+    })
+    .catch(error => {
+      console.error('Error fetching balances:', error);
+      cb({});
+    });
+};

package/functions/get-exchanges-deposits.js

@@ -0,0 +1,79 @@
+const _ = require('lodash')
+const TIMEFRAME_IN_THE_PAST = 90 * 24 * 60 * 60 * 1000
+const INVALID_EXCHANGES_LIST = ['Bitforex', 'Thinkbit', 'Kkcoin']
+
+let exchange_pair_deposits = {}
+let deposits_status = {}
+
+module.exports = function (exchanges, client_currency, cb) {
+  if (!Array.isArray(exchanges)) {
+    console.error('exchanges should be an array')
+    return
+  }
+
+  const promises = exchanges.map((exchange) => {
+    return new Promise((resolve, reject) => {
+      const exchange_name = exchange.Name
+      const exchange_id = exchange.settings.id
+
+      if (_.includes(INVALID_EXCHANGES_LIST, exchange_name)) {
+        resolve()
+        return
+      }
+
+      let deposits_fetch_promises = []
+
+      if (exchange.get_all_deposits) {
+        deposits_fetch_promises.push(
+          new Promise((resolve_pair, reject_pair) => {
+            exchange.get_all_deposits(TIMEFRAME_IN_THE_PAST, function (res) {
+              if (res.success) {
+                const deposits = JSON.parse(JSON.stringify(res.body))
+                _.set(exchange_pair_deposits, [exchange_id], deposits)
+              } else {
+                delete exchange_pair_deposits[exchange_id]
+              }
+              _.set(deposits_status, [exchange_name], true)
+              resolve_pair()
+            })
+          })
+        )
+      } else if (exchange.get_deposits) {
+        client_currency.forEach((pair) => {
+          deposits_fetch_promises.push(
+            new Promise((resolve_pair, reject_pair) => {
+              exchange.get_deposits(pair, TIMEFRAME_IN_THE_PAST, function (res) {
+                if (res.success) {
+                  const deposits = JSON.parse(JSON.stringify(res.body))
+                  _.set(exchange_pair_deposits, [exchange_id, pair], deposits)
+                } else {
+                  delete exchange_pair_deposits[exchange_id][pair]
+                }
+                _.set(deposits_status, [exchange_name + pair], true)
+                resolve_pair()
+              })
+            })
+          )
+        })
+      }
+
+      Promise.all(deposits_fetch_promises)
+        .then(() => {
+          resolve()
+        })
+        .catch((error) => {
+          console.error('Error fetching deposits:', error)
+          resolve()
+        })
+    })
+  })
+
+  Promise.all(promises)
+    .then(() => {
+      cb(exchange_pair_deposits)
+    })
+    .catch((error) => {
+      console.error('Error fetching deposits:', error)
+      cb({})
+    })
+}

package/functions/get-exchanges-open-orders.js

@@ -0,0 +1,92 @@
+const _ = require('lodash')
+
+const INVALID_EXCHANGES_LIST = ['Bitforex', 'Thinkbit', 'Kkcoin']
+
+let exchange_pair_open_orders = {}
+let open_orders_status = {}
+
+module.exports = function (exchanges, exchange_pair_dict, cb, ws_enabled = true) {
+  if (!Array.isArray(exchanges)) {
+    console.error('exchanges should be an array')
+    return
+  }
+
+  const promises = exchanges.map((exchange) => {
+    return new Promise((resolve, reject) => {
+      const exchange_name = exchange.Name
+      const exchange_id = exchange.settings.id
+
+      if (!exchange_pair_dict[exchange_name]) {
+        resolve()
+        return
+      }
+
+      const pair_list = exchange_pair_dict[exchange_name]
+
+      for (let pair of pair_list) {
+        _.set(open_orders_status, [exchange_name + pair], false)
+      }
+
+      if (_.includes(INVALID_EXCHANGES_LIST, exchange_name)) {
+        resolve()
+        return
+      }
+
+      let open_orders_fetch_promises = []
+
+      if (exchange.get_all_open_orders) {
+        open_orders_fetch_promises.push(
+          new Promise((resolvePair, rejectPair) => {
+            exchange.get_all_open_orders(function (res) {
+              if (res.success) {
+                const open_orders = res.body
+                _.set(exchange_pair_open_orders, [exchange_id], open_orders)
+              } else {
+                delete exchange_pair_open_orders[exchange_id]
+              }
+              _.set(open_orders_status, [exchange_name], true)
+              resolvePair()
+            })
+          })
+        )
+      } else if (exchange.get_open_orders) {
+        pair_list.forEach((pair) => {
+          open_orders_fetch_promises.push(
+            new Promise((resolvePair, rejectPair) => {
+              exchange.get_open_orders(pair, function (res) {
+                if (res.success) {
+                  const open_orders = res.body
+                  _.set(exchange_pair_open_orders, [exchange_id, pair], open_orders)
+                } else {
+                  if (exchange_pair_open_orders[exchange_id]) {
+                    delete exchange_pair_open_orders[exchange_id][pair]
+                  }
+                }
+                _.set(open_orders_status, [exchange_name + pair], true)
+                resolvePair()
+              })
+            })
+          )
+        })
+      }
+
+      Promise.all(open_orders_fetch_promises)
+        .then(() => {
+          resolve()
+        })
+        .catch((error) => {
+          console.error('Error fetching open orders:', error)
+          resolve()
+        })
+    })
+  })
+
+  Promise.all(promises)
+    .then(() => {
+      cb(exchange_pair_open_orders)
+    })
+    .catch((error) => {
+      console.error('Error fetching open orders:', error)
+      cb({})
+    })
+}

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

@@ -3,11 +3,13 @@ const _ = require('lodash')
 const DEFAULT_ORDERBOOK_LEVEL = 50
 
 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 = {}
+  let checked_rates = {}
+  let promises = []
+
   if (!Array.isArray(Exchanges)) {
     console.error('Exchanges should be an array')
     return
@@ -18,16 +20,65 @@ module.exports.get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb
         continue
       }
       checked_rates[Exchange_name] = true
+
       if (!exchange_pair_dict[Exchange_name]) {
         continue
       }
+
       if (Exchange.ws_market && ws_enabled) {
-        if (!first_time[Exchange_name]) {
+        let ws_promise = new Promise((resolve, reject) => {
           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) {
+
+          const check_status = () => {
+            let all_pairs_opened = exchange_pair_dict[Exchange_name].every((pair) => {
+              return Exchange.ws.market.pair_status[pair] === 'opened' && Exchange.ws.market.asks_dict[pair].length > 0 && Exchange.ws.market.bids_dict[pair].length > 0
+            })
+
+            if (all_pairs_opened) {
+              let rate_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+                return new Promise((rate_resolve) => {
+                  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]
+                      }
+                    }
+                    rate_resolve()
+                  })
+                })
+              })
+
+              Promise.all(rate_promises)
+                .then(() => {
+                  //   if (Exchange.ws.market.end_base) {
+                  //     Exchange.ws.market.end_base();  // Close the connection and prevent reconnection
+                  //     console.log(`${Exchange_name} WebSocket connection closed.`);
+                  // }
+                  resolve()
+                })
+                .catch((err) => {
+                  console.error(`Error in rate_ws for ${Exchange_name}:`, err)
+                  resolve()
+                })
+            } else {
+              setTimeout(check_status, 100)
+            }
+          }
+
+          check_status()
+        })
+
+        promises.push(ws_promise)
+      } else if (Exchange.rate) {
+        let rate_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+          return new Promise((resolve, reject) => {
+            Exchange.rate(pair, DEFAULT_ORDERBOOK_LEVEL, function (res) {
               if (res.success) {
                 _.set(exchange_pair_rates, [Exchange_name, pair], res.body)
                 _.set(pair_exchange_rates, [pair, Exchange_name], res.body)
@@ -39,48 +90,48 @@ module.exports.get_exchanges_rates = function (Exchanges, exchange_pair_dict, cb
                   delete pair_exchange_rates[pair][Exchange_name]
                 }
               }
+              resolve()
             })
-          }
-        }
-      } else if (Exchange.rate) {
-        for (let pair of exchange_pair_dict[Exchange_name]) {
-          Exchange.rate(pair, DEFAULT_ORDERBOOK_LEVEL, 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]
-              }
-            }
           })
-        }
+        })
+
+        promises = promises.concat(rate_promises) // Add all rate promises
       } else if (Exchange.rate_with_routes) {
-        for (let pair of exchange_pair_dict[Exchange_name]) {
-          Exchange.rate_with_routes(pair, function (res) {
-            if (res.success) {
-              let { asks, bids } = res.body
-              asks = asks.map((ask) => ask.slice(0, 2))
-              bids = bids.map((bid) => bid.slice(0, 2))
-              _.set(exchange_pair_rates, [Exchange_name, pair], { asks, bids })
-              _.set(pair_exchange_rates, [pair, Exchange_name], { asks, bids })
-            } 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]
+        let rate_with_routes_promises = exchange_pair_dict[Exchange_name].map((pair) => {
+          return new Promise((resolve, reject) => {
+            Exchange.rate_with_routes(pair, function (res) {
+              if (res.success) {
+                let { asks, bids } = res.body
+                asks = asks.map((ask) => ask.slice(0, 2))
+                bids = bids.map((bid) => bid.slice(0, 2))
+                _.set(exchange_pair_rates, [Exchange_name, pair], { asks, bids })
+                _.set(pair_exchange_rates, [pair, Exchange_name], { asks, bids })
+              } 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]
+                }
               }
-            }
+              resolve()
+            })
           })
-        }
+        })
+
+        promises = promises.concat(rate_with_routes_promises) // Add all rate_with_routes promises
       }
     }
   }
-  cb({ exchange_pair_rates, pair_exchange_rates })
+
+  Promise.all(promises)
+    .then(() => {
+      cb({ exchange_pair_rates, pair_exchange_rates })
+    })
+    .catch((error) => {
+      console.error('Error in fetching exchange rates:', error)
+      cb({ exchange_pair_rates, pair_exchange_rates })
+    })
 }
 
 let checked_market_history = {},

package/functions/get-exchanges-trades.js

@@ -1,108 +1,140 @@
 const _ = require('lodash')
 
 const INVALID_EXCHANGES_LIST = ['Bitforex', 'Thinkbit', 'Kkcoin']
-const TRADES_TIMEFRAME = 10 * 60 * 1000
+const TRADES_TIMEFRAME = 1000000 * 60 * 1000
 
-let first_time = {},
-  exchange_pair_trades = {},
-  trades_status = {}
-module.exports.get_exchanges_trades = function (Exchanges, exchange_pair_dict, cb, ws_enabled = true) {
-  if (!Array.isArray(Exchanges)) {
-    console.error('Exchanges should be an array')
+let exchange_pair_trades = {}
+let trades_status = {}
+
+module.exports = function (exchanges, exchange_pair_dict, cb, ws_enabled = true) {
+  if (!Array.isArray(exchanges)) {
+    console.error('exchanges should be an array')
     return
-  } else {
-    for (let exchange of Exchanges) {
-      let exchange_name = exchange.name,
-        exchange_id = exchange.exchange_id
+  }
+
+  const promises = exchanges.map((exchange) => {
+    return new Promise((resolve, reject) => {
+      const exchange_name = exchange.Name
+      const exchange_id = exchange.settings.id
+
       if (!exchange_pair_dict[exchange_name]) {
-        continue
+        resolve()
+        return
       }
-      let pair_list = exchange_pair_dict[exchange_name]
+
+      const pair_list = exchange_pair_dict[exchange_name]
+
       for (let pair of pair_list) {
-        _.set(trades_status, [exchange + pair], false)
+        _.set(trades_status, [exchange_name + pair], false)
       }
+
       if (_.includes(INVALID_EXCHANGES_LIST, exchange_name)) {
-        continue
-      } else if (exchange.get_all_trades_ws) {
-        if (exchange.ws_trades_status().trading === 'n-opened') exchange.ws_account()
-        exchange.get_all_trades_ws(TRADES_TIMEFRAME, function (res) {
-          if (res.success) {
-            res.body((trade) => {
-              let pair = trade.pair
-              if (!_.get(exchange_pair_trades, [exchange, pair])) {
-                _.set(exchange_pair_trades, [exchange_id, pair], [])
-              }
-              exchange_pair_trades[exchange][pair].push(trade)
+        resolve()
+        return
+      }
+
+      let trades_fetch_promises = []
+
+      if (exchange && exchange.get_all_trades_ws) {
+        if (exchange.ws_trades_status().trading === 'n-opened') {
+          exchange.ws_account()
+        }
+
+        pair_list.forEach((pair) => {
+          trades_fetch_promises.push(
+            new Promise((resolve_pair, reject_pair) => {
+              exchange.get_all_trades_ws(pair, TRADES_TIMEFRAME, function (res) {
+                if (res.success) {
+                  const trades = res.body
+                  _.set(exchange_pair_trades, [exchange_id, pair], trades)
+                } else {
+                  if (exchange_pair_trades[exchange_id]) {
+                    delete exchange_pair_trades[exchange_id][pair]
+                  }
+                }
+                _.set(trades_status, [exchange_name + pair], true)
+                resolve_pair()
+              })
             })
-            _.set(exchange_pair_trades, [exchange_id, pair], res.body)
-          } else {
-            if (exchange_pair_trades[exchange]) {
-              delete exchange_pair_trades[exchange]
-            }
-          }
-          for (let pair of pair_list) {
-            _.set(trades_status, [exchange + pair], true)
-          }
-          if (!_.includes(_.values(trades_status), false)) {
-            cb(exchange_pair_trades)
-          }
+          )
         })
       } else if (exchange.get_all_trades) {
-        exchange.get_all_trades(TRADES_TIMEFRAME, function (res) {
-          if (res.success) {
-            res.body((trade) => {
-              let pair = trade.pair
-              if (!_.get(exchange_pair_trades, [exchange_id, pair])) {
-                _.set(exchange_pair_trades, [exchange_id, pair], [])
+        trades_fetch_promises.push(
+          new Promise((resolve_pair, reject_pair) => {
+            exchange.get_all_trades(pair, TRADES_TIMEFRAME, function (res) {
+              if (res.success) {
+                const trades = res.body
+                _.set(exchange_pair_trades, [exchange_id, pair], trades)
+              } else {
+                if (exchange_pair_trades[exchange_id]) {
+                  delete exchange_pair_trades[exchange_id][pair]
+                }
               }
-              exchange_pair_trades[exchange][pair].push(trade)
+              _.set(trades_status, [exchange_name + pair], true)
+              resolve_pair()
             })
-          } else {
-            if (exchange_pair_trades[exchange]) {
-              delete exchange_pair_trades[exchange][pair]
-            }
-          }
-          for (let pair of pair_list) {
-            _.set(trades_status, [exchange + pair], true)
-          }
-          if (!_.includes(_.values(trades_status), false)) {
-            cb(exchange_pair_trades)
-          }
-        })
-      } else if (exchange.get_trades_ws) {
-        if (exchange.ws_trades_status().trading === 'n-opened') exchange.ws_account()
-        for (let pair of pair_list) {
-          exchange.get_trades_ws(pair, TRADES_TIMEFRAME, function (res) {
-            if (res.success) {
-              _.set(exchange_pair_trades, [exchange_id, pair], res.body)
-            } else {
-              if (exchange_pair_trades[exchange]) {
-                delete exchange_pair_trades[exchange][pair]
-              }
-            }
-            _.set(trades_status, [exchange + pair], true)
-            if (!_.includes(_.values(trades_status), false)) {
-              cb(exchange_pair_trades)
-            }
           })
+        )
+      } else if (exchange.get_trades_ws) {
+        if (exchange.ws_trades_status().trading === 'n-opened') {
+          exchange.ws_account()
         }
+
+        pair_list.forEach((pair) => {
+          trades_fetch_promises.push(
+            new Promise((resolve_pair, reject_pair) => {
+              exchange.get_trades_ws(pair, TRADES_TIMEFRAME, function (res) {
+                if (res.success) {
+                  _.set(exchange_pair_trades, [exchange_id, pair], res.body)
+                } else {
+                  if (exchange_pair_trades[exchange_id]) {
+                    delete exchange_pair_trades[exchange_id][pair]
+                  }
+                }
+                _.set(trades_status, [exchange_name + pair], true)
+                resolve_pair()
+              })
+            })
+          )
+        })
       } else if (exchange.get_trades) {
-        for (let pair of pair_list) {
-          exchange.get_trades(pair, TRADES_TIMEFRAME, function (res) {
-            if (res.success) {
-              _.set(exchange_pair_trades, [exchange_id, pair], res.body)
-            } else {
-              if (exchange_pair_trades[exchange]) {
-                delete exchange_pair_trades[exchange][pair]
-              }
-            }
-            _.set(trades_status, [exchange + pair], true)
-            if (!_.includes(_.values(trades_status), false)) {
-              cb(exchange_pair_trades)
-            }
-          })
-        }
+        pair_list.forEach((pair) => {
+          trades_fetch_promises.push(
+            new Promise((resolve_pair, reject_pair) => {
+              exchange.get_trades(pair, TRADES_TIMEFRAME, function (res) {
+                if (res.success) {
+                  const trades = res.body
+                  _.set(exchange_pair_trades, [exchange_id, pair], trades)
+                } else {
+                  if (exchange_pair_trades[exchange_id]) {
+                    delete exchange_pair_trades[exchange_id][pair]
+                  }
+                }
+                _.set(trades_status, [exchange_name + pair], true)
+                resolve_pair()
+              })
+            })
+          )
+        })
       }
-    }
-  }
+
+      Promise.all(trades_fetch_promises)
+        .then(() => {
+          resolve()
+        })
+        .catch((error) => {
+          console.error('Error fetching trades:', error)
+          resolve()
+        })
+    })
+  })
+
+  Promise.all(promises)
+    .then(() => {
+      cb(exchange_pair_trades)
+    })
+    .catch((error) => {
+      console.error('Error fetching trades:', error)
+      cb({})
+    })
 }

package/functions/get-exchanges-withdrawals.js

@@ -0,0 +1,79 @@
+const _ = require('lodash')
+const TIMEFRAME_IN_THE_PAST = 90 * 24 * 60 * 60 * 1000
+const INVALID_EXCHANGES_LIST = ['Bitforex', 'Thinkbit', 'Kkcoin']
+
+let exchange_pair_withdrawals = {}
+let withdrawals_status = {}
+
+module.exports = function (exchanges, client_currency, cb) {
+  if (!Array.isArray(exchanges)) {
+    console.error('exchanges should be an array')
+    return
+  }
+
+  const promises = exchanges.map((exchange) => {
+    return new Promise((resolve, reject) => {
+      const exchange_name = exchange.Name
+      const exchange_id = exchange.settings.id
+
+      if (_.includes(INVALID_EXCHANGES_LIST, exchange_name)) {
+        resolve()
+        return
+      }
+
+      let withdrawals_fetch_promises = []
+
+      if (exchange.get_all_withdrawals) {
+        withdrawals_fetch_promises.push(
+          new Promise((resolve_pair, reject_pair) => {
+            exchange.get_all_withdrawals(TIMEFRAME_IN_THE_PAST, function (res) {
+              if (res.success) {
+                const withdrawals = JSON.parse(JSON.stringify(res.body))
+                _.set(exchange_pair_withdrawals, [exchange_id], withdrawals)
+              } else {
+                delete exchange_pair_withdrawals[exchange_id]
+              }
+              _.set(withdrawals_status, [exchange_name], true)
+              resolve_pair()
+            })
+          })
+        )
+      } else if (exchange.get_withdrawals) {
+        client_currency.forEach((pair) => {
+          withdrawals_fetch_promises.push(
+            new Promise((resolve_pair, reject_pair) => {
+              exchange.get_withdrawals(pair, TIMEFRAME_IN_THE_PAST, function (res) {
+                if (res.success) {
+                  const withdrawals = JSON.parse(JSON.stringify(res.body))
+                  _.set(exchange_pair_withdrawals, [exchange_id, pair], withdrawals)
+                } else {
+                  delete exchange_pair_withdrawals[exchange_id][pair]
+                }
+                _.set(withdrawals_status, [exchange_name + pair], true)
+                resolve_pair()
+              })
+            })
+          )
+        })
+      }
+
+      Promise.all(withdrawals_fetch_promises)
+        .then(() => {
+          resolve()
+        })
+        .catch((error) => {
+          console.error('Error fetching withdrawals:', error)
+          resolve()
+        })
+    })
+  })
+
+  Promise.all(promises)
+    .then(() => {
+      cb(exchange_pair_withdrawals)
+    })
+    .catch((error) => {
+      console.error('Error fetching withdrawals:', error)
+      cb({})
+    })
+}

package/index.js

@@ -1,6 +1,9 @@
 const { get_exchanges_rates, get_exchanges_market_history, get_exchanges_ohlcv } = require('./functions/get-exchanges-rates-market-history-ohlcv.js')
 const get_exchanges_balance = require('./functions/get-exchanges-balance.js')
 const get_exchanges_trades = require('./functions/get-exchanges-trades.js')
+const get_exchanges_open_orders = require('./functions/get-exchanges-open-orders.js')
+const get_exchanges_deposits = require('./functions/get-exchanges-deposits.js')
+const get_exchanges_withdrawals = require('./functions/get-exchanges-withdrawals.js')
 
 module.exports.functions = {
   get_exchanges_rates,
@@ -8,6 +11,9 @@ module.exports.functions = {
   get_exchanges_ohlcv,
   get_exchanges_balance,
   get_exchanges_trades,
+  get_exchanges_open_orders,
+  get_exchanges_deposits,
+  get_exchanges_withdrawals,
 }
 
 module.exports.orders = require('./middleware/orders.js')

package/middleware/account.js

@@ -98,7 +98,9 @@ module.exports = class Account {
           _.set(exchange_position, [exchange, cur, 'percentage'], ((diff / exchange_assets_balances[exchange][cur]) * 100).toPrecision(3) + '%')
         }
       }
+      exchange_position[exchange] = utils.sort_keys(exchange_position[exchange])
     }
+    exchange_position = utils.sort_keys(exchange_position)
     return exchange_position
   }
   get_position(balances, type = 'initial') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges-wrapper",
-  "version": "1.12.172",
+  "version": "1.12.174",
   "description": "",
   "main": "index.js",
   "scripts": {