refactor(tmpName): 'tmpName' renamed to 'plugins'

lib/plugins.js

@@ -0,0 +1,356 @@
+'use strict';
+
+var async   = require('async');
+
+var logger  = require('./logger');
+
+
+var SATOSHI_FACTOR = 1e8;
+var SESSION_TIMEOUT = 60 * 60 * 1000;
+var POLLING_RATE = 60 * 1000; // poll each minute
+
+var db = null;
+
+var tickerPlugin = null;
+var traderPlugin = null;
+var walletPlugin = null;
+
+var cachedConfig = null;
+var deviceCurrency = 'USD'; // Can 'USD' it be set as default?
+
+var lastBalances = null;
+var lastRates = {};
+
+var balanceInterval = null;
+var rateInterval = null;
+var tradeInterval = null;
+
+var tradesQueue = [];
+var sessions = {};
+
+
+// that's basically a constructor
+exports.init = function init(databaseHandle) {
+  if (!databaseHandle) {
+    throw new Error('`db` is required');
+  }
+
+  db = databaseHandle;
+}
+
+
+function loadPlugin(name, config) {
+  var moduleMethods = {
+    ticker: [ 'ticker' ],
+    trader: [ 'balance', 'purchase', 'sell' ],
+    wallet: [ 'balance', 'sendBitcoins' ]
+  };
+
+  var plugin = null;
+
+  try {
+    plugin = require('lamassu-' + name);
+
+  } catch(_) {
+    throw new Error(name + ' module is not installed. Try running \'npm install --save lamassu-' + name + '\' first');
+  }
+
+  plugin.SUPPORTED_MODULES.forEach(function(moduleName) {
+    moduleMethods[moduleName].forEach(function(methodName) {
+      if (typeof plugin[methodName] !== 'function') {
+        throw new Error('\'' + name + '\' declares \'' + moduleName + '\', but fails to implement \'' + methodName + '\' method');
+      }
+    });
+  });
+
+  if (config !== null) {
+    plugin.config(config);
+  }
+
+  return plugin;
+};
+
+
+exports.configure = function configure(config) {
+  if (config.exchanges.settings.lowBalanceMargin < 1) {
+    throw new Error('`settings.lowBalanceMargin` has to be >= 1');
+  }
+
+  deviceCurrency = config.exchanges.settings.currency;
+  var plugins = config.exchanges.plugins
+
+  // [required] configure (or load) ticker
+  var tickerName = plugins.current.ticker;
+  var tickerConfig = plugins.settings[tickerName] || {};
+  tickerConfig.currency = deviceCurrency;
+
+  if (tickerPlugin) tickerPlugin.config(tickerConfig);
+  else tickerPlugin = loadPlugin(tickerName, tickerConfig);
+
+
+  // [required] configure (or load) wallet
+  var walletName = plugins.current.transfer;
+  var walletConfig = plugins.settings[walletName];
+
+  if (walletPlugin) walletPlugin.config(walletConfig);
+  else walletPlugin = loadPlugin(walletName, walletConfig);
+
+
+  // [optional] configure (or load) trader
+  var traderName = plugins.current.trade;
+  if (traderName) { // traderPlugin may be disabled
+    var traderConfig = plugins.settings[traderName];
+
+    if (traderPlugin) traderPlugin.config(traderConfig);
+    else traderPlugin = loadPlugin(traderName, traderConfig);
+  }
+
+  cachedConfig = config;
+
+  pollBalance();
+  pollRate();
+};
+
+
+// This is where we record starting trade balance at the beginning
+// of the user session
+exports.trade = function trade(rawTrade, deviceFingerprint) {
+  var sessionInfo = sessions[deviceFingerprint];
+
+  if (!sessionInfo) {
+    sessions[deviceFingerprint] = {
+      timestamp: Date.now(),
+      reaper: setTimeout(function() {
+        delete sessions[deviceFingerprint];
+      }, SESSION_TIMEOUT)
+    };
+  }
+
+  tradesQueue.push({
+    currency: rawTrade.currency,
+    satoshis: rawTrade.satoshis
+  });
+};
+
+exports.fiatBalance = function fiatBalance(deviceFingerprint) {
+  var rawRate = getDeviceRate().rates.ask;
+  var commision = cachedConfig.exchanges.settings.commision;
+
+  if (!rawRate || !lastBalances) return null;
+
+  // The rate is actually our commission times real rate.
+  var rate = commission * rawRate;
+
+  // `lowBalanceMargin` is our safety net. It's a number > 1, and we divide
+  // all our balances by it to provide a safety margin.
+  var lowBalanceMargin = cachedConfig.exchanges.settings.lowBalanceMargin;
+
+  // `balance.transferBalance` is the balance of our transfer account (the one
+  // we use to send Bitcoins to clients) in satoshis.
+  var transferBalance = balance.transferBalance;
+
+  // Since `transferBalance` is in satoshis, we need to turn it into
+  // bitcoins and then fiat to learn how much fiat currency we can exchange.
+  //
+  // Unit validity proof: [ $ ] = [ (B * 10^8) / 10^8 * $/B ]
+  //                      [ $ ] = [ B * $/B ]
+  //                      [ $ ] = [ $ ]
+  var fiatTransferBalance = ((transferBalance / SATOSHI_FACTOR) * rate) / lowBalanceMargin;
+
+  return fiatTransferBalance;
+};
+
+exports.sendBitcoins = function sendBitcoins(deviceFingerprint, tx, callback) {
+  db.summonTransaction(deviceFingerprint, tx, function(err, txInfo) {
+    if (err) return callback(err);
+
+    if (!txInfo) {
+      clearSession(deviceFingerprint);
+
+      return walletPlugin.sendBitcoins(
+        tx.toAddress,
+        tx.satoshis,
+        cachedConfig.exchanges.settings.transactionFee,
+
+        function(err, txHash) {
+          if (err) {
+            var status = err.name === 'InsufficientFunds' ?
+              'insufficientFunds' :
+              'failed';
+
+            db.reportTransactionError(tx, err.message, status);
+            return callback(err);
+          }
+
+          db.completeTransaction(tx, txHash);
+          pollBalance();
+          callback(null, txHash);
+        }
+      );
+    }
+
+    // Out of bitcoins: special case
+    var txErr = null;
+    if (txInfo.err) {
+      txErr = new Error(txInfo.err);
+      if (txInfo.status === 'insufficientFunds') {
+        txErr.name = 'InsufficientFunds';
+      }
+    }
+
+    // transaction exists, but txHash might be null,
+    // in which case ATM should continue polling
+    pollBalance();
+    callback(txErr, txInfo.txHash);
+  });
+};
+
+
+/*
+ * Polling livecycle
+ */
+exports.startPolling = function startPolling() {
+  executeTrades();
+
+  if (!balanceInterval) {
+    balanceInterval = setInterval(pollBalance, POLLING_RATE);
+  }
+
+  if (!rateInterval) {
+    rateInterval = setInterval(pollRate, POLLING_RATE);
+  }
+
+  // Always start trading, even if we don't have a trade exchange configured,
+  // since configuration can always change in `Trader#configure`.
+  // `Trader#executeTrades` returns early if we don't have a trade exchange
+  // configured at the moment.
+  if (!tradeInterval) {
+    tradeInterval = setInterval(
+      executeTrades,
+      cachedConfig.exchanges.settings.tradeInterval
+    );
+  }
+};
+function stopPolling() {
+  clearInterval(balanceInterval);
+  clearInterval(rateInterval);
+  // clearInterval(tradeInterval); // TODO: should this get cleared too?
+};
+
+
+function pollBalance(callback) {
+  logger.debug('collecting balance');
+
+  var jobs = {
+    transferBalance: walletPlugin.balance
+  };
+
+  // only add if trader is enabled
+  // if (traderPlugin) {
+  //   // NOTE: we would need to handle when traderCurrency!=deviceCurrency
+  //   jobs.tradeBalance = traderPlugin.balance;
+  // }
+
+  async.parallel(jobs, function(err, balance) {
+    if (err) {
+      logger.error(err);
+      return callback && callback(err);
+    }
+
+    logger.debug('Balance update:', balance);
+    balance.timestamp = Date.now();
+    lastBalances = balance;
+
+    return callback && callback(null, lastBalances);
+  });
+};
+
+function pollRate(callback) {
+  logger.debug('polling for rates');
+
+  tickerPlugin.ticker(deviceCurrency, function(err, resRates) {
+    if (err) {
+      logger.error(err);
+      return callback && callback(err);
+    }
+
+    logger.debug('got rates: %j', resRates);
+    resRates.timestamp = new Date();
+    lastRates = resRates;
+
+    return callback && callback(null, lastRates);
+  });
+};
+
+
+/*
+ * Getters | Helpers
+ */
+function getLastRate(currency) {
+  if (!lastRates) return null;
+
+  var tmpCurrency = currency || deviceCurrency;
+  if (!lastRates[tmpCurrency]) return null;
+
+  return lastRates[tmpCurrency];
+};
+function getDeviceRate() {
+  return getLastRate(deviceCurrency);
+};
+
+function getBalance() {
+  if (!lastBalances) return null;
+
+  return lastBalances.transferBalance;
+};
+
+function clearSession(deviceFingerprint) {
+  var session = sessions[deviceFingerprint];
+  if (session) {
+    clearTimeout(session.reaper);
+    delete sessions[deviceFingerprint];
+  }
+};
+
+
+/*
+ * Trader functions
+ */
+function purchase(trade, callback) {
+  traderPlugin.purchase(trade.satoshis, null, function(err, _) {
+    if (err) return callback(err);
+    pollBalance();
+    callback && callback();
+  });
+};
+
+function consolidateTrades() {
+  // NOTE: value in satoshis stays the same no matter the currency
+  var consolidatedTrade = {
+    currency: deviceCurrency,
+    satoshis: tradesQueue.reduce(function(prev, current) {
+      return prev + current.satoshis;
+    }, 0)
+  };
+
+  logger.debug('consolidated: ', JSON.stringify(consolidatedTrade));
+  return consolidatedTrade;
+};
+
+function executeTrades() {
+  if (!traderPlugin) return;
+
+  logger.debug('checking for trades');
+
+  var trade = consolidateTrades();
+
+  if (trade.satoshis === 0) {
+    logger.debug('rejecting 0 trade');
+    return;
+  }
+
+  logger.trade.debug('making a trade: %d', trade.satoshis / SATOSHI_FACTOR);
+  purchase(trade, function(err) {
+    if (err) logger.error(err);
+  });
+};