defaults to nonCompliant key derivation

Author: matiu

lib/hdprivatekey.js

@@ -127,6 +127,7 @@ HDPrivateKey._getDerivationIndexes = function(path) {
   return _.any(indexes, isNaN) ? null : indexes;
 };
 
+
 /**
  * Get a derived child based on a string or number.
  *
@@ -156,6 +157,41 @@ HDPrivateKey._getDerivationIndexes = function(path) {
  *
  */
 HDPrivateKey.prototype.derive = function(arg, hardened, nonCompliant) {
+
+  // Defaults to the nonCompliant derivation, for backwards compatibility
+  if (_.isUndefined(nonCompliant))
+    nonCompliant = true;
+
+  if (_.isNumber(arg)) {
+    return this._deriveWithNumber(arg, hardened, nonCompliant);
+  } else if (_.isString(arg)) {
+    return this._deriveFromString(arg, nonCompliant);
+  } else {
+    throw new hdErrors.InvalidDerivationArgument(arg);
+  }
+};
+
+
+
+/**
+ *
+ * WARNING: This method should not be called directly. Please use: `getChild` or `getNonCompliantChild'.
+ *
+ * Internal method to get a derived child based on a string or number.
+ *
+ * @param {string|number} arg
+ * @param {boolean?} hardened
+ * @param {boolean?} nonCompliant - This should not be used and only for backwards compatibility
+ *
+ */
+HDPrivateKey.prototype.derive = function(arg, hardened, nonCompliant) {
+
+  // Defaults to the nonCompliant derivation, for backwards compatibility
+  if (_.isUndefined(nonCompliant)) {
+    console.log('Warning: Using no BIP32 Compliant key derivation. If this is on purpose, use `getNonCompliantChild` to avoid this warning, otherwise use the `getChild`')
+    nonCompliant = true;
+  }
+
   if (_.isNumber(arg)) {
     return this._deriveWithNumber(arg, hardened, nonCompliant);
   } else if (_.isString(arg)) {
@@ -165,9 +201,40 @@ HDPrivateKey.prototype.derive = function(arg, hardened, nonCompliant) {
   }
 };
 
+
+/**
+ * Get a derived child based on a string or number.
+ *
+ * If the first argument is a string, it's parsed as the full path of
+ * derivation. Valid values for this argument include "m" (which returns the
+ * same private key), "m/0/1/40/2'/1000", where the ' quote means a hardened
+ * derivation.
+ *
+ * If the first argument is a number, the child with that index will be
+ * derived. If the second argument is truthy, the hardened version will be
+ * derived. See the example usage for clarification.
+ *
+ * @example
+ * ```javascript
+ * var parent = new HDPrivateKey('xprv...');
+ * var child_0_1_2h = parent.getChild(0).getChild(1).getChild(2, true);
+ * var copy_of_child_0_1_2h = parent.getChild("m/0/1/2'");
+ * assert(child_0_1_2h.xprivkey === copy_of_child_0_1_2h);
+ * ```
+ *
+ * @param {string|number} arg
+ * @param {boolean?} hardened
+ *
+ */
+
+HDPrivateKey.prototype.getChild = function(arg, hardened) {
+  var derived = this.derive(arg, hardened, false);
+  return derived;
+};
+
 /**
  * WARNING: If this is a new implementation you should NOT use this method, you should be using
- * `derive` instead.
+ * `getChild` instead.
  *
  * This method is explicitly for use and compatibility with an implementation that
  * was not compliant with BIP32 regarding the derivation algorithm. The private key
@@ -178,7 +245,7 @@ HDPrivateKey.prototype.derive = function(arg, hardened, nonCompliant) {
  * @param {string|number} arg
  * @param {boolean?} hardened
  */
-HDPrivateKey.prototype.deriveNonCompliant = function(arg, hardened) {
+HDPrivateKey.prototype.getNonCompliantChild = function(arg, hardened) {
   var derived = this.derive(arg, hardened, true);
   return derived;
 };
@@ -209,7 +276,9 @@ HDPrivateKey.prototype._deriveWithNumber = function(index, hardened, nonComplian
     data = BufferUtil.concat([new buffer.Buffer([0]), nonZeroPadded, indexBuffer]);
   } else if (hardened) {
     // This will use a 32 byte zero padded serialization of the private key
-    var privateKeyBuffer = this.privateKey.bn.toBuffer({size: 32});
+    var privateKeyBuffer = this.privateKey.bn.toBuffer({
+      size: 32
+    });
     assert(privateKeyBuffer.length === 32, 'length of private key buffer is expected to be 32 bytes');
     data = BufferUtil.concat([new buffer.Buffer([0]), privateKeyBuffer, indexBuffer]);
   } else {

lib/hdpublickey.js

@@ -86,6 +86,22 @@ HDPublicKey.isValidPath = function(arg) {
   return false;
 };
 
+
+/**
+ * Internal method to get a derivated child based on a string or number.
+ *
+ */
+ 
+HDPublicKey.prototype.derive = function(arg, hardened) {
+  if (_.isNumber(arg)) {
+    return this._deriveWithNumber(arg, hardened);
+  } else if (_.isString(arg)) {
+    return this._deriveFromString(arg);
+  } else {
+    throw new hdErrors.InvalidDerivationArgument(arg);
+  }
+};
+
 /**
  * Get a derivated child based on a string or number.
  *
@@ -108,14 +124,8 @@ HDPublicKey.isValidPath = function(arg) {
  *
  * @param {string|number} arg
  */
-HDPublicKey.prototype.derive = function(arg, hardened) {
-  if (_.isNumber(arg)) {
-    return this._deriveWithNumber(arg, hardened);
-  } else if (_.isString(arg)) {
-    return this._deriveFromString(arg);
-  } else {
-    throw new hdErrors.InvalidDerivationArgument(arg);
-  }
+HDPublicKey.prototype.getChild = function(arg, hardened) {
+  return this.derive(arg, hardened);
 };
 
 HDPublicKey.prototype._deriveWithNumber = function(index, hardened) {

test/hdkeycache.js

@@ -24,29 +24,29 @@ describe('HDKey cache', function() {
   });
 
   it('saves a derived key', function() {
-    var child = master.derive(0);
+    var child = master.getChild(0);
     expect(cache._cache['0' + master.xprivkey + '/0/false'].xprivkey).to.equal(child.xprivkey);
   });
   it('starts erasing unused keys', function() {
-    var child1 = master.derive(0);
-    var child2 = child1.derive(0);
-    var child3 = child2.derive(0);
+    var child1 = master.getChild(0);
+    var child2 = child1.getChild(0);
+    var child3 = child2.getChild(0);
     expect(cache._cache['0' + master.xprivkey + '/0/false'].xprivkey).to.equal(child1.xprivkey);
-    var child4 = child3.derive(0);
+    var child4 = child3.getChild(0);
     expect(cache._cache['0' + master.xprivkey + '/0/false']).to.equal(undefined);
   });
   it('avoids erasing keys that get cache hits ("hot keys")', function() {
-    var child1 = master.derive(0);
-    var child2 = master.derive(0).derive(0);
+    var child1 = master.getChild(0);
+    var child2 = master.getChild(0).getChild(0);
     expect(cache._cache['0' + master.xprivkey + '/0/false'].xprivkey).to.equal(child1.xprivkey);
-    var child1_copy = master.derive(0);
+    var child1_copy = master.getChild(0);
     expect(cache._cache['0' + master.xprivkey + '/0/false'].xprivkey).to.equal(child1.xprivkey);
   });
   it('keeps the size of the cache small', function() {
-    var child1 = master.derive(0);
-    var child2 = child1.derive(0);
-    var child3 = child2.derive(0);
-    var child4 = child3.derive(0);
+    var child1 = master.getChild(0);
+    var child2 = child1.getChild(0);
+    var child3 = child2.getChild(0);
+    var child4 = child3.getChild(0);
     expect(_.size(cache._cache)).to.equal(3);
   });
 });