@smartledger/bsv 8.3.1 → 9.1.0

package/test/crypto/shamir.js

@@ -1,177 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-var assert = require('assert')
-var crypto = require('crypto')
-var Shamir = require('../../lib/crypto/shamir')
-
-describe('Shamir Secret Sharing', function () {
-  describe('split / combine round-trip', function () {
-    it('reconstructs an ASCII secret from exactly threshold shares', function () {
-      var shares = Shamir.split('Hello, Bitcoin SV!', 3, 5)
-      assert.strictEqual(shares.length, 5)
-      var out = Shamir.combine(shares.slice(0, 3))
-      assert.strictEqual(out.toString('utf8'), 'Hello, Bitcoin SV!')
-    })
-
-    it('reconstructs from any threshold-sized subset of shares', function () {
-      var secret = crypto.randomBytes(32)
-      var shares = Shamir.split(secret, 3, 5)
-      // a few different 3-of-5 subsets
-      var subsets = [[0, 1, 2], [2, 3, 4], [0, 2, 4], [1, 3, 4]]
-      subsets.forEach(function (idx) {
-        var pick = idx.map(function (i) { return shares[i] })
-        assert.ok(Shamir.combine(pick).equals(secret), 'subset ' + idx)
-      })
-    })
-
-    it('reconstructs a 32-byte key and more shares than threshold', function () {
-      var key = crypto.randomBytes(32)
-      var shares = Shamir.split(key, 4, 7)
-      assert.ok(Shamir.combine(shares.slice(0, 4)).equals(key))
-      assert.ok(Shamir.combine(shares).equals(key)) // all 7 also works
-    })
-
-    it('preserves leading zero bytes', function () {
-      var secret = Buffer.from('000000deadbeef', 'hex')
-      var shares = Shamir.split(secret, 2, 3)
-      assert.ok(Shamir.combine(shares.slice(0, 2)).equals(secret))
-    })
-
-    it('handles a single zero byte', function () {
-      var shares = Shamir.split(Buffer.from([0]), 2, 2)
-      assert.ok(Shamir.combine(shares).equals(Buffer.from([0])))
-    })
-
-    it('accepts a Buffer secret and returns a Buffer', function () {
-      var secret = Buffer.from('binary\x00\xff data', 'binary')
-      var shares = Shamir.split(secret, 2, 3)
-      var out = Shamir.combine(shares.slice(0, 2))
-      assert.ok(Buffer.isBuffer(out))
-      assert.ok(out.equals(secret))
-    })
-  })
-
-  describe('input validation', function () {
-    it('requires a secret', function () {
-      assert.throws(function () { Shamir.split(null, 2, 3) }, /Secret is required/)
-    })
-    it('requires threshold >= 2', function () {
-      assert.throws(function () { Shamir.split('x', 1, 3) }, /at least 2/)
-    })
-    it('requires shares >= threshold', function () {
-      assert.throws(function () { Shamir.split('x', 3, 2) }, /at least threshold/)
-    })
-    it('caps shares/threshold at 255', function () {
-      assert.throws(function () { Shamir.split('x', 2, 256) }, /<= 255/)
-    })
-    it('requires a non-empty shares array to combine', function () {
-      assert.throws(function () { Shamir.combine([]) }, /required/)
-    })
-    it('rejects fewer than threshold shares', function () {
-      var shares = Shamir.split('secret', 3, 5)
-      assert.throws(function () { Shamir.combine(shares.slice(0, 2)) }, /Insufficient/)
-    })
-  })
-
-  describe('integrity and isolation', function () {
-    it('detects a tampered share at combine time', function () {
-      // checksum is opt-in (off by default to avoid leaking a hash of the secret);
-      // this test exercises the checksum-based detection, so enable it explicitly.
-      var shares = Shamir.split(crypto.randomBytes(16), 3, 5, { checksum: true })
-      // flip a hex nibble in one share's data
-      var s = shares[1]
-      var ch = s.share[s.share.length - 1]
-      shares[1] = Object.assign({}, s, {
-        share: s.share.slice(0, -1) + (ch === '0' ? '1' : '0')
-      })
-      assert.throws(function () { Shamir.combine(shares.slice(0, 3)) },
-        /Integrity check failed|Reconstruction failed/)
-    })
-
-    it('refuses to mix shares from different splits', function () {
-      var secret = crypto.randomBytes(16)
-      var a = Shamir.split(secret, 2, 3)
-      var b = Shamir.split(secret, 2, 3)
-      assert.throws(function () { Shamir.combine([a[0], b[1]]) }, /different splits|splitId/)
-    })
-
-    it('does not embed a secret checksum by default (no leak to sub-threshold holders)', function () {
-      var shares = Shamir.split('low-entropy-pin-1234', 2, 3)
-      assert.strictEqual(shares[0].checksum, null)
-      assert.strictEqual(Shamir.combine(shares.slice(0, 2)).toString('utf8'), 'low-entropy-pin-1234')
-    })
-
-    it('checksum can be disabled', function () {
-      var shares = Shamir.split('no-checksum', 2, 3, { checksum: false })
-      assert.strictEqual(shares[0].checksum, null)
-      assert.strictEqual(Shamir.combine(shares.slice(0, 2)).toString('utf8'), 'no-checksum')
-    })
-
-    it('produces a different splitId for each split', function () {
-      var a = Shamir.split('x', 2, 3)
-      var b = Shamir.split('x', 2, 3)
-      assert.notStrictEqual(a[0].splitId, b[0].splitId)
-    })
-  })
-
-  describe('verifyShare', function () {
-    it('accepts a freshly produced share', function () {
-      var shares = Shamir.split('verify me', 2, 3)
-      assert.strictEqual(Shamir.verifyShare(shares[0]), true)
-    })
-    it('rejects non-objects and malformed shares', function () {
-      assert.strictEqual(Shamir.verifyShare(null), false)
-      assert.strictEqual(Shamir.verifyShare({}), false)
-      assert.strictEqual(Shamir.verifyShare({ v: 2, share: 'nothex!!', threshold: 2, shares: 3, id: 1 }), false)
-    })
-  })
-
-  describe('generateTestVectors', function () {
-    it('round-trips its own vectors', function () {
-      var tv = Shamir.generateTestVectors()
-      assert.strictEqual(tv.valid, true)
-      assert.strictEqual(tv.reconstructed, tv.secret)
-    })
-  })
-
-  describe('legacy (<= 4.x) share recovery', function () {
-    // A real 2-of-3 share set produced by the old 31-bit-prime implementation
-    // for the secret "hi" (0x6869). Kept as a fixed vector so we know old
-    // shares remain recoverable.
-    function legacyShareSetForHi () {
-      // Reconstruct deterministically using the legacy math so the vector
-      // is self-consistent: build points for the polynomial f(x)=secretByte
-      // with known coefficients is non-trivial; instead we exercise the legacy
-      // path by round-tripping through the retained legacy combiner with a
-      // hand-built linear (threshold=2) sharing over the legacy prime.
-      var prime = 2147483647
-      var bytes = [0x68, 0x69] // "hi"
-      // f_b(x) = byte_b + a_b * x  (a_b chosen fixed, nonzero)
-      var a = [12345, 67890]
-      function y (b, x) { return ((bytes[b] + a[b] * x) % prime).toString(16) }
-      function share (id) {
-        return {
-          id: id,
-          threshold: 2,
-          shares: 3,
-          length: 2,
-          bytes: [{ x: id, y: y(0, id) }, { x: id, y: y(1, id) }]
-        }
-      }
-      return [share(1), share(2), share(3)]
-    }
-
-    it('recovers a secret split by the old implementation', function () {
-      var legacy = legacyShareSetForHi()
-      var out = Shamir.combine([legacy[0], legacy[2]])
-      assert.strictEqual(out.toString('utf8'), 'hi')
-    })
-
-    it('verifyShare accepts a legacy share', function () {
-      var legacy = legacyShareSetForHi()
-      assert.strictEqual(Shamir.verifyShare(legacy[0]), true)
-    })
-  })
-})

