@opcat-labs/opcat 1.0.0

package/test/hdprivatekey.js

@@ -0,0 +1,332 @@
+'use strict';
+
+var _ = require('../lib/util/_');
+var assert = require('assert');
+var should = require('chai').should();
+var expect = require('chai').expect;
+var opcat = require('..');
+var errors = opcat.errors;
+var hdErrors = errors.HDPrivateKey;
+var buffer = require('buffer');
+var Networks = opcat.Networks;
+var JSUtil = require('../lib/util/js');
+var HDPrivateKey = opcat.HDPrivateKey;
+var Base58Check = opcat.encoding.Base58Check;
+
+var xprivkey =
+  'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+var json =
+  '{"network":"livenet","depth":0,"fingerPrint":876747070,"parentFingerPrint":0,"childIndex":0,"chainCode":"873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508","privateKey":"e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35","checksum":3883834737,"xprivkey":"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"}';
+describe('HDPrivate key interface', function () {
+  var expectFail = function (func, error) {
+    var got = null;
+    try {
+      func();
+    } catch (e) {
+      got = e instanceof error;
+    }
+    expect(got).to.equal(true);
+  };
+
+  var expectDerivationFail = function (argument, error) {
+    return expectFail(function () {
+      var privateKey = new HDPrivateKey(xprivkey);
+      privateKey.deriveChild(argument);
+    }, error);
+  };
+
+  var expectFailBuilding = function (argument, error) {
+    return expectFail(function () {
+      return new HDPrivateKey(argument);
+    }, error);
+  };
+
+  var expectSeedFail = function (argument, error) {
+    return expectFail(function () {
+      return HDPrivateKey.fromSeed(argument);
+    }, error);
+  };
+
+  it('should make a new private key from random', function () {
+    should.exist(new HDPrivateKey().xprivkey);
+  });
+
+  it('should make a new private key from random for testnet', function () {
+    var key = new HDPrivateKey('testnet');
+    should.exist(key.xprivkey);
+    key.network.name.should.equal('testnet');
+  });
+
+  it('should not be able to change read-only properties', function () {
+    var hdkey = new HDPrivateKey();
+    expect(function () {
+      hdkey.fingerPrint = 'notafingerprint';
+    }).to.throw(TypeError);
+  });
+
+  it('should error with an invalid checksum', function () {
+    expectFailBuilding(xprivkey + '1', errors.InvalidB58Checksum);
+  });
+
+  it('can be rebuilt from a json generated by itself', function () {
+    var regenerate = new HDPrivateKey(json);
+    regenerate.xprivkey.should.equal(xprivkey);
+  });
+
+  it('builds a json keeping the structure and same members', function () {
+    assert.deepStrictEqual(new HDPrivateKey(json).toJSON(), new HDPrivateKey(xprivkey).toJSON());
+  });
+
+  describe('instantiation', function () {
+    it('invalid argument: can not instantiate from a number', function () {
+      expectFailBuilding(1, hdErrors.UnrecognizedArgument);
+    });
+    it('allows no-new calling', function () {
+      HDPrivateKey(xprivkey).toString().should.equal(xprivkey);
+    });
+    it('allows the use of a copy constructor', function () {
+      HDPrivateKey(HDPrivateKey(xprivkey)).xprivkey.should.equal(xprivkey);
+    });
+  });
+
+  describe('public key', function () {
+    var testnetKey = new HDPrivateKey(
+      'tprv8ZgxMBicQKsPdEeU2KiGFnUgRGriMnQxrwrg6FWCBg4jeiidHRyCCdA357kfkZiGaXEapWZsGDKikeeEbvgXo3UmEdbEKNdQH9VXESmGuUK',
+    );
+    var livenetKey = new HDPrivateKey(
+      'xprv9s21ZrQH143K3e39bnn1vyS7YFa1EAJAFGDoeHaSBsgBxgAkTEXeSx7xLvhNQNJxJwhzziWcK3znUFKRPRwWBPkKZ8ijUBa5YYpYPQmeBDX',
+    );
+
+    it('matches the network', function () {
+      testnetKey.publicKey.network.should.equal(Networks.testnet);
+      livenetKey.publicKey.network.should.equal(Networks.livenet);
+    });
+
+    it('cache for xpubkey works', function () {
+      var privateKey = new HDPrivateKey(xprivkey);
+      should.not.exist(privateKey._hdPublicKey);
+      privateKey.xpubkey.should.equal(privateKey.xpubkey);
+      should.exist(privateKey._hdPublicKey);
+    });
+  });
+
+  it('inspect() displays correctly', function () {
+    HDPrivateKey(xprivkey)
+      .inspect()
+      .should.equal('<HDPrivateKey: ' + xprivkey + '>');
+  });
+  it('fails when trying to derive with an invalid argument', function () {
+    expectDerivationFail([], hdErrors.InvalidDerivationArgument);
+  });
+
+  it('catches early invalid paths', function () {
+    expectDerivationFail('s', hdErrors.InvalidPath);
+  });
+
+  it('allows derivation of hardened keys by passing a very big number', function () {
+    var privateKey = new HDPrivateKey(xprivkey);
+    var derivedByNumber = privateKey.deriveChild(0x80000000);
+    var derivedByArgument = privateKey.deriveChild(0, true);
+    derivedByNumber.xprivkey.should.equal(derivedByArgument.xprivkey);
+  });
+
+  it("returns itself with 'm' parameter", function () {
+    var privateKey = new HDPrivateKey(xprivkey);
+    privateKey.should.equal(privateKey.deriveChild('m'));
+  });
+
+  it('returns InvalidArgument if invalid data is given to getSerializedError', function () {
+    expect(HDPrivateKey.getSerializedError(1) instanceof hdErrors.UnrecognizedArgument).to.equal(
+      true,
+    );
+  });
+
+  it('returns InvalidLength if data of invalid length is given to getSerializedError', function () {
+    var b58s = Base58Check.encode(buffer.Buffer.from('onestring'));
+    expect(HDPrivateKey.getSerializedError(b58s) instanceof hdErrors.InvalidLength).to.equal(true);
+  });
+
+  it('returns InvalidNetworkArgument if an invalid network is provided', function () {
+    expect(
+      HDPrivateKey.getSerializedError(xprivkey, 'invalidNetwork') instanceof
+        errors.InvalidNetworkArgument,
+    ).to.equal(true);
+  });
+
+  it('recognizes that the wrong network was asked for', function () {
+    expect(
+      HDPrivateKey.getSerializedError(xprivkey, 'testnet') instanceof errors.InvalidNetwork,
+    ).to.equal(true);
+  });
+
+  it('recognizes the correct network', function () {
+    expect(HDPrivateKey.getSerializedError(xprivkey, 'livenet')).to.equal(null);
+  });
+
+  describe('on creation from seed', function () {
+    it('converts correctly from an hexa string', function () {
+      should.exist(HDPrivateKey.fromSeed('01234567890abcdef01234567890abcdef').xprivkey);
+    });
+    it('fails when argument is not a buffer or string', function () {
+      expectSeedFail(1, hdErrors.InvalidEntropyArgument);
+    });
+    it("fails when argument doesn't provide enough entropy", function () {
+      expectSeedFail('01', hdErrors.InvalidEntropyArgument.NotEnoughEntropy);
+    });
+    it('fails when argument provides too much entropy', function () {
+      var entropy = '0';
+      for (var i = 0; i < 129; i++) {
+        entropy += '1';
+      }
+      expectSeedFail(entropy, hdErrors.InvalidEntropyArgument.TooMuchEntropy);
+    });
+  });
+
+  it('correctly errors if an invalid checksum is provided', function () {
+    var privKey = new HDPrivateKey(xprivkey);
+    var error = null;
+    try {
+      var buffers = privKey._buffers;
+      buffers.checksum = JSUtil.integerAsBuffer(0);
+      new HDPrivateKey(buffers);
+    } catch (e) {
+      error = e;
+    }
+    expect(error instanceof errors.InvalidB58Checksum).to.equal(true);
+  });
+  it('correctly validates the checksum', function () {
+    var privKey = new HDPrivateKey(xprivkey);
+    expect(function () {
+      var buffers = privKey._buffers;
+      return new HDPrivateKey(buffers);
+    }).to.not.throw();
+  });
+
+  it("shouldn't matter if derivations are made with strings or numbers", function () {
+    var privateKey = new HDPrivateKey(xprivkey);
+    var derivedByString = privateKey.deriveChild("m/0'/1/2'");
+    var derivedByNumber = privateKey.deriveChild(0, true).deriveChild(1).deriveChild(2, true);
+    derivedByNumber.xprivkey.should.equal(derivedByString.xprivkey);
+  });
+
+  describe('validates paths', function () {
+    it('validates correct paths', function () {
+      var valid;
+
+      valid = HDPrivateKey.isValidPath("m/0'/1/2'");
+      valid.should.equal(true);
+
+      valid = HDPrivateKey.isValidPath('m');
+      valid.should.equal(true);
+
+      valid = HDPrivateKey.isValidPath(123, true);
+      valid.should.equal(true);
+
+      valid = HDPrivateKey.isValidPath(123);
+      valid.should.equal(true);
+
+      valid = HDPrivateKey.isValidPath(HDPrivateKey.Hardened + 123);
+      valid.should.equal(true);
+
+      valid = HDPrivateKey.isValidPath(HDPrivateKey.Hardened + 123, true);
+      valid.should.equal(true);
+    });
+
+    var invalid = ['m/-1/12', 'bad path', 'K', 'm/', 'm/12asd', 'm/1/2//3'];
+
+    invalid.forEach(function (datum) {
+      it('rejects illegal path ' + datum, function () {
+        HDPrivateKey.isValidPath(datum).should.equal(false);
+        expect(HDPrivateKey._getDerivationIndexes(datum)).to.equal(null);
+      });
+    });
+
+    it('generates deriving indexes correctly', function () {
+      var indexes;
+
+      indexes = HDPrivateKey._getDerivationIndexes('m/-1/12');
+      expect(indexes).to.equal(null);
+
+      indexes = HDPrivateKey._getDerivationIndexes("m/0/12/12'");
+      indexes.should.eql([0, 12, HDPrivateKey.Hardened + 12]);
+
+      indexes = HDPrivateKey._getDerivationIndexes("m/0/12/12'");
+      indexes.should.eql([0, 12, HDPrivateKey.Hardened + 12]);
+    });
+  });
+
+  describe('conversion to/from buffer', function () {
+    var str =
+      'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+    it('should roundtrip to/from a buffer', function () {
+      var priv = new HDPrivateKey(str);
+      var toBuffer = priv.toBuffer();
+      var fromBuffer = HDPrivateKey.fromBuffer(toBuffer);
+      var roundTrip = new HDPrivateKey(fromBuffer.toString());
+      roundTrip.xprivkey.should.equal(str);
+    });
+  });
+
+  describe('conversion to/from hex', function () {
+    var str =
+      'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+    it('should roundtrip to/from a buffer', function () {
+      var priv = new HDPrivateKey(str);
+      var toBuffer = priv.toBuffer();
+      var fromBuffer = HDPrivateKey.fromBuffer(toBuffer);
+      var roundTrip = new HDPrivateKey(fromBuffer.toString());
+      roundTrip.xprivkey.should.equal(str);
+    });
+  });
+
+  describe('from random', function () {
+    var str =
+      'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+    it('should roundtrip to/from a buffer', function () {
+      var xprv1 = new HDPrivateKey(str);
+      var xprv2 = HDPrivateKey.fromRandom();
+      var xprv3 = HDPrivateKey.fromRandom();
+      xprv1.toString().should.not.equal(xprv2.toString());
+      xprv2.toString().should.not.equal(xprv3.toString());
+      xprv1.toString().should.not.equal(xprv3.toString());
+    });
+  });
+
+  describe('conversion to plain object/json', function () {
+    var plainObject = {
+      network: 'livenet',
+      depth: 0,
+      fingerPrint: 876747070,
+      parentFingerPrint: 0,
+      childIndex: 0,
+      chainCode: '873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508',
+      privateKey: 'e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35',
+      checksum: 3883834737,
+      xprivkey:
+        'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvN' +
+        'KmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi',
+    };
+    it('toObject leaves no Buffer instances', function () {
+      var privKey = new HDPrivateKey(xprivkey);
+      var object = privKey.toObject();
+      _.each(_.values(object), function (value) {
+        expect(Buffer.isBuffer(value)).to.equal(false);
+      });
+    });
+    it('roundtrips toObject', function () {
+      expect(HDPrivateKey.fromObject(new HDPrivateKey(xprivkey).toObject()).xprivkey).to.equal(
+        xprivkey,
+      );
+    });
+    it('roundtrips to JSON and to Object', function () {
+      var privkey = new HDPrivateKey(xprivkey);
+      expect(HDPrivateKey.fromObject(privkey.toJSON()).xprivkey).to.equal(xprivkey);
+    });
+    it('recovers state from JSON', function () {
+      new HDPrivateKey(JSON.stringify(plainObject)).xprivkey.should.equal(xprivkey);
+    });
+    it('recovers state from Object', function () {
+      new HDPrivateKey(plainObject).xprivkey.should.equal(xprivkey);
+    });
+  });
+});

