@smartledger/bsv 8.3.1 → 9.1.0

package/test/networks.js

@@ -1,207 +0,0 @@
-'use strict'
-
-var expect = require('chai').expect
-var should = require('chai').should()
-var bsv = require('..')
-var networks = bsv.Networks
-
-describe('Networks', function () {
-  var customnet
-
-  it('should contain all Networks', function () {
-    should.exist(networks.livenet)
-    should.exist(networks.testnet)
-    should.exist(networks.stn)
-    should.exist(networks.defaultNetwork)
-  })
-
-  it('should be able to define a custom Network', function () {
-    var custom = {
-      name: 'customnet',
-      alias: 'mynet',
-      pubkeyhash: 0x10,
-      privatekey: 0x90,
-      scripthash: 0x08,
-      xpubkey: 0x0278b20e,
-      xprivkey: 0x0278ade4,
-      networkMagic: 0xe7beb4d4,
-      port: 20001,
-      dnsSeeds: [
-        'localhost',
-        'mynet.localhost'
-      ]
-    }
-    networks.add(custom)
-    customnet = networks.get('customnet')
-    for (var key in custom) {
-      if (key !== 'networkMagic') {
-        customnet[key].should.equal(custom[key])
-      } else {
-        var expected = Buffer.from('e7beb4d4', 'hex')
-        customnet[key].should.deep.equal(expected)
-      }
-    }
-  })
-
-  it('should have network magic for testnet', function () {
-    var testnet = networks.get('testnet')
-    Buffer.isBuffer(testnet.networkMagic).should.equal(true)
-  })
-
-  it('should have network magic for stn', function () {
-    var stn = networks.get('stn')
-    Buffer.isBuffer(stn.networkMagic).should.equal(true)
-  })
-
-  it('can remove a custom network', function () {
-    networks.remove(customnet)
-    var net = networks.get('customnet')
-    should.equal(net, undefined)
-  })
-
-  it('should not set a network map for an undefined value', function () {
-    var custom = {
-      name: 'somenet',
-      pubkeyhash: 0x13,
-      privatekey: 0x93,
-      scripthash: 0x11,
-      xpubkey: 0x0278b20f,
-      xprivkey: 0x0278ade5,
-      networkMagic: 0xe7beb4d5,
-      port: 20008,
-      dnsSeeds: [
-        'somenet.localhost'
-      ]
-    }
-    networks.add(custom)
-    var network = networks.get(undefined)
-    should.not.exist(network)
-    var somenet = networks.get('somenet')
-    should.exist(somenet)
-    somenet.name.should.equal('somenet')
-    networks.remove(somenet)
-  })
-
-  var constants = ['name', 'alias', 'pubkeyhash', 'scripthash', 'xpubkey', 'xprivkey']
-
-  constants.forEach(function (key) {
-    it('should have constant ' + key + ' for livenet, testnet and stn', function () {
-      networks.testnet.hasOwnProperty(key).should.equal(true)
-      networks.livenet.hasOwnProperty(key).should.equal(true)
-      networks.stn.hasOwnProperty(key).should.equal(true)
-    })
-  })
-
-  it('tests only for the specified key', function () {
-    expect(networks.get(0x6f, 'pubkeyhash')).to.equal(networks.testnet)
-    expect(networks.get(0x6f, 'privatekey')).to.equal(undefined)
-  })
-
-  it('can test for multiple keys', function () {
-    expect(networks.get(0x6f, ['pubkeyhash', 'scripthash'])).to.equal(networks.testnet)
-    expect(networks.get(0xc4, ['pubkeyhash', 'scripthash'])).to.equal(networks.testnet)
-    expect(networks.get(0x6f, ['privatekey', 'port'])).to.equal(undefined)
-  })
-
-  it('should have regtest network', function () {
-    expect(networks.get('regtest').name).to.equal('regtest')
-  })
-
-  it('should have testnet network', function () {
-    expect(networks.get('testnet').name).to.equal('testnet')
-  })
-
-  it('should have stn network', function () {
-    expect(networks.get('stn').name).to.equal('stn')
-  })
-
-  it('should have livenet network', function () {
-    expect(networks.get('livenet').name).to.equal('livenet')
-  })
-
-  it('should have bchtest cashAddrPrefix', function () {
-    expect(networks.get('testnet').cashAddrPrefix).to.equal('bchtest')
-  })
-
-  it('should have bchreg cashAddrPrefix', function () {
-    expect(networks.get('regtest').cashAddrPrefix).to.equal('bchreg')
-  })
-
-  it('should have bchreg cashAddrPrefix after enableRegtest is called', function () {
-    var network = networks.get('testnet')
-    networks.enableRegtest()
-    expect(network.cashAddrPrefix).to.equal('bchreg')
-  })
-
-  it('should have bchtest cashAddrPrefix after disableRegtest is called', function () {
-    var network = networks.get('testnet')
-    networks.disableRegtest()
-    expect(network.cashAddrPrefix).to.equal('bchtest')
-  })
-  it('should have bsvstn cashAddrPrefix after enableStn is called', function () {
-    var network = networks.get('testnet')
-    networks.enableStn()
-    expect(network.cashAddrPrefix).to.equal('bsvstn')
-  })
-
-  it('should have bchtest cashAddrPrefix after disableStn is called', function () {
-    var network = networks.get('testnet')
-    networks.disableStn()
-    expect(network.cashAddrPrefix).to.equal('bchtest')
-  })
-
-  it('converts to string using the "name" property', function () {
-    networks.livenet.toString().should.equal('livenet')
-  })
-
-  it('network object should be immutable', function () {
-    expect(networks.testnet.name).to.equal('testnet')
-    var fn = function () { networks.testnet.name = 'livenet' }
-    expect(fn).to.throw(TypeError)
-  })
-  // The `cashAddrPrefixArray` getter has three branches; only the STN one reached for
-  // the helper on the STN data object instead of the module-level function, so reading
-  // it with STN enabled threw `STN.cashAddrPrefixToArray is not a function`. The tests
-  // above cover `cashAddrPrefix` (the string) but never the array getter, which is why
-  // a live TypeError survived a 4,597-test suite.
-  describe('cashAddrPrefixArray across the regtest/stn toggles', function () {
-    // enableStn/enableRegtest mutate the shared testnet object, so without a reset the
-    // flags leak into every later test in the run.
-    afterEach(function () {
-      networks.disableStn()
-      networks.disableRegtest()
-    })
-
-    function assertPrefixArray (arr) {
-      Array.isArray(arr).should.equal(true)
-      arr.length.should.be.above(0)
-      arr.forEach(function (n) { n.should.be.a('number') })
-    }
-
-    it('works with stn enabled', function () {
-      networks.enableStn()
-      assertPrefixArray(networks.testnet.cashAddrPrefixArray)
-    })
-
-    it('works with regtest enabled', function () {
-      networks.enableRegtest()
-      assertPrefixArray(networks.testnet.cashAddrPrefixArray)
-    })
-
-    it('works with neither enabled', function () {
-      assertPrefixArray(networks.testnet.cashAddrPrefixArray)
-    })
-
-    it('returns a different prefix array per mode', function () {
-      var plain = networks.testnet.cashAddrPrefixArray.join(',')
-      networks.enableStn()
-      var stn = networks.testnet.cashAddrPrefixArray.join(',')
-      networks.disableStn()
-      networks.enableRegtest()
-      var regtest = networks.testnet.cashAddrPrefixArray.join(',')
-      stn.should.not.equal(plain)
-      regtest.should.not.equal(plain)
-      stn.should.not.equal(regtest)
-    })
-  })
-})