package/test/crypto/shamir_rngcap.js

@@ -1,29 +0,0 @@
-'use strict'
-
-/* global describe, it, afterEach */
-
-// Regression: the secrets.js RNG callback re-draws on an all-zero draw. A broken
-// or stubbed CSPRNG that returns all-zero bytes forever (e.g. a bundle mocking
-// node crypto to Buffer.alloc) previously made that loop spin forever. The bounded
-// loop now throws a clear error instead of hanging.
-
-var assert = require('assert')
-var Shamir = require('../../lib/crypto/shamir')
-var Random = require('../../lib/crypto/random')
-
-describe('Shamir RNG degenerate-source cap', function () {
-  var orig = Random.getRandomBuffer
-  afterEach(function () { Random.getRandomBuffer = orig })
-
-  it('throws (does not hang) when the CSPRNG is stuck returning all zeros', function () {
-    Random.getRandomBuffer = function (n) { return Buffer.alloc(n, 0) }
-    assert.throws(function () {
-      Shamir.split('secret', 2, 3)
-    }, /all-zero|degenerate/)
-  })
-
-  it('still splits/combines normally with a healthy CSPRNG', function () {
-    var shares = Shamir.split('round-trip', 2, 3)
-    assert.strictEqual(Shamir.combine(shares.slice(0, 2)).toString('utf8'), 'round-trip')
-  })
-})

