@smartledger/bsv 1.5.6-fix1

package/lib/block/merkleblock.js

@@ -0,0 +1,316 @@
+'use strict'
+
+var _ = require('../util/_')
+var BlockHeader = require('./blockheader')
+var BufferReader = require('../encoding/bufferreader')
+var BufferWriter = require('../encoding/bufferwriter')
+var Hash = require('../crypto/hash')
+var Transaction = require('../transaction')
+var errors = require('../errors')
+var $ = require('../util/preconditions')
+
+/**
+ * Instantiate a MerkleBlock from a Buffer, JSON object, or Object with
+ * the properties of the Block
+ *
+ * @param {*} - A Buffer, JSON string, or Object representing a MerkleBlock
+ * @returns {MerkleBlock}
+ * @constructor
+ */
+function MerkleBlock (arg) {
+  if (!(this instanceof MerkleBlock)) {
+    return new MerkleBlock(arg)
+  }
+
+  var info = {}
+  if (Buffer.isBuffer(arg)) {
+    info = MerkleBlock._fromBufferReader(BufferReader(arg))
+  } else if (_.isObject(arg)) {
+    var header
+    if (arg.header instanceof BlockHeader) {
+      header = arg.header
+    } else {
+      header = BlockHeader.fromObject(arg.header)
+    }
+    info = {
+      /**
+       * @name MerkleBlock#header
+       * @type {BlockHeader}
+       */
+      header: header,
+      /**
+       * @name MerkleBlock#numTransactions
+       * @type {Number}
+       */
+      numTransactions: arg.numTransactions,
+      /**
+       * @name MerkleBlock#hashes
+       * @type {String[]}
+       */
+      hashes: arg.hashes,
+      /**
+       * @name MerkleBlock#flags
+       * @type {Number[]}
+       */
+      flags: arg.flags
+    }
+  } else {
+    throw new TypeError('Unrecognized argument for MerkleBlock')
+  }
+  _.extend(this, info)
+  this._flagBitsUsed = 0
+  this._hashesUsed = 0
+
+  return this
+}
+
+/**
+ * @param {Buffer} - MerkleBlock data in a Buffer object
+ * @returns {MerkleBlock} - A MerkleBlock object
+ */
+MerkleBlock.fromBuffer = function fromBuffer (buf) {
+  return MerkleBlock.fromBufferReader(BufferReader(buf))
+}
+
+/**
+ * @param {BufferReader} - MerkleBlock data in a BufferReader object
+ * @returns {MerkleBlock} - A MerkleBlock object
+ */
+MerkleBlock.fromBufferReader = function fromBufferReader (br) {
+  return new MerkleBlock(MerkleBlock._fromBufferReader(br))
+}
+
+/**
+ * @returns {Buffer} - A buffer of the block
+ */
+MerkleBlock.prototype.toBuffer = function toBuffer () {
+  return this.toBufferWriter().concat()
+}
+
+/**
+ * @param {BufferWriter} - An existing instance of BufferWriter
+ * @returns {BufferWriter} - An instance of BufferWriter representation of the MerkleBlock
+ */
+MerkleBlock.prototype.toBufferWriter = function toBufferWriter (bw) {
+  if (!bw) {
+    bw = new BufferWriter()
+  }
+  bw.write(this.header.toBuffer())
+  bw.writeUInt32LE(this.numTransactions)
+  bw.writeVarintNum(this.hashes.length)
+  for (var i = 0; i < this.hashes.length; i++) {
+    bw.write(Buffer.from(this.hashes[i], 'hex'))
+  }
+  bw.writeVarintNum(this.flags.length)
+  for (i = 0; i < this.flags.length; i++) {
+    bw.writeUInt8(this.flags[i])
+  }
+  return bw
+}
+
+/**
+ * @returns {Object} - A plain object with the MerkleBlock properties
+ */
+MerkleBlock.prototype.toObject = MerkleBlock.prototype.toJSON = function toObject () {
+  return {
+    header: this.header.toObject(),
+    numTransactions: this.numTransactions,
+    hashes: this.hashes,
+    flags: this.flags
+  }
+}
+
+/**
+ * Verify that the MerkleBlock is valid
+ * @returns {Boolean} - True/False whether this MerkleBlock is Valid
+ */
+MerkleBlock.prototype.validMerkleTree = function validMerkleTree () {
+  $.checkState(_.isArray(this.flags), 'MerkleBlock flags is not an array')
+  $.checkState(_.isArray(this.hashes), 'MerkleBlock hashes is not an array')
+
+  // Can't have more hashes than numTransactions
+  if (this.hashes.length > this.numTransactions) {
+    return false
+  }
+
+  // Can't have more flag bits than num hashes
+  if (this.flags.length * 8 < this.hashes.length) {
+    return false
+  }
+
+  var height = this._calcTreeHeight()
+  var opts = { hashesUsed: 0, flagBitsUsed: 0 }
+  var root = this._traverseMerkleTree(height, 0, opts)
+  if (opts.hashesUsed !== this.hashes.length) {
+    return false
+  }
+  return root.equals(this.header.merkleRoot)
+}
+
+/**
+ * WARNING: This method is deprecated. Use filteredTxsHash instead.
+ *
+ * Return a list of all the txs hash that match the filter
+ * @returns {Array} - txs hash that match the filter
+ */
+MerkleBlock.prototype.filterdTxsHash = function filterdTxsHash () {
+  throw new Error('filterdTxsHash has been deprecated. use filteredTxsHash.')
+}
+
+/**
+ * Return a list of all the txs hash that match the filter
+ * @returns {Array} - txs hash that match the filter
+ */
+MerkleBlock.prototype.filteredTxsHash = function filteredTxsHash () {
+  $.checkState(_.isArray(this.flags), 'MerkleBlock flags is not an array')
+  $.checkState(_.isArray(this.hashes), 'MerkleBlock hashes is not an array')
+
+  // Can't have more hashes than numTransactions
+  if (this.hashes.length > this.numTransactions) {
+    throw new errors.MerkleBlock.InvalidMerkleTree()
+  }
+
+  // Can't have more flag bits than num hashes
+  if (this.flags.length * 8 < this.hashes.length) {
+    throw new errors.MerkleBlock.InvalidMerkleTree()
+  }
+
+  // If there is only one hash the filter do not match any txs in the block
+  if (this.hashes.length === 1) {
+    return []
+  };
+
+  var height = this._calcTreeHeight()
+  var opts = { hashesUsed: 0, flagBitsUsed: 0 }
+  var txs = this._traverseMerkleTree(height, 0, opts, true)
+  if (opts.hashesUsed !== this.hashes.length) {
+    throw new errors.MerkleBlock.InvalidMerkleTree()
+  }
+  return txs
+}
+
+/**
+ * Traverse a the tree in this MerkleBlock, validating it along the way
+ * Modeled after Bitcoin Core merkleblock.cpp TraverseAndExtract()
+ * @param {Number} - depth - Current height
+ * @param {Number} - pos - Current position in the tree
+ * @param {Object} - opts - Object with values that need to be mutated throughout the traversal
+ * @param {Boolean} - checkForTxs - if true return opts.txs else return the Merkle Hash
+ * @param {Number} - opts.flagBitsUsed - Number of flag bits used, should start at 0
+ * @param {Number} - opts.hashesUsed - Number of hashes used, should start at 0
+ * @param {Array} - opts.txs - Will finish populated by transactions found during traversal that match the filter
+ * @returns {Buffer|null} - Buffer containing the Merkle Hash for that height
+ * @returns {Array} - transactions found during traversal that match the filter
+ * @private
+ */
+MerkleBlock.prototype._traverseMerkleTree = function traverseMerkleTree (depth, pos, opts, checkForTxs) {
+  opts = opts || {}
+  opts.txs = opts.txs || []
+  opts.flagBitsUsed = opts.flagBitsUsed || 0
+  opts.hashesUsed = opts.hashesUsed || 0
+  checkForTxs = checkForTxs || false
+
+  if (opts.flagBitsUsed > this.flags.length * 8) {
+    return null
+  }
+  var isParentOfMatch = (this.flags[opts.flagBitsUsed >> 3] >>> (opts.flagBitsUsed++ & 7)) & 1
+  if (depth === 0 || !isParentOfMatch) {
+    if (opts.hashesUsed >= this.hashes.length) {
+      return null
+    }
+    var hash = this.hashes[opts.hashesUsed++]
+    if (depth === 0 && isParentOfMatch) {
+      opts.txs.push(hash)
+    }
+    return Buffer.from(hash, 'hex')
+  } else {
+    var left = this._traverseMerkleTree(depth - 1, pos * 2, opts)
+    var right = left
+    if (pos * 2 + 1 < this._calcTreeWidth(depth - 1)) {
+      right = this._traverseMerkleTree(depth - 1, pos * 2 + 1, opts)
+    }
+    if (checkForTxs) {
+      return opts.txs
+    } else {
+      return Hash.sha256sha256(Buffer.concat([left, right]))
+    }
+  }
+}
+
+/** Calculates the width of a merkle tree at a given height.
+ *  Modeled after Bitcoin Core merkleblock.h CalcTreeWidth()
+ * @param {Number} - Height at which we want the tree width
+ * @returns {Number} - Width of the tree at a given height
+ * @private
+ */
+MerkleBlock.prototype._calcTreeWidth = function calcTreeWidth (height) {
+  return (this.numTransactions + (1 << height) - 1) >> height
+}
+
+/** Calculates the height of the merkle tree in this MerkleBlock
+ * @param {Number} - Height at which we want the tree width
+ * @returns {Number} - Height of the merkle tree in this MerkleBlock
+ * @private
+ */
+MerkleBlock.prototype._calcTreeHeight = function calcTreeHeight () {
+  var height = 0
+  while (this._calcTreeWidth(height) > 1) {
+    height++
+  }
+  return height
+}
+
+/**
+ * @param {Transaction|String} - Transaction or Transaction ID Hash
+ * @returns {Boolean} - return true/false if this MerkleBlock has the TX or not
+ * @private
+ */
+MerkleBlock.prototype.hasTransaction = function hasTransaction (tx) {
+  $.checkArgument(!_.isUndefined(tx), 'tx cannot be undefined')
+  $.checkArgument(tx instanceof Transaction || typeof tx === 'string',
+    'Invalid tx given, tx must be a "string" or "Transaction"')
+
+  var hash = tx
+  if (tx instanceof Transaction) {
+    // We need to reverse the id hash for the lookup
+    hash = Buffer.from(tx.id, 'hex').reverse().toString('hex')
+  }
+
+  var txs = []
+  var height = this._calcTreeHeight()
+  this._traverseMerkleTree(height, 0, { txs: txs })
+  return txs.indexOf(hash) !== -1
+}
+
+/**
+ * @param {Buffer} - MerkleBlock data
+ * @returns {Object} - An Object representing merkleblock data
+ * @private
+ */
+MerkleBlock._fromBufferReader = function _fromBufferReader (br) {
+  $.checkState(!br.finished(), 'No merkleblock data received')
+  var info = {}
+  info.header = BlockHeader.fromBufferReader(br)
+  info.numTransactions = br.readUInt32LE()
+  var numHashes = br.readVarintNum()
+  info.hashes = []
+  for (var i = 0; i < numHashes; i++) {
+    info.hashes.push(br.read(32).toString('hex'))
+  }
+  var numFlags = br.readVarintNum()
+  info.flags = []
+  for (i = 0; i < numFlags; i++) {
+    info.flags.push(br.readUInt8())
+  }
+  return info
+}
+
+/**
+ * @param {Object} - A plain JavaScript object
+ * @returns {Block} - An instance of block
+ */
+MerkleBlock.fromObject = function fromObject (obj) {
+  return new MerkleBlock(obj)
+}
+
+module.exports = MerkleBlock

