@opcat-labs/opcat 1.0.0

package/test/crypto/point.js

@@ -0,0 +1,224 @@
+'use strict';
+
+var should = require('chai').should();
+var opcat = require('../..');
+var Point = opcat.crypto.Point;
+var BN = opcat.crypto.BN;
+
+describe('Point', function () {
+  var valid = {
+    x: 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2',
+    y: '4836ab292c105a711ed10fcfd30999c31ff7c02456147747e03e739ad527c380',
+  };
+
+  it('should create a point', function () {
+    var p = Point(valid.x, valid.y);
+    should.exist(p);
+  });
+
+  it('should create a point when called with "new"', function () {
+    var p = new Point(valid.x, valid.y);
+    should.exist(p);
+  });
+
+  describe('#getX', function () {
+    it('should return x', function () {
+      var p = Point(valid.x, valid.y);
+      var x = p.getX();
+      x.toString('hex', 64).should.equal(valid.x);
+    });
+
+    it('should be convertable to a buffer', function () {
+      var p = Point(valid.x, valid.y);
+      var a = p.getX().toBuffer({ size: 32 });
+      a.length.should.equal(32);
+      a.should.deep.equal(Buffer.from(valid.x, 'hex'));
+    });
+  });
+
+  describe('#getY', function () {
+    it('should return y', function () {
+      var p = Point(valid.x, valid.y);
+      p.getY().toString('hex', 64).should.equal(valid.y);
+    });
+
+    it('should be convertable to a buffer', function () {
+      var p = Point(valid.x, valid.y);
+      var a = p.getY().toBuffer({ size: 32 });
+      a.length.should.equal(32);
+      a.should.deep.equal(Buffer.from(valid.y, 'hex'));
+    });
+  });
+
+  describe('#add', function () {
+    it('should accurately add g to itself', function () {
+      var p1 = Point.getG();
+      var p2 = Point.getG();
+      var p3 = p1.add(p2);
+      p3.getX()
+        .toString()
+        .should.equal(
+          '89565891926547004231252920425935692360644145829622209' + '833684329913297188986597',
+        );
+      p3.getY()
+        .toString()
+        .should.equal(
+          '12158399299693830322967808612713398636155367887041628' + '176798871954788371653930',
+        );
+    });
+  });
+
+  describe('#mul', function () {
+    it('should accurately multiply g by 2', function () {
+      var g = Point.getG();
+      var b = g.mul(new BN(2));
+      b.getX()
+        .toString()
+        .should.equal(
+          '8956589192654700423125292042593569236064414582962220983' + '3684329913297188986597',
+        );
+      b.getY()
+        .toString()
+        .should.equal(
+          '1215839929969383032296780861271339863615536788704162817' + '6798871954788371653930',
+        );
+    });
+
+    it('should accurately multiply g by n-1', function () {
+      var g = Point.getG();
+      var n = Point.getN();
+      var b = g.mul(n.sub(new BN(1)));
+      b.getX()
+        .toString()
+        .should.equal(
+          '55066263022277343669578718895168534326250603453777594175' + '500187360389116729240',
+        );
+      b.getY()
+        .toString()
+        .should.equal(
+          '83121579216557378445487899878180864668798711284981320763' + '518679672151497189239',
+        );
+    });
+
+    // not sure if this is technically accurate or not...
+    // normally, you should always multiply g by something less than n
+    // but it is the same result in OpenSSL
+    it('should accurately multiply g by n+1', function () {
+      var g = Point.getG();
+      var n = Point.getN();
+      var b = g.mul(n.add(new BN(1)));
+      b.getX()
+        .toString()
+        .should.equal(
+          '550662630222773436695787188951685343262506034537775941755' + '00187360389116729240',
+        );
+      b.getY()
+        .toString()
+        .should.equal(
+          '326705100207588169780830851305070431844712733806592432759' + '38904335757337482424',
+        );
+    });
+  });
+
+  describe('@fromX', function () {
+    it('should return g', function () {
+      var g = Point.getG();
+      var p = Point.fromX(false, g.getX());
+      g.eq(p).should.equal(true);
+    });
+  });
+
+  describe('@pointToCompressed', function () {
+    it('should return g', function () {
+      let g = Point.getG();
+      let pbuf = Point.pointToCompressed(g);
+      pbuf.length.should.equal(33);
+      pbuf
+        .toString('hex')
+        .should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798');
+    });
+  });
+
+  describe('#toBuffer', function () {
+    it('should return g', function () {
+      let g = Point.getG();
+      let pbuf = g.toBuffer();
+      pbuf.length.should.equal(33);
+      pbuf
+        .toString('hex')
+        .should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798');
+    });
+  });
+
+  describe('@fromBuffer', function () {
+    it('should return g', function () {
+      let buf = Buffer.from(
+        '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+        'hex',
+      );
+      let p = Point.fromBuffer(buf);
+      p.toBuffer().toString('hex').should.equal(buf.toString('hex'));
+    });
+  });
+
+  describe('#toHex', function () {
+    it('should return g', function () {
+      let g = Point.getG();
+      let phex = g.toHex();
+      phex.length.should.equal(33 * 2);
+      phex.should.equal('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798');
+    });
+  });
+
+  describe('@fromHex', function () {
+    it('should return g', function () {
+      let hex = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
+      let p = Point.fromHex(hex);
+      p.toHex().should.equal(hex);
+    });
+  });
+
+  describe('#validate', function () {
+    it('should describe this point as valid', function () {
+      var p = Point(valid.x, valid.y);
+      should.exist(p.validate());
+    });
+
+    it('should describe this point as invalid because of zero y', function () {
+      var x = 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2';
+      var y = '0000000000000000000000000000000000000000000000000000000000000000';
+      (function () {
+        Point(x, y);
+      }).should.throw('Invalid y value for curve.');
+    });
+
+    it('should describe this point as invalid because of invalid y', function () {
+      var x = 'ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2';
+      var y = '00000000000000000000000000000000000000000000000000000000000000FF';
+      (function () {
+        Point(x, y);
+      }).should.throw('Invalid y value for curve.');
+    });
+
+    it('should describe this point as invalid because out of curve bounds', function () {
+      // point larger than max
+      var x = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDCE6AF48A03BBFD25E8CD0364141';
+      // calculated y of x
+      var y = 'ed3970f129bc2ca7c7c6cf92fa7da4de6a1dfc9c14da4bf056aa868d3dd74034';
+
+      (function () {
+        // set the point
+        Point(x, y);
+      }).should.throw('Point does not lie on the curve');
+    });
+
+    it('should describe this point as invalid because out of curve bounds', function () {
+      var x = '0000000000000000000000000000000000000000000000000000000000000000';
+
+      (function () {
+        // set the point
+        Point.fromX(false, x);
+      }).should.throw('Invalid X');
+    });
+  });
+});