package/test/notaryhash/batch_leaf.js

@@ -1,140 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// BRC-220 batch mode: what is in a Merkle leaf.
-//
-// The spec writes `leaf = SHA256(0x00 ‖ d)` and never binds `d`. That is RFC 6962's own
-// generic notation for the construction, quoted to identify WHICH tree — domain
-// separation, the power-of-two split, no duplicated last leaf — not to define the leaf's
-// contents. `canonicalBytes` appears once in the whole document, in the proofHash
-// definition, and nowhere in the batch text.
-//
-// This library reads `d` as proofHash. The alternative reading, d = canonicalBytes, is
-// equally sound cryptographically and produces a DIFFERENT root — so the two do not
-// interoperate, and the failure is silent: the fold just does not reach the root.
-//
-// These tests pin the choice, and pin the divergence too. A comment saying "we use
-// proofHash" would not fail if someone changed it; this does.
-//
-// Reasoning and proposed spec text: docs/BRC220_BATCH_LEAF_AMENDMENT.md
-
-require('chai').should()
-var NotaryHash = require('../../lib/notaryhash')
-var Merkle = require('../../lib/notaryhash/merkle')
-var Hash = require('../../lib/crypto/hash')
-var NotaryScript = require('../../lib/notaryhash/script')
-
-// Four fixed proofHash values, standing in for a four-proof batch.
-var PROOF_HASHES = [
-  '00'.repeat(31) + '01',
-  '00'.repeat(31) + '02',
-  'ab'.repeat(32),
-  'ff'.repeat(32)
-].map(function (h) { return Buffer.from(h, 'hex') })
-
-function batchCertificate (index, leaves) {
-  return {
-    mode: NotaryScript.MODE.BATCH,
-    proofHash: leaves[index].toString('hex'),
-    merkle: {
-      root: Merkle.root(leaves).toString('hex'),
-      leafIndex: index,
-      leafCount: leaves.length,
-      path: Merkle.path(leaves, index).map(function (n) { return n.toString('hex') })
-    }
-  }
-}
-
-describe('BRC-220 batch leaf', function () {
-  describe('the leaf datum is proofHash', function () {
-    it('a leaf is SHA-256(0x00 || proofHash)', function () {
-      var proofHash = PROOF_HASHES[0]
-      Merkle.hashLeaf(proofHash).toString('hex').should.equal(
-        Hash.sha256(Buffer.concat([Buffer.from([0x00]), proofHash])).toString('hex')
-      )
-    })
-
-    // Stated the long way round, because this is the identity the spec leaves open.
-    it('is therefore SHA-256(0x00 || SHA-256(canonicalBytes))', function () {
-      var canonicalBytes = Buffer.from('any canonical proof bytes at all')
-      var proofHash = Hash.sha256(canonicalBytes)
-      Merkle.hashLeaf(proofHash).toString('hex').should.equal(
-        Hash.sha256(Buffer.concat([
-          Buffer.from([0x00]), Hash.sha256(canonicalBytes)
-        ])).toString('hex')
-      )
-    })
-
-    it('verifies inclusion for every leaf of a four-proof batch', function () {
-      for (var i = 0; i < PROOF_HASHES.length; i++) {
-        var report = NotaryHash.verifyBatchInclusion(batchCertificate(i, PROOF_HASHES))
-        report.valid.should.equal(true, 'leaf ' + i + ' should verify')
-        report.errors.should.deep.equal([])
-      }
-    })
-  })
-
-  describe('the two readings of `d` are not interchangeable', function () {
-    var canonicalBytesSet = [
-      Buffer.from('proof one canonical bytes'),
-      Buffer.from('proof two canonical bytes'),
-      Buffer.from('proof three canonical bytes'),
-      Buffer.from('proof four canonical bytes')
-    ]
-    var proofHashes = canonicalBytesSet.map(function (b) { return Hash.sha256(b) })
-
-    it('produces a different root under each reading', function () {
-      Merkle.root(proofHashes).toString('hex')
-        .should.not.equal(Merkle.root(canonicalBytesSet).toString('hex'))
-    })
-
-    // The interoperability failure, made concrete. This is what a batch built by an
-    // implementation using the other reading would look like to this verifier.
-    it('REJECTS a certificate whose tree was built over canonicalBytes', function () {
-      var certificate = {
-        mode: NotaryScript.MODE.BATCH,
-        proofHash: proofHashes[1].toString('hex'),
-        merkle: {
-          // Root and path from the canonicalBytes tree — the other reading.
-          root: Merkle.root(canonicalBytesSet).toString('hex'),
-          leafIndex: 1,
-          leafCount: 4,
-          path: Merkle.path(canonicalBytesSet, 1).map(function (n) { return n.toString('hex') })
-        }
-      }
-      var report = NotaryHash.verifyBatchInclusion(certificate)
-      report.valid.should.equal(false)
-      report.errors.should.deep.equal(['merkle inclusion proof does not fold to the batch root'])
-    })
-
-    // Both are sound; neither is being called wrong. The point is only that a choice had
-    // to be made and that it is checkable.
-    it('both readings are domain-separated and second-preimage resistant', function () {
-      var leafBytes = Buffer.alloc(64, 7)
-      Merkle.hashLeaf(leafBytes).toString('hex')
-        .should.not.equal(Merkle.hashNode(Buffer.alloc(32, 7), Buffer.alloc(32, 7)).toString('hex'))
-    })
-  })
-
-  describe('the verdict is a strict report, not a truthy object', function () {
-    it('reports valid:false rather than throwing on a malformed merkle object', function () {
-      var report = NotaryHash.verifyBatchInclusion({
-        mode: NotaryScript.MODE.BATCH,
-        proofHash: PROOF_HASHES[0].toString('hex'),
-        merkle: { root: 'not-hex', leafIndex: 0, leafCount: 1, path: [] }
-      })
-      report.valid.should.equal(false)
-      report.errors.length.should.be.above(0)
-    })
-
-    it('rejects a non-batch certificate by mode', function () {
-      var report = NotaryHash.verifyBatchInclusion({
-        mode: NotaryScript.MODE.FULL,
-        proofHash: PROOF_HASHES[0].toString('hex')
-      })
-      report.valid.should.equal(false)
-      report.errors.should.deep.equal(['certificate is not in batch mode'])
-    })
-  })
-})

