@smartledger/bsv 8.3.1 → 9.1.0

package/test/crypto/ecdsa.js

@@ -1,426 +0,0 @@
-'use strict'
-
-var ECDSA = require('../../lib/crypto/ecdsa')
-var Hash = require('../../lib/crypto/hash')
-var Privkey = require('../../lib/privatekey')
-var Pubkey = require('../../lib/publickey')
-var Signature = require('../../lib/crypto/signature')
-var BN = require('../../lib/crypto/bn')
-var point = require('../../lib/crypto/point')
-var should = require('chai').should()
-var vectors = require('../data/ecdsa')
-
-describe('ECDSA', function () {
-  it('instantiation', function () {
-    var ecdsa = new ECDSA()
-    should.exist(ecdsa)
-  })
-
-  var ecdsa = new ECDSA()
-  ecdsa.hashbuf = Hash.sha256(Buffer.from('test data'))
-  ecdsa.privkey = new Privkey(BN.fromBuffer(
-    Buffer.from('fee0a1f7afebf9d2a5a80c0c98a31c709681cce195cbcd06342b517970c0be1e', 'hex')
-  ))
-  ecdsa.privkey2pubkey()
-
-  describe('#set', function () {
-    it('sets hashbuf', function () {
-      should.exist(ECDSA().set({
-        hashbuf: ecdsa.hashbuf
-      }).hashbuf)
-    })
-  })
-
-  describe('#calci', function () {
-    it('calculates i correctly', function () {
-      ecdsa.randomK()
-      ecdsa.sign()
-      ecdsa.calci()
-      should.exist(ecdsa.sig.i)
-    })
-
-    it('calulates this known i', function () {
-      var hashbuf = Hash.sha256(Buffer.from('some data'))
-      var r = new BN('71706645040721865894779025947914615666559616020894583599959600180037551395766', 10)
-      var s = new BN('109412465507152403114191008482955798903072313614214706891149785278625167723646', 10)
-      var ecdsa = new ECDSA({
-        privkey: new Privkey(BN.fromBuffer(Hash.sha256(Buffer.from('test')))),
-        hashbuf: hashbuf,
-        sig: new Signature({
-          r: r,
-          s: s
-        })
-      })
-
-      ecdsa.calci()
-      ecdsa.sig.i.should.equal(1)
-    })
-  })
-
-  describe('#fromString', function () {
-    it('round trip with fromString', function () {
-      var str = ecdsa.toString()
-      var ecdsa2 = ECDSA.fromString(str)
-      should.exist(ecdsa2.hashbuf)
-      should.exist(ecdsa2.privkey)
-    })
-  })
-
-  describe('#randomK', function () {
-    it('should generate a new random k when called twice in a row', function () {
-      ecdsa.randomK()
-      var k1 = ecdsa.k
-      ecdsa.randomK()
-      var k2 = ecdsa.k;
-      (k1.cmp(k2) === 0).should.equal(false)
-    })
-
-    it('should generate a random k that is (almost always) greater than this relatively small number', function () {
-      ecdsa.randomK()
-      var k1 = ecdsa.k
-      var k2 = new BN(Math.pow(2, 32)).mul(new BN(Math.pow(2, 32))).mul(new BN(Math.pow(2, 32)))
-      k2.gt(k1).should.equal(false)
-    })
-  })
-
-  describe('#deterministicK', function () {
-    it('should generate the same deterministic k', function () {
-      ecdsa.deterministicK()
-      ecdsa.k.toBuffer().toString('hex')
-        .should.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
-    })
-    it('should generate the same deterministic k if badrs is set', function () {
-      ecdsa.deterministicK(0)
-      ecdsa.k.toBuffer().toString('hex')
-        .should.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
-      ecdsa.deterministicK(1)
-      ecdsa.k.toBuffer().toString('hex')
-        .should.not.equal('fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e')
-      ecdsa.k.toBuffer().toString('hex')
-        .should.equal('727fbcb59eb48b1d7d46f95a04991fc512eb9dbf9105628e3aec87428df28fd8')
-    })
-    it('should compute this test vector correctly', function () {
-      // test fixture from bitcoinjs
-      // https://github.com/bitcoinjs/bitcoinjs-lib/blob/10630873ebaa42381c5871e20336fbfb46564ac8/test/fixtures/ecdsa.json#L6
-      var ecdsa = new ECDSA()
-      ecdsa.hashbuf = Hash.sha256(Buffer.from('Everything should be made as simple as possible, but not simpler.'))
-      ecdsa.privkey = new Privkey(new BN(1))
-      ecdsa.privkey2pubkey()
-      ecdsa.deterministicK()
-      ecdsa.k.toBuffer().toString('hex')
-        .should.equal('ec633bd56a5774a0940cb97e27a9e4e51dc94af737596a0c5cbb3d30332d92a5')
-      ecdsa.sign()
-      ecdsa.sig.r.toString()
-        .should.equal('23362334225185207751494092901091441011938859014081160902781146257181456271561')
-      ecdsa.sig.s.toString()
-        .should.equal('50433721247292933944369538617440297985091596895097604618403996029256432099938')
-    })
-  })
-
-  describe('nonce reuse', function () {
-    // Signing two different messages under one nonce reveals the private key.
-    var N = point.getN()
-    var h1 = Hash.sha256(Buffer.from('pay alice 1 coin'))
-    var h2 = Hash.sha256(Buffer.from('pay bob 2 coins'))
-
-    var freshSigner = function () {
-      return ECDSA().set({
-        privkey: new Privkey(BN.fromBuffer(Buffer.from(
-          'fee0a1f7afebf9d2a5a80c0c98a31c709681cce195cbcd06342b517970c0be1e', 'hex')))
-      })
-    }
-
-    it('does not reuse k when one instance signs two different messages', function () {
-      var e = freshSigner()
-      var sig1 = e.set({ hashbuf: h1 }).sign().sig
-      var k1 = e.k
-      var sig2 = e.set({ hashbuf: h2 }).sign().sig
-      var k2 = e.k;
-      (k1.cmp(k2) === 0).should.equal(false)
-      sig1.r.eq(sig2.r).should.equal(false)
-    })
-
-    it('does not reuse k across signRandomK calls on one instance', function () {
-      var e = freshSigner()
-      var sig1 = e.set({ hashbuf: h1 }).signRandomK().sig
-      var sig2 = e.set({ hashbuf: h2 }).sign().sig
-      sig1.r.eq(sig2.r).should.equal(false)
-    })
-
-    it('does not leak the private key from two signatures by one instance', function () {
-      var e = freshSigner()
-      var d = e.privkey.bn
-      var sig1 = e.set({ hashbuf: h1 }).sign().sig
-      var sig2 = e.set({ hashbuf: h2 }).sign().sig
-
-      // toLowS may have flipped either s, so try every sign combination.
-      var red = BN.red(N)
-      var inv = function (x) { return x.toRed(red).redInvm().fromRed() }
-      var mul = function (a, b) { return a.toRed(red).redMul(b.toRed(red)).fromRed() }
-      var e1 = BN.fromBuffer(h1)
-      var e2 = BN.fromBuffer(h2)
-      var recovered = false
-      ;[1, -1].forEach(function (f1) {
-        ;[1, -1].forEach(function (f2) {
-          var S1 = f1 === 1 ? sig1.s : N.sub(sig1.s)
-          var S2 = f2 === 1 ? sig2.s : N.sub(sig2.s)
-          var diff = S1.sub(S2).umod(N)
-          if (diff.isZero()) return
-          var k = mul(e1.sub(e2).umod(N), inv(diff))
-          var guess = mul(S1.mul(k).umod(N).sub(e1).umod(N), inv(sig1.r))
-          if (guess.toString(16) === d.toString(16)) recovered = true
-        })
-      })
-      recovered.should.equal(false)
-    })
-
-    it('still honours an explicitly supplied k for a single signature', function () {
-      var k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
-      var a = freshSigner().set({ hashbuf: h1, k: k })
-      var b = freshSigner().set({ hashbuf: h1, k: k })
-      a.sign().sig.r.eq(b.sign().sig.r).should.equal(true)
-      a.k.eq(k).should.equal(true)
-    })
-
-    it('signs the same message deterministically across instances', function () {
-      var a = freshSigner().set({ hashbuf: h1 }).sign().sig
-      var b = freshSigner().set({ hashbuf: h1 }).sign().sig
-      a.r.eq(b.r).should.equal(true)
-      a.s.eq(b.s).should.equal(true)
-    })
-  })
-
-  describe('#toPublicKey', function () {
-    it('should calculate the correct public key', function () {
-      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
-      ecdsa.sign()
-      ecdsa.sig.i = 0
-      var pubkey = ecdsa.toPublicKey()
-      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
-    })
-
-    it('should calculate the correct public key for this signature with low s', function () {
-      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
-      ecdsa.sig = Signature.fromString('3045022100ec3cfe0e335791ad278b4ec8eac93d0347' +
-        'a97877bb1d54d35d189e225c15f6650220278cf15b05ce47fb37d2233802899d94c774d5480bba9f0f2d996baa13370c43')
-      ecdsa.sig.i = 0
-      var pubkey = ecdsa.toPublicKey()
-      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
-    })
-
-    it('should calculate the correct public key for this signature with high s', function () {
-      ecdsa.k = new BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10)
-      ecdsa.sign()
-      ecdsa.sig = Signature.fromString('3046022100ec3cfe0e335791ad278b4ec8eac93d0347' +
-        'a97877bb1d54d35d189e225c15f665022100d8730ea4fa31b804c82ddcc7fd766269f33a079ea38e012c9238f2e2bcff34fe')
-      ecdsa.sig.i = 1
-      var pubkey = ecdsa.toPublicKey()
-      pubkey.point.eq(ecdsa.pubkey.point).should.equal(true)
-    })
-  })
-
-  describe('#sigError', function () {
-    it('should return an error if the hash is invalid', function () {
-      var ecdsa = new ECDSA()
-      ecdsa.sigError().should.equal('hashbuf must be a 32 byte buffer')
-    })
-
-    it('should return an error if r, s are invalid', function () {
-      var ecdsa = new ECDSA()
-      ecdsa.hashbuf = Hash.sha256(Buffer.from('test'))
-      var pk = Pubkey.fromDER(Buffer.from('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49' +
-        '710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341', 'hex'))
-      ecdsa.pubkey = pk
-      ecdsa.sig = new Signature()
-      ecdsa.sig.r = new BN(0)
-      ecdsa.sig.s = new BN(0)
-      ecdsa.sigError().should.equal('r and s not in range')
-    })
-
-    it('should return an error if the signature is incorrect', function () {
-      ecdsa.sig = Signature.fromString('3046022100e9915e6236695f093a4128ac2a956c40' +
-        'ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827')
-      ecdsa.sig.r = ecdsa.sig.r.add(new BN(1))
-      ecdsa.sigError().should.equal('Invalid signature')
-    })
-  })
-
-  describe('#sign', function () {
-    it('should create a valid signature', function () {
-      ecdsa.randomK()
-      ecdsa.sign()
-      ecdsa.verify().should.equal(true)
-    })
-
-    it('should should throw an error if hashbuf is not 32 bytes', function () {
-      var ecdsa2 = ECDSA().set({
-        hashbuf: ecdsa.hashbuf.slice(0, 31),
-        privkey: ecdsa.privkey
-      })
-      ecdsa2.randomK()
-      ecdsa2.sign.bind(ecdsa2).should.throw('hashbuf must be a 32 byte buffer')
-    })
-
-    it('should default to deterministicK', function () {
-      var ecdsa2 = new ECDSA(ecdsa)
-      ecdsa2.k = undefined
-      var called = 0
-      var deterministicK = ecdsa2.deterministicK.bind(ecdsa2)
-      ecdsa2.deterministicK = function () {
-        deterministicK()
-        called++
-      }
-      ecdsa2.sign()
-      called.should.equal(1)
-    })
-
-    it('should generate right K', function () {
-      var msg1 = Buffer.from('52204d20fd0131ae1afd173fd80a3a746d2dcc0cddced8c9dc3d61cc7ab6e966', 'hex')
-      var msg2 = [].reverse.call(Buffer.from(msg1))
-      var pk = Buffer.from('16f243e962c59e71e54189e67e66cf2440a1334514c09c00ddcc21632bac9808', 'hex')
-      var signature1 = ECDSA.sign(msg1, Privkey.fromBuffer(pk)).toBuffer().toString('hex')
-      var signature2 = ECDSA.sign(msg2, Privkey.fromBuffer(pk), 'little').toBuffer().toString('hex')
-      signature1.should.equal(signature2)
-    })
-  })
-
-  describe('#toString', function () {
-    it('should convert this to a string', function () {
-      var str = ecdsa.toString();
-      (typeof str === 'string').should.equal(true)
-    })
-  })
-
-  describe('signing and verification', function () {
-    describe('@sign', function () {
-      it('should produce a signature', function () {
-        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey)
-        ;(sig instanceof Signature).should.equal(true)
-      })
-
-      it('should produce a signaturei', function () {
-        var sig = ECDSA.signWithCalcI(ecdsa.hashbuf, ecdsa.privkey)
-        ;(sig instanceof Signature).should.equal(true)
-        should.exist(sig.i)
-        sig.toCompact().toString('base64').should.equal('IF7ucRrxMczOWYg28NkA+krY4aXx9XgT7KVglwpLEqqyIUtqBrrU5mSDQqOm0ETZ47KdQEMv121aWkxO7P1hbGk=')
-      })
-
-      it('should produce a signature', function () {
-        var sig = ECDSA.signRandomK(ecdsa.hashbuf, ecdsa.privkey)
-        ;(sig instanceof Signature).should.equal(true)
-        var sig2 = ECDSA.signRandomK(ecdsa.hashbuf, ecdsa.privkey)
-        ;(sig2 instanceof Signature).should.equal(true)
-        sig.toString().should.not.equal(sig2.toString())
-      })
-
-      it('should produce a signature, and be different when called twice', function () {
-        ecdsa.signRandomK()
-        should.exist(ecdsa.sig)
-        var ecdsa2 = ECDSA(ecdsa)
-        ecdsa2.signRandomK()
-        ecdsa.sig.toString().should.not.equal(ecdsa2.sig.toString())
-      })
-    })
-
-    describe('#verify', function () {
-      it('should verify a signature that was just signed', function () {
-        ecdsa.sig = Signature.fromString('3046022100e9915e6236695f093a4128ac2a956c' +
-          '40ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827')
-        ecdsa.verify().should.equal(true)
-      })
-      // 7.0: verify() returns a strict boolean, not the (always-truthy) instance.
-      // A forged signature must be REJECTED by `if (ecdsa.verify())`, which was the
-      // whole point of removing the trap.
-      it('returns a strict boolean, not the instance (7.0 trap closed)', function () {
-        ecdsa.signRandomK()
-        var result = ecdsa.verify()
-        result.should.be.a('boolean')
-        result.should.equal(true)
-        // Forge the signature: the return value itself must be falsy.
-        var forged = new ECDSA()
-        forged.hashbuf = ecdsa.hashbuf
-        forged.pubkey = ecdsa.pubkey
-        forged.sig = new Signature(ecdsa.sig.r.add(new BN(1)), ecdsa.sig.s)
-        forged.verify().should.equal(false)
-        ;(!!forged.verify()).should.equal(false) // `if (forged.verify())` does NOT enter
-      })
-      it('verifyBool() remains a strict-boolean alias', function () {
-        ecdsa.signRandomK()
-        ecdsa.verifyBool().should.equal(true)
-        var forged = new ECDSA()
-        forged.hashbuf = ecdsa.hashbuf
-        forged.pubkey = ecdsa.pubkey
-        forged.sig = new Signature(ecdsa.sig.r.add(new BN(1)), ecdsa.sig.s)
-        forged.verifyBool().should.equal(false)
-      })
-      it('should verify this known good signature', function () {
-        ecdsa.signRandomK()
-        ecdsa.verify().should.equal(true)
-      })
-      it('should verify a valid signature, and unverify an invalid signature', function () {
-        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey)
-        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey).should.equal(true)
-        var fakesig = new Signature(sig.r.add(new BN(1)), sig.s)
-        ECDSA.verify(ecdsa.hashbuf, fakesig, ecdsa.pubkey).should.equal(false)
-      })
-      it('should work with big and little endian', function () {
-        var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey, 'big')
-        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'big').should.equal(true)
-        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'little').should.equal(false)
-        sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.privkey, 'little')
-        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'big').should.equal(false)
-        ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.pubkey, 'little').should.equal(true)
-      })
-    })
-
-    describe('vectors', function () {
-      vectors.valid.forEach(function (obj, i) {
-        it('should validate valid vector ' + i, function () {
-          var ecdsa = ECDSA().set({
-            privkey: new Privkey(BN.fromBuffer(Buffer.from(obj.d, 'hex'))),
-            k: BN.fromBuffer(Buffer.from(obj.k, 'hex')),
-            hashbuf: Hash.sha256(Buffer.from(obj.message)),
-            sig: new Signature().set({
-              r: new BN(obj.signature.r),
-              s: new BN(obj.signature.s),
-              i: obj.i
-            })
-          })
-          var ecdsa2 = ECDSA(ecdsa)
-          ecdsa2.k = undefined
-          ecdsa2.sign()
-          ecdsa2.calci()
-          ecdsa2.k.toString().should.equal(ecdsa.k.toString())
-          ecdsa2.sig.toString().should.equal(ecdsa.sig.toString())
-          ecdsa2.sig.i.should.equal(ecdsa.sig.i)
-          ecdsa.verify().should.equal(true)
-        })
-      })
-
-      vectors.invalid.sigError.forEach(function (obj, i) {
-        it('should validate invalid.sigError vector ' + i + ': ' + obj.description, function () {
-          var ecdsa = ECDSA().set({
-            pubkey: Pubkey.fromPoint(point.fromX(true, 1)),
-            sig: new Signature(new BN(obj.signature.r), new BN(obj.signature.s)),
-            hashbuf: Hash.sha256(Buffer.from(obj.message))
-          })
-          ecdsa.sigError().should.equal(obj.exception)
-        })
-      })
-
-      vectors.deterministicK.forEach(function (obj, i) {
-        it('should validate deterministicK vector ' + i, function () {
-          var hashbuf = Hash.sha256(Buffer.from(obj.message))
-          var privkey = Privkey(BN.fromBuffer(Buffer.from(obj.privkey, 'hex')), 'mainnet')
-          var ecdsa = ECDSA({
-            privkey: privkey,
-            hashbuf: hashbuf
-          })
-          ecdsa.deterministicK(0).k.toString('hex').should.equal(obj.k_bad00)
-          ecdsa.deterministicK(1).k.toString('hex').should.equal(obj.k_bad01)
-          ecdsa.deterministicK(15).k.toString('hex').should.equal(obj.k_bad15)
-        })
-      })
-    })
-  })
-})