package/test/crypto/random.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var opcat = require('../..');
+var Random = opcat.crypto.Random;
+
+describe('Random', function () {
+  describe('@getRandomBuffer', function () {
+    it('should return a buffer', function () {
+      var bytes = Random.getRandomBuffer(8);
+      bytes.length.should.equal(8);
+      Buffer.isBuffer(bytes).should.equal(true);
+    });
+
+    it('should not equate two 256 bit random buffers', function () {
+      var bytes1 = Random.getRandomBuffer(32);
+      var bytes2 = Random.getRandomBuffer(32);
+      bytes1.toString('hex').should.not.equal(bytes2.toString('hex'));
+    });
+
+    it('should generate 100 8 byte buffers in a row that are not equal', function () {
+      var hexs = [];
+      for (var i = 0; i < 100; i++) {
+        hexs[i] = Random.getRandomBuffer(8).toString('hex');
+      }
+      for (i = 0; i < 100; i++) {
+        for (var j = i + 1; j < 100; j++) {
+          hexs[i].should.not.equal(hexs[j]);
+        }
+      }
+    });
+  });
+});

package/test/crypto/signature.js

@@ -0,0 +1,409 @@
+'use strict';
+
+var _ = require('../../lib/util/_');
+var should = require('chai').should();
+var opcat = require('../..');
+var BN = opcat.crypto.BN;
+var Signature = opcat.crypto.Signature;
+var JSUtil = opcat.util.js;
+var Interpreter = opcat.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);
+    });
+  });
+
+  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]);
+      });
+    });
+  });
+});