@smartledger/bsv 5.4.2 → 5.5.1

package/test/block/blockheader.js

@@ -0,0 +1,270 @@
+'use strict'
+
+var bsv = require('../..')
+var BN = require('../../lib/crypto/bn')
+var BufferReader = bsv.encoding.BufferReader
+var BufferWriter = bsv.encoding.BufferWriter
+
+var BlockHeader = bsv.BlockHeader
+var fs = require('fs')
+var should = require('chai').should()
+
+// https://test-insight.bitpay.com/block/000000000b99b16390660d79fcc138d2ad0c89a0d044c4201a02bdf1f61ffa11
+var dataRawBlockBuffer = fs.readFileSync('test/data/blk86756-testnet.dat')
+var dataRawBlockBinary = fs.readFileSync('test/data/blk86756-testnet.dat', 'binary')
+var dataRawId = '000000000b99b16390660d79fcc138d2ad0c89a0d044c4201a02bdf1f61ffa11'
+var data = require('../data/blk86756-testnet')
+
+describe('BlockHeader', function () {
+  var version = data.version
+  var prevblockidbuf = Buffer.from(data.prevblockidhex, 'hex')
+  var merklerootbuf = Buffer.from(data.merkleroothex, 'hex')
+  var time = data.time
+  var bits = data.bits
+  var nonce = data.nonce
+  var bh = new BlockHeader({
+    version: version,
+    prevHash: prevblockidbuf,
+    merkleRoot: merklerootbuf,
+    time: time,
+    bits: bits,
+    nonce: nonce
+  })
+  var bhhex = data.blockheaderhex
+  var bhbuf = Buffer.from(bhhex, 'hex')
+
+  it('should make a new blockheader', function () {
+    BlockHeader(bhbuf).toBuffer().toString('hex').should.equal(bhhex)
+  })
+
+  it('should not make an empty block', function () {
+    (function () {
+      BlockHeader()
+    }).should.throw('Unrecognized argument for BlockHeader')
+  })
+
+  describe('#constructor', function () {
+    it('should set all the variables', function () {
+      var bh = new BlockHeader({
+        version: version,
+        prevHash: prevblockidbuf,
+        merkleRoot: merklerootbuf,
+        time: time,
+        bits: bits,
+        nonce: nonce
+      })
+      should.exist(bh.version)
+      should.exist(bh.prevHash)
+      should.exist(bh.merkleRoot)
+      should.exist(bh.time)
+      should.exist(bh.bits)
+      should.exist(bh.nonce)
+    })
+
+    it('will throw an error if the argument object hash property doesn\'t match', function () {
+      (function () {
+        new BlockHeader({ //eslint-disable-line
+          hash: '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f',
+          version: version,
+          prevHash: prevblockidbuf,
+          merkleRoot: merklerootbuf,
+          time: time,
+          bits: bits,
+          nonce: nonce
+        })
+      }).should.throw('Argument object hash property does not match block hash.')
+    })
+  })
+
+  describe('version', function () {
+    it('is interpreted as an int32le', function () {
+      var hex = 'ffffffff00000000000000000000000000000000000000000000000000000000000000004141414141414141414141414141414141414141414141414141414141414141010000000200000003000000'
+      var header = BlockHeader.fromBuffer(Buffer.from(hex, 'hex'))
+      header.version.should.equal(-1)
+      header.timestamp.should.equal(1)
+    })
+  })
+
+  describe('#fromObject', function () {
+    it('should set all the variables', function () {
+      var bh = BlockHeader.fromObject({
+        version: version,
+        prevHash: prevblockidbuf.toString('hex'),
+        merkleRoot: merklerootbuf.toString('hex'),
+        time: time,
+        bits: bits,
+        nonce: nonce
+      })
+      should.exist(bh.version)
+      should.exist(bh.prevHash)
+      should.exist(bh.merkleRoot)
+      should.exist(bh.time)
+      should.exist(bh.bits)
+      should.exist(bh.nonce)
+    })
+  })
+
+  describe('#toJSON', function () {
+    it('should set all the variables', function () {
+      var json = bh.toJSON()
+      should.exist(json.version)
+      should.exist(json.prevHash)
+      should.exist(json.merkleRoot)
+      should.exist(json.time)
+      should.exist(json.bits)
+      should.exist(json.nonce)
+    })
+  })
+
+  describe('#fromJSON', function () {
+    it('should parse this known json string', function () {
+      var jsonString = JSON.stringify({
+        version: version,
+        prevHash: prevblockidbuf,
+        merkleRoot: merklerootbuf,
+        time: time,
+        bits: bits,
+        nonce: nonce
+      })
+
+      var json = new BlockHeader(JSON.parse(jsonString))
+      should.exist(json.version)
+      should.exist(json.prevHash)
+      should.exist(json.merkleRoot)
+      should.exist(json.time)
+      should.exist(json.bits)
+      should.exist(json.nonce)
+    })
+  })
+
+  describe('#fromString/#toString', function () {
+    it('should output/input a block hex string', function () {
+      var b = BlockHeader.fromString(bhhex)
+      b.toString().should.equal(bhhex)
+    })
+  })
+
+  describe('#fromBuffer', function () {
+    it('should parse this known buffer', function () {
+      BlockHeader.fromBuffer(bhbuf).toBuffer().toString('hex').should.equal(bhhex)
+    })
+  })
+
+  describe('#fromBufferReader', function () {
+    it('should parse this known buffer', function () {
+      BlockHeader.fromBufferReader(BufferReader(bhbuf)).toBuffer().toString('hex').should.equal(bhhex)
+    })
+  })
+
+  describe('#toBuffer', function () {
+    it('should output this known buffer', function () {
+      BlockHeader.fromBuffer(bhbuf).toBuffer().toString('hex').should.equal(bhhex)
+    })
+  })
+
+  describe('#toBufferWriter', function () {
+    it('should output this known buffer', function () {
+      BlockHeader.fromBuffer(bhbuf).toBufferWriter().concat().toString('hex').should.equal(bhhex)
+    })
+
+    it('doesn\'t create a bufferWriter if one provided', function () {
+      var writer = new BufferWriter()
+      var blockHeader = BlockHeader.fromBuffer(bhbuf)
+      blockHeader.toBufferWriter(writer).should.equal(writer)
+    })
+  })
+
+  describe('#inspect', function () {
+    it('should return the correct inspect of the genesis block', function () {
+      var block = BlockHeader.fromRawBlock(dataRawBlockBinary)
+      block.inspect().should.equal('<BlockHeader ' + dataRawId + '>')
+    })
+  })
+
+  describe('#fromRawBlock', function () {
+    it('should instantiate from a raw block binary', function () {
+      var x = BlockHeader.fromRawBlock(dataRawBlockBinary)
+      x.version.should.equal(2)
+      new BN(x.bits).toString('hex').should.equal('1c3fffc0')
+    })
+
+    it('should instantiate from raw block buffer', function () {
+      var x = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+      x.version.should.equal(2)
+      new BN(x.bits).toString('hex').should.equal('1c3fffc0')
+    })
+  })
+
+  describe('#validTimestamp', function () {
+    var x = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+
+    it('should validate timpstamp as true', function () {
+      var valid = x.validTimestamp(x)
+      valid.should.equal(true)
+    })
+
+    it('should validate timestamp as false', function () {
+      x.time = Math.round(new Date().getTime() / 1000) + BlockHeader.Constants.MAX_TIME_OFFSET + 100
+      var valid = x.validTimestamp(x)
+      valid.should.equal(false)
+    })
+  })
+
+  describe('#validProofOfWork', function () {
+    it('should validate proof-of-work as true', function () {
+      var x = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+      var valid = x.validProofOfWork(x)
+      valid.should.equal(true)
+    })
+
+    it('should validate proof of work as false because incorrect proof of work', function () {
+      var x = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+      var nonce = x.nonce
+      x.nonce = 0
+      var valid = x.validProofOfWork(x)
+      valid.should.equal(false)
+      x.nonce = nonce
+    })
+  })
+
+  describe('#getDifficulty', function () {
+    it('should get the correct difficulty for block 86756', function () {
+      var x = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+      x.bits.should.equal(0x1c3fffc0)
+      x.getDifficulty().should.equal(4)
+    })
+
+    it('should get the correct difficulty for testnet block 552065', function () {
+      var x = new BlockHeader({
+        bits: 0x1b00c2a8
+      })
+      x.getDifficulty().should.equal(86187.62562209)
+    })
+
+    it('should get the correct difficulty for livenet block 373043', function () {
+      var x = new BlockHeader({
+        bits: 0x18134dc1
+      })
+      x.getDifficulty().should.equal(56957648455.01001)
+    })
+
+    it('should get the correct difficulty for livenet block 340000', function () {
+      var x = new BlockHeader({
+        bits: 0x1819012f
+      })
+      x.getDifficulty().should.equal(43971662056.08958)
+    })
+
+    it('should use exponent notation if difficulty is larger than Javascript number', function () {
+      var x = new BlockHeader({
+        bits: 0x0900c2a8
+      })
+      x.getDifficulty().should.equal(1.9220482782645836 * 1e48)
+    })
+  })
+
+  it('coverage: caches the "_id" property', function () {
+    var blockHeader = BlockHeader.fromRawBlock(dataRawBlockBuffer)
+    blockHeader.id.should.equal(blockHeader.id)
+  })
+})