package/test/notaryhash/certificate.js

@@ -1,249 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// BRC-220 certificate. This is validity check 2 of the three the spec requires — proof
-// integrity — plus the object a verifier is actually handed.
-//
-// The tests below concentrate on three things the spec makes explicit and that would fail
-// silently if got wrong: the certificate carries FULL blobs even when the chain carries
-// digests; the SPV envelope never disturbs proofHash; and proofHash is over the binary
-// proof bytes, NOT over the certificate JSON.
-
-require('chai').should()
-var Certificate = require('../../lib/notaryhash/certificate')
-var Encoding = require('../../lib/notaryhash/encoding')
-var NS = require('../../lib/notaryhash/script')
-var Hash = require('../../lib/crypto/hash')
-var JCS = require('../../lib/util/jcs')
-
-var PARAMS = {
-  mode: NS.MODE.FULL,
-  algorithm: 'ECDSA-secp256k1',
-  hashAlgorithm: 'SHA-256',
-  payloadHash: Buffer.alloc(32, 0x11),
-  publicKey: Buffer.alloc(33, 0x02),
-  signature: Buffer.alloc(64, 0x30),
-  createdAt: '2026-08-16T00:00:00.000Z',
-  anchor: { txid: 'ab'.repeat(32), blockHeight: 800000 }
-}
-
-var SPV = {
-  rawTx: 'deadbeef',
-  blockHash: 'cc'.repeat(32),
-  blockHeight: 800000,
-  merkleProof: { index: 0, nodes: ['aa'.repeat(32), '*'] }
-}
-
-describe('BRC-220 certificate', function () {
-  describe('build', function () {
-    it('carries every field the spec requires', function () {
-      var cert = Certificate.build(PARAMS)
-      Certificate.REQUIRED_FIELDS.forEach(function (field) {
-        ;(cert[field] === undefined).should.equal(false, 'missing ' + field)
-      })
-    })
-
-    it('defaults encoding to raw', function () {
-      Certificate.build(PARAMS).encoding.should.equal('raw')
-    })
-
-    it('accepts der for Bitcoin-native signers', function () {
-      Certificate.build(Object.assign({}, PARAMS, { encoding: 'der' })).encoding.should.equal('der')
-    })
-
-    it('rejects an unknown encoding rather than passing it through', function () {
-      ;(function () {
-        Certificate.build(Object.assign({}, PARAMS, { encoding: 'base64' }))
-      }).should.throw(/encoding must be/)
-    })
-
-    it('hex-encodes the byte fields', function () {
-      var cert = Certificate.build(PARAMS)
-      cert.payloadHash.should.equal(PARAMS.payloadHash.toString('hex'))
-      cert.publicKey.should.equal(PARAMS.publicKey.toString('hex'))
-      cert.signature.should.equal(PARAMS.signature.toString('hex'))
-    })
-
-    // proofHash is computed, never accepted. A caller cannot hand in a value that
-    // disagrees with the fields beside it — which is precisely the artefact this protocol
-    // exists to make impossible.
-    it('computes proofHash rather than accepting one', function () {
-      var cert = Certificate.build(Object.assign({}, PARAMS, { proofHash: 'ff'.repeat(32) }))
-      cert.proofHash.should.not.equal('ff'.repeat(32))
-      Certificate.proofHashMatches(cert).should.equal(true)
-    })
-
-    it('requires a merkle proof for batch mode', function () {
-      ;(function () {
-        Certificate.build(Object.assign({}, PARAMS, { mode: NS.MODE.BATCH }))
-      }).should.throw(/merkle/)
-    })
-
-    it('carries the merkle proof when batched', function () {
-      var cert = Certificate.build(Object.assign({}, PARAMS, {
-        mode: NS.MODE.BATCH,
-        merkle: { root: 'aa'.repeat(32), leafIndex: 2, leafCount: 8, path: [] }
-      }))
-      cert.merkle.leafIndex.should.equal(2)
-      cert.merkle.leafCount.should.equal(8)
-    })
-
-    // Hybrid puts only digests on chain; the certificate keeps the originals. That
-    // asymmetry is the whole point of the mode.
-    it('keeps the FULL key and signature in hybrid mode', function () {
-      var cert = Certificate.build(Object.assign({}, PARAMS, { mode: NS.MODE.HYBRID }))
-      cert.publicKey.should.equal(PARAMS.publicKey.toString('hex'))
-      cert.signature.should.equal(PARAMS.signature.toString('hex'))
-      // What goes on chain is the digest of each — different values entirely.
-      var onChain = NS.parse(NS.build(Object.assign({}, PARAMS, { mode: NS.MODE.HYBRID, proofHash: Buffer.alloc(32) })))
-      onChain.publicKeyHash.toString('hex').should.equal(Hash.sha256(PARAMS.publicKey).toString('hex'))
-      onChain.publicKeyHash.toString('hex').should.not.equal(cert.publicKey)
-    })
-  })
-
-  describe('proof integrity (validity check 2)', function () {
-    it('matches for a well-formed certificate', function () {
-      Certificate.proofHashMatches(Certificate.build(PARAMS)).should.equal(true)
-    })
-
-    // Each field is inside the canonical proof bytes, so tampering with any of them must
-    // be detected. This is the certificate-level counterpart of the encoding module's
-    // coverage test.
-    it('detects tampering with any covered field', function () {
-      var cert = Certificate.build(PARAMS)
-      var tampers = {
-        algorithm: 'ML-DSA-65',
-        hashAlgorithm: 'SHA-512',
-        payloadHash: 'ff'.repeat(32),
-        publicKey: '03' + '11'.repeat(32),
-        signature: 'aa'.repeat(64),
-        createdAt: '2026-08-17T00:00:00.000Z'
-      }
-      Object.keys(tampers).forEach(function (field) {
-        var bad = Object.assign({}, cert)
-        bad[field] = tampers[field]
-        Certificate.proofHashMatches(bad)
-          .should.equal(false, 'tampering with ' + field + ' was not detected')
-      })
-    })
-
-    // Fields NOT in the canonical proof bytes must not affect it — otherwise the SPV
-    // envelope could not be additive.
-    it('is unaffected by fields outside the canonical bytes', function () {
-      var cert = Certificate.build(PARAMS)
-      var moved = Object.assign({}, cert, {
-        anchor: { txid: 'ff'.repeat(32), blockHeight: 999999 },
-        mode: NS.MODE.HYBRID
-      })
-      Certificate.proofHashMatches(moved).should.equal(true)
-    })
-
-    it('returns a strict boolean, never a truthy object', function () {
-      Certificate.proofHashMatches(Certificate.build(PARAMS)).should.be.a('boolean')
-      Certificate.proofHashMatches(null).should.equal(false)
-      Certificate.proofHashMatches({}).should.equal(false)
-      Certificate.proofHashMatches({ proofHash: 'nonsense' }).should.equal(false)
-    })
-
-    // The hex fields decode to bytes before hashing. Hashing the strings would be twice
-    // as many bytes and produce something that still looks like a hash.
-    it('hashes the decoded bytes, not the hex strings', function () {
-      var cert = Certificate.build(PARAMS)
-      var overHex = Hash.sha256(Encoding.canonicalBytes({
-        algorithm: cert.algorithm,
-        hashAlgorithm: cert.hashAlgorithm,
-        payloadHash: Buffer.from(cert.payloadHash, 'utf8'), // the STRING, wrongly
-        publicKey: Buffer.from(cert.publicKey, 'hex'),
-        signature: Buffer.from(cert.signature, 'hex'),
-        createdAtUnix: Encoding.toUnixSeconds(cert.createdAt)
-      })).toString('hex')
-      overHex.should.not.equal(cert.proofHash)
-    })
-  })
-
-  describe('SPV envelope', function () {
-    // The spec's explicit guarantee. If it ever broke, every previously issued
-    // certificate would become unverifiable.
-    it('never changes proofHash', function () {
-      var cert = Certificate.build(PARAMS)
-      var withSPV = Certificate.attachSPV(cert, SPV)
-      withSPV.proofHash.should.equal(cert.proofHash)
-      Certificate.proofHashMatches(withSPV).should.equal(true)
-    })
-
-    it('does not mutate the certificate it was given', function () {
-      var cert = Certificate.build(PARAMS)
-      Certificate.attachSPV(cert, SPV)
-      ;(cert.spv === undefined).should.equal(true)
-    })
-
-    it('defaults format to TSC', function () {
-      Certificate.attachSPV(Certificate.build(PARAMS), SPV).spv.format.should.equal('TSC')
-    })
-
-    it('keeps an explicit format, for BUMP or BEEF', function () {
-      var withSPV = Certificate.attachSPV(Certificate.build(PARAMS),
-        Object.assign({}, SPV, { format: 'BUMP' }))
-      withSPV.spv.format.should.equal('BUMP')
-    })
-  })
-
-  describe('validateShape', function () {
-    it('passes a well-formed certificate', function () {
-      Certificate.validateShape(Certificate.build(PARAMS)).should.deep.equal([])
-    })
-
-    it('names every missing required field', function () {
-      var problems = Certificate.validateShape({})
-      problems.length.should.equal(Certificate.REQUIRED_FIELDS.length)
-      problems[0].should.match(/missing required field/)
-    })
-
-    it('rejects a foreign protocol or version', function () {
-      var cert = Certificate.build(PARAMS)
-      Certificate.validateShape(Object.assign({}, cert, { protocol: 'Other' }))
-        .should.include('protocol must be "NotaryHash"')
-      Certificate.validateShape(Object.assign({}, cert, { version: 2 }))
-        .should.include('unsupported version: 2')
-    })
-
-    it('rejects a hash field of the wrong length or that is not hex', function () {
-      var cert = Certificate.build(PARAMS)
-      Certificate.validateShape(Object.assign({}, cert, { payloadHash: 'ab' }))
-        .should.include('payloadHash must be 32 bytes (64 hex chars)')
-      Certificate.validateShape(Object.assign({}, cert, { proofHash: 'zz'.repeat(32) }))
-        .should.include('proofHash must be a hex string')
-    })
-
-    // Shape is not verification, and a test says so — otherwise it gets used as one.
-    it('says nothing about whether the proofHash is correct', function () {
-      var cert = Certificate.build(PARAMS)
-      var lying = Object.assign({}, cert, { proofHash: '00'.repeat(32) })
-      Certificate.validateShape(lying).should.deep.equal([])
-      Certificate.proofHashMatches(lying).should.equal(false)
-    })
-  })
-
-  describe('canonicalize', function () {
-    it('is RFC 8785 over the certificate', function () {
-      var cert = Certificate.build(PARAMS)
-      Certificate.canonicalize(cert).should.equal(JCS.stringify(cert))
-    })
-
-    it('sorts keys, so transport order does not matter', function () {
-      var cert = Certificate.build(PARAMS)
-      var reordered = {}
-      Object.keys(cert).reverse().forEach(function (k) { reordered[k] = cert[k] })
-      Certificate.canonicalize(reordered).should.equal(Certificate.canonicalize(cert))
-    })
-
-    // proofHash is over the length-prefixed BINARY proof bytes, not over this JSON.
-    // Confusing the two produces a value that looks like a proofHash and is not one.
-    it('is not what proofHash is computed over', function () {
-      var cert = Certificate.build(PARAMS)
-      Hash.sha256(Buffer.from(Certificate.canonicalize(cert), 'utf8')).toString('hex')
-        .should.not.equal(cert.proofHash)
-    })
-  })
-})