Bitcoin Forum

var zlib = require('zlib');

var redis = require('redis');
var async = require('async');
var request = require('request');

var os = require('os');

var algos = require('stratum-pool/lib/algoProperties.js');


module.exports = function(logger, portalConfig, poolConfigs){

    var _this = this;

    var logSystem = 'Stats';

    var redisClients = [];
    var redisStats;

    this.statHistory = [];
    this.statPoolHistory = [];

    this.stats = {};
    this.statsString = '';

    setupStatsRedis();
    gatherStatHistory();

    var canDoStats = true;

    Object.keys(poolConfigs).forEach(function(coin){

        if (!canDoStats) return;

        var poolConfig = poolConfigs[coin];

        var redisConfig = poolConfig.redis;

        for (var i = 0; i < redisClients.length; i++){
            var client = redisClients[i];
            if (client.client.port === redisConfig.port && client.client.host === redisConfig.host){
                client.coins.push(coin);
                return;
            }
        }
        redisClients.push({
            coins: [coin],
            client: redis.createClient(redisConfig.port, redisConfig.host)
        });
    });


    function setupStatsRedis(){
        redisStats = redis.createClient(portalConfig.redis.port, portalConfig.redis.host);
        redisStats.on('error', function(err){
            logger.error(logSystem, 'Historics', 'Redis for stats had an error ' + JSON.stringify(err));
        });
    }

    function gatherStatHistory(){

        var retentionTime = (((Date.now() / 1000) - portalConfig.website.stats.historicalRetention) | 0).toString();

        redisStats.zrangebyscore(['statHistory', retentionTime, '+inf'], function(err, replies){
            if (err) {
                logger.error(logSystem, 'Historics', 'Error when trying to grab historical stats ' + JSON.stringify(err));
                return;
            }
            for (var i = 0; i < replies.length; i++){
                _this.statHistory.push(JSON.parse(replies[i]));
            }
            _this.statHistory = _this.statHistory.sort(function(a, b){
                return a.time - b.time;
            });
            _this.statHistory.forEach(function(stats){
                addStatPoolHistory(stats);
            });
        });
    }

    function addStatPoolHistory(stats){
        var data = {
            time: stats.time,
            pools: {}
        };
        for (var pool in stats.pools){
            data.pools[pool] = {
                hashrate: stats.pools[pool].hashrate,
                workerCount: stats.pools[pool].workerCount,
                blocks: stats.pools[pool].blocks
            }
        }
        _this.statPoolHistory.push(data);
    }


this.getCoins = function(cback){
        _this.stats.coins = redisClients[0].coins;
        cback();
    };

    this.getPayout = function(address, cback){

        async.waterfall([

            function(callback){

                _this.getBalanceByAddress(address, function(){

                    callback(null, 'test');
                });

            },

            function(msg, callback){

                var totaltargetcoin = 0;

                async.each(_this.stats.balances, function(balance, cb){

                    _this.getCoinTotals(balance.coin, balance.balance, function(targetcoin){

                        if(typeof(targetcoin) != "undefined"){
                            totaltargetcoin += targetcoin;
                        }

                        cb();
                    });

                }, function(err){
                    callback(null, totaltargetcoin);
                });
            }

        ], function(err, total){

            cback(total.toFixed());

        });
    };


    this.getBalanceByAddress = function(address, cback){

        var client = redisClients[0].client,
            coins = redisClients[0].coins,
            balances = [];
          payouts = [];



                    client.hgetall('Payouts:' + address, function(error, txns){
                                                                         //logger.error(logSystem, 'TEMP', 'txnid variable is:' + txnid);

                                                                        if (error) {
                                                                                callback ('There was no payouts found');
                                                                                return;
                                                                        }
                                                                        if(txns === null){
                                                                               var index = [];
                                                                               } else{
                                                                               payouts=txns;

                                                                               }

                                                                        });


        async.each(coins, function(coin, cb){

            client.hget(coin + ':balances', address, function(error, result){
                if (error){
                    callback('There was an error getting balances');
                    return;
                }

                if(result === null) {
                    result = 0;
                }else{
                    result = result;
                }

                balances.push({
                    coin:coin,
                    balance:result
                });

                cb();
            });

        }, function(err){
            _this.stats.balances = balances;
            _this.stats.address = address;

 
            cback();
        });
    };

this.getCoinTotals = function(coin, balance, cback){
        var client = redisClients[0].client,
        coinData = poolConfigs[coin].coin;
       logger.error(logSystem, 'TEMP', 'var is' + JSON.stringify(poolConfigs[coin].coin));
         //logger.error(logSystem, 'TEMP', 'coinData.ID variable is:' + coinData.ID);

        async.waterfall([

  // Get all balances from redis if no balance was provided already
            function(callback){

                if(balance) {
                    callback(null, balance);
                    return;
                }

                client.hgetall(coin + ':balances', function(error, results){
                    if (error){
                        callback('There was an error getting balances');
                        return;
                    }

                    callback(null, results);
                });
            },

            // make a call to Mintpal to get targetcoin exchange rate
            function(balances_results, callback){
                var options = {
                  // url:'https://api.mintpal.com/market/stats/<TICKER SYMBOL OF YOUR TARGET COIN HERE>/BTC',
                url:'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=<CRYPTSY MARKET ID OF YOUR TARGET COIN>',
                json:true
                }

                request(options, function (error, response, body) {
                  if (!error && response.statusCode == 200) {
                   // var targetcoin_price = parseFloat(body[0].last_price);
                        var targetcoin_price =  body['return'].markets['<YOUR POS TARGET COIN TICKET SYMBOL HERE>'].lasttradeprice;
                    callback(null, targetcoin_price, balances_results);

                  } else {
                    callback('There was an error getting mintpal targetcoin exchange rate');
                  }
                });
            },

            // make call to get coin's exchange rate
            function(targetcoin_price, balances_results, callback){


               // logger.error(logSystem, 'TEMP', '#1 ---- coinData.ID variable is:' + coinData.ID);

                if(coinData.ID === 'mintpal') {

                        var optionsB = {
                   url:'https://api.mintpal.com/market/stats/' + coinData.symbol + '/BTC',
                json:true
                }

                request(optionsB, function (error, responseB, bodyB) {
             
                  if (!error && responseB.statusCode == 200) {
                   var coinB_price = parseFloat(bodyB[0].last_price);
                        logger.error(logSystem, 'TEMP', 'coinB_price variable is:' + coinB_price);

                    callback(null, targetcoin_price, coinB_price, balances_results);

                  } else {
                    callback('There was an error getting mintpal exchange rate');
                  }
                });

                } else if (coinData.ID) {

                    var options = {
                        url:'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=' + coinData.ID,
                        json:true
                    }

                    request(options, function (error, response, body) {
                      if (!error && response.statusCode == 200) {
                        var coin_price = body['return'].markets[coinData.symbol].lasttradeprice;

                        /*
                        if(coin_price.toString().indexOf('-') === -1) {
                            // Good it doesn't have a dash.. no need to convert it to a fixed number
                        }
                        else {
                            var decimal_places = coin_price.toString().split('-')[1];
                            coin_price = coin_price.toFixed(parseInt(decimal_places));
                        }
                        */

                        callback(null, targetcoin_price, coin_price, balances_results);

                      } else {
                        callback('There was an error getting mintpal targetcoin exchange rate');
                      }
                    });
                }
                else {
                    callback(null, targetcoin_price, coinData.rate, balances_results);
                }
            },

            // Calculate the amount of targetcoin earned from the worker's balance
            function(targetcoin_price, coin_price, balances_results, callback){

                if(typeof balances_results !== 'object') {
                    var total_coins = balances_results
                    var bitcoins = parseFloat(total_coins) * coin_price;
                    var balance = (bitcoins / targetcoin_price);

                    callback(null, balance);
                    return;
                }

                var balances = [];

                for(var worker in balances_results){
                    var total_coins = parseFloat(balances_results[worker]) / 1;
                    var bitcoins = total_coins.toFixed() * coin_price;
                    var balance = (bitcoins / targetcoin_price);
                    balances.push({worker:worker, balance:balance.toFixed( 8 )});
                }

                callback(null, balances);
            }

        ], function(err, balances){

            if(balance) {
                cback(balances);
                return;
            }

            _this.stats.balances = balances;
         _this.stats.payout  = payouts;
        //logger.error(logSystem, 'TEMP', '_this.stats right before CB variable is:' + JSON.stringify(_this.stats));

    cback();
        });

    };





    this.getGlobalStats = function(callback){

        var statGatherTime = Date.now() / 1000 | 0;

        var allCoinStats = {};

        async.each(redisClients, function(client, callback){
            var windowTime = (((Date.now() / 1000) - portalConfig.website.stats.hashrateWindow) | 0).toString();
            var redisCommands = [];


            var redisCommandTemplates = [
                ['zremrangebyscore', ':hashrate', '-inf', '(' + windowTime],
                ['zrangebyscore', ':hashrate', windowTime, '+inf'],
                ['hgetall', ':stats'],
                ['scard', ':blocksPending'],
                ['scard', ':blocksConfirmed'],
                ['scard', ':blocksOrphaned']
            ];

            var commandsPerCoin = redisCommandTemplates.length;

            client.coins.map(function(coin){
                redisCommandTemplates.map(function(t){
                    var clonedTemplates = t.slice(0);
                    clonedTemplates[1] = coin + clonedTemplates[1];
                    redisCommands.push(clonedTemplates);
                });
            });


            client.client.multi(redisCommands).exec(function(err, replies){
                if (err){
                    logger.error(logSystem, 'Global', 'error with getting global stats ' + JSON.stringify(err));
                    callback(err);
                }
                else{
                    for(var i = 0; i < replies.length; i += commandsPerCoin){
                        var coinName = client.coins[i / commandsPerCoin | 0];
                        var coinStats = {
                            name: coinName,
                            symbol: poolConfigs[coinName].coin.symbol.toUpperCase(),
                            algorithm: poolConfigs[coinName].coin.algorithm,
                            hashrates: replies[i + 1],
                            poolStats: {
                                validShares: replies[i + 2] ? (replies[i + 2].validShares || 0) : 0,
                                validBlocks: replies[i + 2] ? (replies[i + 2].validBlocks || 0) : 0,
                                invalidShares: replies[i + 2] ? (replies[i + 2].invalidShares || 0) : 0,
                                totalPaid: replies[i + 2] ? (replies[i + 2].totalPaid || 0) : 0
                            },
                            blocks: {
                                pending: replies[i + 3],
                                confirmed: replies[i + 4],
                                orphaned: replies[i + 5]
                            }
                        };
                        allCoinStats[coinStats.name] = (coinStats);
                    }
                    callback();
                }
            });
        }, function(err){
            if (err){
                logger.error(logSystem, 'Global', 'error getting all stats' + JSON.stringify(err));
                callback();
                return;
            }

            var portalStats = {
                time: statGatherTime,
                global:{
                    workers: 0,
                    hashrate: 0
                },
                algos: {},
                pools: allCoinStats
            };

            Object.keys(allCoinStats).forEach(function(coin){
                var coinStats = allCoinStats[coin];
                coinStats.workers = {};
                coinStats.shares = 0;
                coinStats.hashrates.forEach(function(ins){
                    var parts = ins.split(':');
                    var workerShares = parseFloat(parts[0]);
                    var worker = parts[1];
                    if (workerShares > 0) {
                        coinStats.shares += workerShares;
                        if (worker in coinStats.workers)
                            coinStats.workers[worker].shares += workerShares;
                        else
                            coinStats.workers[worker] = {
                                shares: workerShares,
                                invalidshares: 0,
                                hashrateString: null
                            };
                    }
                    else {
                        if (worker in coinStats.workers)
                            coinStats.workers[worker].invalidshares -= workerShares; // workerShares is negative number!
                        else
                            coinStats.workers[worker] = {
                                shares: 0,
                                invalidshares: -workerShares,
                                hashrateString: null
                            };
                    }
                });

                var shareMultiplier = Math.pow(2, 32) / algos[coinStats.algorithm].multiplier;
                coinStats.hashrate = shareMultiplier * coinStats.shares / portalConfig.website.stats.hashrateWindow;

                coinStats.workerCount = Object.keys(coinStats.workers).length;
                portalStats.global.workers += coinStats.workerCount;

                /* algorithm specific global stats */
                var algo = coinStats.algorithm;
                if (!portalStats.algos.hasOwnProperty(algo)){
                    portalStats.algos[algo] = {
                        workers: 0,
                        hashrate: 0,
                        hashrateString: null
                    };
                }
                portalStats.algos[algo].hashrate += coinStats.hashrate;
                portalStats.algos[algo].workers += Object.keys(coinStats.workers).length;

                for (var worker in coinStats.workers) {
                    coinStats.workers[worker].hashrateString = _this.getReadableHashRateString(shareMultiplier * coinStats.workers[worker].shares / portalConfig.website.stats.hashrateWindow);
                }

                delete coinStats.hashrates;
                delete coinStats.shares;
                coinStats.hashrateString = _this.getReadableHashRateString(coinStats.hashrate);
            });

            Object.keys(portalStats.algos).forEach(function(algo){
                var algoStats = portalStats.algos[algo];
                algoStats.hashrateString = _this.getReadableHashRateString(algoStats.hashrate);
            });

            _this.stats = portalStats;
            _this.statsString = JSON.stringify(portalStats);



            _this.statHistory.push(portalStats);
            addStatPoolHistory(portalStats);

            var retentionTime = (((Date.now() / 1000) - portalConfig.website.stats.historicalRetention) | 0);

            for (var i = 0; i < _this.statHistory.length; i++){
                if (retentionTime < _this.statHistory[i].time){
                    if (i > 0) {
                        _this.statHistory = _this.statHistory.slice(i);
                        _this.statPoolHistory = _this.statPoolHistory.slice(i);
                    }
                    break;
                }
            }

            redisStats.multi([
                ['zadd', 'statHistory', statGatherTime, _this.statsString],
                ['zremrangebyscore', 'statHistory', '-inf', '(' + retentionTime]
            ]).exec(function(err, replies){
                if (err)
                    logger.error(logSystem, 'Historics', 'Error adding stats to historics ' + JSON.stringify(err));
            });
            callback();
        });

    };

    this.getReadableHashRateString = function(hashrate){
        var i = -1;
        var byteUnits = [ ' KH', ' MH', ' GH', ' TH', ' PH' ];
        do {
            hashrate = hashrate / 1024;
                        i++;
        } while (hashrate > 1024);
        return hashrate.toFixed(2) + byteUnits[i];
    };

};
[/code

Delete the stock website.js file as well, make a new one:
[code]

var fs = require('fs');
var path = require('path');

var async = require('async');
var watch = require('node-watch');
var redis = require('redis');

var dot = require('dot');
var express = require('express');
var bodyParser = require('body-parser');
var compress = require('compression');

var Stratum = require('stratum-pool');
var util = require('stratum-pool/lib/util.js');

var api = require('./api.js');


module.exports = function(logger){

    dot.templateSettings.strip = false;

    var portalConfig = JSON.parse(process.env.portalConfig);
    var poolConfigs = JSON.parse(process.env.pools);

    var websiteConfig = portalConfig.website;

    var portalApi = new api(logger, portalConfig, poolConfigs);
    var portalStats = portalApi.stats;

    var logSystem = 'Website';


var pageFiles = {
        'index.html': 'index',
        'home.html': '',
        'tbs.html': 'tbs',
        'workers.html': 'workers',
        'api.html': 'api',
        'admin.html': 'admin',
        'mining_key.html': 'mining_key',
        'miner.html': 'miner',
        'miner_stats.html': 'miner_stats',
        'user_shares.html': 'user_shares',
        'getting_started.html': 'getting_started'
    };

    var pageTemplates = {};

    var pageProcessed = {};
    var indexesProcessed = {};

    var keyScriptTemplate = '';
    var keyScriptProcessed = '';


    var processTemplates = function(){

        for (var pageName in pageTemplates){
            if (pageName === 'index') continue;
            pageProcessed[pageName] = pageTemplates[pageName]({
                poolsConfigs: poolConfigs,
                stats: portalStats.stats,
                portalConfig: portalConfig
            });
            indexesProcessed[pageName] = pageTemplates.index({
                page: pageProcessed[pageName],
                selected: pageName,
                stats: portalStats.stats,
                poolConfigs: poolConfigs,
                portalConfig: portalConfig
            });
        }

        //logger.debug(logSystem, 'Stats', 'Website updated to latest stats');
    };



    var readPageFiles = function(files){
        async.each(files, function(fileName, callback){
            var filePath = 'website/' + (fileName === 'index.html' ? '' : 'pages/') + fileName;
            fs.readFile(filePath, 'utf8', function(err, data){
                var pTemp = dot.template(data);
                pageTemplates[pageFiles[fileName]] = pTemp
                callback();
            });
        }, function(err){
            if (err){
                console.log('error reading files for creating dot templates: '+ JSON.stringify(err));
                return;
            }
            processTemplates();
        });
    };


    //If an html file was changed reload it
    watch('website', function(filename){
        var basename = path.basename(filename);
        if (basename in pageFiles){
            console.log(filename);
            readPageFiles([basename]);
            logger.debug(logSystem, 'Server', 'Reloaded file ' + basename);
        }
    });

    portalStats.getGlobalStats(function(){
        readPageFiles(Object.keys(pageFiles));
    });

    var buildUpdatedWebsite = function(){
        portalStats.getGlobalStats(function(){
            processTemplates();

            var statData = 'data: ' + JSON.stringify(portalStats.stats) + '\n\n';
            for (var uid in portalApi.liveStatConnections){
                var res = portalApi.liveStatConnections[uid];
                res.write(statData);
            }

        });
    };

    setInterval(buildUpdatedWebsite, websiteConfig.stats.updateInterval * 1000);


    var buildKeyScriptPage = function(){
        async.waterfall([
            function(callback){
                var client = redis.createClient(portalConfig.redis.port, portalConfig.redis.host);
                client.hgetall('coinVersionBytes', function(err, coinBytes){
                    if (err){
                        client.quit();
                        return callback('Failed grabbing coin version bytes from redis ' + JSON.stringify(err));
                    }
                    callback(null, client, coinBytes || {});
                });
            },
            function (client, coinBytes, callback){
                var enabledCoins = Object.keys(poolConfigs).map(function(c){return c.toLowerCase()});
                var missingCoins = [];
                enabledCoins.forEach(function(c){
                    if (!(c in coinBytes))
                        missingCoins.push(c);
                });
                callback(null, client, coinBytes, missingCoins);
            },
            function(client, coinBytes, missingCoins, callback){
                var coinsForRedis = {};
                async.each(missingCoins, function(c, cback){
                    var coinInfo = (function(){
                        for (var pName in poolConfigs){
                            if (pName.toLowerCase() === c)
                                return {
                                    daemon: poolConfigs[pName].paymentProcessing.daemon,
                                    address: poolConfigs[pName].address
                                }
                        }
                    })();
                    var daemon = new Stratum.daemon.interface([coinInfo.daemon], function(severity, message){
                        logger[severity](logSystem, c, message);
                    });
                    daemon.cmd('dumpprivkey', [coinInfo.address], function(result){
                        if (result[0].error){
                            logger.error(logSystem, c, 'Could not dumpprivkey for ' + c + ' ' + JSON.stringify(result[0].error));
                            cback();
                            return;
                        }

                        var vBytePub = util.getVersionByte(coinInfo.address)[0];
                        var vBytePriv = util.getVersionByte(result[0].response)[0];

                        coinBytes[c] = vBytePub.toString() + ',' + vBytePriv.toString();
                        coinsForRedis[c] = coinBytes[c];
                        cback();
                    });
                }, function(err){
                    callback(null, client, coinBytes, coinsForRedis);
                });
            },
            function(client, coinBytes, coinsForRedis, callback){
                if (Object.keys(coinsForRedis).length > 0){
                    client.hmset('coinVersionBytes', coinsForRedis, function(err){
                        if (err)
                            logger.error(logSystem, 'Init', 'Failed inserting coin byte version into redis ' + JSON.stringify(err));
                        client.quit();
                    });
                }
                else{
                    client.quit();
                }
                callback(null, coinBytes);
            }
        ], function(err, coinBytes){
            if (err){
                logger.error(logSystem, 'Init', err);
                return;
            }
            try{
                keyScriptTemplate = dot.template(fs.readFileSync('website/key.html', {encoding: 'utf8'}));
                keyScriptProcessed = keyScriptTemplate({coins: coinBytes});
            }
            catch(e){
                logger.error(logSystem, 'Init', 'Failed to read key.html file');
            }
        });

    };
    buildKeyScriptPage();

    var getPage = function(pageId){
        if (pageId in pageProcessed){
            var requestedPage = pageProcessed[pageId];
            return requestedPage;
        }
    };




    var minerpage = function(req, res, next){
        var address = req.params.address || null;

        if (address != null){
            portalStats.getBalanceByAddress(address, function(){
                processTemplates();

                res.end(indexesProcessed['miner_stats']);

            });
        }
        else
            next();
    };

    var payout = function(req, res, next){
        var address = req.params.address || null;

        if (address != null){
            portalStats.getPayout(address, function(data){
                res.write(data.toString());
                res.end();
            });
        }
        else
            next();
    };


    var shares = function(req, res, next){
        portalStats.getCoins(function(){
            processTemplates();

            res.end(indexesProcessed['user_shares']);

        });
    };

    var usershares = function(req, res, next){

        var coin = req.params.coin || null;

        if(coin != null){
            portalStats.getCoinTotals(coin, null, function(){
                processTemplates();

                res.end(indexesProcessed['user_shares']);

            });
        }
        else
            next();
    };


    var route = function(req, res, next){
        var pageId = req.params.page || '';
        if (pageId in indexesProcessed){
            res.header('Content-Type', 'text/html');
            res.end(indexesProcessed[pageId]);
        }
        else
            next();

    };



    var app = express();


    app.use(bodyParser.json());

    app.get('/get_page', function(req, res, next){
        var requestedPage = getPage(req.query.id);
        if (requestedPage){
            res.end(requestedPage);
            return;
        }
        next();
    });

    app.get('/key.html', function(req, res, next){
        res.end(keyScriptProcessed);
    });


        app.get('/stats/shares/:coin', usershares);
    app.get('/stats/shares', shares);
    app.get('/miner/:address', minerpage);
    app.get('/payout/:address', payout);



    app.get('/:page', route);
    app.get('/', route);

    app.get('/api/:method', function(req, res, next){
        portalApi.handleApiRequest(req, res, next);
    });

    app.post('/api/admin/:method', function(req, res, next){
        if (portalConfig.website
            && portalConfig.website.adminCenter
            && portalConfig.website.adminCenter.enabled){
            if (portalConfig.website.adminCenter.password === req.body.password)
                portalApi.handleAdminApiRequest(req, res, next);
            else
                res.send(401, JSON.stringify({error: 'Incorrect Password'}));

        }
        else
            next();

    });

    app.use(compress());
    app.use('/static', express.static('website/static'));

    app.use(function(err, req, res, next){
        console.error(err.stack);
        res.send(500, 'Something broke!');
    });

    try {
        app.listen(portalConfig.website.port, portalConfig.website.host, function () {
            logger.debug(logSystem, 'Server', 'Website started on ' + portalConfig.website.host + ':' + portalConfig.website.port);
        });
    }
    catch(e){
        logger.error(logSystem, 'Server', 'Could not start website on ' + portalConfig.website.host + ':' + portalConfig.website.port
            +  ' - its either in use or you do not have permission');
    }


};

<div class="row">
        <div class="col-md-2"> </div>
        <div class="col-md-4">
                <p class="lead">Enter Your <YOUR COIN> Wallet address</p>
                <div class="input-group">
                        <input type="text" class="form-control input-lg">
                        <span class="input-group-btn">
                                <button class="btn btn-default btn-lg" type="button">Go!</button>
                        </span>
                </div>
        </div>
<div class="col-md-4"></div>
</div> <!--- end row --!>


<script type="text/javascript">
        $(document).ready(function(){

                $('.btn-lg').click(function(){
                        window.location = "miner/" + $('.input-lg').val();
                });
        });
</script>

                <div class="row">
                                                <div class="col-md-6">
{{? it.stats.balances }}

                                <div class="row"> </div>
                                <div class="row">
                                                        <div class="panel panel-default">
                            <div class="panel-heading"> <h1><strong><span id="address">{{=it.stats.address}}<span></strong> </h1></div>
                            <div class="panel-body">
                                <p class="lead">So far this shift you have earned: <strong><span class="payout"></span></strong> <<INSERT UR TARGET SYMBOL HERE> (estimate).</p>

                                <p class="lead">Your previous balance with the pool is currently: <strong><span class="owed"></span></strong>  <INSERT UR TARGET SYMBOL HERE> </p?
                            </div>
                        </div>
                </div>
                                </div> <!-- end row -->
                        <div class="row"> </div>



                                                </div>
                                </div>
                        <div class="row"> &nbsp;</div>
                        <center>
                        <div class="panel panel-default">
                                <div class="panel-body">
                                <div class="stat-panel row">

<div>

    <!-- content -->
        <div class="row">

        <!-- main col left -->
        <div class="col-sm-12">

                    <div class="panel panel-default">
                            <div class="panel-body">

                        <div class="stat-panel row">
                                                              {{ for(var balance in it.stats.balances) { }}
                                                                               <div class="panel panel-default col-md-2 col-xs-4">
                                                                                  <div class="panel-heading" style="background-color:#3d3d3d;color:white;"><center><span class="text-xs"> {{=it.stats.balances[balance].coin}}</span></center></div>
                                                                               <div class="panel-body"><span class="text-bg"><strong>{{=it.stats.balances[balance].balance}}</strong></span> &nbsp</div>
                                                                               </div>
                                              {{ } }}
                                                                               </div>
                        </div>


                </div>



        <!-- Debug -->
        <div class="debug" style="display:none;">
                {{=JSON.stringify(it.stats)}}
        </div>

</div>
{{?}}

<script type="text/javascript">

$(document).ready(function(){

        var addr = $('#address').text();

        $.get('http://ururl:7379/hget/Pool_Stats:CurrentShift:WorkerTgtCoin/' + addr + '.txt', function(payoutdata){
                $('.payout').text(payoutdata);
        });



/*
        $.each($('.blockAmount'), function(i, v){
                if($(v).html() === "undefined") {
                        $(v).html(' --- ');
                }
        });

        $.each($('.blockShares'), function(i, v){
                if($(v).html() === "undefined") {
                        $(v).html(' --- ');
                }
        });
        */
});


$(function() {
                   var addr = $('#address').text();

                $.get("http://ururl:7379/ZSCORE/Pool_Stats:Balances/" + addr, function( payoutdata ) {
                                                $('.owed').append(payoutdata.ZSCORE);
                                });
                });


</script>

root@blackcoinpool:/FORFREEDOM/# cat ~/webdis-home/webdis.json
{
        "redis_host":   "127.0.0.1",

        "redis_port":   6379,
        "redis_auth":   null,

        "http_host":    "0.0.0.0",
        "http_port":    7379,

        "threads":      5,
        "pool_size": 20,

        "daemonize":    true,
        "websockets":   true,
        "default_root": "/GET/index.html",
        "database":     0,

        "acl": [
                {
                        "disabled":     ["*"]
                },

                {
                        "enabled":              ["GET", "HGET", "ZRANGE", "ZCARD", "ZRANGEBYSCORE", "ZVAL", "LRANGE", "HGETALL", "HKEYS", "HVALS", "GETALL", "HGETALL", "ZRANGE", "SMEMBERS", "ZSCORE"]
                }
        ],

        "verbosity": 6,
        "logfile": "/root/webdis-home/webdis.log"
}

#!/bin/bash
workercounter=0
arraycounter=0
now="`date +%s`"
TenMins=$((now - 600))
interval=600
modifier=65536
SHAmodifier=4294967296
redis-cli del tmpkey

while read Algo
do
        TotalWorkers=0
        WorkerTotals=0
        unset arrWorkerTotals
        unset arrWorkerCounts
        unset arrWorkerNames
        typeset -A arrWorkerTotals
        typeset -A arrWorkerCounts
        typeset -A arrWorkerNames
        AlgoCounter=0
        workercounter=0
        redis-cli del tmpkey
        while read CoinType
        do
                echo "$CoinType"

                counter=0
                CoinKeyName=$CoinType":hashrate"
                totalhashes=`redis-cli zcard $CoinKeyName`
        if [ -z "$totalhashes" ]
        then
                echo "no hashes" >/dev/null
        else
                while read LineItem
                do
#                       echo "$LineItem"
        counter=$(($counter + 1))
                        AlgoCounter=$(($AlgoCounter + 1))
                        IN=$LineItem
            arrIN=(${IN//:/ })
            preworker=(${arrIN[1]})
            #strip HTML tags out to ensure safe displaying later
            workername=`echo "$preworker," | tr -d '<>,'`
                        echo "$workername"
                        if [[ $workername == "" ]]
                        then
                                echo "ignore worker"
                        else
                               share=(${arrIN[0]})
                                arrWorkerCounts[$workername]=$((${arrWorkerCounts[$workername]} + 1))
if [[ ${arrWorkerCounts[$workername]} -eq 1 ]]
                                  then
                                #must have been this workers first share, so thi                                                                                                             s is a new worker
                                TotalWorkers=$(($TotalWorkers + 1))
                workercounter=$(($workercounter + 1))
                        arrWorkerNames[$workercounter]=$workername
                                echo "TotalWorkers - $TotalWorkers ~~~ workercounter - $workercounter ~~~ arrWorkerNames -" ${arrWorkerNames[$workercounter]}
                                  else
                                        #this was a duplicate worker, do nothing
                                        echo " " >/dev/null
                                fi
                        if [ -z "${arrWorkerTotals[$workername]}" ]
                        then
                                tempvar=0
                        else
                                tempvar=${arrWorkerTotals[$workername]}
                        fi


                         arrWorkerTotals[$workername]=`echo "scale=6;$tempvar + $share" | bc -l`

                        echo "${arrWorkerNames[$workercounter]}"



            fi
                        done< <(redis-cli zrangebyscore $CoinKeyName $TenMins $now)

                        TotalHash=`echo "$TotalHash + $share" | bc -l`
fi
                done< <(redis-cli hkeys Coin_Names_$Algo)


                  # break it down - sha is stored a GH, everything else is stored a MH
                                if [ $Algo = "sha256" ]
                                then
                                        modifier=4294967296
                                        divisor=1073741824
                                elif [ $Algo = "keccak" ]
                                then
                                        modifier=16777216
                                        divisor=1048576
                                elif [ $Algo = "x11" ]
                                then
                                        modifier=4294967296
                                        divisor=1048576
                                else
                                        modifier=65536
                                        divisor=1048576
                                fi

                                TotalHR=`echo "scale=3;$TotalHash * $modifier / $interval / $divisor" | bc`
                redis-cli zadd Pool_Stats:avgHR:$Algo $now $TotalHR":"$now
                #go over the array of WorkerNames and calculate each workers HR
                                counterB=0
                while [[ $counterB -lt $workercounter ]]
                do
                        counterB=$(($counterB + 1))
                        workerName=${arrWorkerNames[$counterB]}
                        echo $workerName
                        temporary=`echo "scale=6;${arrWorkerTotals[$workerName]} * $modifier" | bc -l`
                                        #               number=`echo "$interval / $divisor" | bc -l`
                          arrWorkerHashRates[$counterB]=`echo "$temporary / $interval / $divisor" | bc -l`
                                                workerName=${arrWorkerNames[$counterB]}
                                                rate=${arrWorkerHashRates[$counterB]}
                                                echo $workerName $rate
                                                string=$rate":"$now
                                                redis-cli zadd Pool_Stats:WorkerHRs:$Algo:$workerName $now $string
                                                echo "$Algo - $workerName -"$arrWorkerHashRates[$counterB]}
                done


done< <(redis-cli hkeys Coin_Algos)

#!/bin/bash
BC2BTC=`curl -G 'https://api.mintpal.com/v1/market/stats/BC/BTC/' | jq -r .[].last_price`
FTC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=5' | jq -r .return.markets.FTC.lasttradeprice`
MZC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=164' | jq -r .return.markets.MZC.lasttradeprice`
NET2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=134' | jq -r .return.markets.NET.lasttradeprice`
DRK2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=155' | jq -r .return.markets.DRK.lasttradeprice`
WDC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=14' | jq -r .return.markets.WDC.lasttradeprice`
STR2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=83' | jq -r .return.markets.STR.lasttradeprice`
KDC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=178' | jq -r .return.markets.KDC.lasttradeprice`
NYAN2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=184' | jq -r .return.markets.NYAN.lasttradeprice`
MNC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=7' | jq -r .return.markets.MNC.lasttradeprice`
POT2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=173' | jq -r .return.markets.POT.lasttradeprice`
GDC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=82' | jq -r .return.markets.GDC.lasttradeprice`
GLC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=76' | jq -r .return.markets.GLC.lasttradeprice`
BTE2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=49' | jq -r .return.markets.BTE.lasttradeprice`
UNO2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=133' | jq -r .return.markets.UNO.lasttradeprice`
USDE2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_USDE.last`
HIRO2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_HIRO.last`
GDN2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_GDN.last`
cinni2btc=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_CINNI.last`
NOBL2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_NOBL.last`
REDD2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_REDD.last`
LGC2BTC=`curl -G 'https://poloniex.com/public?command=returnTicker' | jq -r .BTC_LGC.last`
EAC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=139' | jq -r .return.markets.EAC.lasttradeprice`
CAP2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=53' | jq -r .return.markets.CAP.lasttradeprice`
RBY2BTC=`curl -G 'https://bittrex.com/api/v1/public/getticker?market=BTC-RBY' | jq -r .result.Last`
tips2ltc=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=147' | jq -r .return.markets.TIPS.lasttradeprice`
ltc2btc=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=3' | jq -r .return.markets.LTC.lasttradeprice`
nxt2btc=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=159' | jq -r .return.markets.NXT.lasttradeprice`
tips2btc=`echo "$tips2ltc * $ltc2btc" | bc -l`
TRC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=27' | jq -r .return.markets.TRC.lasttradeprice`
LOT2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=137' | jq -r .return.markets.LOT.lasttradeprice`
GLD2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=30' | jq -r .return.markets.GLD.lasttradeprice`
MEC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=45' | jq -r .return.markets.MEC.lasttradeprice`
MYR2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=200' | jq -r .return.markets.MYR.lasttradeprice`
MEOW2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=149' | jq -r .return.markets.MEOW.lasttradeprice`
EXE2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=183' | jq -r .return.markets.EXE.lasttradeprice`
VTC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=151' | jq -r .return.markets.VTC.lasttradeprice`
SAT2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=168' | jq -r .return.markets.SAT.lasttradeprice`
NXT2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=159' | jq -r .return.markets.NXT.lasttradeprice`
MAX2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=152' | jq -r .return.markets.MAX.lasttradeprice`
THREE2BTC=`curl -G 'https://api.mintpal.com/v1/market/stats/365/BTC/' | jq -r .[].last_price`
ZET2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=85' | jq -r .return.markets.ZET.lasttradeprice`
XC2BTC=`curl -G 'http://pubapi.cryptsy.com/api.php?method=singlemarketdata&marketid=210' | jq -r .return.markets.XC.lasttradeprice`

redis-cli hset Exchange_Rates blackcoin $BC2BTC
redis-cli hset Exchange_Rates globaldenomination $GDN2BTC
redis-cli hset Exchange_Rates zetacoin $ZET2BTC
redis-cli hset Exchange_Rates logicoin $LGC2BTC
redis-cli hset Exchange_Rates cinnicoin $cinni2btc
redis-cli hset Exchange_Rates 365coin $THREE2BTC
redis-cli hset Exchange_Rates NXT $NXT2BTC
redis-cli hset Exchange_Rates execoin $EXE2BTC
redis-cli hset Exchange_Rates vertcoin $VTC2BTC
redis-cli hset Exchange_Rates kittehcoin $MEOW2BTC
redis-cli hset Exchange_Rates megacoin $MEC2BTC
redis-cli hset Exchange_Rates netcoin $NET2BTC
redis-cli hset Exchange_Rates globalcoin $GLC2BTC
redis-cli hset Exchange_Rates grandcoin $GDC2BTC
redis-cli hset Exchange_Rates goldcoin $GLD2BTC
redis-cli hset Exchange_Rates fedoracoin $tips2btc
redis-cli hset Exchange_Rates litecoin $ltc2btc
redis-cli hset Exchange_Rates nxt $NXT2BTC
redis-cli hset Exchange_Rates terracoin $TRC2BTC
redis-cli hset Exchange_Rates feathercoin $FTC2BTC
redis-cli hset Exchange_Rates reddcoin $REDD2BTC
redis-cli hset Exchange_Rates earthcoin $EAC2BTC
redis-cli hset Exchange_Rates bottlecaps $CAP2BTC
redis-cli hset Exchange_Rates rubycoin $RBY2BTC
redis-cli hset Exchange_Rates terracoin $TRC2BTC
redis-cli hset Exchange_Rates noblecoin $NOBL2BTC
redis-cli hset Exchange_Rates mincoin $MNC2BTC
redis-cli hset Exchange_Rates klondikecoin $KDC2BTC
redis-cli hset Exchange_Rates darkcoin $DRK2BTC
redis-cli hset Exchange_Rates mazacoin $MZC2BTC
redis-cli hset Exchange_Rates unobtanium $UNO2BTC
redis-cli hset Exchange_Rates hirocoin $HIRO2BTC
redis-cli hset Exchange_Rates cinnicoin $cinni2btc
redis-cli hset Exchange_Rates usde $USDE2BTC
redis-cli hset Exchange_Rates lottocoin $LOT2BTC
redis-cli hset Exchange_Rates nyancoin $NYAN2BTC
redis-cli hset Exchange_Rates worldcoin $WDC2BTC
redis-cli hset Exchange_Rates potcoin $POT2BTC
redis-cli hset Exchange_Rates myriadcoin $MYR2BTC
redis-cli hset Exchange_Rates myriad-scrypt $MYR2BTC
redis-cli hset Exchange_Rates myriadsha $MYR2BTC
redis-cli hset Exchange_Rates saturncoin $SAT2BTC
redis-cli hset Exchange_Rates maxcoin $MAX2BTC
redis-cli hset Exchange_Rates rubycoin $RBY2BTC
redis-cli hset Exchange_Rates xccoin $XC2BTC

#!/bin/bash
declare -A ProArr
declare -A NameArr
AlgoCounter=0
now="`date +%s`"
ShiftNumber=`redis-cli hget Pool_Stats This_Shift`
echo "Test"
startstring="Pool_Stats:"$ShiftNumber
starttime=`redis-cli hget $startstring starttime`
endtime=$now
length=$(($endtime - $starttime))
redis-cli hset Pool_Stats CurLength $length
dayslength=`echo "scale=3;$length / 86400" | bc -l`
TgtCoinPrice=`redis-cli hget Exchange_Rates <TARGET COIN NAME HERE>`
TotalEarned=0
TotalEarnedTgtCoin=0
redis-cli hset Pool_Stats CurDaysLength $dayslength
redis-cli del Pool_Stats:CurrentShift:WorkerBTC
redis-cli del Pool_Stats:CurrentShift:WorkerTgtCoin

# START CALCULATING COIN PROFIT FOR CURRENT ROUND - THIS ALSO CALCULATES WORKER EARNINGS MID SHIFT.
# PLEASE NOTE ALL COIN NAMES IN COIN_ALGO REDIS KEY MUST MATCH KEY NAMES IN EXCHANGE_RATES KEY CASE-WISE
while read line
do
        AlgoTotal=0
        AlgoTotalTgtCoin=0
        logkey2="Pool_Stats:CurrentShift:Algos"
        logkey2TgtCoin="Pool_Stats:CurrentShift:AlgosTgtCoin"
        echo "LOGKEY2: $logkey2"
        # loop through each coin for that algo
        while read CoinName
        do
                coinTotal=0
                coinTotalTgtCoin=0
                thiskey=$CoinName":balances"
                logkey="Pool_Stats:CurrentShift:Coins"
                logkeyTgtCoin="Pool_Stats:CurrentShift:CoinsTgtCoin"
                #Determine price for Coin
                coin2btc=`redis-cli hget Exchange_Rates $CoinName`
#               echo "$CoinName - $coin2btc"
                workersPerCoin=`redis-cli hlen $thiskey`
                if [ $workersPerCoin = 0 ]
                then
                        echo "do nothing" > /dev/null
                else

                        while read WorkerName
                        do
                                thisBalance=`redis-cli hget $thiskey $WorkerName`
                                thisEarned=`echo "scale=6;$thisBalance * $coin2btc" | bc -l`
                                coinTotal=`echo "scale=6;$coinTotal + $thisEarned" | bc -l`
                                AlgoTotal=`echo "scale=6;$AlgoTotal + $thisEarned" | bc -l`
                                TgtCoinEarned=`echo "scale=6;$thisEarned / $TgtCoinPrice" | bc -l`
                                coinTotalTgtCoin=`echo "scale=6;$coinTotalTgtCoin + $TgtCoinEarned" | bc -l`
                                AlgoTotalTgtCoin=`echo "scale=6;$AlgoTotalTgtCoin + $TgtCoinEarned" | bc -l`

#                               echo "$WorkerName earned $TgtCoinEarned from $CoinName"
                                redis-cli hincrbyfloat Pool_Stats:CurrentShift:WorkerTgtCoin $WorkerName $TgtCoinEarned
                                redis-cli hincrbyfloat Pool_Stats:CurrentShift:WorkerBTC $WorkerName $thisEarned
                        done< <(redis-cli hkeys $CoinName:balances)
                        redis-cli hset $logkey $CoinName $coinTotal
                        redis-cli hset $logkeyTgtCoin $CoinName $coinTotalTgtCoin
                        echo "$CoinName: $coinTotal"

                fi
        done< <(redis-cli hkeys Coin_Names_$line)
          redis-cli hset $logkey2 $line $AlgoTotal
        redis-cli hset $logkey2TgtCoin $line $AlgoTotalTgtCoin
TotalEarned=`echo "scale=6;$TotalEarned + $AlgoTotal" | bc -l`
TotalEarnedTgtCoin=`echo "scale=6;$TotalEarnedTgtCoin + $AlgoTotalTgtCoin" | bc -l`

done< <(redis-cli hkeys Coin_Algos)


# END CALCULATING COIN PROFITS FOR CURRENT SHIFT


# START CALCULATIN AVERAGE HASHRATES SO FAR THIS SHIFT
echo "Start: $starttime End: $endtime"
        AlgoCounter=0
        while read Algo
        do
                AlgoCounter=$(($AlgoCounter + 1))
                if [ $Algo = "sha256" ]
                then
                        Algo="sha256"
                fi
                AlgoHRTotal=0
                counter=0
                loopstring="Pool_Stats:AvgHRs:"$Algo
                while read HR
                do
                        IN=$HR
                        arrIN=(${IN//:/ })
                        amt=${arrIN[0]}
                        counter=`echo "$counter + 1" | bc`
                        AlgoHRTotal=`echo "$AlgoHRTotal + $amt" | bc -l`
               done< <(redis-cli zrangebyscore $loopstring $starttime $endtime)

                if [ $Algo = "sha" ]
                then
                        Algo="sha256"
                fi
                thisalgoAVG=`echo "scale=8;$AlgoHRTotal / $counter" |  bc -l`
                string="average_"$Algo
                redis-cli hset Pool_Stats:CurrentShift $string $thisalgoAVG
                string3="Pool_Stats:CurrentShift:Algos"
                thisalgoEarned=`redis-cli hget $string3 $Algo`
                thisalgoP=`echo "scale=8;$thisalgoEarned / $thisalgoAVG / $dayslength" | bc -l`
                string2="Profitability_$Algo"
                redis-cli hset Pool_Stats:CurrentShift $string2 $thisalgoP
                if [ $Algo = "keccak" ]
                then
                        thisalgoP=`echo "scale=8;$thisalgoP * 500" | bc -l`
                elif [ $Algo = "sha256" ]
                then
                        thisalgoP=`echo "scale=8;$thisalgoP * 100" | bc -l`
                elif [ $Algo = "x11" ]
                then
                        thisalgoP=`echo "scale=8;$thisalgoP * 4" | bc -l`
                else
                        echo "done" >/dev/null
                fi
                if [ -z "$thisalgoP" ]
                then
                        thisalgoP=0
                fi

                ProArr[$AlgoCounter]=$thisalgoP
                NameArr[$AlgoCounter]=$Algo
                redis-cli hset Pool_Stats:CurrentShift $string2 $thisalgoP

                echo "For Current Shift Algo $Algo had an average of $thisalgoAVG - profitability was $thisalgoP"
        done< <(redis-cli hkeys Coin_Algos)

                profitstring=${ProArr[1]}":"${ProArr[2]}":"${ProArr[3]}":"${ProArr[4]}":"${ProArr[5]}
                stringnames=${NameArr[1]}":"${NameArr[2]}":"${NameArr[3]}":"${NameArr[4]}":"${NameArr[5]}
redis-cli hset Pool_Stats:CurrentShift:Profitability $now $profitstring
redis-cli hset Pool_Stats:CurrentShift  NameString $stringnames

#!/bin/bash
cp /Scripts/payouts /Scripts/old_payouts
rm /Scripts/payouts
counter=0
                redis-cli del Pool_Stats:CurrentRoundBTCD
                redis-cli del Pool_Stats:CurrentRoundBTC
now="`date +%s`"
thisShift=`redis-cli hget Pool_Stats This_Shift`
ShiftStart=`redis-cli hget Pool_Stats:$thisShift starttime`
BTCDPrice=`redis-cli hget Exchange_Rates btcdcoin`
TotalEarned=0
TotalEarnedBTCD=0
# loop through algos
while read line
do
        AlgoTotal=0
        AlgoTotalBTCD=0
        logkey2="Pool_Stats:"$thisShift":Algos"
        logkey2BTCD="Pool_Stats:"$thisShift":AlgosBTCD"
echo "LOGKEY2: $logkey2"

        # loop through each coin for that algo
        while read CoinName
        do
                coinTotal=0
                coinTotalBTCD=0
                thiskey=$CoinName":balances"
                logkey="Pool_Stats:"$thisShift":Coins"
                logkeyBTCD="Pool_Stats:"$thisShift":CoinsBTCD"
                #Determine price for Coin
                coin2btc=`redis-cli hget Exchange_Rates $CoinName`
#               echo "$CoinName - $coin2btc"
                workersPerCoin=`redis-cli hlen $thiskey`
                if [ $workersPerCoin = 0 ]
                then
                        echo "do nothing" > /dev/null
                else

                        while read WorkerName
                        do
                                thisBalance=`redis-cli hget $thiskey $WorkerName`
                                thisEarned=`echo "scale=4;$thisBalance * $coin2btc" | bc -l`
                                coinTotal=`echo "scale=4;$coinTotal + $thisEarned" | bc -l`
                                AlgoTotal=`echo "scale=4;$AlgoTotal + $thisEarned" | bc -l`
                                BTCDEarned=`echo "scale=4;$thisEarned / $BTCDPrice" | bc -l`
                                coinTotalBTCD=`echo "scale=4;$coinTotalBTCD + $BTCDEarned" | bc -l`
                                AlgoTotalBTCD=`echo "scale=4;$AlgoTotalBTCD + $BTCDEarned" | bc -l`

#                               echo "$WorkerName earned $BTCDEarned from $CoinName"
                                redis-cli hincrbyfloat Pool_Stats:CurrentRoundBTCD $WorkerName $BTCDEarned
                                redis-cli hincrbyfloat Pool_Stats:CurrentRoundBTC $WorkerName $thisEarned
                        done< <(redis-cli hkeys $CoinName:balances)
                        redis-cli hset $logkey $CoinName $coinTotal
                        redis-cli hset $logkeyBTCD $CoinName $coinTotalBTCD
                        echo "$CoinName: $coinTotal"

                fi
        done< <(redis-cli hkeys Coin_Names_$line)
          redis-cli hset $logkey2 $line $AlgoTotal
        redis-cli hset $logkey2BTCD $line $AlgoTotalBTCD
TotalEarned=`echo "scale=4;$TotalEarned + $AlgoTotal" | bc -l`
TotalEarnedBTCD=`echo "scale=4;$TotalEarnedBTCD + $AlgoTotalBTCD" | bc -l`

done< <(redis-cli hkeys Coin_Algos)
redis-cli hset Pool_Stats:$thisShift Earned_BTC $TotalEarned
redis-cli hset Pool_Stats:$thisShift Earned_BTCD $TotalEarnedBTCD

echo "Total Earned: $TotalEarned"

redis-cli hset Pool_Stats:$thisShift endtime $now
nextShift=$(($thisShift + 1))
redis-cli hincrby Pool_Stats This_Shift 1
echo "$thisShift" >>/Scripts/Shifts
redis-cli hset Pool_Stats:$nextShift starttime $now
echo "Printing Earnings report" >> /Scripts/ShiftChangeLog.txt
echo "Shift change switching from $thisShift to $nextShift at $now" >>/Scripts/ShiftChangeErrorCheckerReport
while read WorkerName
do

        PrevBalance=`redis-cli zscore Pool_Stats:Balances $WorkerName`
        if [[ $PrevBalance == "" ]]
        then
                PrevBalance=0
        fi
        thisBalance=`redis-cli hget Pool_Stats:CurrentRoundBTCD $WorkerName`
        TotalBalance=`echo "scale=4;$PrevBalance + $thisBalance" | bc -l` >/dev/null
        echo $WorkerName $TotalBalance
#       echo "$WorkerName $TotalBalance" >> /Scripts/PayoutReport
        echo "$WorkerName $TotalBalance - was $PrevBalance plus today's $thisBalance" >> /Scripts/ShiftChangeErrorCheckerReport

        redis-cli zadd Pool_Stats:Balances $TotalBalance $WorkerName
        redis-cli hset Worker_Stats:Earnings:$WorkerName $thisShift $thisBalance
        redis-cli hincrbyfloat Worker_Stats:TotalEarned $WorkerName $thisBalance
        #Log each earning in the redis instance in the HTML format.
        #But first, mask the worker address.
                str=$WorkerName
                n=7
                hiddenWorkerName="***************"${str:${#str} - $n}


         redis-cli hincrby Pool_Stats Earning_Log_Entries 1
EarningNumber=`redis-cli hget Pool_Stats Earning_Log_Entries`
redis-cli hset Pool_Stats:EarningsLog $EarningNumber "<tr><td><center>$thisShift</center></td><td><b><center>Shift Earning</center></b></td><td><b>$hiddenWorkerName</td><td><center>$thisBalance</center></td><td><center>$PrevBalance</center></td><td><center>$TotalBalance</center></td><td><center>$now</center></td></tr>"


done< <(redis-cli hkeys Pool_Stats:CurrentRoundBTCD)
echo "Done adding coins, clearing balances now." >> /Scripts/ShiftChangeLog.log


# Save the total BTC/BTCD earned for each shift into a historical key for auditing purposes.
redis-cli rename Pool_Stats:CurrentRoundBTCD Pool_Stats:$thisShift:ShiftBTCD
redis-cli rename Pool_Stats:CurrentRoundBTC Pool_Stats:$thisShift:ShiftBTC

#for every coin on the pool....
while read Coin_Names2
do
        #Save the old balances key for every coin into a historical key.
        redis-cli rename $Coin_Names2:balances Prev:$thisShift:$Coin_Names2:balances

        # This loop will move every block from the blocksConfirmed keys into the blocksPaid keys. This means only blocksConfirmed are unpaid.
        while read PaidLine
        do
                redis-cli sadd $Coin_Names2:"blocksPaid" $PaidLine
                redis-cli srem $Coin_Names2:"blocksConfirmed" $PaidLine
                echo "nothing" > /dev/null
        done< <(redis-cli smembers $Coin_Names2:"blocksConfirmed")


done< <(redis-cli hkeys Coin_Names)

echo "Done script at $now" >> /Scripts/ShiftChangeLog.log

#Calculate workers owed in excesss of 5 BTCDcoin and generate a report of them.
while read PayoutLine
do

        amount=`redis-cli zscore Pool_Stats:Balances $PayoutLine`
        roundedamount=`echo "scale=4;$amount - 1" | bc -l`
        echo "$PayoutLine $roundedamount"
#log a file named /Scripts/pallp0pp
        echo "$PayoutLine $amount" >> /Scripts/payouts
#send all of the payments using the coin daemon
        txn=`bitcoindarkd sendtoaddress $PayoutLine $amount`
        if [ -z "$txn" ]
        then
	#log failed payout to txt file.
                echo "payment failed! $PayoutLine" >>/Scripts/AlertLog
        else
                urlstring="http://btcd.explorer.ssdpool.com:9050/tx/$txn"

                 newtotal=`echo "scale=4;$amount - $roundedamount" | bc -l` >/dev/null
                redis-cli hincrby Pool_Stats Earning_Log_Entries 1
                redis-cli hset Worker_Stats:Payouts:$PayoutLine $thisShift $amount
                redis-cli hincrbyfloat Worker_Stats:TotalPaid $PayoutLine $amount
EarningNumber=`redis-cli hget Pool_Stats Earning_Log_Entries`
                str=$PayoutLine
                n=7
                hiddenPayoutLine="***************"${str:${#str} - $n}
#log in redis for displaying on website
redis-cli hset Pool_Stats:EarningsLog $EarningNumber "<tr><td>$thisShift</td><td><b>Payout</b></td><td>$hiddenPayoutLine</td><td>$amount</td><td>$amount</td><td><a href=\"$urlstring\">here</a></td><td>$now</td></tr>"
                redis-cli zadd Pool_Stats:Balances 0 $PayoutLine
        fi
done< <(redis-cli zrangebyscore Pool_Stats:Balances 5 inf)
#move old profitability stats
redis-cli rename Pool_Stats:CurrentShift:Profitability Pool_Stats:$thisShift:Profitability

<!--- Start Pie --->
 <script>

                                        var data_arr3=[];
                                        init.push(function () {
                                                var item = { "label": "Scrypt",
                                                        "value": {{=it.stats.algos['scrypt'].hashrate/1024/1024}}
                                                        }
                                                data_arr3.push(item);
                                                var item = { "label": "SHA",
                                                        "value": {{=it.stats.algos['sha256'].hashrate/1024/1024/1024/100}}
                                                        }
                                                data_arr3.push(item);
                                                var item = { "label": "X11",
                                                        "value": {{=it.stats.algos['x11'].hashrate/1024/1024/4}}
                                                        }
                                                data_arr3.push(item);
                                                var item = { "label": "Keccak",
                                                        "value": {{=it.stats.algos['keccak'].hashrate/1024/1024/500}}
                                                        }
                                                data_arr3.push(item);
                                                var item = { "label": "ScryptN",
                                                        "value": {{=it.stats.algos['scrypt-n'].hashrate/1024/1024}}
                                                        }
                                                data_arr3.push(item);
                                                Morris.Donut({
                                                        element: 'hero-donut',
                                                        data: data_arr3,
                                                        colors: PixelAdmin.settings.consts.COLORS,
                                                        resize: true,
                                                        labelColor: '#888',
                                                        formatter: function (y, data) {
                                                                if(data.label == "Keccak")
                                                                        return(Math.round(y * 500,2) + ' MH');
                                                                else if(data.label == "Scrypt")
                                                                        return(Math.round(y,2) + ' MH');
                                                                else if(data.label == "SHA")
                                                                        return(Math.round(y * 100,2) + ' GH');
                                                                else if(data.label == "X11")
                                                                        return(Math.round(y * 4,2) + ' MH');
                                                                else
                                                                        return(y + ' MH');

                                                        }

                                                });
                                        });
                                </script>
                                <!-- / Javascript -->


                        <div class="row">
                                <div class="col-md-5">
                                                <div class="graph-container">
                                                        <div id="hero-donut" class="graph"></div>
                                                </div>
                                </div>
<!--- END PIE -->

<!--- start worker pie chart --->
  <script>

                                        var data_arr4=[];
                                        init.push(function () {
                                                var item = { "label": "Scrypt",
                                                        "value": {{=it.stats.algos['scrypt'].workers}}
                                                        }
                                                data_arr4.push(item);
                                                var item = { "label": "SHA",
                                                        "value": {{=it.stats.algos['sha256'].workers}}
                                                        }
                                                data_arr4.push(item);
                                                var item = { "label": "X11",
                                                        "value": {{=it.stats.algos['x11'].workers}}
                                                        }
                                                data_arr4.push(item);
                                                var item = { "label": "Keccak",
                                                        "value": {{=it.stats.algos['keccak'].workers}}
                                                        }
                                                data_arr4.push(item);
                                                var item = { "label": "ScryptN",
                                                        "value": {{=it.stats.algos['scrypt-n'].workers}}
                                                        }
                                                data_arr4.push(item);
                                                Morris.Donut({
                                                        element: 'hero-donut2',
                                                        data: data_arr4,
                                                        colors: PixelAdmin.settings.consts.COLORS,
                                                        resize: true,
                                                        labelColor: '#888',
                                                        formatter: function (y, data) {
                                                                        return(y + ' Workers');
                                                        }

                                                });
                                        });
                                </script>
                                <!-- / Javascript -->

                                                <div class="graph-container">
                                                        <div id="hero-donut2" class="graph"></div>
                                                </div>
<!-- end worker pie chart --->

{
    "logLevel": "debug",
    "logColors": true,

    "cliPort": 17117,

    "clustering": {
        "enabled": true,
        "forks": "auto"
    },

    "defaultPoolConfigs": {
        "blockRefreshInterval": 1000,
        "jobRebroadcastTimeout": 55,
        "connectionTimeout": 600,
        "emitInvalidBlockHashes": false,
        "validateWorkerUsername": true,
        "tcpProxyProtocol": false,
        "banning": {
            "enabled": true,
            "time": 600,
            "invalidPercent": 50,
            "checkThreshold": 500,
            "purgeInterval": 300
        },
        "redis": {
            "host": "127.0.0.1",
            "port": 6379
        }
    },

    "website": {
        "enabled": true,
        "host": "127.0.0.1",
        "port": 8080,
        "stratumHost": "bogus.ddns.net",
        "stats": {
            "updateInterval": 60,
            "historicalRetention": 43200,
            "hashrateWindow": 300
        },
        "adminCenter": {
            "enabled": true,
            "password": "password1bogus"
        }
    },

    "redis": {
        "host": "127.0.0.1",
        "port": 6379
    },

    "switching": {
        "switch1": {
            "enabled": true,
            "algorithm": "groestl",
            "ports": {
                "3333": {
                    "diff": 0.00390625,
                    "varDiff": {
                        "minDiff": 0.00390625,
                        "maxDiff": 4,
                        "targetTime": 15,
                        "retargetTime": 90,
                        "variancePercent": 30
                    }
                }
            }
        },
        "switch2": {
            "enabled": false,
            "algorithm": "scrypt",
            "ports": {
                "4444": {
                    "diff": 10,
                    "varDiff": {
                        "minDiff": 16,
                        "maxDiff": 512,
                        "targetTime": 15,
                        "retargetTime": 90,
                        "variancePercent": 30
                    }
                }
            }
        },
        "switch3": {
            "enabled": false,
            "algorithm": "x11",
            "ports": {
                "5555": {
                    "diff": 0.001,
                    "varDiff": {
                        "minDiff": 0.001,
                        "maxDiff": 1, 
                        "targetTime": 15, 
                        "retargetTime": 60, 
                        "variancePercent": 30 
                    }
                }
            }
    
        }

    },

    "profitSwitch": {
        "enabled": false,
        "updateInterval": 600,
        "depth": 0.90,
        "usePoloniex": true,
        "useCryptsy": true,
        "useMintpal": true,
        "useBittrex": true
    }
}

{
    "name": "Diamondcoin",
    "symbol": "DMD",
    "algorithm": "groestl",
    "txMessages": false,
    "normalHashing" : true,
    "peerMagic" : "e4e8dbfd",
    "peerMagicTestnet" : "edf2c0ef"
}

{
    "enabled": true,
    "coin": "diamondcoin.json",

    "address": "dQKbYwJFpq9MDojuwE99D3MHihEkEW6aqk",

    "rewardRecipients": {
        "dZi9hpA5nBC6tSAbPSsiMjb6HeQTprcWHz" : 4.76190477,
        "dEdj7aH7Pgt3oVAeEFmA46sXCDcZYeiQjP" : 0.95238095
    },

    "paymentProcessing": {
        "enabled": true,
        "paymentInterval": 600,
        "minimumPayment": 1,
        "daemon": {
            "host": "127.0.0.1",
            "port": 17772,
            "user": "bogususer",
            "password": "boguspass"
        }
    },

    "ports": {
        "3333": {
            "diff": 0.008,
            "varDiff": {
                "minDiff": 0.00390625,
                "maxDiff": 8,
                "targetTime": 15,
                "retargetTime": 90,
                "variancePercent": 30
            }
        }
    },

    "daemons": [
        {
            "host": "127.0.0.1",
            "port": 17772,
            "user": "bogususer",
            "password": "boguspass"
        }
    ],

    "p2p": {
        "enabled": false,
        "host": "127.0.0.1",
        "port": 17772,
        "disableTransactions": true
    },

    "mposMode": {
        "enabled": false,
        "host": "127.0.0.1",
        "port": 3306,
        "user": "dmdpool",
        "password": "boguspass",
        "database": "dmd",
        "checkPassword": true,
        "autoCreateWorker": false
    }

}

sudo apt-get install git

git init

git add .

git commit -m "first commit"

git remote add origin https://github.com/paradigmflux/multipool.git

git push -u origin master

# Save the DB on disk:
#
#   save <seconds> <changes>
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving at all commenting all the "save" lines.
#
#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

save 900 1
save 300 10
save 60 10000

bind 127.0.0.1

# The filename where to dump the DB
dbfilename dump.rdb

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir /var/lib/redis/

(integer) 0
(integer) 0
monacoin

ignore worker
(standard_in) 1: syntax error
wildbeastbitcoin

ignore worker
(standard_in) 1: syntax error
(standard_in) 1: syntax error
(integer) 1

127.0.0.1:6379> keys *
 1) "Pool_Stats:avgHR:"
 2) "coinVersionBytes"
 3) "monacoin:shares:roundCurrent"
 4) "Pool_Stats:avgHR:scrypt"
 5) "statHistory"
 6) "Coin_Names_scrypt"
 7) "monacoin:stats"
 8) "Coin_Algos"
 9) "Coin_Names"
