Use truncated diff1 (max difficulty) for algos by default. Report difficulty of low-diff shares.

lib/algoProperties.js

@@ -1,3 +1,4 @@
+var bignum = require('bignum');
 var multiHashing = require('multi-hashing');
 var util = require('./util.js');
 
@@ -99,9 +100,8 @@ var algos = module.exports = global.algos = {
         shift: 24,
         multiplier: Math.pow(2, 8),
         hash: function(){
-            return function(data, nTime){
+            return function(data){
-                var f = Buffer.concat([data, new Buffer(nTime.toString(16), 'hex')]);
+                return multiHashing.keccak(data);
-                return multiHashing.keccak(f);
             }
         }
     },
@@ -173,7 +173,46 @@ function ShiftMax256Right(shiftRight){
     return new Buffer(octets);;
 }
 
+
+function BufferToCompact(startingBuff){
+    var bigNum = bignum.fromBuffer(startingBuff);
+    var buff = bigNum.toBuffer();
+
+    buff = buff.readUInt8(0) > 0x7f ? Buffer.concat([new Buffer([0x00]), buff]) : buff;
+
+    buff = Buffer.concat([new Buffer([buff.length]), buff]);
+    var compact = buff.slice(0, 4);
+    return compact;
+}
+
+
+function ConvertBitsToHex(bitsBuff){
+    var numBytes = bitsBuff.readUInt8(0);
+    var bigBits = bignum.fromBuffer(bitsBuff.slice(1));
+    var target = bigBits.mul(
+        bignum(2).pow(
+            bignum(8).mul(
+                    numBytes - 3
+            )
+        )
+    );
+
+    var resultBuff = target.toBuffer();
+    var buff256 = new Buffer(32);
+    buff256.fill(0);
+    resultBuff.copy(buff256, buff256.length - resultBuff.length);
+
+    var hexResult = buff256.toString('hex');
+
+    return hexResult;
+}
+
 for (var algo in algos){
-    if (!algos[algo].diff)
+    if (!algos[algo].diff) {
-        algos[algo].diff = ShiftMax256Right(algos[algo].shift);
+        var nonTruncatedDiff = ShiftMax256Right(algos[algo].shift);
+        var compactBits = BufferToCompact(nonTruncatedDiff);
+        var truncatedDiff = ConvertBitsToHex(compactBits);
+
+        algos[algo].diff = truncatedDiff;
+    }
 }

lib/jobManager.js

@@ -56,9 +56,9 @@ var JobManager = module.exports = function JobManager(maxDifficulty, hashDigest,
     
     //public members
 
-    this.extraNonceCounter     = new ExtraNonceCounter(options.instanceId);
+    this.extraNonceCounter = new ExtraNonceCounter(options.instanceId);
     this.extraNoncePlaceholder = new Buffer('f000000ff111111f', 'hex');
-    this.extraNonce2Size       = this.extraNoncePlaceholder.length - this.extraNonceCounter.size;
+    this.extraNonce2Size = this.extraNoncePlaceholder.length - this.extraNonceCounter.size;
 
     this.currentJob;
     this.validJobs = {};
@@ -182,6 +182,7 @@ var JobManager = module.exports = function JobManager(maxDifficulty, hashDigest,
         var blockHex;
 
 
+
         if (job.target.ge(headerBigNum)){
             blockHex = job.serializeBlock(headerBuffer, coinbaseBuffer).toString('hex');
             blockHash = util.reverseBuffer(util.sha256d(headerBuffer)).toString('hex');
@@ -189,8 +190,8 @@ var JobManager = module.exports = function JobManager(maxDifficulty, hashDigest,
         else {
             var targetUser = maxDifficulty.div(difficulty);
             if (headerBigNum.gt(targetUser)){
-                var lowPercent = headerBigNum.sub(targetUser).div(headerBigNum).mul(100).toNumber().toFixed(10);
+                var shareDiff = maxDifficulty.div(headerBigNum).toString();
-                return shareError([23, 'low difficulty share, need to be ' + lowPercent + '% higher']);
+                return shareError([23, 'low difficulty share of ' + shareDiff]);
             }
         }
         if (!!blockHex) {