Restore error when trying to derive a hardened path with HDPublicKey.

- Restores InvalidIndexCantDeriveHardened error in spec
- Passes hardened argument in HDPublicKey (in case the feature is attempted to be used similarly to HDPrivateKey)
- Fixes undefined error with InvalidLength
- Fixes tests to check for the error type
- Various formatting cleanup improvements

lib/errors/spec.js

@@ -164,6 +164,9 @@ module.exports = [{
   }, {
     name: 'InvalidPath',
     message: 'Invalid derivation path, it should look like: "m/1/100", got "{0}"'
+  }, {
+    name: 'InvalidIndexCantDeriveHardened',
+    message: 'Invalid argument: creating a hardened path requires an HDPrivateKey'
   }, {
     name: 'MustSupplyArgument',
     message: 'Must supply an argument to create a HDPublicKey'

lib/hdpublickey.js

@@ -108,9 +108,9 @@ HDPublicKey.isValidPath = function(arg) {
  *
  * @param {string|number} arg
  */
-HDPublicKey.prototype.derive = function (arg) {
+HDPublicKey.prototype.derive = function(arg, hardened) {
   if (_.isNumber(arg)) {
-    return this._deriveWithNumber(arg);
+    return this._deriveWithNumber(arg, hardened);
   } else if (_.isString(arg)) {
     return this._deriveFromString(arg);
   } else {
@@ -118,8 +118,8 @@ HDPublicKey.prototype.derive = function (arg) {
   }
 };
 
-HDPublicKey.prototype._deriveWithNumber = function (index) {
-  if (index >= HDPublicKey.Hardened) {
+HDPublicKey.prototype._deriveWithNumber = function(index, hardened) {
+  if (index >= HDPublicKey.Hardened || hardened) {
     throw new hdErrors.InvalidIndexCantDeriveHardened();
   }
   if (index < 0) {
@@ -203,7 +203,7 @@ HDPublicKey.getSerializedError = function (data, network) {
     return new errors.InvalidB58Checksum(data);
   }
   if (data.length !== HDPublicKey.DataSize) {
-    return new errors.InvalidLength(data);
+    return new hdErrors.InvalidLength(data);
   }
   if (!_.isUndefined(network)) {
     var error = HDPublicKey._validateNetwork(data, network);

test/hdpublickey.js

@@ -24,31 +24,22 @@ var derived_0_1_200000 = 'xpub6BqyndF6rkBNTV6LXwiY8Pco8aqctqq7tGEUdA8fmGDTnDJphn
 describe('HDPublicKey interface', function() {
 
   var expectFail = function(func, errorType) {
-    var got = null;
-    var error = null;
-    try {
+    (function() {
       func();
-    } catch (e) {
-      error = e;
-      got = e instanceof errorType;
-    }
-    if (!error instanceof errorType) {
-      console.log('Error', typeof error);
-    }
-    // expect(got).to.equal(true);
+    }).should.throw(errorType);
   };
 
   var expectDerivationFail = function(argument, error) {
-    return expectFail(function() {
+    (function() {
       var pubkey = new HDPublicKey(xpubkey);
-      xpubkey.derive(argument);
-    }, error);
+      pubkey.derive(argument);
+    }).should.throw(error);
   };
 
   var expectFailBuilding = function(argument, error) {
-    return expectFail(function() {
+    (function() {
       return new HDPublicKey(argument);
-    }, error);
+    }).should.throw(error);
   };
 
   describe('creation formats', function() {
@@ -225,16 +216,22 @@ describe('HDPublicKey interface', function() {
 
     it('doesn\'t allow other parameters like m\' or M\' or "s"', function() {
       /* jshint quotmark: double */
-      expectDerivationFail("m'", hdErrors.InvalidDerivationArgument);
-      expectDerivationFail("M'", hdErrors.InvalidDerivationArgument);
-      expectDerivationFail("1", hdErrors.InvalidDerivationArgument);
-      expectDerivationFail("S", hdErrors.InvalidDerivationArgument);
+      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).derive(HDPublicKey.Hardened);
-      }, hdErrors.InvalidDerivationArgument);
+      }, hdErrors.InvalidIndexCantDeriveHardened);
+    });
+
+    it('can\'t derive hardened keys via second argument', function() {
+      expectFail(function() {
+        return new HDPublicKey(xpubkey).derive(5, true);
+      }, hdErrors.InvalidIndexCantDeriveHardened);
     });
 
     it('validates correct paths', function() {