10) "wildbeastbitcoin:stats"
11) "wildbeastbitcoin:shares:roundCurrent"

configure in algoProperties.js to deploy magic pool
[code]
m7mhash: {
        hash: function(){
            return function(){
                return multiHashing.m7mhash.apply(this, arguments);
            }
        }
     }

[2017-09-23 12:51:14.705] [INFO] [default] - New Relic
[2017-09-23 12:51:14.707] [DEBUG] [default] - NewRelic Monitor New Relic initiated
[2017-09-23 12:51:14.708] [INFO] [default] - POSIX Not Installed
[2017-09-23 12:51:14.708] [DEBUG] [default] - POSIX Connection Limit (Safe to ignore) POSIX module not installed and resource (connection) limit was not raised
[2017-09-23 12:51:14.708] [INFO] [default] - Run Workers
[2017-09-23 12:51:14.966] [DEBUG] [default] - Master PoolSpawner Spawned 1 pool(s) on 1 thread(s)
[2017-09-23 12:51:15.398] [INFO] [default] - New Relic
[2017-09-23 12:51:15.401] [INFO] [default] - POSIX Not Installed
[2017-09-23 12:51:15.402] [INFO] [default] - Run Workers
[2017-09-23 12:51:15.410] [INFO] [default] - Switching Setup Thread 1 Loading last proxy state from redis
[2017-09-23 12:51:15.417] [DEBUG] [default] - Pool magicoin Thread 1 Share processing setup with redis (127.0.0.1:6379)
[2017-09-23 12:51:15.448] [DEBUG] [default] - Pool magicoin Thread 1 started for magicoin [XMG] {m7mhash}
                                                Network Connected:      Mainnet
                                                font=Verdana]Detected ReOSrd Type:   POW
                                                Current Block Height:   1489428
                                                Current Connect Peers:  2
                                                Current Block Diff:     2.305667004
                                                Network Difficulty:     NaN
                                                Network Hash Rate:      30.37 MH
                                                Stratum Port(s):        3008, 3032, 3256
                                                Pool Fee Percent:       1%
                                                Block polling every:    1000 ms
