@smartledger/bsv 8.3.1 → 9.1.0

package/test/block/blockheader.js

@@ -1,270 +0,0 @@
-'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

@@ -1,207 +0,0 @@
-'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])
-      })
-    })
-  })
-})

package/test/build/bundle_crypto_shim.js

@@ -1,104 +0,0 @@
-'use strict'
-
-/* global describe, it, before */
-
-// The browser `crypto` polyfill is our own three-function shim, not crypto-browserify.
-//
-// Two things have to hold, and neither is visible to a test that stays inside lib/.
-//
-// 1. `elliptic` must not re-enter the bundles. It carries an advisory with no patched
-//    version, and it is reachable from crypto-browserify via browserify-sign and
-//    create-ecdh. build/esbuild.js used to keep it out with a hand-written onResolve
-//    stub; removing crypto-browserify removed the need for the stub, and this file
-//    replaces it. A stub is silent when it stops matching — an assertion is not.
-//
-// 2. The shim must keep implementing what the bundles actually call. If someone adds a
-//    `crypto.pbkdf2` call to a bundled module, resolution still succeeds and the member
-//    is simply `undefined`, so the failure surfaces far from its cause.
-//
-// The known-answer test exists because "the bundle builds" and "the bundle hashes
-// correctly" are different claims, and only the second one matters to a caller.
-
-require('chai').should()
-var crypto = require('crypto')
-var esbuild = require('../../build/esbuild.js')
-var shim = require('../../build/esbuild/crypto-shim.js')
-
-// Reachable from crypto-browserify; `elliptic` is the one with no fix available.
-var BANNED = ['elliptic', 'browserify-sign', 'create-ecdh', 'crypto-browserify']
-
-describe('browser crypto shim', function () {
-  this.timeout(300000)
-
-  var pkgsByBundle = {}
-
-  before(function () {
-    return Promise.all(esbuild.BUNDLES.map(function (cfg) {
-      return esbuild.buildOne(cfg, { metafile: true, write: false, logLevel: 'silent' })
-        .then(function (result) {
-          pkgsByBundle[cfg.file] = Object.keys(result.metafile.inputs)
-            .map(function (p) {
-              var m = /node_modules\/((?:@[^/]+\/)?[^/]+)\//.exec(p)
-              return m && m[1]
-            })
-            .filter(Boolean)
-        })
-    }))
-  })
-
-  it('built every bundle', function () {
-    esbuild.BUNDLES.length.should.be.above(0)
-    Object.keys(pkgsByBundle).length.should.equal(esbuild.BUNDLES.length)
-  })
-
-  // Guard against the graph being empty for an unrelated reason, which would make the
-  // "no banned packages" assertion below pass without checking anything.
-  it('resolved a non-trivial dependency graph', function () {
-    Object.keys(pkgsByBundle).forEach(function (file) {
-      pkgsByBundle[file].length.should.be.above(0, file + ' has no node_modules inputs')
-    })
-  })
-
-  it('pulls no part of the elliptic chain into any bundle', function () {
-    var offenders = []
-    Object.keys(pkgsByBundle).forEach(function (file) {
-      BANNED.forEach(function (pkg) {
-        if (pkgsByBundle[file].indexOf(pkg) !== -1) offenders.push(file + ' → ' + pkg)
-      })
-    })
-    offenders.should.deep.equal([])
-  })
-
-  it('exports exactly the members the bundles call', function () {
-    Object.keys(shim).sort().should.deep.equal(['createHash', 'createHmac', 'randomBytes'])
-  })
-
-  // Deliberately absent: secrets.js-grempe prefers getRandomValues over randomBytes when
-  // it is present, so exporting it would silently move the Shamir CSPRNG to another code
-  // path. crypto-browserify did not expose it either.
-  it('does not expose getRandomValues', function () {
-    ;(shim.getRandomValues === undefined).should.equal(true)
-  })
-
-  it('hashes identically to node crypto', function () {
-    ['', 'abc', 'The quick brown fox jumps over the lazy dog'].forEach(function (input) {
-      ;['sha1', 'sha256', 'sha512', 'ripemd160'].forEach(function (alg) {
-        shim.createHash(alg).update(input).digest('hex')
-          .should.equal(crypto.createHash(alg).update(input).digest('hex'), alg + ' of ' + JSON.stringify(input))
-      })
-    })
-  })
-
-  it('hmacs identically to node crypto', function () {
-    shim.createHmac('sha512', Buffer.from('key')).update('message').digest('hex')
-      .should.equal(crypto.createHmac('sha512', Buffer.from('key')).update('message').digest('hex'))
-  })
-
-  it('draws distinct random bytes of the requested length', function () {
-    var a = shim.randomBytes(32)
-    var b = shim.randomBytes(32)
-    a.length.should.equal(32)
-    b.length.should.equal(32)
-    a.toString('hex').should.not.equal(b.toString('hex'))
-  })
-})