package/lib/crypto/bn.js

@@ -0,0 +1,278 @@
+'use strict'
+
+var BN = require('bn.js')
+var $ = require('../util/preconditions')
+var _ = require('../util/_')
+
+var reversebuf = function (buf) {
+  var buf2 = Buffer.alloc(buf.length)
+  for (var i = 0; i < buf.length; i++) {
+    buf2[i] = buf[buf.length - 1 - i]
+  }
+  return buf2
+}
+
+BN.Zero = new BN(0)
+BN.One = new BN(1)
+BN.Minus1 = new BN(-1)
+
+/**
+ * Convert a number into a big number.
+ *
+ * @param {number} n Any positive or negative integer.
+ */
+BN.fromNumber = function (n) {
+  $.checkArgument(_.isNumber(n))
+  return new BN(n)
+}
+
+/**
+ * Convert a string number into a big number.
+ *
+ * @param {string} str Any positive or negative integer formatted as a string.
+ * @param {number} base The base of the number, defaults to 10.
+ */
+BN.fromString = function (str, base) {
+  $.checkArgument(_.isString(str))
+  return new BN(str, base)
+}
+
+/**
+ * Convert a buffer (such as a 256 bit binary private key) into a big number.
+ * Sometimes these numbers can be formatted either as 'big endian' or 'little
+ * endian', and so there is an opts parameter that lets you specify which
+ * endianness is specified.
+ *
+ * @param {Buffer} buf A buffer number, such as a 256 bit hash or key.
+ * @param {Object} opts With a property 'endian' that can be either 'big' or 'little'. Defaults big endian (most significant digit first).
+ */
+BN.fromBuffer = function (buf, opts) {
+  if (typeof opts !== 'undefined' && opts.endian === 'little') {
+    buf = reversebuf(buf)
+  }
+  var hex = buf.toString('hex')
+  var bn = new BN(hex, 16)
+  return bn
+}
+
+/**
+ * Instantiate a BigNumber from a "signed magnitude buffer". (a buffer where the
+ * most significant bit represents the sign (0 = positive, 1 = negative)
+ *
+ * @param {Buffer} buf A buffer number, such as a 256 bit hash or key.
+ * @param {Object} opts With a property 'endian' that can be either 'big' or 'little'. Defaults big endian (most significant digit first).
+ */
+BN.fromSM = function (buf, opts) {
+  var ret
+  if (buf.length === 0) {
+    return BN.fromBuffer(Buffer.from([0]))
+  }
+
+  var endian = 'big'
+  if (opts) {
+    endian = opts.endian
+  }
+  if (endian === 'little') {
+    buf = reversebuf(buf)
+  }
+
+  if (buf[0] & 0x80) {
+    buf[0] = buf[0] & 0x7f
+    ret = BN.fromBuffer(buf)
+    ret.neg().copy(ret)
+  } else {
+    ret = BN.fromBuffer(buf)
+  }
+  return ret
+}
+
+/**
+ * Convert a big number into a number.
+ */
+BN.prototype.toNumber = function () {
+  return parseInt(this.toString(10), 10)
+}
+
+/**
+ * Convert a big number into a buffer. This is somewhat ambiguous, so there is
+ * an opts parameter that let's you specify the endianness or the size.
+ * opts.endian can be either 'big' or 'little' and opts.size can be any
+ * sufficiently large number of bytes. If you always want to create a 32 byte
+ * big endian number, then specify opts = { endian: 'big', size: 32 }
+ *
+ * @param {Object} opts Defaults to { endian: 'big', size: 32 }
+ */
+BN.prototype.toBuffer = function (opts) {
+  var buf, hex
+  if (opts && opts.size) {
+    hex = this.toString(16, 2)
+    var natlen = hex.length / 2
+    buf = Buffer.from(hex, 'hex')
+
+    if (natlen === opts.size) {
+      // buf = buf
+    } else if (natlen > opts.size) {
+      buf = BN.trim(buf, natlen)
+    } else if (natlen < opts.size) {
+      buf = BN.pad(buf, natlen, opts.size)
+    }
+  } else {
+    hex = this.toString(16, 2)
+    buf = Buffer.from(hex, 'hex')
+  }
+
+  if (typeof opts !== 'undefined' && opts.endian === 'little') {
+    buf = reversebuf(buf)
+  }
+
+  return buf
+}
+
+/**
+ * For big numbers that are either positive or negative, you can convert to
+ * "sign magnitude" format whereby the first bit specifies whether the number is
+ * positive or negative.
+ */
+BN.prototype.toSMBigEndian = function () {
+  var buf
+  if (this.cmp(BN.Zero) === -1) {
+    buf = this.neg().toBuffer()
+    if (buf[0] & 0x80) {
+      buf = Buffer.concat([Buffer.from([0x80]), buf])
+    } else {
+      buf[0] = buf[0] | 0x80
+    }
+  } else {
+    buf = this.toBuffer()
+    if (buf[0] & 0x80) {
+      buf = Buffer.concat([Buffer.from([0x00]), buf])
+    }
+  }
+
+  if (buf.length === 1 & buf[0] === 0) {
+    buf = Buffer.from([])
+  }
+  return buf
+}
+
+/**
+ * For big numbers that are either positive or negative, you can convert to
+ * "sign magnitude" format whereby the first bit specifies whether the number is
+ * positive or negative.
+ *
+ * @param {Object} opts Defaults to { endian: 'big' }
+ */
+BN.prototype.toSM = function (opts) {
+  var endian = opts ? opts.endian : 'big'
+  var buf = this.toSMBigEndian()
+
+  if (endian === 'little') {
+    buf = reversebuf(buf)
+  }
+  return buf
+}
+
+/**
+ * Create a BN from a "ScriptNum": This is analogous to the constructor for
+ * CScriptNum in bitcoind. Many ops in bitcoind's script interpreter use
+ * CScriptNum, which is not really a proper bignum. Instead, an error is thrown
+ * if trying to input a number bigger than 4 bytes. We copy that behavior here.
+ * A third argument, `size`, is provided to extend the hard limit of 4 bytes, as
+ * some usages require more than 4 bytes.
+ *
+ * @param {Buffer} buf A buffer of a number.
+ * @param {boolean} fRequireMinimal Whether to require minimal size encoding.
+ * @param {number} size The maximum size.
+ */
+BN.fromScriptNumBuffer = function (buf, fRequireMinimal, size) {
+  var nMaxNumSize = size || 4
+  $.checkArgument(buf.length <= nMaxNumSize, new Error('script number overflow'))
+  if (fRequireMinimal && buf.length > 0) {
+    // Check that the number is encoded with the minimum possible
+    // number of bytes.
+    //
+    // If the most-significant-byte - excluding the sign bit - is zero
+    // then we're not minimal. Note how this test also rejects the
+    // negative-zero encoding, 0x80.
+    if ((buf[buf.length - 1] & 0x7f) === 0) {
+      // One exception: if there's more than one byte and the most
+      // significant bit of the second-most-significant-byte is set
+      // it would conflict with the sign bit. An example of this case
+      // is +-255, which encode to 0xff00 and 0xff80 respectively.
+      // (big-endian).
+      if (buf.length <= 1 || (buf[buf.length - 2] & 0x80) === 0) {
+        throw new Error('non-minimally encoded script number')
+      }
+    }
+  }
+  return BN.fromSM(buf, {
+    endian: 'little'
+  })
+}
+
+/**
+ * The corollary to the above, with the notable exception that we do not throw
+ * an error if the output is larger than four bytes. (Which can happen if
+ * performing a numerical operation that results in an overflow to more than 4
+ * bytes).
+ */
+BN.prototype.toScriptNumBuffer = function () {
+  return this.toSM({
+    endian: 'little'
+  })
+}
+
+/**
+ * Trims a buffer if it starts with zeros.
+ *
+ * @param {Buffer} buf A buffer formatted number.
+ * @param {number} natlen The natural length of the number.
+ */
+BN.trim = function (buf, natlen) {
+  return buf.slice(natlen - buf.length, buf.length)
+}
+
+/**
+ * Adds extra zeros to the start of a number.
+ *
+ * @param {Buffer} buf A buffer formatted number.
+ * @param {number} natlen The natural length of the number.
+ * @param {number} size How big to pad the number in bytes.
+ */
+BN.pad = function (buf, natlen, size) {
+  var rbuf = Buffer.alloc(size)
+  for (var i = 0; i < buf.length; i++) {
+    rbuf[rbuf.length - 1 - i] = buf[buf.length - 1 - i]
+  }
+  for (i = 0; i < size - natlen; i++) {
+    rbuf[i] = 0
+  }
+  return rbuf
+}
+/**
+ * Convert a big number into a hex string. This is somewhat ambiguous, so there
+ * is an opts parameter that let's you specify the endianness or the size.
+ * opts.endian can be either 'big' or 'little' and opts.size can be any
+ * sufficiently large number of bytes. If you always want to create a 32 byte
+ * big endian number, then specify opts = { endian: 'big', size: 32 }
+ *
+ * @param {Object} opts Defaults to { endian: 'big', size: 32 }
+ */
+BN.prototype.toHex = function (...args) {
+  return this.toBuffer(...args).toString('hex')
+}
+
+/**
+ * Convert a hex string (such as a 256 bit binary private key) into a big
+ * number. Sometimes these numbers can be formatted either as 'big endian' or
+ * 'little endian', and so there is an opts parameter that lets you specify
+ * which endianness is specified.
+ *
+ * @param {Buffer} buf A buffer number, such as a 256 bit hash or key.
+ * @param {Object} opts With a property 'endian' that can be either 'big' or 'little'. Defaults big endian (most significant digit first).
+ */
+BN.fromHex = function (hex, ...args) {
+  return BN.fromBuffer(Buffer.from(hex, 'hex'), ...args)
+}
+
+module.exports = BN