package/test/hdpublickey.js

@@ -0,0 +1,304 @@
+'use strict';
+
+var assert = require('assert');
+require('chai').should();
+var expect = require('chai').expect;
+var opcat = require('..');
+var buffer = require('buffer');
+var errors = opcat.errors;
+var hdErrors = opcat.errors.HDPublicKey;
+var JSUtil = require('../lib/util/js');
+var HDPrivateKey = opcat.HDPrivateKey;
+var HDPublicKey = opcat.HDPublicKey;
+var Base58Check = opcat.encoding.Base58Check;
+var Networks = opcat.Networks;
+
+var xprivkey =
+  'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+var xpubkey =
+  'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+var xpubkeyTestnet =
+  'tpubD6NzVbkrYhZ4WZaiWHz59q5EQ61bd6dUYfU4ggRWAtNAyyYRNWT6ktJ7UHJEXURvTfTfskFQmK7Ff4FRkiRN5wQH8nkGAb6aKB4Yyeqsw5m';
+var json =
+  '{"network":"livenet","depth":0,"fingerPrint":876747070,"parentFingerPrint":0,"childIndex":0,"chainCode":"873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508","publicKey":"0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2","checksum":2873572129,"xpubkey":"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8"}';
+var derived01200000 =
+  'xpub6BqyndF6rkBNTV6LXwiY8Pco8aqctqq7tGEUdA8fmGDTnDJphn2fmxr3eM8Lm3m8TrNUsLbEjHvpa3adBU18YpEx4tp2Zp6nqax3mQkudhX';
+
+describe('HDPublicKey interface', function () {
+  var expectFail = function (func, errorType) {
+    (function () {
+      func();
+    }).should.throw(errorType);
+  };
+
+  var expectDerivationFail = function (argument, error) {
+    (function () {
+      var pubkey = new HDPublicKey(xpubkey);
+      pubkey.deriveChild(argument);
+    }).should.throw(error);
+  };
+
+  var expectFailBuilding = function (argument, error) {
+    (function () {
+      return new HDPublicKey(argument);
+    }).should.throw(error);
+  };
+
+  describe('creation formats', function () {
+    it('returns same argument if already an instance of HDPublicKey', function () {
+      var publicKey = new HDPublicKey(xpubkey);
+      publicKey.should.equal(new HDPublicKey(publicKey));
+    });
+
+    it('returns the correct xpubkey for a xprivkey', function () {
+      var publicKey = new HDPublicKey(xprivkey);
+      publicKey.xpubkey.should.equal(xpubkey);
+    });
+
+    it('allows to call the argument with no "new" keyword', function () {
+      HDPublicKey(xpubkey).xpubkey.should.equal(new HDPublicKey(xpubkey).xpubkey);
+    });
+
+    it("fails when user doesn't supply an argument", function () {
+      expectFailBuilding(null, hdErrors.MustSupplyArgument);
+    });
+
+    it('should not be able to change read-only properties', function () {
+      var publicKey = new HDPublicKey(xprivkey);
+      expect(function () {
+        publicKey.fingerPrint = 'notafingerprint';
+      }).to.throw(TypeError);
+    });
+
+    it("doesn't recognize an invalid argument", function () {
+      expectFailBuilding(1, hdErrors.UnrecognizedArgument);
+      expectFailBuilding(true, hdErrors.UnrecognizedArgument);
+    });
+
+    describe('xpubkey string serialization errors', function () {
+      it('fails on invalid length', function () {
+        expectFailBuilding(
+          Base58Check.encode(buffer.Buffer.from([1, 2, 3])),
+          hdErrors.InvalidLength,
+        );
+      });
+      it('fails on invalid base58 encoding', function () {
+        expectFailBuilding(xpubkey + '1', errors.InvalidB58Checksum);
+      });
+      it('user can ask if a string is valid', function () {
+        HDPublicKey.isValidSerialized(xpubkey).should.equal(true);
+      });
+    });
+
+    it('can be generated from a json', function () {
+      expect(new HDPublicKey(JSON.parse(json)).xpubkey).to.equal(xpubkey);
+    });
+
+    it('can generate a json that has a particular structure', function () {
+      assert.deepStrictEqual(
+        new HDPublicKey(JSON.parse(json)).toJSON(),
+        new HDPublicKey(xpubkey).toJSON(),
+      );
+    });
+
+    it('builds from a buffer object', function () {
+      new HDPublicKey(new HDPublicKey(xpubkey)._buffers).xpubkey.should.equal(xpubkey);
+    });
+
+    it('checks the checksum', function () {
+      var buffers = new HDPublicKey(xpubkey)._buffers;
+      buffers.checksum = JSUtil.integerAsBuffer(1);
+      expectFail(function () {
+        return new HDPublicKey(buffers);
+      }, errors.InvalidB58Checksum);
+    });
+  });
+
+  describe('error checking on serialization', function () {
+    var compareType = function (a, b) {
+      expect(a instanceof b).to.equal(true);
+    };
+    it('throws invalid argument when argument is not a string or buffer', function () {
+      compareType(HDPublicKey.getSerializedError(1), hdErrors.UnrecognizedArgument);
+    });
+    it('if a network is provided, validates that data corresponds to it', function () {
+      compareType(HDPublicKey.getSerializedError(xpubkey, 'testnet'), errors.InvalidNetwork);
+    });
+    it('recognizes invalid network arguments', function () {
+      compareType(
+        HDPublicKey.getSerializedError(xpubkey, 'invalid'),
+        errors.InvalidNetworkArgument,
+      );
+    });
+    it('recognizes a valid network', function () {
+      expect(HDPublicKey.getSerializedError(xpubkey, 'livenet')).to.equal(null);
+    });
+  });
+
+  it('toString() returns the same value as .xpubkey', function () {
+    var pubKey = new HDPublicKey(xpubkey);
+    pubKey.toString().should.equal(pubKey.xpubkey);
+  });
+
+  it('publicKey property matches network', function () {
+    var livenet = new HDPublicKey(xpubkey);
+    var testnet = new HDPublicKey(xpubkeyTestnet);
+
+    livenet.publicKey.network.should.equal(Networks.livenet);
+    testnet.publicKey.network.should.equal(Networks.testnet);
+  });
+
+  it('inspect() displays correctly', function () {
+    var pubKey = new HDPublicKey(xpubkey);
+    pubKey.inspect().should.equal('<HDPublicKey: ' + pubKey.xpubkey + '>');
+  });
+
+  describe('conversion to/from buffer', function () {
+    it('should roundtrip to an equivalent object', function () {
+      var pubKey = new HDPublicKey(xpubkey);
+      var toBuffer = pubKey.toBuffer();
+      var fromBuffer = HDPublicKey.fromBuffer(toBuffer);
+      var roundTrip = new HDPublicKey(fromBuffer.toBuffer());
+      roundTrip.xpubkey.should.equal(xpubkey);
+    });
+  });
+
+  describe('conversion to/from hex', function () {
+    it('should roundtrip to an equivalent object', function () {
+      var pubKey = new HDPublicKey(xpubkey);
+      var toHex = pubKey.toHex();
+      var fromHex = HDPublicKey.fromHex(toHex);
+      var roundTrip = new HDPublicKey(fromHex.toBuffer());
+      roundTrip.xpubkey.should.equal(xpubkey);
+    });
+  });
+
+  describe('from hdprivatekey', function () {
+    var str =
+      'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
+    it('should roundtrip to/from a buffer', function () {
+      var xprv1 = new HDPrivateKey(str);
+      var xprv2 = HDPrivateKey.fromRandom();
+      var xprv3 = HDPrivateKey.fromRandom();
+      var xpub1 = HDPublicKey.fromHDPrivateKey(xprv1);
+      var xpub2 = HDPublicKey.fromHDPrivateKey(xprv2);
+      var xpub3 = HDPublicKey.fromHDPrivateKey(xprv3);
+      xpub1
+        .toString()
+        .should.equal(
+          'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8',
+        );
+      xpub1.toString().should.not.equal(xpub2.toString());
+      xpub1.toString().should.not.equal(xpub3.toString());
+    });
+  });
+
+  describe('conversion to different formats', function () {
+    var plainObject = {
+      network: 'livenet',
+      depth: 0,
+      fingerPrint: 876747070,
+      parentFingerPrint: 0,
+      childIndex: 0,
+      chainCode: '873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508',
+      publicKey: '0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2',
+      checksum: 2873572129,
+      xpubkey:
+        'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8',
+    };
+    it('roundtrips to JSON and to Object', function () {
+      var pubkey = new HDPublicKey(xpubkey);
+      expect(HDPublicKey.fromObject(pubkey.toJSON()).xpubkey).to.equal(xpubkey);
+    });
+    it('recovers state from Object', function () {
+      new HDPublicKey(plainObject).xpubkey.should.equal(xpubkey);
+    });
+  });
+
+  describe('derivation', function () {
+    it('derivation is the same whether deriving with number or string', function () {
+      var pubkey = new HDPublicKey(xpubkey);
+      var derived1 = pubkey.deriveChild(0).deriveChild(1).deriveChild(200000);
+      var derived2 = pubkey.deriveChild('m/0/1/200000');
+      derived1.xpubkey.should.equal(derived01200000);
+      derived2.xpubkey.should.equal(derived01200000);
+    });
+
+    it('allows special parameters m, M', function () {
+      var expectDerivationSuccess = function (argument) {
+        new HDPublicKey(xpubkey).deriveChild(argument).xpubkey.should.equal(xpubkey);
+      };
+      expectDerivationSuccess('m');
+      expectDerivationSuccess('M');
+    });
+
+    it("doesn't allow object arguments for derivation", function () {
+      expectFail(function () {
+        return new HDPublicKey(xpubkey).deriveChild({});
+      }, hdErrors.InvalidDerivationArgument);
+    });
+
+    it('needs first argument for derivation', function () {
+      expectFail(function () {
+        return new HDPublicKey(xpubkey).deriveChild('s');
+      }, hdErrors.InvalidPath);
+    });
+
+    it("doesn't allow other parameters like m' or M' or \"s\"", function () {
+      expectDerivationFail("m'", hdErrors.InvalidIndexCantDeriveHardened);
+      expectDerivationFail("M'", hdErrors.InvalidIndexCantDeriveHardened);
+      expectDerivationFail('1', hdErrors.InvalidPath);
+      expectDerivationFail('S', hdErrors.InvalidPath);
+    });
+
+    it("can't derive hardened keys", function () {
+      expectFail(function () {
+        return new HDPublicKey(xpubkey).deriveChild(HDPublicKey.Hardened);
+      }, hdErrors.InvalidIndexCantDeriveHardened);
+    });
+
+    it("can't derive hardened keys via second argument", function () {
+      expectFail(function () {
+        return new HDPublicKey(xpubkey).deriveChild(5, true);
+      }, hdErrors.InvalidIndexCantDeriveHardened);
+    });
+
+    it('validates correct paths', function () {
+      var valid;
+
+      valid = HDPublicKey.isValidPath('m/123/12');
+      valid.should.equal(true);
+
+      valid = HDPublicKey.isValidPath('m');
+      valid.should.equal(true);
+
+      valid = HDPublicKey.isValidPath(123);
+      valid.should.equal(true);
+    });
+
+    it('rejects illegal paths', function () {
+      var valid;
+
+      valid = HDPublicKey.isValidPath('m/-1/12');
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath("m/0'/12");
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath('m/8000000000/12');
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath('bad path');
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath(-1);
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath(8000000000);
+      valid.should.equal(false);
+
+      valid = HDPublicKey.isValidPath(HDPublicKey.Hardened);
+      valid.should.equal(false);
+    });
+  });
+});

package/test/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var should = require('chai').should();
+var opcat = require('../');
+
+describe('#versionGuard', function () {
+  it('global.opcat should be defined', function () {
+    should.equal(global.opcat, opcat.version);
+  });
+
+  it('throw an error if version is already defined', function () {
+    (function () {
+      opcat.versionGuard('version');
+    }).should.not.throw('More than one instance of opcat');
+  });
+});