Source: mining/common.js

  1. /*!
  2.  * common.js - mining utils
  3.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  4.  * https://github.com/bcoin-org/bcoin
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const consensus = require('../protocol/consensus');
  11. const BN = require('bcrypto/lib/bn.js');
  13. /**
  14.  * @exports mining/common
  15.  */
  17. const common = exports;
  19. /*
  20.  * Constants
  21.  */
  23. const DIFF = 0x00000000ffff0000000000000000000000000000000000000000000000000000;
  24. const B192 = 0x1000000000000000000000000000000000000000000000000;
  25. const B128 = 0x100000000000000000000000000000000;
  26. const B64 = 0x10000000000000000;
  27. const B0 = 0x1;
  29. /**
  30.  * Swap 32 bit endianness of uint256.
  31.  * @param {Buffer} data
  32.  * @returns {Buffer}
  33.  */
  35. common.swap32 = function swap32(data) {
  36.   for (let i = 0; i < data.length; i += 4) {
  37.     const field = data.readUInt32LE(i, true);
  38.     data.writeUInt32BE(field, i, true);
  39.   }
  41.   return data;
  42. };
  44. /**
  45.  * Compare two uint256le's.
  46.  * @param {Buffer} a
  47.  * @param {Buffer} b
  48.  * @returns {Number}
  49.  */
  51. common.rcmp = function rcmp(a, b) {
  52.   assert(a.length === b.length);
  54.   for (let i = a.length - 1; i >= 0; i--) {
  55.     if (a[i] < b[i])
  56.       return -1;
  57.     if (a[i] > b[i])
  58.       return 1;
  59.   }
  61.   return 0;
  62. };
  64. /**
  65.  * Convert a uint256le to a double.
  66.  * @param {Buffer} target
  67.  * @returns {Number}
  68.  */
  70. common.double256 = function double256(target) {
  71.   let n = 0;
  72.   let hi, lo;
  74.   assert(target.length === 32);
  76.   hi = target.readUInt32LE(28, true);
  77.   lo = target.readUInt32LE(24, true);
  78.   n += (hi * 0x100000000 + lo) * B192;
  80.   hi = target.readUInt32LE(20, true);
  81.   lo = target.readUInt32LE(16, true);
  82.   n += (hi * 0x100000000 + lo) * B128;
  84.   hi = target.readUInt32LE(12, true);
  85.   lo = target.readUInt32LE(8, true);
  86.   n += (hi * 0x100000000 + lo) * B64;
  88.   hi = target.readUInt32LE(4, true);
  89.   lo = target.readUInt32LE(0, true);
  90.   n += (hi * 0x100000000 + lo) * B0;
  92.   return n;
  93. };
  95. /**
  96.  * Calculate mining difficulty
  97.  * from little-endian target.
  98.  * @param {Buffer} target
  99.  * @returns {Number}
  100.  */
  102. common.getDifficulty = function getDifficulty(target) {
  103.   const d = DIFF;
  104.   const n = common.double256(target);
  106.   if (n === 0)
  107.     return d;
  109.   return Math.floor(d / n);
  110. };
  112. /**
  113.  * Get target from bits as a uint256le.
  114.  * @param {Number} bits
  115.  * @returns {Buffer}
  116.  */
  118. common.getTarget = function getTarget(bits) {
  119.   const target = consensus.fromCompact(bits);
  121.   if (target.isNeg())
  122.     throw new Error('Target is negative.');
  124.   if (target.isZero())
  125.     throw new Error('Target is zero.');
  127.   return target.toArrayLike(Buffer, 'le', 32);
  128. };
  130. /**
  131.  * Get bits from target.
  132.  * @param {Buffer} data
  133.  * @returns {Buffer}
  134.  */
  136. common.getBits = function getBits(data) {
  137.   const target = new BN(data, 'le');
  139.   if (target.isZero())
  140.     throw new Error('Target is zero.');
  142.   return consensus.toCompact(target);
  143. };