optimize target checking.

lib/bcoin/chain.js

@@ -1983,7 +1983,7 @@ Chain.prototype.getOrphanRoot = function getOrphanRoot(hash) {
 
 Chain.prototype.getCurrentTarget = function getCurrentTarget(callback) {
   if (!this.tip)
-    return callback(null, utils.toCompact(this.network.pow.limit));
+    return callback(null, this.network.pow.bits);
   return this.getTargetAsync(null, this.tip, callback);
 };
 
@@ -2021,12 +2021,11 @@ Chain.prototype.getTargetAsync = function getTargetAsync(block, prev, callback)
  */
 
 Chain.prototype.getTarget = function getTarget(block, prev, ancestors) {
-  var powLimit = utils.toCompact(this.network.pow.limit);
   var ts, first, i;
 
   // Genesis
   if (!prev)
-    return powLimit;
+    return this.network.pow.bits;
 
   // Do not retarget
   if ((prev.height + 1) % this.network.pow.retargetInterval !== 0) {
@@ -2034,12 +2033,12 @@ Chain.prototype.getTarget = function getTarget(block, prev, ancestors) {
       // Special behavior for testnet:
       ts = block ? (block.ts || block) : bcoin.now();
       if (ts > prev.ts + this.network.pow.targetSpacing * 2)
-        return powLimit;
+        return this.network.pow.bits;
 
       i = 1;
       while (ancestors[i]
         && prev.height % this.network.pow.retargetInterval !== 0
-        && prev.bits === powLimit) {
+        && prev.bits === this.network.pow.bits) {
         prev = ancestors[i++];
       }
     }
@@ -2063,26 +2062,26 @@ Chain.prototype.getTarget = function getTarget(block, prev, ancestors) {
  */
 
 Chain.prototype.retarget = function retarget(prev, first) {
-  var powTargetTimespan = new bn(this.network.pow.targetTimespan);
+  var targetTimespan = this.network.pow.targetTimespan;
   var actualTimespan, target;
 
   if (this.network.pow.noRetargeting)
     return prev.bits;
 
-  actualTimespan = new bn(prev.ts - first.ts);
+  actualTimespan = prev.ts - first.ts;
   target = utils.fromCompact(prev.bits);
 
-  if (actualTimespan.cmp(powTargetTimespan.divn(4)) < 0)
+  if (actualTimespan < targetTimespan / 4)
-    actualTimespan = powTargetTimespan.divn(4);
+    actualTimespan = targetTimespan / 4;
 
-  if (actualTimespan.cmp(powTargetTimespan.muln(4)) > 0)
+  if (actualTimespan > targetTimespan * 4)
-    actualTimespan = powTargetTimespan.muln(4);
+    actualTimespan = targetTimespan * 4;
 
-  target.imul(actualTimespan);
+  target.imuln(actualTimespan);
-  target = target.div(powTargetTimespan);
+  target.idivn(targetTimespan);
 
   if (target.cmp(this.network.pow.limit) > 0)
-    target = this.network.pow.limit.clone();
+    return this.network.pow.bits;
 
   return utils.toCompact(target);
 };

lib/bcoin/protocol/network.js

@@ -214,6 +214,14 @@ main.pow = {
 
 main.pow.retargetInterval = main.pow.targetTimespan / main.pow.targetSpacing | 0;
 
+/**
+ * Compact pow limit.
+ * @const {Number}
+ * @default
+ */
+
+main.pow.bits = utils.toCompact(main.pow.limit);
+
 /**
  * Block constants.
  * @enum {Number}
@@ -519,6 +527,8 @@ testnet.pow = {
 
 testnet.pow.retargetInterval = testnet.pow.targetTimespan / testnet.pow.targetSpacing | 0;
 
+testnet.pow.bits = utils.toCompact(testnet.pow.limit);
+
 testnet.block = {
   majorityEnforceUpgrade: 51,
   majorityRejectOutdated: 75,
@@ -661,6 +671,8 @@ regtest.pow = {
 
 regtest.pow.retargetInterval = regtest.pow.targetTimespan / regtest.pow.targetSpacing | 0;
 
+regtest.pow.bits = utils.toCompact(regtest.pow.limit);
+
 regtest.block = {
   majorityEnforceUpgrade: 750,
   majorityRejectOutdated: 950,
@@ -801,6 +813,8 @@ segnet3.pow = {
 
 segnet3.pow.retargetInterval = segnet3.pow.targetTimespan / segnet3.pow.targetSpacing | 0;
 
+segnet3.pow.bits = utils.toCompact(segnet3.pow.limit);
+
 segnet3.block = {
   majorityEnforceUpgrade: 7,
   majorityRejectOutdated: 9,
@@ -925,6 +939,8 @@ segnet4.pow = {
 
 segnet4.pow.retargetInterval = segnet4.pow.targetTimespan / segnet4.pow.targetSpacing | 0;
 
+segnet4.pow.bits = utils.toCompact(segnet4.pow.limit);
+
 segnet4.block = {
   majorityEnforceUpgrade: 7,
   majorityRejectOutdated: 9,