mirror of https://github.com/BTCPrivate/z-nomp.git
547 lines
24 KiB
JavaScript
547 lines
24 KiB
JavaScript
var async = require('async');
|
|
var net = require('net');
|
|
var bignum = require('bignum');
|
|
var algos = require('stratum-pool/lib/algoProperties.js');
|
|
var util = require('stratum-pool/lib/util.js');
|
|
|
|
var Cryptsy = require('./apiCryptsy.js');
|
|
var Poloniex = require('./apiPoloniex.js');
|
|
var Mintpal = require('./apiMintpal.js');
|
|
var Stratum = require('stratum-pool');
|
|
|
|
module.exports = function(logger){
|
|
|
|
var _this = this;
|
|
|
|
var portalConfig = JSON.parse(process.env.portalConfig);
|
|
var poolConfigs = JSON.parse(process.env.pools);
|
|
|
|
var logSystem = 'Profit';
|
|
|
|
//
|
|
// build status tracker for collecting coin market information
|
|
//
|
|
var profitStatus = {};
|
|
var symbolToAlgorithmMap = {};
|
|
Object.keys(poolConfigs).forEach(function(coin){
|
|
|
|
var poolConfig = poolConfigs[coin];
|
|
var algo = poolConfig.coin.algorithm;
|
|
|
|
if (!profitStatus.hasOwnProperty(algo)) {
|
|
profitStatus[algo] = {};
|
|
}
|
|
var coinStatus = {
|
|
name: poolConfig.coin.name,
|
|
symbol: poolConfig.coin.symbol,
|
|
difficulty: 0,
|
|
reward: 0,
|
|
exchangeInfo: {}
|
|
};
|
|
profitStatus[algo][poolConfig.coin.symbol] = coinStatus;
|
|
symbolToAlgorithmMap[poolConfig.coin.symbol] = algo;
|
|
});
|
|
|
|
|
|
//
|
|
// ensure we have something to switch
|
|
//
|
|
Object.keys(profitStatus).forEach(function(algo){
|
|
if (Object.keys(profitStatus[algo]).length <= 1) {
|
|
delete profitStatus[algo];
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
if (symbolToAlgorithmMap[symbol] === algo)
|
|
delete symbolToAlgorithmMap[symbol];
|
|
});
|
|
}
|
|
});
|
|
if (Object.keys(profitStatus).length == 0){
|
|
logger.debug(logSystem, 'Config', 'No alternative coins to switch to in current config, switching disabled.');
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// setup APIs
|
|
//
|
|
var poloApi = new Poloniex(
|
|
// 'API_KEY',
|
|
// 'API_SECRET'
|
|
);
|
|
var cryptsyApi = new Cryptsy(
|
|
// 'API_KEY',
|
|
// 'API_SECRET'
|
|
);
|
|
var mintpalApi = new Mintpal(
|
|
// 'API_KEY',
|
|
// 'API_SECRET'
|
|
);
|
|
|
|
//
|
|
// market data collection from Poloniex
|
|
//
|
|
this.getProfitDataPoloniex = function(callback){
|
|
async.series([
|
|
function(taskCallback){
|
|
poloApi.getTicker(function(err, data){
|
|
if (err){
|
|
taskCallback(err);
|
|
return;
|
|
}
|
|
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
var exchangeInfo = profitStatus[symbolToAlgorithmMap[symbol]][symbol].exchangeInfo;
|
|
if (!exchangeInfo.hasOwnProperty('Poloniex'))
|
|
exchangeInfo['Poloniex'] = {};
|
|
var marketData = exchangeInfo['Poloniex'];
|
|
|
|
if (data.hasOwnProperty('BTC_' + symbol)) {
|
|
if (!marketData.hasOwnProperty('BTC'))
|
|
marketData['BTC'] = {};
|
|
|
|
var btcData = data['BTC_' + symbol];
|
|
marketData['BTC'].ask = new Number(btcData.lowestAsk);
|
|
marketData['BTC'].bid = new Number(btcData.highestBid);
|
|
marketData['BTC'].last = new Number(btcData.last);
|
|
marketData['BTC'].baseVolume = new Number(btcData.baseVolume);
|
|
marketData['BTC'].quoteVolume = new Number(btcData.quoteVolume);
|
|
}
|
|
if (data.hasOwnProperty('LTC_' + symbol)) {
|
|
if (!marketData.hasOwnProperty('LTC'))
|
|
marketData['LTC'] = {};
|
|
|
|
var ltcData = data['LTC_' + symbol];
|
|
marketData['LTC'].ask = new Number(ltcData.lowestAsk);
|
|
marketData['LTC'].bid = new Number(ltcData.highestBid);
|
|
marketData['LTC'].last = new Number(ltcData.last);
|
|
marketData['LTC'].baseVolume = new Number(ltcData.baseVolume);
|
|
marketData['LTC'].quoteVolume = new Number(ltcData.quoteVolume);
|
|
}
|
|
// save LTC to BTC exchange rate
|
|
if (marketData.hasOwnProperty('LTC') && data.hasOwnProperty('BTC_LTC')) {
|
|
var btcLtc = data['BTC_LTC'];
|
|
marketData['LTC'].ltcToBtc = new Number(btcLtc.highestBid);
|
|
}
|
|
});
|
|
|
|
taskCallback();
|
|
});
|
|
},
|
|
function(taskCallback){
|
|
var depthTasks = [];
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
var marketData = profitStatus[symbolToAlgorithmMap[symbol]][symbol].exchangeInfo['Poloniex'];
|
|
if (marketData.hasOwnProperty('BTC') && marketData['BTC'].bid > 0){
|
|
depthTasks.push(function(callback){
|
|
_this.getMarketDepthFromPoloniex('BTC', symbol, marketData['BTC'].bid, callback)
|
|
});
|
|
}
|
|
if (marketData.hasOwnProperty('LTC') && marketData['LTC'].bid > 0){
|
|
depthTasks.push(function(callback){
|
|
_this.getMarketDepthFromPoloniex('LTC', symbol, marketData['LTC'].bid, callback)
|
|
});
|
|
}
|
|
});
|
|
|
|
if (!depthTasks.length){
|
|
taskCallback();
|
|
return;
|
|
}
|
|
async.series(depthTasks, function(err){
|
|
if (err){
|
|
taskCallback(err);
|
|
return;
|
|
}
|
|
taskCallback();
|
|
});
|
|
}
|
|
], function(err){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
callback(null);
|
|
});
|
|
|
|
};
|
|
this.getMarketDepthFromPoloniex = function(symbolA, symbolB, coinPrice, callback){
|
|
poloApi.getOrderBook(symbolA, symbolB, function(err, data){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
var depth = new Number(0);
|
|
var totalQty = new Number(0);
|
|
if (data.hasOwnProperty('bids')){
|
|
data['bids'].forEach(function(order){
|
|
var price = new Number(order[0]);
|
|
var limit = new Number(coinPrice * portalConfig.profitSwitch.depth);
|
|
var qty = new Number(order[1]);
|
|
// only measure the depth down to configured depth
|
|
if (price >= limit){
|
|
depth += (qty * price);
|
|
totalQty += qty;
|
|
}
|
|
});
|
|
}
|
|
|
|
var marketData = profitStatus[symbolToAlgorithmMap[symbolB]][symbolB].exchangeInfo['Poloniex'];
|
|
marketData[symbolA].depth = depth;
|
|
if (totalQty > 0)
|
|
marketData[symbolA].weightedBid = new Number(depth / totalQty);
|
|
callback();
|
|
});
|
|
};
|
|
|
|
|
|
this.getProfitDataCryptsy = function(callback){
|
|
async.series([
|
|
function(taskCallback){
|
|
cryptsyApi.getTicker(function(err, data){
|
|
if (err || data.success != 1){
|
|
taskCallback(err);
|
|
return;
|
|
}
|
|
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
var exchangeInfo = profitStatus[symbolToAlgorithmMap[symbol]][symbol].exchangeInfo;
|
|
if (!exchangeInfo.hasOwnProperty('Cryptsy'))
|
|
exchangeInfo['Cryptsy'] = {};
|
|
|
|
var marketData = exchangeInfo['Cryptsy'];
|
|
var results = data.return.markets;
|
|
|
|
if (results && results.hasOwnProperty(symbol + '/BTC')) {
|
|
if (!marketData.hasOwnProperty('BTC'))
|
|
marketData['BTC'] = {};
|
|
|
|
var btcData = results[symbol + '/BTC'];
|
|
marketData['BTC'].last = new Number(btcData.lasttradeprice);
|
|
marketData['BTC'].baseVolume = new Number(marketData['BTC'].last / btcData.volume);
|
|
marketData['BTC'].quoteVolume = new Number(btcData.volume);
|
|
if (btcData.sellorders != null)
|
|
marketData['BTC'].ask = new Number(btcData.sellorders[0].price);
|
|
if (btcData.buyorders != null) {
|
|
marketData['BTC'].bid = new Number(btcData.buyorders[0].price);
|
|
var limit = new Number(marketData['BTC'].bid * portalConfig.profitSwitch.depth);
|
|
var depth = new Number(0);
|
|
var totalQty = new Number(0);
|
|
btcData['buyorders'].forEach(function(order){
|
|
var price = new Number(order.price);
|
|
var qty = new Number(order.quantity);
|
|
if (price >= limit){
|
|
depth += (qty * price);
|
|
totalQty += qty;
|
|
}
|
|
});
|
|
marketData['BTC'].depth = depth;
|
|
if (totalQty > 0)
|
|
marketData['BTC'].weightedBid = new Number(depth / totalQty);
|
|
}
|
|
}
|
|
|
|
if (results && results.hasOwnProperty(symbol + '/LTC')) {
|
|
if (!marketData.hasOwnProperty('LTC'))
|
|
marketData['LTC'] = {};
|
|
|
|
var ltcData = results[symbol + '/LTC'];
|
|
marketData['LTC'].last = new Number(ltcData.lasttradeprice);
|
|
marketData['LTC'].baseVolume = new Number(marketData['LTC'].last / ltcData.volume);
|
|
marketData['LTC'].quoteVolume = new Number(ltcData.volume);
|
|
if (ltcData.sellorders != null)
|
|
marketData['LTC'].ask = new Number(ltcData.sellorders[0].price);
|
|
if (ltcData.buyorders != null) {
|
|
marketData['LTC'].bid = new Number(ltcData.buyorders[0].price);
|
|
var limit = new Number(marketData['LTC'].bid * portalConfig.profitSwitch.depth);
|
|
var depth = new Number(0);
|
|
var totalQty = new Number(0);
|
|
ltcData['buyorders'].forEach(function(order){
|
|
var price = new Number(order.price);
|
|
var qty = new Number(order.quantity);
|
|
if (price >= limit){
|
|
depth += (qty * price);
|
|
totalQty += qty;
|
|
}
|
|
});
|
|
marketData['LTC'].depth = depth;
|
|
if (totalQty > 0)
|
|
marketData['LTC'].weightedBid = new Number(depth / totalQty);
|
|
}
|
|
}
|
|
});
|
|
taskCallback();
|
|
});
|
|
}
|
|
], function(err){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
callback(null);
|
|
});
|
|
|
|
};
|
|
|
|
|
|
this.getProfitDataMintpal = function(callback){
|
|
async.series([
|
|
function(taskCallback){
|
|
mintpalApi.getTicker(function(err, response){
|
|
if (err || !response.data){
|
|
taskCallback(err);
|
|
return;
|
|
}
|
|
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
response.data.forEach(function(market){
|
|
var exchangeInfo = profitStatus[symbolToAlgorithmMap[symbol]][symbol].exchangeInfo;
|
|
if (!exchangeInfo.hasOwnProperty('Mintpal'))
|
|
exchangeInfo['Mintpal'] = {};
|
|
|
|
var marketData = exchangeInfo['Mintpal'];
|
|
|
|
if (market.exchange == 'BTC' && market.code == symbol) {
|
|
if (!marketData.hasOwnProperty('BTC'))
|
|
marketData['BTC'] = {};
|
|
|
|
marketData['BTC'].last = new Number(market.last_price);
|
|
marketData['BTC'].baseVolume = new Number(market['24hvol']);
|
|
marketData['BTC'].quoteVolume = new Number(market['24hvol'] / market.last_price);
|
|
marketData['BTC'].ask = new Number(market.top_ask);
|
|
marketData['BTC'].bid = new Number(market.top_bid);
|
|
}
|
|
|
|
if (market.exchange == 'LTC' && market.code == symbol) {
|
|
if (!marketData.hasOwnProperty('LTC'))
|
|
marketData['LTC'] = {};
|
|
|
|
marketData['LTC'].last = new Number(market.last_price);
|
|
marketData['LTC'].baseVolume = new Number(market['24hvol']);
|
|
marketData['LTC'].quoteVolume = new Number(market['24hvol'] / market.last_price);
|
|
marketData['LTC'].ask = new Number(market.top_ask);
|
|
marketData['LTC'].bid = new Number(market.top_bid);
|
|
}
|
|
|
|
});
|
|
});
|
|
taskCallback();
|
|
});
|
|
},
|
|
function(taskCallback){
|
|
var depthTasks = [];
|
|
Object.keys(symbolToAlgorithmMap).forEach(function(symbol){
|
|
var marketData = profitStatus[symbolToAlgorithmMap[symbol]][symbol].exchangeInfo['Mintpal'];
|
|
if (marketData.hasOwnProperty('BTC') && marketData['BTC'].bid > 0){
|
|
depthTasks.push(function(callback){
|
|
_this.getMarketDepthFromMintpal('BTC', symbol, marketData['BTC'].bid, callback)
|
|
});
|
|
}
|
|
if (marketData.hasOwnProperty('LTC') && marketData['LTC'].bid > 0){
|
|
depthTasks.push(function(callback){
|
|
_this.getMarketDepthFromMintpal('LTC', symbol, marketData['LTC'].bid, callback)
|
|
});
|
|
}
|
|
});
|
|
|
|
if (!depthTasks.length){
|
|
taskCallback();
|
|
return;
|
|
}
|
|
async.series(depthTasks, function(err){
|
|
if (err){
|
|
taskCallback(err);
|
|
return;
|
|
}
|
|
taskCallback();
|
|
});
|
|
}
|
|
], function(err){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
callback(null);
|
|
});
|
|
};
|
|
this.getMarketDepthFromMintpal = function(symbolA, symbolB, coinPrice, callback){
|
|
mintpalApi.getBuyOrderBook(symbolA, symbolB, function(err, response){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
var depth = new Number(0);
|
|
if (response.hasOwnProperty('data')){
|
|
var totalQty = new Number(0);
|
|
response['data'].forEach(function(order){
|
|
var price = new Number(order.price);
|
|
var limit = new Number(coinPrice * portalConfig.profitSwitch.depth);
|
|
var qty = new Number(order.amount);
|
|
// only measure the depth down to configured depth
|
|
if (price >= limit){
|
|
depth += (qty * price);
|
|
totalQty += qty;
|
|
}
|
|
});
|
|
}
|
|
|
|
var marketData = profitStatus[symbolToAlgorithmMap[symbolB]][symbolB].exchangeInfo['Mintpal'];
|
|
marketData[symbolA].depth = depth;
|
|
if (totalQty > 0)
|
|
marketData[symbolA].weightedBid = new Number(depth / totalQty);
|
|
callback();
|
|
});
|
|
};
|
|
|
|
|
|
this.getCoindDaemonInfo = function(callback){
|
|
var daemonTasks = [];
|
|
Object.keys(profitStatus).forEach(function(algo){
|
|
Object.keys(profitStatus[algo]).forEach(function(symbol){
|
|
var coinName = profitStatus[algo][symbol].name;
|
|
var poolConfig = poolConfigs[coinName];
|
|
var daemonConfig = poolConfig.shareProcessing.internal.daemon;
|
|
daemonTasks.push(function(callback){
|
|
_this.getDaemonInfoForCoin(symbol, daemonConfig, callback)
|
|
});
|
|
});
|
|
});
|
|
|
|
if (daemonTasks.length == 0){
|
|
callback();
|
|
return;
|
|
}
|
|
async.series(daemonTasks, function(err){
|
|
if (err){
|
|
callback(err);
|
|
return;
|
|
}
|
|
callback(null);
|
|
});
|
|
};
|
|
this.getDaemonInfoForCoin = function(symbol, cfg, callback){
|
|
var daemon = new Stratum.daemon.interface([cfg]);
|
|
daemon.on('error', function(error){
|
|
logger.error(logSystem, symbol, JSON.stringify(error));
|
|
callback(null); // fail gracefully for each coin
|
|
}).init();
|
|
|
|
daemon.cmd('getblocktemplate', [{"capabilities": [ "coinbasetxn", "workid", "coinbase/append" ]}], function(result) {
|
|
if (result[0].error != null) {
|
|
logger.error(logSystem, symbol, 'Error while reading daemon info: ' + JSON.stringify(result[0]));
|
|
callback(null); // fail gracefully for each coin
|
|
return;
|
|
}
|
|
var coinStatus = profitStatus[symbolToAlgorithmMap[symbol]][symbol];
|
|
var response = result[0].response;
|
|
|
|
// some shitcoins dont provide target, only bits, so we need to deal with both
|
|
var target = response.target ? bignum(response.target, 16) : util.bignumFromBitsHex(response.bits);
|
|
coinStatus.difficulty = parseFloat((diff1 / target.toNumber()).toFixed(9));
|
|
logger.debug(logSystem, symbol, 'difficulty is ' + coinStatus.difficulty);
|
|
|
|
coinStatus.reward = response.coinbasevalue / 100000000;
|
|
callback(null);
|
|
});
|
|
};
|
|
|
|
|
|
this.getMiningRate = function(callback){
|
|
var daemonTasks = [];
|
|
Object.keys(profitStatus).forEach(function(algo){
|
|
Object.keys(profitStatus[algo]).forEach(function(symbol){
|
|
var coinStatus = profitStatus[symbolToAlgorithmMap[symbol]][symbol];
|
|
coinStatus.blocksPerMhPerHour = 86400 / ((coinStatus.difficulty * Math.pow(2,32)) / (1 * 1000 * 1000));
|
|
coinStatus.coinsPerMhPerHour = coinStatus.reward * coinStatus.blocksPerMhPerHour;
|
|
});
|
|
});
|
|
callback(null);
|
|
};
|
|
|
|
|
|
this.switchToMostProfitableCoins = function() {
|
|
Object.keys(profitStatus).forEach(function(algo) {
|
|
var algoStatus = profitStatus[algo];
|
|
|
|
var bestExchange;
|
|
var bestCoin;
|
|
var bestBtcPerMhPerHour = 0;
|
|
|
|
Object.keys(profitStatus[algo]).forEach(function(symbol) {
|
|
var coinStatus = profitStatus[algo][symbol];
|
|
|
|
Object.keys(coinStatus.exchangeInfo).forEach(function(exchange){
|
|
var exchangeData = coinStatus.exchangeInfo[exchange];
|
|
if (exchangeData.hasOwnProperty('BTC') && exchangeData['BTC'].hasOwnProperty('weightedBid')){
|
|
var btcPerMhPerHour = exchangeData['BTC'].weightedBid * coinStatus.coinsPerMhPerHour;
|
|
if (btcPerMhPerHour > bestBtcPerMhPerHour){
|
|
bestBtcPerMhPerHour = btcPerMhPerHour;
|
|
bestExchange = exchange;
|
|
bestCoin = profitStatus[algo][symbol].name;
|
|
}
|
|
coinStatus.btcPerMhPerHour = btcPerMhPerHour;
|
|
logger.debug(logSystem, 'CALC', 'BTC/' + symbol + ' on ' + exchange + ' with ' + coinStatus.btcPerMhPerHour.toFixed(8) + ' BTC/day per Mh/s');
|
|
}
|
|
if (exchangeData.hasOwnProperty('LTC') && exchangeData['LTC'].hasOwnProperty('weightedBid')){
|
|
var btcPerMhPerHour = (exchangeData['LTC'].weightedBid * coinStatus.coinsPerMhPerHour) * exchangeData['LTC'].ltcToBtc;
|
|
if (btcPerMhPerHour > bestBtcPerMhPerHour){
|
|
bestBtcPerMhPerHour = btcPerMhPerHour;
|
|
bestExchange = exchange;
|
|
bestCoin = profitStatus[algo][symbol].name;
|
|
}
|
|
coinStatus.btcPerMhPerHour = btcPerMhPerHour;
|
|
logger.debug(logSystem, 'CALC', 'LTC/' + symbol + ' on ' + exchange + ' with ' + coinStatus.btcPerMhPerHour.toFixed(8) + ' BTC/day per Mh/s');
|
|
}
|
|
});
|
|
});
|
|
logger.debug(logSystem, 'RESULT', 'Best coin for ' + algo + ' is ' + bestCoin + ' on ' + bestExchange + ' with ' + bestBtcPerMhPerHour.toFixed(8) + ' BTC/day per Mh/s');
|
|
|
|
|
|
var client = net.connect(portalConfig.cliPort, function () {
|
|
client.write(JSON.stringify({
|
|
command: 'coinswitch',
|
|
params: [bestCoin],
|
|
options: {algorithm: algo}
|
|
}) + '\n');
|
|
}).on('error', function(error){
|
|
if (error.code === 'ECONNREFUSED')
|
|
logger.error(logSystem, 'CLI', 'Could not connect to NOMP instance on port ' + portalConfig.cliPort);
|
|
else
|
|
logger.error(logSystem, 'CLI', 'Socket error ' + JSON.stringify(error));
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
|
|
var checkProfitability = function(){
|
|
logger.debug(logSystem, 'Check', 'Collecting profitability data.');
|
|
|
|
profitabilityTasks = [];
|
|
if (portalConfig.profitSwitch.usePoloniex)
|
|
profitabilityTasks.push(_this.getProfitDataPoloniex);
|
|
|
|
if (portalConfig.profitSwitch.useCryptsy)
|
|
profitabilityTasks.push(_this.getProfitDataCryptsy);
|
|
|
|
if (portalConfig.profitSwitch.useMintpal)
|
|
profitabilityTasks.push(_this.getProfitDataMintpal);
|
|
|
|
profitabilityTasks.push(_this.getCoindDaemonInfo);
|
|
profitabilityTasks.push(_this.getMiningRate);
|
|
|
|
// has to be series
|
|
async.series(profitabilityTasks, function(err){
|
|
if (err){
|
|
logger.error(logSystem, 'Check', 'Error while checking profitability: ' + err);
|
|
return;
|
|
}
|
|
//
|
|
// TODO offer support for a userConfigurable function for deciding on coin to override the default
|
|
//
|
|
_this.switchToMostProfitableCoins();
|
|
});
|
|
};
|
|
setInterval(checkProfitability, portalConfig.profitSwitch.updateInterval * 1000);
|
|
|
|
};
|