package/test/block/merkleblock.js

@@ -0,0 +1,207 @@
+'use strict'
+
+var should = require('chai').should()
+
+var bsv = require('../..')
+var MerkleBlock = bsv.MerkleBlock
+var BufferReader = bsv.encoding.BufferReader
+var BufferWriter = bsv.encoding.BufferWriter
+var Transaction = bsv.Transaction
+var data = require('../data/merkleblocks.js')
+var transactionVector = require('../data/tx_creation')
+
+describe('MerkleBlock', function () {
+  var blockhex = data.HEX[0]
+  var blockbuf = Buffer.from(blockhex, 'hex')
+  var blockJSON = JSON.stringify(data.JSON[0])
+  var blockObject = JSON.parse(JSON.stringify(data.JSON[0]))
+
+  describe('#constructor', function () {
+    it('should make a new merkleblock from buffer', function () {
+      var b = MerkleBlock(blockbuf)
+      b.toBuffer().toString('hex').should.equal(blockhex)
+    })
+
+    it('should make a new merkleblock from object', function () {
+      var b = MerkleBlock(blockObject)
+      b.toObject().should.deep.equal(blockObject)
+    })
+
+    it('should make a new merkleblock from JSON', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON))
+      JSON.stringify(b).should.equal(blockJSON)
+    })
+
+    it('should not make an empty block', function () {
+      (function () {
+        return new MerkleBlock()
+      }).should.throw('Unrecognized argument for MerkleBlock')
+    })
+  })
+
+  describe('#fromObject', function () {
+    it('should set these known values', function () {
+      var block = MerkleBlock.fromObject(JSON.parse(blockJSON))
+      should.exist(block.header)
+      should.exist(block.numTransactions)
+      should.exist(block.hashes)
+      should.exist(block.flags)
+    })
+
+    it('should set these known values', function () {
+      var block = MerkleBlock(JSON.parse(blockJSON))
+      should.exist(block.header)
+      should.exist(block.numTransactions)
+      should.exist(block.hashes)
+      should.exist(block.flags)
+    })
+
+    it('accepts an object as argument', function () {
+      var block = MerkleBlock(blockbuf)
+      should.exist(MerkleBlock.fromObject(block.toObject()))
+    })
+  })
+
+  describe('#toJSON', function () {
+    it('should recover these known values', function () {
+      var block = new MerkleBlock(JSON.parse(blockJSON))
+      var b = JSON.parse(JSON.stringify(block))
+      should.exist(block.header)
+      should.exist(block.numTransactions)
+      should.exist(block.hashes)
+      should.exist(block.flags)
+      should.exist(b.header)
+      should.exist(b.numTransactions)
+      should.exist(b.hashes)
+      should.exist(b.flags)
+    })
+  })
+
+  describe('#fromBuffer', function () {
+    it('should make a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf)
+      block.toBuffer().toString('hex').should.equal(blockhex)
+    })
+  })
+
+  describe('#fromBufferReader', function () {
+    it('should make a block from this known buffer', function () {
+      var block = MerkleBlock.fromBufferReader(BufferReader(blockbuf))
+      block.toBuffer().toString('hex').should.equal(blockhex)
+    })
+  })
+
+  describe('#toBuffer', function () {
+    it('should recover a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf)
+      block.toBuffer().toString('hex').should.equal(blockhex)
+    })
+  })
+
+  describe('#toBufferWriter', function () {
+    it('should recover a block from this known buffer', function () {
+      var block = MerkleBlock.fromBuffer(blockbuf)
+      block.toBufferWriter().concat().toString('hex').should.equal(blockhex)
+    })
+
+    it('doesn\'t create a bufferWriter if one provided', function () {
+      var writer = new BufferWriter()
+      var block = MerkleBlock.fromBuffer(blockbuf)
+      block.toBufferWriter(writer).should.equal(writer)
+    })
+  })
+
+  describe('#validMerkleTree', function () {
+    it('should validate good merkleblocks', function () {
+      data.JSON.forEach(function (data) {
+        var b = MerkleBlock(data)
+        b.validMerkleTree().should.equal(true)
+      })
+    })
+
+    it('should not validate merkleblocks with too many hashes', function () {
+      var b = MerkleBlock(data.JSON[0])
+      // Add too many hashes
+      var i = 0
+      while (i <= b.numTransactions) {
+        b.hashes.push('bad' + i++)
+      }
+      b.validMerkleTree().should.equal(false)
+    })
+
+    it('should not validate merkleblocks with too few bit flags', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON))
+      b.flags.pop()
+      b.validMerkleTree().should.equal(false)
+    })
+  })
+
+  describe('#filteredTxsHash', function () {
+    it('should validate good merkleblocks', function () {
+      var hashOfFilteredTx = '6f64fd5aa9dd01f74c03656d376625cf80328d83d9afebe60cc68b8f0e245bd9'
+      var b = MerkleBlock(data.JSON[3])
+      b.filteredTxsHash()[0].should.equal(hashOfFilteredTx)
+    })
+
+    it('should fail with merkleblocks with too many hashes', function () {
+      var b = MerkleBlock(data.JSON[0])
+      // Add too many hashes
+      var i = 0
+      while (i <= b.numTransactions) {
+        b.hashes.push('bad' + i++)
+      }
+      (function () {
+        b.filteredTxsHash()
+      }).should.throw('This MerkleBlock contain an invalid Merkle Tree')
+    })
+
+    it('should fail with merkleblocks with too few bit flags', function () {
+      var b = MerkleBlock(JSON.parse(blockJSON))
+      b.flags.pop();
+      (function () {
+        b.filteredTxsHash()
+      }).should.throw('This MerkleBlock contain an invalid Merkle Tree')
+    })
+  })
+
+  describe('#hasTransaction', function () {
+    it('should find transactions via hash string', function () {
+      var jsonData = data.JSON[0]
+      var txId = Buffer.from(jsonData.hashes[1], 'hex').toString('hex')
+      var b = MerkleBlock(jsonData)
+      b.hasTransaction(txId).should.equal(true)
+      b.hasTransaction(txId + 'abcd').should.equal(false)
+    })
+
+    it('should find transactions via Transaction object', function () {
+      var jsonData = data.JSON[0]
+      var txBuf = Buffer.from(data.TXHEX[0][0], 'hex')
+      var tx = new Transaction().fromBuffer(txBuf)
+      var b = MerkleBlock(jsonData)
+      b.hasTransaction(tx).should.equal(true)
+    })
+
+    it('should not find non-existant Transaction object', function () {
+      // Reuse another transaction already in data/ dir
+      var serialized = transactionVector[0][7]
+      var tx = new Transaction().fromBuffer(Buffer.from(serialized, 'hex'))
+      var b = MerkleBlock(data.JSON[0])
+      b.hasTransaction(tx).should.equal(false)
+    })
+
+    it('should not match with merkle nodes', function () {
+      var b = MerkleBlock(data.JSON[0])
+
+      var hashData = [
+        ['3612262624047ee87660be1a707519a443b1c1ce3d248cbfc6c15870f6c5daa2', false],
+        ['019f5b01d4195ecbc9398fbf3c3b1fa9bb3183301d7a1fb3bd174fcfa40a2b65', true],
+        ['41ed70551dd7e841883ab8f0b16bf04176b7d1480e4f0af9f3d4c3595768d068', false],
+        ['20d2a7bc994987302e5b1ac80fc425fe25f8b63169ea78e68fbaaefa59379bbf', false]
+      ]
+
+      hashData.forEach(function check (d) {
+        b.hasTransaction(d[0]).should.equal(d[1])
+      })
+    })
+  })
+})