package/test/crypto/signature.js

@@ -1,399 +0,0 @@
-'use strict'
-
-var _ = require('../../lib/util/_')
-var should = require('chai').should()
-var expect = require('chai').expect
-var bsv = require('../..')
-var BN = bsv.crypto.BN
-var Signature = bsv.crypto.Signature
-var ECDSA = bsv.crypto.ECDSA
-var Hash = bsv.crypto.Hash
-var PrivateKey = bsv.PrivateKey
-var JSUtil = bsv.util.js
-var Interpreter = bsv.Script.Interpreter
-
-var sigCanonical = require('../data/bitcoind/sig_canonical')
-var sigNonCanonical = require('../data/bitcoind/sig_noncanonical')
-
-describe('Signature', function () {
-  it('should make a blank signature', function () {
-    var sig = new Signature()
-    should.exist(sig)
-  })
-
-  it('should work with conveniently setting r, s', function () {
-    var r = new BN()
-    var s = new BN()
-    var sig = new Signature(r, s)
-    should.exist(sig)
-    sig.r.toString().should.equal(r.toString())
-    sig.s.toString().should.equal(s.toString())
-  })
-
-  describe('#set', function () {
-    it('should set compressed', function () {
-      should.exist(Signature().set({
-        compressed: true
-      }))
-    })
-
-    it('should set nhashtype', function () {
-      var sig = Signature().set({
-        nhashtype: Signature.SIGHASH_ALL
-      })
-      sig.nhashtype.should.equal(Signature.SIGHASH_ALL)
-      sig.set({
-        nhashtype: Signature.SIGHASH_ALL | Signature.SIGHASH_ANYONECANPAY
-      })
-      sig.nhashtype.should.equal(Signature.SIGHASH_ALL | Signature.SIGHASH_ANYONECANPAY)
-    })
-  })
-
-  describe('#fromCompact', function () {
-    it('should create a signature from a compressed signature', function () {
-      var blank = Buffer.alloc(32)
-      blank.fill(0)
-      var compressed = Buffer.concat([
-        Buffer.from([0 + 27 + 4]),
-        blank,
-        blank
-      ])
-      var sig = Signature.fromCompact(compressed)
-      sig.r.cmp(BN.Zero).should.equal(0)
-      sig.s.cmp(BN.Zero).should.equal(0)
-      sig.compressed.should.equal(true)
-    })
-
-    it('should create a signature from an uncompressed signature', function () {
-      var sigHexaStr = '1cd5e61ab5bfd0d1450997894cb1a53e917f89d82eb43f06fa96f32c96e061aec12fc1188e8b' +
-        '0dc553a2588be2b5b68dbbd7f092894aa3397786e9c769c5348dc6'
-      var sig = Signature.fromCompact(Buffer.from(sigHexaStr, 'hex'))
-      var r = 'd5e61ab5bfd0d1450997894cb1a53e917f89d82eb43f06fa96f32c96e061aec1'
-      var s = '2fc1188e8b0dc553a2588be2b5b68dbbd7f092894aa3397786e9c769c5348dc6'
-      sig.r.toString('hex').should.equal(r)
-      sig.s.toString('hex').should.equal(s)
-      sig.compressed.should.equal(false)
-    })
-  })
-
-  describe('#fromDER', function () {
-    var buf = Buffer.from('3044022075fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e62770220729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2', 'hex')
-
-    it('should parse this DER format signature', function () {
-      var sig = Signature.fromDER(buf)
-      sig.r.toBuffer({
-        size: 32
-      }).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277')
-      sig.s.toBuffer({
-        size: 32
-      }).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2')
-    })
-  })
-
-  describe('#fromString', function () {
-    var buf = Buffer.from('3044022075fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e62770220729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2', 'hex')
-
-    it('should parse this DER format signature in hex', function () {
-      var sig = Signature.fromString(buf.toString('hex'))
-      sig.r.toBuffer({
-        size: 32
-      }).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277')
-      sig.s.toBuffer({
-        size: 32
-      }).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2')
-    })
-  })
-
-  describe('#toTxFormat', function () {
-    it('should parse this known signature and rebuild it with updated zero-padded sighash types', function () {
-      var original = '30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e7201'
-      var buf = Buffer.from(original, 'hex')
-      var sig = Signature.fromTxFormat(buf)
-      sig.nhashtype.should.equal(Signature.SIGHASH_ALL)
-      sig.set({
-        nhashtype: Signature.SIGHASH_ALL | Signature.SIGHASH_ANYONECANPAY
-      })
-      sig.toTxFormat().toString('hex').should.equal(original.slice(0, -2) + '81')
-      sig.set({
-        nhashtype: Signature.SIGHASH_SINGLE
-      })
-      sig.toTxFormat().toString('hex').should.equal(original.slice(0, -2) + '03')
-    })
-  })
-
-  describe('#fromTxFormat', function () {
-    it('should convert from this known tx-format buffer', function () {
-      var buf = Buffer.from('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e7201', 'hex')
-      var sig = Signature.fromTxFormat(buf)
-      sig.r.toString().should.equal('63173831029936981022572627018246571655303050627048489594159321588908385378810')
-      sig.s.toString().should.equal('4331694221846364448463828256391194279133231453999942381442030409253074198130')
-      sig.nhashtype.should.equal(Signature.SIGHASH_ALL)
-    })
-
-    it('should parse this known signature and rebuild it', function () {
-      var hex = '3044022007415aa37ce7eaa6146001ac8bdefca0ddcba0e37c5dc08c4ac99392124ebac802207d382307fd53f65778b07b9c63b6e196edeadf0be719130c5db21ff1e700d67501'
-      var buf = Buffer.from(hex, 'hex')
-      var sig = Signature.fromTxFormat(buf)
-      sig.toTxFormat().toString('hex').should.equal(hex)
-    })
-  })
-
-  describe('#parseDER', function () {
-    it('should parse this signature generated in node', function () {
-      var sighex = '30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72'
-      var sig = Buffer.from(sighex, 'hex')
-      var parsed = Signature.parseDER(sig)
-      parsed.header.should.equal(0x30)
-      parsed.length.should.equal(69)
-      parsed.rlength.should.equal(33)
-      parsed.rneg.should.equal(true)
-      parsed.rbuf.toString('hex').should.equal('008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa')
-      parsed.r.toString().should.equal('63173831029936981022572627018246571655303050627048489594159321588908385378810')
-      parsed.slength.should.equal(32)
-      parsed.sneg.should.equal(false)
-      parsed.sbuf.toString('hex').should.equal('0993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72')
-      parsed.s.toString().should.equal('4331694221846364448463828256391194279133231453999942381442030409253074198130')
-    })
-
-    it('should parse this 69 byte signature', function () {
-      var sighex = '3043021f59e4705959cc78acbfcf8bd0114e9cc1b389a4287fb33152b73a38c319b50302202f7428a27284c757e409bf41506183e9e49dfb54d5063796dfa0d403a4deccfa'
-      var sig = Buffer.from(sighex, 'hex')
-      var parsed = Signature.parseDER(sig)
-      parsed.header.should.equal(0x30)
-      parsed.length.should.equal(67)
-      parsed.rlength.should.equal(31)
-      parsed.rneg.should.equal(false)
-      parsed.rbuf.toString('hex').should.equal('59e4705959cc78acbfcf8bd0114e9cc1b389a4287fb33152b73a38c319b503')
-      parsed.r.toString().should.equal('158826015856106182499128681792325160381907915189052224498209222621383996675')
-      parsed.slength.should.equal(32)
-      parsed.sneg.should.equal(false)
-      parsed.sbuf.toString('hex').should.equal('2f7428a27284c757e409bf41506183e9e49dfb54d5063796dfa0d403a4deccfa')
-      parsed.s.toString().should.equal('21463938592353267769710297084836796652964571266930856168996063301532842380538')
-    })
-
-    it('should parse this 68 byte signature', function () {
-      var sighex = '3042021e17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632022061bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a51'
-      var sig = Buffer.from(sighex, 'hex')
-      var parsed = Signature.parseDER(sig)
-      parsed.header.should.equal(0x30)
-      parsed.length.should.equal(66)
-      parsed.rlength.should.equal(30)
-      parsed.rneg.should.equal(false)
-      parsed.rbuf.toString('hex').should.equal('17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632')
-      parsed.r.toString().should.equal('164345250294671732127776123343329699648286106708464198588053542748255794')
-      parsed.slength.should.equal(32)
-      parsed.sneg.should.equal(false)
-      parsed.sbuf.toString('hex').should.equal('61bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a51')
-      parsed.s.toString().should.equal('44212963026209759051804639008236126356702363229859210154760104982946304432721')
-    })
-
-    it('should parse this signature from script_valid.json', function () {
-      var sighex = '304502203e4516da7253cf068effec6b95c41221c0cf3a8e6ccb8cbf1725b562e9afde2c022100ab1e3da73d67e32045a20e0b999e049978ea8d6ee5480d485fcf2ce0d03b2ef051'
-      var sig = Buffer.from(sighex, 'hex')
-      var parsed = Signature.parseDER(sig, false)
-      should.exist(parsed)
-    })
-
-    it('reports sneg for a padded s', function () {
-      // 02 21 00ab.. — s carries the pad that clears its high bit.
-      var sighex = '304502203e4516da7253cf068effec6b95c41221c0cf3a8e6ccb8cbf1725b562e9afde2c' +
-        '022100ab1e3da73d67e32045a20e0b999e049978ea8d6ee5480d485fcf2ce0d03b2ef0'
-      var parsed = Signature.parseDER(Buffer.from(sighex, 'hex'))
-      parsed.sbuf[0].should.equal(0x00)
-      parsed.sneg.should.equal(true)
-      parsed.rneg.should.equal(false)
-    })
-  })
-
-  describe('#parseDER canonicality', function () {
-    // A non-canonical INTEGER is a second encoding of the same number, i.e. a
-    // malleable signature. Strict (the default, used by fromDER/fromString and
-    // so by credential/proof verification) rejects them; non-strict must keep
-    // accepting them, because signatures already on chain are not canonical and
-    // fromTxFormat has to parse them.
-    var cases = [
-      { name: 'r negative (high bit set, unpadded)', hex: '3006' + '0201ff' + '020101', err: /Value of r is negative/ },
-      { name: 's negative (high bit set, unpadded)', hex: '3006' + '020101' + '0201ff', err: /Value of s is negative/ },
-      { name: 'r excessively padded', hex: '3007' + '02020011' + '020101', err: /Value of r is excessively padded/ },
-      { name: 's excessively padded', hex: '3007' + '020101' + '02020011', err: /Value of s is excessively padded/ },
-      { name: 'r zero-length', hex: '3005' + '0200' + '020101', err: /Length of r is zero/ },
-      { name: 's zero-length', hex: '3005' + '020101' + '0200', err: /Length of s is zero/ }
-    ]
-
-    cases.forEach(function (c) {
-      it('strict rejects ' + c.name, function () {
-        expect(function () {
-          Signature.parseDER(Buffer.from(c.hex, 'hex'))
-        }).to.throw(c.err)
-      })
-
-      it('non-strict still accepts ' + c.name + ' (chain compatibility)', function () {
-        should.exist(Signature.parseDER(Buffer.from(c.hex, 'hex'), false))
-      })
-    })
-
-    it('strict accepts a minimally padded integer', function () {
-      // 0x00ff is canonical: the pad is required to clear the high bit.
-      should.exist(Signature.parseDER(Buffer.from('3008020200ff020200ff', 'hex')))
-    })
-
-    it('strict accepts a canonical zero integer', function () {
-      should.exist(Signature.parseDER(Buffer.from('3006020100020100', 'hex')))
-    })
-
-    it('rejects a malleated re-encoding while the original still verifies', function () {
-      var privkey = new PrivateKey()
-      var hashbuf = Hash.sha256(Buffer.from('der canonicality'))
-      var sig = ECDSA.sign(hashbuf, privkey)
-      var der = sig.toDER()
-
-      ECDSA.verify(hashbuf, Signature.fromDER(der), privkey.toPublicKey()).should.equal(true)
-
-      // Re-encode r with one pad byte more than DER allows: same r, different
-      // bytes. The extra zero goes on top of the canonical encoding, so this is
-      // excess padding whether or not r needed a pad to begin with.
-      var canonical = function (nbuf) {
-        return (nbuf[0] & 0x80) ? Buffer.concat([Buffer.from([0x00]), nbuf]) : nbuf
-      }
-      var padded = Buffer.concat([Buffer.from([0x00]), canonical(sig.r.toBuffer())])
-      var sEnc = canonical(sig.s.toBuffer())
-      var body = Buffer.concat([
-        Buffer.from([0x02, padded.length]), padded,
-        Buffer.from([0x02, sEnc.length]), sEnc
-      ])
-      var malleated = Buffer.concat([Buffer.from([0x30, body.length]), body])
-
-      malleated.toString('hex').should.not.equal(der.toString('hex'))
-      expect(function () {
-        Signature.fromDER(malleated)
-      }).to.throw(/excessively padded/)
-      // The same bytes remain parseable on the non-strict (chain) path.
-      Signature.parseDER(malleated, false).r.eq(sig.r).should.equal(true)
-    })
-  })
-
-  describe('#toDER', function () {
-    it('should convert these known r and s values into a known signature', function () {
-      var r = new BN('63173831029936981022572627018246571655303050627048489594159321588908385378810')
-      var s = new BN('4331694221846364448463828256391194279133231453999942381442030409253074198130')
-      var sig = new Signature({
-        r: r,
-        s: s
-      })
-      var der = sig.toDER(r, s)
-      der.toString('hex').should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72')
-    })
-  })
-
-  describe('#toString', function () {
-    it('should convert this signature in to hex DER', function () {
-      var r = new BN('63173831029936981022572627018246571655303050627048489594159321588908385378810')
-      var s = new BN('4331694221846364448463828256391194279133231453999942381442030409253074198130')
-      var sig = new Signature({
-        r: r,
-        s: s
-      })
-      var hex = sig.toString()
-      hex.should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72')
-    })
-  })
-
-  describe('@isTxDER', function () {
-    it('should know this is a DER signature', function () {
-      var sighex = '3042021e17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632022061bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a5101'
-      var sigbuf = Buffer.from(sighex, 'hex')
-      Signature.isTxDER(sigbuf).should.equal(true)
-    })
-
-    it('should know this is not a DER signature', function () {
-      // for more extensive tests, see the script interpreter
-      var sighex = '3042021e17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632022061bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a5101'
-      var sigbuf = Buffer.from(sighex, 'hex')
-      sigbuf[0] = 0x31
-      Signature.isTxDER(sigbuf).should.equal(false)
-    })
-
-    describe('bitcoind fixtures', function () {
-      var testSigs = function (set, expected) {
-        var i = 0
-        set.forEach(function (vector) {
-          if (!JSUtil.isHexa(vector)) {
-            // non-hex strings are ignored
-            return
-          }
-          it('should be ' + (expected ? '' : 'in') + 'valid for fixture #' + i, function () {
-            var sighex = vector
-            var interp = Interpreter()
-            interp.flags = Interpreter.SCRIPT_VERIFY_DERSIG |
-              Interpreter.SCRIPT_VERIFY_STRICTENC
-            var result = interp.checkSignatureEncoding(Buffer.from(sighex, 'hex'))
-            result.should.equal(expected)
-          })
-          i++
-        })
-      }
-      testSigs(sigCanonical, true)
-      testSigs(sigNonCanonical, false)
-    })
-  })
-  describe('#hasLowS', function () {
-    it('should detect high and low S', function () {
-      var r = new BN('63173831029936981022572627018246571655303050627048489594159321588908385378810')
-
-      var sig = new Signature({
-        r: r,
-        s: new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A1', 'hex')
-      })
-      sig.hasLowS().should.equal(false)
-
-      var sig2 = new Signature({
-        r: r,
-        s: new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex')
-      })
-      sig2.hasLowS().should.equal(true)
-
-      var sig3 = new Signature({
-        r: r,
-        s: new BN(1)
-      })
-      sig3.hasLowS().should.equal(true)
-
-      var sig4 = new Signature({
-        r: r,
-        s: new BN(0)
-      })
-      sig4.hasLowS().should.equal(false)
-    })
-  })
-
-  describe('#hasDefinedHashtype', function () {
-    it('should reject invalid sighash types and accept valid ones', function () {
-      var sig = new Signature()
-      sig.hasDefinedHashtype().should.equal(false)
-      var testCases = [
-        [undefined, false],
-        [null, false],
-        [0, false],
-        [1.1, false],
-        [-1, false],
-        [-1.1, false],
-        ['', false],
-        ['1', false],
-        [Signature.SIGHASH_ANYONECANPAY, false],
-        [Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_ALL, true],
-        [Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_NONE, true],
-        [Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_SINGLE, true],
-        [Signature.SIGHASH_ALL, true],
-        [Signature.SIGHASH_NONE, true],
-        [Signature.SIGHASH_SINGLE, true],
-        [Signature.SIGHASH_SINGLE + 1, false],
-        [(Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_SINGLE) + 1, false],
-        [(Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_ALL) - 1, false]
-      ]
-      _.each(testCases, function (testCase) {
-        sig.nhashtype = testCase[0]
-        sig.hasDefinedHashtype().should.equal(testCase[1])
-      })
-    })
-  })
-})