[2017-09-23 12:51:15.449] [DEBUG] [default] - Switching Setup m7mhash Setting proxy difficulties after pool start
[2017-09-23 12:51:24.719] [DEBUG] [default] - Master CLI CLI listening on port 17117
[2017-09-23 12:51:25.598] [INFO] [default] - New Relic
[2017-09-23 12:51:25.597] [INFO] [default] - New Relic
[2017-09-23 12:51:25.604] [INFO] [default] - POSIX Not Installed
[2017-09-23 12:51:25.605] [INFO] [default] - Run Workers
[2017-09-23 12:51:25.604] [INFO] [default] - POSIX Not Installed
[2017-09-23 12:51:25.605] [INFO] [default] - Run Workers
[2017-09-23 12:51:25.633] [DEBUG] [default] - Payments magicoin Payment processing setup to run every 600 sekannon(s) with daemon (magi@127.0.0.1:8232) and redis (127.0.0.1:6379)
[2017-09-23 12:51:25.676] [DEBUG] [default] - Website Server Website started on xxxxx:80

[2017-09-23 12:51:30.848] [DEBUG] [default] - Pool magicoin Thread 1 getting block notification via RPC polling
[2017-09-23 12:51:31.600] [DEBUG] [default] - Pool magicoin Thread 1 Authorized 9QodNwAEKeetejjtNZiX6N4xxxxxx:x [190.38.xx]

