@smartledger/bsv 1.5.6-fix1

package/lib/block/block.js

@@ -0,0 +1,277 @@
+'use strict'
+
+var _ = require('../util/_')
+var BlockHeader = require('./blockheader')
+var BN = require('../crypto/bn')
+var BufferReader = require('../encoding/bufferreader')
+var BufferWriter = require('../encoding/bufferwriter')
+var Hash = require('../crypto/hash')
+var Transaction = require('../transaction')
+var $ = require('../util/preconditions')
+
+/**
+ * Instantiate a Block from a Buffer, JSON object, or Object with
+ * the properties of the Block
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {Block}
+ * @constructor
+ */
+function Block (arg) {
+  if (!(this instanceof Block)) {
+    return new Block(arg)
+  }
+  _.extend(this, Block._from(arg))
+  return this
+}
+
+Block.MAX_BLOCK_SIZE = 128000000
+
+/**
+ * @param {*} - A Buffer, JSON string or Object
+ * @returns {Object} - An object representing block data
+ * @throws {TypeError} - If the argument was not recognized
+ * @private
+ */
+Block._from = function _from (arg) {
+  var info = {}
+  if (Buffer.isBuffer(arg)) {
+    info = Block._fromBufferReader(BufferReader(arg))
+  } else if (_.isObject(arg)) {
+    info = Block._fromObject(arg)
+  } else {
+    throw new TypeError('Unrecognized argument for Block')
+  }
+  return info
+}
+
+/**
+ * @param {Object} - A plain JavaScript object
+ * @returns {Object} - An object representing block data
+ * @private
+ */
+Block._fromObject = function _fromObject (data) {
+  var transactions = []
+  data.transactions.forEach(function (tx) {
+    if (tx instanceof Transaction) {
+      transactions.push(tx)
+    } else {
+      transactions.push(Transaction().fromObject(tx))
+    }
+  })
+  var info = {
+    header: BlockHeader.fromObject(data.header),
+    transactions: transactions
+  }
+  return info
+}
+
+/**
+ * @param {Object} - A plain JavaScript object
+ * @returns {Block} - An instance of block
+ */
+Block.fromObject = function fromObject (obj) {
+  var info = Block._fromObject(obj)
+  return new Block(info)
+}
+
+/**
+ * @param {BufferReader} - Block data
+ * @returns {Object} - An object representing the block data
+ * @private
+ */
+Block._fromBufferReader = function _fromBufferReader (br) {
+  var info = {}
+  $.checkState(!br.finished(), 'No block data received')
+  info.header = BlockHeader.fromBufferReader(br)
+  var transactions = br.readVarintNum()
+  info.transactions = []
+  for (var i = 0; i < transactions; i++) {
+    info.transactions.push(Transaction().fromBufferReader(br))
+  }
+  return info
+}
+
+/**
+ * @param {BufferReader} - A buffer reader of the block
+ * @returns {Block} - An instance of block
+ */
+Block.fromBufferReader = function fromBufferReader (br) {
+  $.checkArgument(br, 'br is required')
+  var info = Block._fromBufferReader(br)
+  return new Block(info)
+}
+
+/**
+ * @param {Buffer} - A buffer of the block
+ * @returns {Block} - An instance of block
+ */
+Block.fromBuffer = function fromBuffer (buf) {
+  return Block.fromBufferReader(new BufferReader(buf))
+}
+
+/**
+ * @param {string} - str - A hex encoded string of the block
+ * @returns {Block} - A hex encoded string of the block
+ */
+Block.fromString = function fromString (str) {
+  var buf = Buffer.from(str, 'hex')
+  return Block.fromBuffer(buf)
+}
+
+/**
+ * @param {Binary} - Raw block binary data or buffer
+ * @returns {Block} - An instance of block
+ */
+Block.fromRawBlock = function fromRawBlock (data) {
+  if (!Buffer.isBuffer(data)) {
+    data = Buffer.from(data, 'binary')
+  }
+  var br = BufferReader(data)
+  br.pos = Block.Values.START_OF_BLOCK
+  var info = Block._fromBufferReader(br)
+  return new Block(info)
+}
+
+/**
+ * @returns {Object} - A plain object with the block properties
+ */
+Block.prototype.toObject = Block.prototype.toJSON = function toObject () {
+  var transactions = []
+  this.transactions.forEach(function (tx) {
+    transactions.push(tx.toObject())
+  })
+  return {
+    header: this.header.toObject(),
+    transactions: transactions
+  }
+}
+
+/**
+ * @returns {Buffer} - A buffer of the block
+ */
+Block.prototype.toBuffer = function toBuffer () {
+  return this.toBufferWriter().concat()
+}
+
+/**
+ * @returns {string} - A hex encoded string of the block
+ */
+Block.prototype.toString = function toString () {
+  return this.toBuffer().toString('hex')
+}
+
+/**
+ * @param {BufferWriter} - An existing instance of BufferWriter
+ * @returns {BufferWriter} - An instance of BufferWriter representation of the Block
+ */
+Block.prototype.toBufferWriter = function toBufferWriter (bw) {
+  if (!bw) {
+    bw = new BufferWriter()
+  }
+  bw.write(this.header.toBuffer())
+  bw.writeVarintNum(this.transactions.length)
+  for (var i = 0; i < this.transactions.length; i++) {
+    this.transactions[i].toBufferWriter(bw)
+  }
+  return bw
+}
+
+/**
+ * Will iterate through each transaction and return an array of hashes
+ * @returns {Array} - An array with transaction hashes
+ */
+Block.prototype.getTransactionHashes = function getTransactionHashes () {
+  var hashes = []
+  if (this.transactions.length === 0) {
+    return [Block.Values.NULL_HASH]
+  }
+  for (var t = 0; t < this.transactions.length; t++) {
+    hashes.push(this.transactions[t]._getHash())
+  }
+  return hashes
+}
+
+/**
+ * Will build a merkle tree of all the transactions, ultimately arriving at
+ * a single point, the merkle root.
+ * @link https://en.bitcoin.it/wiki/Protocol_specification#Merkle_Trees
+ * @returns {Array} - An array with each level of the tree after the other.
+ */
+Block.prototype.getMerkleTree = function getMerkleTree () {
+  var tree = this.getTransactionHashes()
+
+  var j = 0
+  for (var size = this.transactions.length; size > 1; size = Math.floor((size + 1) / 2)) {
+    for (var i = 0; i < size; i += 2) {
+      var i2 = Math.min(i + 1, size - 1)
+      var buf = Buffer.concat([tree[j + i], tree[j + i2]])
+      tree.push(Hash.sha256sha256(buf))
+    }
+    j += size
+  }
+
+  return tree
+}
+
+/**
+ * Calculates the merkleRoot from the transactions.
+ * @returns {Buffer} - A buffer of the merkle root hash
+ */
+Block.prototype.getMerkleRoot = function getMerkleRoot () {
+  var tree = this.getMerkleTree()
+  return tree[tree.length - 1]
+}
+
+/**
+ * Verifies that the transactions in the block match the header merkle root
+ * @returns {Boolean} - If the merkle roots match
+ */
+Block.prototype.validMerkleRoot = function validMerkleRoot () {
+  var h = new BN(this.header.merkleRoot.toString('hex'), 'hex')
+  var c = new BN(this.getMerkleRoot().toString('hex'), 'hex')
+
+  if (h.cmp(c) !== 0) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * @returns {Buffer} - The little endian hash buffer of the header
+ */
+Block.prototype._getHash = function () {
+  return this.header._getHash()
+}
+
+var idProperty = {
+  configurable: false,
+  enumerable: true,
+  /**
+   * @returns {string} - The big endian hash buffer of the header
+   */
+  get: function () {
+    if (!this._id) {
+      this._id = this.header.id
+    }
+    return this._id
+  },
+  set: _.noop
+}
+Object.defineProperty(Block.prototype, 'id', idProperty)
+Object.defineProperty(Block.prototype, 'hash', idProperty)
+
+/**
+ * @returns {string} - A string formatted for the console
+ */
+Block.prototype.inspect = function inspect () {
+  return '<Block ' + this.id + '>'
+}
+
+Block.Values = {
+  START_OF_BLOCK: 8, // Start of block in raw block data
+  NULL_HASH: Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
+}
+
+module.exports = Block

package/lib/block/blockheader.js

@@ -0,0 +1,294 @@
+'use strict'
+
+var _ = require('../util/_')
+var BN = require('../crypto/bn')
+var BufferReader = require('../encoding/bufferreader')
+var BufferWriter = require('../encoding/bufferwriter')
+var Hash = require('../crypto/hash')
+var $ = require('../util/preconditions')
+
+var GENESIS_BITS = 0x1d00ffff
+
+/**
+ * Instantiate a BlockHeader from a Buffer, JSON object, or Object with
+ * the properties of the BlockHeader
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {BlockHeader} - An instance of block header
+ * @constructor
+ */
+var BlockHeader = function BlockHeader (arg) {
+  if (!(this instanceof BlockHeader)) {
+    return new BlockHeader(arg)
+  }
+  var info = BlockHeader._from(arg)
+  this.version = info.version
+  this.prevHash = info.prevHash
+  this.merkleRoot = info.merkleRoot
+  this.time = info.time
+  this.timestamp = info.time
+  this.bits = info.bits
+  this.nonce = info.nonce
+
+  if (info.hash) {
+    $.checkState(
+      this.hash === info.hash,
+      'Argument object hash property does not match block hash.'
+    )
+  }
+
+  return this
+}
+
+/**
+ * @param {*} - A Buffer, JSON string or Object
+ * @returns {Object} - An object representing block header data
+ * @throws {TypeError} - If the argument was not recognized
+ * @private
+ */
+BlockHeader._from = function _from (arg) {
+  var info = {}
+  if (Buffer.isBuffer(arg)) {
+    info = BlockHeader._fromBufferReader(BufferReader(arg))
+  } else if (_.isObject(arg)) {
+    info = BlockHeader._fromObject(arg)
+  } else {
+    throw new TypeError('Unrecognized argument for BlockHeader')
+  }
+  return info
+}
+
+/**
+ * @param {Object} - A JSON string
+ * @returns {Object} - An object representing block header data
+ * @private
+ */
+BlockHeader._fromObject = function _fromObject (data) {
+  $.checkArgument(data, 'data is required')
+  var prevHash = data.prevHash
+  var merkleRoot = data.merkleRoot
+  if (_.isString(data.prevHash)) {
+    prevHash = Buffer.from(data.prevHash, 'hex').reverse()
+  }
+  if (_.isString(data.merkleRoot)) {
+    merkleRoot = Buffer.from(data.merkleRoot, 'hex').reverse()
+  }
+  var info = {
+    hash: data.hash,
+    version: data.version,
+    prevHash: prevHash,
+    merkleRoot: merkleRoot,
+    time: data.time,
+    timestamp: data.time,
+    bits: data.bits,
+    nonce: data.nonce
+  }
+  return info
+}
+
+/**
+ * @param {Object} - A plain JavaScript object
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromObject = function fromObject (obj) {
+  var info = BlockHeader._fromObject(obj)
+  return new BlockHeader(info)
+}
+
+/**
+ * @param {Binary} - Raw block binary data or buffer
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromRawBlock = function fromRawBlock (data) {
+  if (!Buffer.isBuffer(data)) {
+    data = Buffer.from(data, 'binary')
+  }
+  var br = BufferReader(data)
+  br.pos = BlockHeader.Constants.START_OF_HEADER
+  var info = BlockHeader._fromBufferReader(br)
+  return new BlockHeader(info)
+}
+
+/**
+ * @param {Buffer} - A buffer of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromBuffer = function fromBuffer (buf) {
+  var info = BlockHeader._fromBufferReader(BufferReader(buf))
+  return new BlockHeader(info)
+}
+
+/**
+ * @param {string} - A hex encoded buffer of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromString = function fromString (str) {
+  var buf = Buffer.from(str, 'hex')
+  return BlockHeader.fromBuffer(buf)
+}
+
+/**
+ * @param {BufferReader} - A BufferReader of the block header
+ * @returns {Object} - An object representing block header data
+ * @private
+ */
+BlockHeader._fromBufferReader = function _fromBufferReader (br) {
+  var info = {}
+  info.version = br.readInt32LE()
+  info.prevHash = br.read(32)
+  info.merkleRoot = br.read(32)
+  info.time = br.readUInt32LE()
+  info.bits = br.readUInt32LE()
+  info.nonce = br.readUInt32LE()
+  return info
+}
+
+/**
+ * @param {BufferReader} - A BufferReader of the block header
+ * @returns {BlockHeader} - An instance of block header
+ */
+BlockHeader.fromBufferReader = function fromBufferReader (br) {
+  var info = BlockHeader._fromBufferReader(br)
+  return new BlockHeader(info)
+}
+
+/**
+ * @returns {Object} - A plain object of the BlockHeader
+ */
+BlockHeader.prototype.toObject = BlockHeader.prototype.toJSON = function toObject () {
+  return {
+    hash: this.hash,
+    version: this.version,
+    prevHash: Buffer.from(this.prevHash).reverse().toString('hex'),
+    merkleRoot: Buffer.from(this.merkleRoot).reverse().toString('hex'),
+    time: this.time,
+    bits: this.bits,
+    nonce: this.nonce
+  }
+}
+
+/**
+ * @returns {Buffer} - A Buffer of the BlockHeader
+ */
+BlockHeader.prototype.toBuffer = function toBuffer () {
+  return this.toBufferWriter().concat()
+}
+
+/**
+ * @returns {string} - A hex encoded string of the BlockHeader
+ */
+BlockHeader.prototype.toString = function toString () {
+  return this.toBuffer().toString('hex')
+}
+
+/**
+ * @param {BufferWriter} - An existing instance BufferWriter
+ * @returns {BufferWriter} - An instance of BufferWriter representation of the BlockHeader
+ */
+BlockHeader.prototype.toBufferWriter = function toBufferWriter (bw) {
+  if (!bw) {
+    bw = new BufferWriter()
+  }
+  bw.writeInt32LE(this.version)
+  bw.write(this.prevHash)
+  bw.write(this.merkleRoot)
+  bw.writeUInt32LE(this.time)
+  bw.writeUInt32LE(this.bits)
+  bw.writeUInt32LE(this.nonce)
+  return bw
+}
+
+/**
+ * Returns the target difficulty for this block
+ * @param {Number} bits
+ * @returns {BN} An instance of BN with the decoded difficulty bits
+ */
+BlockHeader.prototype.getTargetDifficulty = function getTargetDifficulty (bits) {
+  bits = bits || this.bits
+
+  var target = new BN(bits & 0xffffff)
+  var mov = 8 * ((bits >>> 24) - 3)
+  while (mov-- > 0) {
+    target = target.mul(new BN(2))
+  }
+  return target
+}
+
+/**
+ * @link https://en.bitcoin.it/wiki/Difficulty
+ * @return {Number}
+ */
+BlockHeader.prototype.getDifficulty = function getDifficulty () {
+  var difficulty1TargetBN = this.getTargetDifficulty(GENESIS_BITS).mul(new BN(Math.pow(10, 8)))
+  var currentTargetBN = this.getTargetDifficulty()
+
+  var difficultyString = difficulty1TargetBN.div(currentTargetBN).toString(10)
+  var decimalPos = difficultyString.length - 8
+  difficultyString = difficultyString.slice(0, decimalPos) + '.' + difficultyString.slice(decimalPos)
+
+  return parseFloat(difficultyString)
+}
+
+/**
+ * @returns {Buffer} - The little endian hash buffer of the header
+ */
+BlockHeader.prototype._getHash = function hash () {
+  var buf = this.toBuffer()
+  return Hash.sha256sha256(buf)
+}
+
+var idProperty = {
+  configurable: false,
+  enumerable: true,
+  /**
+   * @returns {string} - The big endian hash buffer of the header
+   */
+  get: function () {
+    if (!this._id) {
+      this._id = BufferReader(this._getHash()).readReverse().toString('hex')
+    }
+    return this._id
+  },
+  set: _.noop
+}
+Object.defineProperty(BlockHeader.prototype, 'id', idProperty)
+Object.defineProperty(BlockHeader.prototype, 'hash', idProperty)
+
+/**
+ * @returns {Boolean} - If timestamp is not too far in the future
+ */
+BlockHeader.prototype.validTimestamp = function validTimestamp () {
+  var currentTime = Math.round(new Date().getTime() / 1000)
+  if (this.time > currentTime + BlockHeader.Constants.MAX_TIME_OFFSET) {
+    return false
+  }
+  return true
+}
+
+/**
+ * @returns {Boolean} - If the proof-of-work hash satisfies the target difficulty
+ */
+BlockHeader.prototype.validProofOfWork = function validProofOfWork () {
+  var pow = new BN(this.id, 'hex')
+  var target = this.getTargetDifficulty()
+
+  if (pow.cmp(target) > 0) {
+    return false
+  }
+  return true
+}
+
+/**
+ * @returns {string} - A string formatted for the console
+ */
+BlockHeader.prototype.inspect = function inspect () {
+  return '<BlockHeader ' + this.id + '>'
+}
+
+BlockHeader.Constants = {
+  START_OF_HEADER: 8, // Start buffer position in raw block data
+  MAX_TIME_OFFSET: 2 * 60 * 60, // The max a timestamp can be in the future
+  LARGEST_HASH: new BN('10000000000000000000000000000000000000000000000000000000000000000', 'hex')
+}
+
+module.exports = BlockHeader

package/lib/block/index.js

@@ -0,0 +1,4 @@
+module.exports = require('./block')
+
+module.exports.BlockHeader = require('./blockheader')
+module.exports.MerkleBlock = require('./merkleblock')