package/test/crypto/elliptic-fixed.js

@@ -1,61 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
-var ec = require('../../lib/crypto/elliptic-fixed')
-
-describe('elliptic-fixed (hardened secp256k1)', function () {
-  var key = ec.keyFromPrivate(
-    '0101010101010101010101010101010101010101010101010101010101010101', 'hex'
-  )
-  var msg = 'deadbeef'.repeat(8) // 32-byte hash, hex
-
-  it('produces low-S canonical signatures', function () {
-    for (var i = 0; i < 20; i++) {
-      var m = (i.toString(16).padStart(2, '0')).repeat(32)
-      var sig = ec.sign(m, key)
-      var halfN = ec.curve.n.ushrn(1)
-      assert.ok(sig.s.cmp(halfN) <= 0, 's must be <= n/2 (low-S)')
-    }
-  })
-
-  it('keeps recoveryParam consistent so the pubkey recovers correctly', function () {
-    // Regression guard: a manual s-flip without flipping recoveryParam (the
-    // pre-fix behaviour) recovers the WRONG public key whenever s was high —
-    // which is ~50% of signatures. Use buffer messages for both sign and
-    // recover so the encoding is identical on each side.
-    var pub = key.getPublic()
-    for (var i = 1; i <= 40; i++) {
-      var m = Buffer.from(i.toString(16).padStart(2, '0').repeat(32), 'hex')
-      var sig = ec.sign(m, key)
-      assert.notStrictEqual(sig.recoveryParam, null)
-      var recovered = ec.recoverPubKey(m, sig, sig.recoveryParam)
-      assert.ok(recovered.eq(pub), 'recovered pubkey must match signer (iter ' + i + ')')
-    }
-  })
-
-  it('still verifies its own canonical signatures', function () {
-    var sig = ec.sign(msg, key)
-    assert.strictEqual(ec.verify(msg, sig, key), true)
-  })
-
-  it('rejects zero r or s', function () {
-    var sig = ec.sign(msg, key)
-    var BN = sig.r.constructor // bn.js
-    assert.strictEqual(ec.verify(msg, { r: new BN(0), s: sig.s }, key), false)
-    assert.strictEqual(ec.verify(msg, { r: sig.r, s: new BN(0) }, key), false)
-  })
-
-  it('rejects out-of-range r or s (>= n)', function () {
-    var sig = ec.sign(msg, key)
-    assert.strictEqual(ec.verify(msg, { r: ec.curve.n, s: sig.s }, key), false)
-    assert.strictEqual(ec.verify(msg, { r: sig.r, s: ec.curve.n }, key), false)
-  })
-
-  it('returns false (never throws) on malformed signatures', function () {
-    assert.strictEqual(ec.verify(msg, null, key), false)
-    assert.strictEqual(ec.verify(msg, {}, key), false)
-    assert.strictEqual(ec.verify(msg, { r: 'x', s: 'y' }, key), false)
-  })
-})

