Update ripple-address-codec dependency

packages/ripple-keypairs/package.json

@@ -19,7 +19,7 @@
     "brorand": "^1.0.5",
     "elliptic": "^5.1.0",
     "hash.js": "^1.0.3",
-    "ripple-address-codec": "^1.5.0"
+    "ripple-address-codec": "^1.6.0"
   },
   "devDependencies": {
     "assert-diff": "^1.0.1",
@@ -42,7 +42,7 @@
     "build": "gulp",
     "compile": "babel -i runtime -d dist/npm/ src/",
     "compile-with-source-maps": "babel -i runtime -s -t -d dist/npm/ src/",
-    "prepublish": "npm run compile",
+    "prepublish": "npm test && npm run lint && npm run compile",
     "test": "istanbul test _mocha",
     "coveralls": "cat ./coverage/lcov.info | coveralls",
     "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc'; fi; eslint --reset -c eslintrc src/*.js test/*.js"

packages/ripple-keypairs/src/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-/* -------------------------------- REQUIRES -------------------------------- */
-
 const assert = require('assert');
 const codec = require('ripple-address-codec');
 const rand = require('brorand');
@@ -11,28 +9,22 @@ const {KeyPair, KeyType} = require('./keypair');
 const Ed25519Pair = require('./ed25519');
 const K256Pair = require('./secp256k1');
 
+KeyPair.fromSeed = function(seedBytes, type, options) {
+  const Pair = type === 'ed25519' ? Ed25519Pair : K256Pair;
+  return Pair.fromSeed(seedBytes, options);
+};
+
 function keyPairFromSeed(seedString, options) {
   const decoded = codec.decodeSeed(seedString);
-  const Pair = decoded.type === 'ed25519' ? Ed25519Pair : K256Pair;
-  return Pair.fromSeed(decoded.bytes, options);
+  return KeyPair.fromSeed(decoded.bytes, decoded.type, options);
 }
 
 function deriveWallet(type, seedBytes) {
   assert(type === 'secp256k1' || type === 'ed25519');
-
-  let pair;
-  let seed;
-
-  if (type === 'secp256k1') {
-    seed = codec.encodeK256Seed(seedBytes);
-    pair = K256Pair.fromSeed(seedBytes);
-  } else {
-    seed = codec.encodeEdSeed(seedBytes);
-    pair = Ed25519Pair.fromSeed(seedBytes);
-  }
+  const pair = KeyPair.fromSeed(seedBytes, type);
 
   return {
-    seed,
+    seed: pair.seed(),
     accountID: pair.accountID(),
     publicKey: pair.pubKeyHex()
   };

packages/ripple-keypairs/src/keypair.js

@@ -50,6 +50,10 @@ hasCachedProperty(KeyPair, 'accountID', function() {
   return codec.encodeAccountID(this.accountBytes());
 });
 
+hasCachedProperty(KeyPair, 'seed', function() {
+  return codec.encodeSeed(this.seedBytes, this.type);
+});
+
 KeyPair.prototype.signHex = function(message) {
   return bytesToHex(this.sign(message));
 };

packages/ripple-keypairs/src/secp256k1.js

@@ -10,7 +10,7 @@ const {
   hasCachedProperty
 } = require('./utils');
 
-function findk256Key(bytes, discrim) {
+function deriveScalar(bytes, discrim) {
   const order = secp256k1.curve.n;
   for (let i = 0; i <= 0xFFFFFFFF; i++) {
     // We hash the bytes to find a 256 bit number, looping until we are sure it
@@ -38,13 +38,13 @@ function findk256Key(bytes, discrim) {
 * @return {bn.js} - 256 bit scalar value
 *
 */
-function derivek256Scalar(seed, opts={}) {
+function deriveSecret(seed, opts={}) {
   const root = opts.validator;
   const order = secp256k1.curve.n;
 
   // This private generator represents the `root` private key, and is what's
   // used by validators for signing when a keypair is generated from a seed.
-  const privateGen = findk256Key(seed);
+  const privateGen = deriveScalar(seed);
   if (root) {
     // As returned by validation_create for a given seed
     return privateGen;
@@ -53,7 +53,7 @@ function derivek256Scalar(seed, opts={}) {
   // A seed can generate many keypairs as a function of the seed and a uint32.
   // Almost everyone just uses the first account, `0`.
   const accountIndex = opts.accountIndex || 0;
-  return findk256Key(publicGen.encodeCompressed(), accountIndex)
+  return deriveScalar(publicGen.encodeCompressed(), accountIndex)
             .add(privateGen).mod(order);
 }
 
@@ -75,7 +75,7 @@ K256Pair.fromSeed = function(seedBytes, opts={}) {
 hasCachedProperty(K256Pair, 'key', function() {
   if (this.seedBytes) {
     const options = {validator: this.validator};
-    return secp256k1.keyFromPrivate(derivek256Scalar(this.seedBytes, options));
+    return secp256k1.keyFromPrivate(deriveSecret(this.seedBytes, options));
   }
   return secp256k1.keyFromPublic(this.pubKeyCanonicalBytes());
 });