[2017-09-23 08:59:56] Stratum requested work restart
[2017-09-23 08:59:56] thread 2: 261273 hashes, 5.11 khash/s
[2017-09-23 08:59:56] thread 4: 530541 hashes, 10.37 khash/s
[2017-09-23 08:59:56] thread 3: 194764 hashes, 8.83 khash/s
[2017-09-23 08:59:56] thread 5: 333126 hashes, 10.01 khash/s
[2017-09-23 08:59:56] thread 0: 495504 hashes, 9.69 khash/s
[2017-09-23 08:59:56] thread 1: 263041 hashes, 5.14 khash/s
[2017-09-23 09:00:07] thread 3: 124013 hashes, 11.22 khash/s
[color=red][2017-09-23 09:00:07] stratum_recv_line failed
[2017-09-23 09:00:07] Stratum connection interrupted[/color]

/home/ubuntu/unomp/node_modules/merged-pooler/lib/algoProperties.js:227
                return multiHashing.m7mhash.apply(this, arguments);
                                            ^
TypeError: Cannot call method 'apply' of undefined
    at /home/ubuntu/unomp/node_modules/merged-pooler/lib/algoProperties.js:227:45
    at JobManager.processShare (/home/ubuntu/unomp/node_modules/merged-pooler/lib/jobManager.js:263:26)
    at null.<anonymous> (/home/ubuntu/unomp/node_modules/merged-pooler/lib/pool.js:630:46)
    at EventEmitter.emit (events.js:117:20)
    at handleSubmit (/home/ubuntu/unomp/node_modules/merged-pooler/lib/stratum.js:175:15)
    at handleMessage (/home/ubuntu/unomp/node_modules/merged-pooler/lib/stratum.js:88:17)
    at /home/ubuntu/unomp/node_modules/merged-pooler/lib/stratum.js:248:25
    at Array.forEach (native)
    at Socket.<anonymous> (/home/ubuntu/unomp/node_modules/merged-pooler/lib/stratum.js:234:26)
    at Socket.EventEmitter.emit (events.js:95:17)