package/test/crypto/hash.browser.js

@@ -1,121 +0,0 @@
-'use strict'
-
-require('chai').should()
-var Hash = require('../../lib/crypto/hash.browser')
-
-describe('Hash', function () {
-  var buf = Buffer.from([0, 1, 2, 3, 253, 254, 255])
-  var str = 'test string'
-
-  describe('@sha1', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.sha1(buf)
-      hash.toString('hex').should.equal('de69b8a4a5604d0486e6420db81e39eb464a17b2')
-      hash = Hash.sha1(Buffer.alloc(0))
-      hash.toString('hex').should.equal('da39a3ee5e6b4b0d3255bfef95601890afd80709')
-    })
-
-    it('throws an error when the input is not a buffer', function () {
-      Hash.sha1.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#sha256', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.sha256(buf)
-      hash.toString('hex').should.equal('6f2c7b22fd1626998287b3636089087961091de80311b9279c4033ec678a83e8')
-    })
-
-    it('fails when the input is not a buffer', function () {
-      Hash.sha256.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#sha256hmac', function () {
-    it('computes this known big key correctly', function () {
-      var key = Buffer.from('b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
-        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
-        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad' +
-        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad')
-      var data = Buffer.from('')
-      Hash.sha256hmac(data, key).toString('hex')
-        .should.equal('fb1f87218671f1c0c4593a88498e02b6dfe8afd814c1729e89a1f1f6600faa23')
-    })
-
-    it('computes this known empty test vector correctly', function () {
-      var key = Buffer.from('')
-      var data = Buffer.from('')
-      Hash.sha256hmac(data, key).toString('hex')
-        .should.equal('b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad')
-    })
-
-    it('computes this known non-empty test vector correctly', function () {
-      var key = Buffer.from('key')
-      var data = Buffer.from('The quick brown fox jumps over the lazy dog')
-      Hash.sha256hmac(data, key).toString('hex')
-        .should.equal('f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8')
-    })
-  })
-
-  describe('#sha256sha256', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.sha256sha256(buf)
-      hash.toString('hex').should.equal('be586c8b20dee549bdd66018c7a79e2b67bb88b7c7d428fa4c970976d2bec5ba')
-    })
-
-    it('fails when the input is not a buffer', function () {
-      Hash.sha256sha256.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#sha256ripemd160', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.sha256ripemd160(buf)
-      hash.toString('hex').should.equal('7322e2bd8535e476c092934e16a6169ca9b707ec')
-    })
-
-    it('fails when the input is not a buffer', function () {
-      Hash.sha256ripemd160.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#ripemd160', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.ripemd160(buf)
-      hash.toString('hex').should.equal('fa0f4565ff776fee0034c713cbf48b5ec06b7f5c')
-    })
-
-    it('fails when the input is not a buffer', function () {
-      Hash.ripemd160.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#sha512', function () {
-    it('calculates the hash of this buffer correctly', function () {
-      var hash = Hash.sha512(buf)
-      hash.toString('hex')
-        .should.equal('c0530aa32048f4904ae162bc14b9eb535eab6c465e960130005fedd' +
-          'b71613e7d62aea75f7d3333ba06e805fc8e45681454524e3f8050969fe5a5f7f2392e31d0')
-    })
-
-    it('fails when the input is not a buffer', function () {
-      Hash.sha512.bind(Hash, str).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#sha512hmac', function () {
-    it('calculates this known empty test vector correctly', function () {
-      var hex = 'b936cee86c9f87aa5d3c6f2e84cb5a4239a5fe50480a6ec66b70ab5b1f4a' +
-        'c6730c6c515421b327ec1d69402e53dfb49ad7381eb067b338fd7b0cb22247225d47'
-      Hash.sha512hmac(Buffer.from([]), Buffer.from([])).toString('hex').should.equal(hex)
-    })
-
-    it('calculates this known non-empty test vector correctly', function () {
-      var hex = 'c40bd7c15aa493b309c940e08a73ffbd28b2e4cb729eb94480d727e4df577' +
-        'b13cc403a78e6150d83595f3b17c4cc331f12ca5952691de3735a63c1d4c69a2bac'
-      var data = Buffer.from('test1')
-      var key = Buffer.from('test2')
-      Hash.sha512hmac(data, key).toString('hex').should.equal(hex)
-    })
-  })
-})