Bump version to 0.12.5-rc2

[TASK] add short circuit when there are no direct nor autobridged offers

.flowconfig

@@ -0,0 +1,7 @@
+[ignore]
+
+[include]
+
+[libs]
+
+[options]

.gitignore

@@ -25,6 +25,7 @@ Release/*.*
 
 # Ignore locally installed node_modules
 node_modules
+!test/node_modules
 
 # Ignore tmp directory.
 tmp
@@ -52,3 +53,11 @@ npm-debug.log
 
 # Ignore dist folder, build for bower
 dist/
+
+# Ignore flow output directory
+out/
+
+# Ignore perf test cache
+scripts/cache
+
+eslintrc

.travis.yml

@@ -1,10 +1,15 @@
 language: node_js
 node_js:
   - "0.10"
-script: npm test --coverage
+before_script:
+  - npm install -g eslint
+  - curl 'https://raw.githubusercontent.com/ripple/javascript-style-guide/master/eslintrc' > ./eslintrc
+  - eslint --reset -c ./eslintrc $(git --no-pager diff --name-only --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
+script: MOCHA_REPORTER=tap npm test --coverage
 after_success:
 - npm run coveralls
 notifications:
+  email: false
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/d1ec4245f90231619d30

Gulpfile.js

@@ -1,22 +1,22 @@
+'use strict';
 var gulp = require('gulp');
+var gutil = require('gulp-util');
+var watch = require('gulp-watch');
+var plumber = require('gulp-plumber');
+var filelog = require('gulp-filelog');
+var cleanDest = require('gulp-clean-dest');
 var concat = require('gulp-concat');
 var uglify = require('gulp-uglify');
 var rename = require('gulp-rename');
 var webpack = require('webpack');
-var jshint = require('gulp-jshint');
-var map = require('map-stream');
 var bump = require('gulp-bump');
+var react = require('gulp-react');
+var flow = require('gulp-flowtype');
 var argv = require('yargs').argv;
-//var header = require('gulp-header');
+// var header = require('gulp-header');
 
 var pkg = require('./package.json');
 
-var banner = '/*! <%= pkg.name %> - v<%= pkg.version %> - '
-+ '<%= new Date().toISOString() %>\n'
-+ '<%= pkg.homepage ? "* " + pkg.homepage + "\n" : "" %>'
-+ '* Copyright (c) <%= new Date().getFullYear() %> <%= pkg.author.name %>;'
-+ ' Licensed <%= pkg.license %> */'
-
 var sjclSrc = [
   'src/js/sjcl/core/sjcl.js',
   'src/js/sjcl/core/aes.js',
@@ -50,39 +50,43 @@ var sjclSrc = [
   'src/js/sjcl-custom/sjcl-jacobi.js'
 ];
 
+function logPluginError(error) {
+  gutil.log(error.toString());
+}
+
 gulp.task('concat-sjcl', function() {
   return gulp.src(sjclSrc)
   .pipe(concat('sjcl.js'))
   .pipe(gulp.dest('./build/'));
 });
 
-gulp.task('build', [ 'concat-sjcl' ], function(callback) {
+gulp.task('build', ['concat-sjcl'], function(callback) {
   webpack({
     cache: true,
     entry: './src/js/ripple/index.js',
     output: {
       library: 'ripple',
       path: './build/',
-      filename: [ 'ripple-', '.js' ].join(pkg.version)
-    },
+      filename: ['ripple-', '.js'].join(pkg.version)
+    }
   }, callback);
 });
 
-gulp.task('build-min', [ 'build' ], function(callback) {
-  return gulp.src([ './build/ripple-', '.js' ].join(pkg.version))
+gulp.task('build-min', ['build'], function() {
+  return gulp.src(['./build/ripple-', '.js'].join(pkg.version))
   .pipe(uglify())
-  .pipe(rename([ 'ripple-', '-min.js' ].join(pkg.version)))
+  .pipe(rename(['ripple-', '-min.js'].join(pkg.version)))
   .pipe(gulp.dest('./build/'));
 });
 
-gulp.task('build-debug', [ 'concat-sjcl' ], function(callback) {
+gulp.task('build-debug', ['concat-sjcl'], function(callback) {
   webpack({
     cache: true,
     entry: './src/js/ripple/index.js',
     output: {
       library: 'ripple',
       path: './build/',
-      filename: [ 'ripple-', '-debug.js' ].join(pkg.version)
+      filename: ['ripple-', '-debug.js'].join(pkg.version)
     },
     debug: true,
     devtool: 'eval'
@@ -95,11 +99,12 @@ gulp.task('build-debug', [ 'concat-sjcl' ], function(callback) {
  */
 
 function buildUseError(cons) {
-  return 'var {<CONS>:function(){throw new Error("Class is unavailable in this build: <CONS>")}}'
+  return ('var {<CONS>:function(){throw new Error('
+          + '"Class is unavailable in this build: <CONS>")}}')
           .replace(new RegExp('<CONS>', 'g'), cons);
-};
+}
 
-gulp.task('build-core', [ 'concat-sjcl' ], function(callback) {
+gulp.task('build-core', ['concat-sjcl'], function(callback) {
   webpack({
     entry: [
       './src/js/ripple/remote.js'
@@ -115,7 +120,7 @@ gulp.task('build-core', [ 'concat-sjcl' ], function(callback) {
     output: {
       library: 'ripple',
       path: './build/',
-      filename: [ 'ripple-', '-core.js' ].join(pkg.version)
+      filename: ['ripple-', '-core.js'].join(pkg.version)
     },
     plugins: [
       new webpack.optimize.UglifyJsPlugin()
@@ -123,76 +128,70 @@ gulp.task('build-core', [ 'concat-sjcl' ], function(callback) {
   }, callback);
 });
 
-gulp.task('bower-build', [ 'build' ], function(callback) {
-  return gulp.src([ './build/ripple-', '.js' ].join(pkg.version))
+gulp.task('bower-build', ['build'], function() {
+  return gulp.src(['./build/ripple-', '.js'].join(pkg.version))
   .pipe(rename('ripple.js'))
   .pipe(gulp.dest('./dist/'));
 });
 
-gulp.task('bower-build-min', [ 'build-min' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-min.js' ].join(pkg.version))
+gulp.task('bower-build-min', ['build-min'], function() {
+  return gulp.src(['./build/ripple-', '-min.js'].join(pkg.version))
   .pipe(rename('ripple-min.js'))
   .pipe(gulp.dest('./dist/'));
 });
 
-gulp.task('bower-build-debug', [ 'build-debug' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-debug.js' ].join(pkg.version))
+gulp.task('bower-build-debug', ['build-debug'], function() {
+  return gulp.src(['./build/ripple-', '-debug.js'].join(pkg.version))
   .pipe(rename('ripple-debug.js'))
   .pipe(gulp.dest('./dist/'));
 });
 
 gulp.task('bower-version', function() {
   gulp.src('./dist/bower.json')
-  .pipe(bump({ version: pkg.version }))
+  .pipe(bump({version: pkg.version}))
   .pipe(gulp.dest('./dist/'));
 });
 
-gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug', 'bower-version']);
+gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug',
+                    'bower-version']);
 
-gulp.task('lint', function() {
-  gulp.src('src/js/ripple/*.js')
-  .pipe(jshint())
-  .pipe(map(function(file, callback) {
-    if (!file.jshint.success) {
-      console.log('\nIn', file.path);
+gulp.task('watch', function() {
+  gulp.watch('src/js/ripple/*', ['build-debug']);
+});
 
-      file.jshint.results.forEach(function(err) {
-        if (err && err.error) {
-          var col1 = err.error.line + ':' + err.error.character;
-          var col2 = '[' + err.error.reason + ']';
-          var col3 = '(' + err.error.code + ')';
-
-          while (col1.length < 8) {
-            col1 += ' ';
-          }
-
-          console.log('  ' + [ col1, col2, col3 ].join(' '));
-        }
-      });
-    }
-
-    callback(null, file);
+// To use this, each javascript file must have /* @flow */ on the first line
+gulp.task('typecheck', function() {
+  return gulp.src('src/js/ripple/*.js')
+  .pipe(flow({      // note: do not set the 'all' option, it is broken
+    weak: true,   // remove this after all errors are addressed
+    killFlow: true
   }));
 });
 
-gulp.task('watch', function() {
-  gulp.watch('src/js/ripple/*', [ 'build-debug' ]);
+gulp.task('strip', function() {
+  return gulp.src('src/js/ripple/*.js')
+  .pipe(watch('src/js/ripple/*.js'))
+  .pipe(cleanDest('out'))   // delete outdated output file before stripping
+  .pipe(plumber())        // prevent an error in one file from ending build
+  .pipe(react({stripTypes: true}).on('error', logPluginError))
+  .pipe(filelog())
+  .pipe(gulp.dest('out'));
 });
 
 gulp.task('version-bump', function() {
   if (!argv.type) {
-    throw new Error("No type found, pass it in using the --type argument");
+    throw new Error('No type found, pass it in using the --type argument');
   }
 
   gulp.src('./package.json')
-  .pipe(bump({ type: argv.type }))
+  .pipe(bump({type: argv.type}))
   .pipe(gulp.dest('./'));
 });
 
 gulp.task('version-beta', function() {
   gulp.src('./package.json')
-  .pipe(bump({ version: pkg.version + '-beta' }))
+  .pipe(bump({version: pkg.version + '-beta'}))
   .pipe(gulp.dest('./'));
 });
 
-gulp.task('default', [ 'concat-sjcl', 'build', 'build-debug', 'build-min' ]);
+gulp.task('default', ['concat-sjcl', 'build', 'build-debug', 'build-min']);

HISTORY.md

@@ -1,3 +1,171 @@
+##0.12.15
+
++ [Add offer autobridging](https://github.com/ripple/ripple-lib/commit/c7bbce83719c1e8c6a4fae5ca850e7515db1a4a5)
+
++ [Fix empty order edgecase](https://github.com/ripple/ripple-lib/commit/64809d9ae23dc24f47accd4b4788b48f49880d3e)
+
++ [Remove unused float.js and wallet.js](https://github.com/ripple/ripple-lib/commit/d4a4b5f4fbbf09677a59ce81bace35c6426a2fda)
+
++ [Remove config singleton to reduce global state](https://github.com/ripple/ripple-lib/commit/c655c2a20ee5d150a4b5a1b6717b9fb81f636025)
+
+##0.12.4
+
++ [Improve entropy security](https://github.com/ripple/ripple-lib/commit/c7ba822320880037796f57876d1abb4e525648ed)
+
++ [Remove unused crypt.js file](https://github.com/ripple/ripple-lib/commit/1f68eba1461bca03a4d22872450d15ae5a185334)
+
+##0.12.3
+
++ [Add getLedgerSequence to Remote](https://github.com/ripple/ripple-lib/commit/d09548d04d3238fca653d482ec1d5faa7254559a)
+
++ [Improve randomness when generating ECDSA signatures](https://github.com/ripple/ripple-lib/commit/fe7e30b737ead6e71adfa466f5835ba546feab31)
+
++ [Improve SerializedObject.append performance](https://github.com/ripple/ripple-lib/commit/f7c35b118ebba549a64bcaa1a0629385ec6dbf6f)
+
++ [Add `Amount.scale`. Multiply an amount’s value by a scale factor](https://github.com/ripple/ripple-lib/commit/74dac97b368493056474468520f05671f458a69f)
+
+
+##0.12.2
+
++ [Check that stack trace is available, fixes logging in browser](https://github.com/ripple/ripple-lib/commit/53cae3a66d48e88e8a6bbb96d6489ce7b9e22975)
+
+
+##0.12.1
+
+**Breaking Changes**
+
++ [Removed support for parsing native amounts in floating point format](https://github.com/ripple/ripple-lib/commit/e80cd1ff55deae9cd5b0ae85be957f86856b887e)
+
+
+**Changes**
+
++ [Fix taker pays funded calculation](https://github.com/ripple/ripple-lib/commit/5af824f5cf46c7b9caa58ee0a757bf854d26c8dc)
+
++ [Fix order funded amount calculation](https://github.com/ripple/ripple-lib/commit/b2cdb1a6aed968b1f306e8dadbd4b7ca37e5aa03)
+
++ [Fix handling of quality in order book](https://github.com/ripple/ripple-lib/commit/2a5a8b498da60df738ba18d5c265f34771e8a1af)
+
++ [Fix currency parsing of non-alphanumeric and no-currency currencies](https://github.com/ripple/ripple-lib/commit/2166bb2e88eae8d5f1aba77338f69e8a9edf6a6f)
+
++ [Add Amount.strict_mode for toggling range validation](https://github.com/ripple/ripple-lib/commit/b5ed8f59a7dab1a17491618b8d9193646c314fb4)
+
++ [Add filename and line number to log, use log.warn() for deprecations](https://github.com/ripple/ripple-lib/commit/90329d3d73f1a76675063655b407513e32dc048b)
+
++ [Add GlobalFreeze and NoFreeze flags](https://github.com/ripple/ripple-lib/commit/e2ed2bdbf6f01c7d4d690c2cf0b83fba94558dd7)
+
++ [Fix handling of falsy parameters in requestLedger](https://github.com/ripple/ripple-lib/commit/6023efed41b7812b3bab660a1c0dc9f0a21000b9)
+
++ [Fix Base:decode](https://github.com/ripple/ripple-lib/commit/719f39c01c6941d9a650aa94f95617793dd53ea0)
+
++ [Fix Amount: clone in ratio_human, product_human](https://github.com/ripple/ripple-lib/commit/19e17a8431550cf156b1ad669a19dedfe4e28e4a)
+
++ [Fix Amount.to_human for very small numbers](https://github.com/ripple/ripple-lib/commit/6abfa759aa09d68074ac558d96c4b126a7cd1719)
+
++ [Refactor base conversion](https://github.com/ripple/ripple-lib/commit/f2b63fa4a80663eb29472bc6bb1aea8159f1f205)
+
++ [Update binary transaction format](https://github.com/ripple/ripple-lib/commit/8e134918fb4c22983320a3102f955e4568bb1dfb)
+
++ [Add DefaultRipple account flag](https://github.com/ripple/ripple-lib/commit/3e249902c4cf25b4da5e75048c84ae391be83b10)
+
++ [Remove `Features` field requirement in `SetFee` transaction format](https://github.com/ripple/ripple-lib/commit/a20a649013646710c078d4ce1e210f87c7fe74fe)
+
++ [Remove `RegularKey` field requirement in `SetRegularKey` transaction format](https://github.com/ripple/ripple-lib/commit/c275174f27877ba8f389eb4efe969feb514d6e46)
+
+
+##0.12.0
+
+**Breaking Changes**
+
++ REMOVED Remote storage interface
++ REMOVED Remote `ping` configuration
++ REMOVED Old/deprecated Remote server configuration (websocket_ip, websocket_port)
++ REMOVED browser `online` reconnect listener
+    - [Cleanup, deprecations - 2833a7b6](https://github.com/ripple/ripple-lib/commit/2833a7b66e696dab427464625077f9b93092d0d5)
+
++ Remove `jsbn` and use `bignumber.js` instead for big number math
++ The `allow_nan` flag has been removed. Results for invalid amounts will always be `NaN`
+    - [Refactor to use bignumber.js - d025b4a0](https://github.com/ripple/ripple-lib/commit/d025b4a0c3a98a6de27a1bee9573c85347bcd66b)
+    - [Handle invalid input in parse_human - c8f18c8c](https://github.com/ripple/ripple-lib/commit/c8f18c8c8590b7b48e370e0325b6677b7720294f)
+    - [Check for null in isNumber - b86790c8](https://github.com/ripple/ripple-lib/commit/b86790c8543c239a532fd7697d4652829019d385)
+    - [Cleanup amount.js - d0fb291c](https://github.com/ripple/ripple-lib/commit/d0fb291c4e330193a244902156f1d74730da357d)
+
+
+**Changes**
+
++ [Add deprecation warnings to request constructors. The first argument to request constructor functions should be an object containing request properties](https://github.com/ripple/ripple-lib/commit/35d76b3520934285f80059c1badd6c522539104c)
+
++ [Fix taker_gets_funded exceeding offer.TakerGets](https://github.com/ripple/ripple-lib/commit/b19ecb4482b589d575382b7a5d0480b963383bb1)
+
++ [Fix unsymmetric memo serializing](https://github.com/ripple/ripple-lib/commit/1ed36fabdbd54f4d31078c2b0eaa3becc0fe2821)
+
++ [Fix IOU value passed to `Amount.from_json()`](https://github.com/ripple/ripple-lib/commit/fd1b64393dffb3d1819cd40b8d43df43a4db042d)
+
++ [Update transaction binary parsing to account for XRP delivered amounts](https://github.com/ripple/ripple-lib/commit/35a346a674e6ee1e1e495db93700d55984efc7dd)
+
++ [Bumped dependencies](https://github.com/ripple/ripple-lib/commit/f9bc7cc746b44b24b61bbe260ae2e9d9617286da)
+
+
+
+##0.11.0
+
++ [Track the funded status of an order based on cumulative account orders](https://github.com/ripple/ripple-lib/commit/67d39737a4d5e0fcd9d9b47b9083ee00e5a9e652) and [67d3973](https://github.com/ripple/ripple-lib/commit/b6b99dde022e1e14c4797e454b1d7fca50e49482)
+
++ Remove blobvault client from ripple-lib, use the [`ripple-vault-client`](https://github.com/ripple/ripple-vault-client) instead [9b3d62b7](https://github.com/ripple/ripple-lib/commit/9b3d62b765c4c25beae6eb0fa57ef3a07f2581b1)
+
++ [Add support for `ledger` option in requestBookOffers](https://github.com/ripple/ripple-lib/commit/34c0677c453c409ef0a5b351959abdc176d3bacb)
+
++ [Add support for `limit` option in requestBookOffers](https://github.com/ripple/ripple-lib/commit/d1d4452217c878d0b377d24830b4cd8b3162f6e0)
+
++ [Add `ledgerSelect` request constructor in `Remote`](https://github.com/ripple/ripple-lib/commit/98f40abfc3aa74dec5067a2d90002756cc8acd01)
+
++ [Default to binary data for commands that accept the binary flag](https://github.com/ripple/ripple-lib/commit/7cb113fcbcfc1e3e9830a999148b3e78df3387cc)
+
++ [Fix metadata account check](https://github.com/ripple/ripple-lib/commit/3f61598d6c87e3cc877af60e2d515f9eff73dfe1)
+
++ [Double check `tes` code before emitting `success`](https://github.com/ripple/ripple-lib/commit/97a8c874903eb7309d8f755955ac80872f670582)
+
++ [Decrease redundancy in binary account_tx parsing](https://github.com/ripple/ripple-lib/commit/0aba638e6e7f4f6e22cb6424eed3897ebad90a5a)
+
++ [Abort server connection on unrecoverable TLS error](https://github.com/ripple/ripple-lib/commit/000a2ea00c57157044aeca0fb3f24b37669b163c)
+
++ [Fix complete ledgers check on subscription that is not initial](https://github.com/ripple/ripple-lib/commit/89de91301e682a46dc60aaacc7ae152e8fe1b7c7)
+
+
+##0.10.0
+
++ [Transaction changes](https://github.com/ripple/ripple-lib/pull/221)
+
++ **Important** `tef*` and `tel*` and errors will no longer be presented as
+final. Rather than considering these errors final, ripple-lib will wait until
+the `LastLedgerSequence` specified in the transaction is exceeded.  This makes
+failures more definitive, and ensures that no transaction will resubmit
+indefinitely.
+
++ A new, final tej-class error is introduced to account for transactions that
+are locally determined to have expired: `tejMaxLedger`.
+
++ [Allow per transaction fees to be set, `transaction.setFixedFee()`](https://github.com/ripple/ripple-lib/commit/9b22f279bcbe60ee6bcf4b7fa60a48e9c197a828)
+
++ [Improve memo support](https://github.com/ripple/ripple-lib/commit/1704ac4ae144c0ce54afad86f644c75a632080b1)
+    - Add `MemoFormat` property for memo
+    - Enforce `MemoFormat` and `MemoType` to be valid ASCII
+    - Support `text` and `json` MemoFormat
+
++ [Update jscl library](https://github.com/ripple/ripple-lib/commit/3204998fcb6f31d6c90532a737a4adb8a1e420f6)
+    - Improved entropy by taking advantage of platform crypto
+    - Use jscl's k256 curve instead of altering the c256 curve with k256 configuration
+    - **deprecated:** the c256 curve is linked to the k256 curve to provide backwards compatibility, this link will be removed in the future
+
++ [Fix empty queue check on reconnect](https://github.com/ripple/ripple-lib/commit/3c21994adcf72d1fbd87d453ceb917f9ad6df4ec)
+
+##0.9.4
+
++ [Normalize offers from book_offers and transaction stream](https://github.com/ripple/ripple-lib/commit/86ed24b94cf7c8929c87db3a63e9bbea7f767e9c)
+
++ [Fix: Amount.to_human() precision rounding](https://github.com/ripple/ripple-lib/commit/e371cc2c3ceccb3c1cfdf18b98d80093147dd8b2)
+
++ [Fix: fractional drops in funded taker_pays setter](https://github.com/ripple/ripple-lib/commit/0d7fc0a573a144caac15dd13798b23eeb1f95fb4)
+
 ##0.9.3
 
 + [Change `presubmit` to emit immediately before transaction submit](https://github.com/ripple/ripple-lib/commit/7a1feaa89701bf861ab31ebd8ffdc8d8d1474e29)

README.md

@@ -9,7 +9,7 @@ A JavaScript API for interacting with Ripple in Node.js and the browser
 ###Features
 
 + Connect to a rippled server in JavaScript (Node.js or browser)
-+ Issue [rippled API](https://ripple.com/wiki/JSON_Messages) requests
++ Issue [rippled API](https://ripple.com/build/rippled-apis/) requests
 + Listen to events on the Ripple network (transaction, ledger, etc.)
 + Sign and submit transactions to the Ripple network
 

docs/BUILD.md

@@ -0,0 +1,20 @@
+Using Flow typechecking
+=======================
+
+Stage 1
+-------
+1. Add /* @flow */ to the top of a file you want to typecheck
+2. Run `gulp typecheck` to generate a list of warnings
+
+Stage 2
+-------
+When all source files have the /* @flow */ header and all warnings have been
+addressed, remove the `weak: true` option from Gulpfile.js, run
+`gulp typecheck` and remove all the additional warnings.
+
+Stage 3
+-------
+Add type annotations to the source code and run `gulp strip` to strip
+the type annotations and write the output to the `out` directory. After
+type annotations are added, the program must be run from the `out` directory
+because Node does not understand the annotations

docs/GUIDES.md

@@ -16,20 +16,9 @@ This file provides step-by-step walkthroughs for some of the most common usages
 1. [The ripple-lib README](../README.md)
 2. [The ripple-lib API Reference](REFERENCE.md)
 
-##Generating a new Ripple Wallet
-
-  ```js
-    var Wallet = require('ripple-lib').Wallet;
-
-    var wallet = Wallet.generate();
-    console.log(wallet);
-    // { address: 'rEf4sbVobiiDGExrNj2PkNHGMA8eS6jWh3',
-    //   secret: 'shFh4a38EZpEdZxrLifEnVPAoBRce' }
-  ```
-
 ##Connecting to the Ripple network
 
-1. [Get ripple-lib](README.md#getting-ripple-lib)
+1. [Get ripple-lib](../README.md#installation)
 2. Load the ripple-lib module into a Node.js file or webpage:
   ```js
   /* Loading ripple-lib with Node.js */
@@ -50,7 +39,7 @@ This file provides step-by-step walkthroughs for some of the most common usages
     ]
   }
 
-  var remote = new Remote({options});
+  var remote = new Remote(options);
 
   remote.connect(function(err, res) {
     /* remote connected, use some remote functions here */
@@ -60,6 +49,33 @@ This file provides step-by-step walkthroughs for some of the most common usages
 
 4. You're connected! Read on to see what to do now.
 
+##Generating a new Ripple Wallet
+
+  ```js
+    var ripple = require('ripple-lib');
+
+    // subscribing to a server allows for more entropy
+    var remote = new ripple.Remote({
+      servers: [
+        { host: 's1.ripple.com', port: 443, secure: true }
+      ]
+    });
+
+    remote.connect(function(err, res) {
+     /* remote connected */
+    });
+
+    // Wait for randomness to have been added.
+    // The entropy of the random generator is increased
+    // by random data received from a rippled
+    remote.once('random', function(err, info) {
+      var wallet = ripple.Wallet.generate();
+      console.log(wallet);
+      // { address: 'rEf4sbVobiiDGExrNj2PkNHGMA8eS6jWh3',
+      //   secret: 'shFh4a38EZpEdZxrLifEnVPAoBRce' }
+    });
+  ```
+
 
 ##Sending rippled API requests
 
@@ -201,9 +217,9 @@ Since the fee required for a transaction may change between the time when the or
 The [`max_fee`](REFERENCE.md#1-remote-options) option can be used to avoid submitting a transaction to a server that is charging unreasonably high fees.
 
 
-##4. Submitting a trade offer to the network
+##Submitting a trade offer to the network
 
-Submitting a trade offer to the network is similar to submitting a payment transaction. Here is an example for a trade that expires in 24 hours where you are offering to sell 1 USD in exchange for 100 XRP:
+Submitting a trade offer to the network is similar to submitting a payment transaction. Here is an example offering to sell 1 USD in exchange for 100 XRP:
 
 ```js
 /* Loading ripple-lib Remote and Amount modules in Node.js */
@@ -225,7 +241,7 @@ remote.connect(function() {
 
   var transaction = remote.createTransaction('OfferCreate', {
     account: MY_ADDRESS,
-    taker_pays: '1',
+    taker_pays: '100',
     taker_gets: '1/USD/' + GATEWAY
   });
 

npm-shrinkwrap.json

@@ -1,140 +1,72 @@
 {
   "name": "ripple-lib",
-  "version": "0.9.3",
+  "version": "0.12.5-rc2",
+  "npm-shrinkwrap-version": "5.4.0",
+  "node-version": "v0.10.38",
   "dependencies": {
     "async": {
-      "version": "0.8.0",
-      "from": "async@>=0.8.0 <0.9.0"
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/async/-/async-0.9.0.tgz"
+    },
+    "bignumber.js": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-2.0.7.tgz"
     },
     "extend": {
       "version": "1.2.1",
-      "from": "extend@>=1.2.1 <1.3.0"
+      "resolved": "https://registry.npmjs.org/extend/-/extend-1.2.1.tgz"
+    },
+    "lodash": {
+      "version": "3.7.0",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.7.0.tgz"
     },
     "lru-cache": {
-      "version": "2.5.0",
-      "from": "lru-cache@>=2.5.0 <2.6.0"
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.5.2.tgz"
     },
     "ripple-wallet-generator": {
-      "version": "1.0.1",
-      "from": "ripple-wallet-generator@1.0.1",
-      "resolved": "https://registry.npmjs.org/ripple-wallet-generator/-/ripple-wallet-generator-1.0.1.tgz"
-    },
-    "superagent": {
-      "version": "0.18.2",
-      "from": "superagent@>=0.18.0 <0.19.0",
-      "dependencies": {
-        "qs": {
-          "version": "0.6.6",
-          "from": "qs@0.6.6",
-          "resolved": "https://registry.npmjs.org/qs/-/qs-0.6.6.tgz"
-        },
-        "formidable": {
-          "version": "1.0.14",
-          "from": "formidable@1.0.14",
-          "resolved": "https://registry.npmjs.org/formidable/-/formidable-1.0.14.tgz"
-        },
-        "mime": {
-          "version": "1.2.11",
-          "from": "mime@1.2.11",
-          "resolved": "https://registry.npmjs.org/mime/-/mime-1.2.11.tgz"
-        },
-        "component-emitter": {
-          "version": "1.1.2",
-          "from": "component-emitter@1.1.2",
-          "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.1.2.tgz"
-        },
-        "methods": {
-          "version": "1.0.1",
-          "from": "methods@1.0.1",
-          "resolved": "https://registry.npmjs.org/methods/-/methods-1.0.1.tgz"
-        },
-        "cookiejar": {
-          "version": "2.0.1",
-          "from": "cookiejar@2.0.1",
-          "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.0.1.tgz"
-        },
-        "debug": {
-          "version": "1.0.4",
-          "from": "debug@>=1.0.1 <1.1.0",
-          "dependencies": {
-            "ms": {
-              "version": "0.6.2",
-              "from": "ms@0.6.2",
-              "resolved": "https://registry.npmjs.org/ms/-/ms-0.6.2.tgz"
-            }
-          }
-        },
-        "reduce-component": {
-          "version": "1.0.1",
-          "from": "reduce-component@1.0.1",
-          "resolved": "https://registry.npmjs.org/reduce-component/-/reduce-component-1.0.1.tgz"
-        },
-        "form-data": {
-          "version": "0.1.3",
-          "from": "form-data@0.1.3",
-          "resolved": "https://registry.npmjs.org/form-data/-/form-data-0.1.3.tgz",
-          "dependencies": {
-            "combined-stream": {
-              "version": "0.0.5",
-              "from": "combined-stream@>=0.0.4 <0.1.0",
-              "dependencies": {
-                "delayed-stream": {
-                  "version": "0.0.5",
-                  "from": "delayed-stream@0.0.5",
-                  "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-0.0.5.tgz"
-                }
-              }
-            },
-            "async": {
-              "version": "0.9.0",
-              "from": "async@>=0.9.0 <0.10.0"
-            }
-          }
-        },
-        "readable-stream": {
-          "version": "1.0.27-1",
-          "from": "readable-stream@1.0.27-1",
-          "dependencies": {
-            "core-util-is": {
-              "version": "1.0.1",
-              "from": "core-util-is@>=1.0.0 <1.1.0"
-            },
-            "isarray": {
-              "version": "0.0.1",
-              "from": "isarray@0.0.1",
-              "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
-            },
-            "string_decoder": {
-              "version": "0.10.31",
-              "from": "string_decoder@>=0.10.0 <0.11.0"
-            },
-            "inherits": {
-              "version": "2.0.1",
-              "from": "inherits@>=2.0.1 <2.1.0"
-            }
-          }
-        }
-      }
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/ripple-wallet-generator/-/ripple-wallet-generator-1.0.3.tgz"
     },
     "ws": {
-      "version": "0.4.32",
-      "from": "ws@>=0.4.31 <0.5.0",
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-0.7.1.tgz",
       "dependencies": {
-        "commander": {
-          "version": "2.1.0",
-          "from": "commander@>=2.1.0 <2.2.0"
+        "bufferutil": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-1.0.1.tgz",
+          "dependencies": {
+            "bindings": {
+              "version": "1.2.1",
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
             },
             "nan": {
-          "version": "1.0.0",
-          "from": "nan@>=1.0.0 <1.1.0"
-        },
-        "tinycolor": {
-          "version": "0.0.1",
-          "from": "tinycolor@>=0.0.0 <1.0.0"
+              "version": "1.6.2",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.6.2.tgz"
+            }
+          }
         },
         "options": {
           "version": "0.0.6",
-          "from": "options@>=0.0.5"
+          "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz"
+        },
+        "ultron": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.1.tgz"
+        },
+        "utf-8-validate": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-1.0.1.tgz",
+          "dependencies": {
+            "bindings": {
+              "version": "1.2.1",
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
+            },
+            "nan": {
+              "version": "1.6.2",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.6.2.tgz"
+            }
+          }
         }
       }
     }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripple-lib",
-  "version": "0.9.3",
+  "version": "0.12.5-rc2",
   "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
   "files": [
     "src/js/*",
@@ -15,33 +15,44 @@
     "test": "test"
   },
   "dependencies": {
-    "async": "~0.8.0",
-    "ws": "~0.4.31",
+    "async": "~0.9.0",
+    "bignumber.js": "^2.0.3",
     "extend": "~1.2.1",
+    "lodash": "^3.1.0",
     "lru-cache": "~2.5.0",
-    "superagent": "^0.18.0",
-    "ripple-wallet-generator": "1.0.1"
+    "ripple-wallet-generator": "^1.0.3",
+    "ws": "~0.7.1"
   },
   "devDependencies": {
-    "mocha": "~1.14.0",
-    "gulp": "~3.6.2",
-    "gulp-concat": "~2.2.0",
-    "gulp-jshint": "~1.5.5",
-    "gulp-uglify": "~0.3.0",
-    "gulp-rename": "~1.2.0",
-    "gulp-bump": "~0.1.10",
-    "webpack": "~1.1.11",
-    "map-stream": "~0.1.0",
-    "istanbul": "~0.2.10",
+    "assert-diff": "^1.0.1",
     "coveralls": "~2.10.0",
+    "eslint": "^0.18.0",
+    "gulp": "~3.8.10",
+    "gulp-bump": "~0.1.13",
+    "gulp-clean-dest": "^0.1.0",
+    "gulp-concat": "~2.4.3",
+    "gulp-filelog": "^0.4.1",
+    "gulp-flowtype": "^0.4.1",
+    "gulp-plumber": "^0.6.6",
+    "gulp-react": "^2.0.0",
+    "gulp-rename": "~1.2.0",
+    "gulp-uglify": "~1.1.0",
+    "gulp-util": "^3.0.3",
+    "gulp-watch": "^4.1.0",
+    "istanbul": "~0.3.5",
+    "map-stream": "~0.1.0",
+    "mocha": "~2.1.0",
     "nock": "^0.34.1",
+    "webpack": "~1.5.3",
     "yargs": "~1.3.1"
   },
   "scripts": {
     "build": "node_modules/.bin/gulp",
     "pretest": "node_modules/.bin/gulp concat-sjcl",
-    "test": "./node_modules/.bin/istanbul test -x build/sjcl.js -x src/js/jsbn/* ./node_modules/mocha/bin/_mocha -- --reporter spec test/*-test.js",
-    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
+    "test": "./node_modules/.bin/istanbul test -x build/sjcl.js -x src/js/jsbn/* ./node_modules/mocha/bin/_mocha -- --reporter ${MOCHA_REPORTER:=spec} --timeout 10000 --slow 500 test/*-test.js",
+    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls",
+    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/master/eslintrc'; fi; eslint --reset -c eslintrc src/js/ripple/*.js",
+    "perf": "./scripts/perf_test.sh"
   },
   "repository": {
     "type": "git",

scripts/perf_test.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+URL="https://www.dropbox.com/s/a0gy7vbb86eeqlq/ledger-full-1000000.json?dl=1"
+DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+DEST="$DIR/cache/ledger-full-1000000.json"
+if [ ! -e "$DEST" ]
+then
+  echo "Downloading test data..."
+  mkdir -p "$DIR/cache"
+  curl -L "$URL" > "$DEST"
+fi
+time node "$DIR/verify_ledger_json.js" "$DEST"

scripts/verify_ledger_json.js

@@ -1,31 +1,34 @@
+'use strict';
+
 var fs = require('fs');
+var Amount = require('../src/js/ripple').Amount;
 var Ledger = require('../src/js/ripple/ledger').Ledger;
 
 function parse_options(from, flags) {
   var argv = from.slice(),
-      opts = {argv:argv};
+      opts_ = {argv: argv};
 
   flags.forEach(function(f) {
     // Do we have the flag?
     var flag_index = argv.indexOf('--' + f);
     // normalize the name of the flag
     f = f.replace('-', '_');
-    // opts has Boolean value for normalized flag key
-    opts[f] = !!~flag_index;
-    if (opts[f]) {
+    // opts_ has Boolean value for normalized flag key
+    opts_[f] = flag_index !== -1;
+    if (opts_[f]) {
       // remove the flag from the argv
       argv.splice(flag_index, 1);
     }
   });
-  return opts;
+  return opts_;
 }
 
 var opts = parse_options(process.argv.slice(2), // remove `node` and `this.js`
                         ['sanity-test']);
 
 if (opts.argv.length < 1) {
-  console.error("Usage: scripts/verify_ledger_json path/to/ledger.json");
-  console.error("       optional: --sanity-test (json>binary>json>binary)");
+  console.error('Usage: scripts/verify_ledger_json path/to/ledger.json');
+  console.error('       optional: --sanity-test (json>binary>json>binary)');
   process.exit(1);
 }
 
@@ -36,14 +39,27 @@ var ledger = Ledger.from_json(JSON.parse(json));
 // before finally serializing for hashing. This is mostly to expose any issues
 // with ripple-libs binary <--> json codecs.
 if (opts.sanity_test) {
-    console.log("All accountState nodes will be processed from " +
-                "json->binary->json->binary. This may take some time " +
-                "with large ledgers.");
+  console.log('All accountState nodes will be processed from ' +
+              'json->binary->json->binary. This may take some time ' +
+              'with large ledgers.');
 }
 
-console.log("Transaction hash in header:    " + ledger.ledger_json.transaction_hash);
-console.log("Calculated transaction hash:   " + ledger.calc_tx_hash().to_hex());
-console.log("Account state hash in header:  " + ledger.ledger_json.account_hash);
-console.log("Calculated account state hash: " + ledger.calc_account_hash(
-                                                 {sanity_test:opts.sanity_test})
+// To recompute the hashes of some ledgers, we must allow values that slipped in
+// before strong policies were in place.
+Amount.strict_mode = false;
+
+console.log('Transaction hash in header:    ' +
+             ledger.ledger_json.transaction_hash);
+console.log('Calculated transaction hash:   ' +
+             ledger.calc_tx_hash().to_hex());
+
+console.log('Account state hash in header:  ' +
+             ledger.ledger_json.account_hash);
+
+if (ledger.ledger_json.accountState) {
+  console.log('Calculated account state hash: ' +
+               ledger.calc_account_hash({sanity_test: opts.sanity_test})
                                                       .to_hex());
+} else {
+  console.log('Ledger has no accountState');
+}

src/js/ripple/account.js

@@ -45,7 +45,7 @@ function Account(remote, account) {
       if (!self._subs && self._remote._connected) {
         self._remote.request_subscribe()
         .add_account(self._account_id)
-        .broadcast();
+        .broadcast().request();
       }
       self._subs += 1;
     }
@@ -59,7 +59,7 @@ function Account(remote, account) {
       if (!self._subs && self._remote._connected) {
         self._remote.request_unsubscribe()
         .add_account(self._account_id)
-        .broadcast();
+        .broadcast().request();
       }
     }
   };

src/js/ripple/authinfo.js

@@ -1,59 +0,0 @@
-var async      = require('async');
-var superagent = require('superagent');
-var RippleTxt  = require('./rippletxt').RippleTxt;
-
-var AuthInfo = { };
-
-AuthInfo._getRippleTxt = function(domain, callback) {
-  RippleTxt.get(domain, callback);
-};
-
-AuthInfo._getUser = function(url, callback) {
-  superagent.get(url, callback);
-};
-
-
-/**
- * Get auth info for a given username
- *
- * @param {string}    domain - Domain which hosts the user's info
- * @param {string}    username - Username who's info we are retreiving
- * @param {function}  fn - Callback function
- */
-
-AuthInfo.get = function(domain, username, callback) {
-  var self = this;
-  username = username.toLowerCase();
-  
-  function getRippleTxt(callback) {
-    self._getRippleTxt(domain, function(err, txt) {
-      if (err) {
-        return callback(err);
-      }
-
-      if (!txt.authinfo_url) {
-        return callback(new Error('Authentication is not supported on ' + domain));
-      }
-
-      var url = Array.isArray(txt.authinfo_url) ? txt.authinfo_url[0] : txt.authinfo_url;
-
-      url += '?domain=' + domain + '&username=' + username;
-
-      callback(null, url);
-    });
-  };
-
-  function getUser(url, callback) {
-    self._getUser(url, function(err, res) {
-      if (err || res.error) {
-        callback(new Error('Authentication info server unreachable'));
-      } else {
-        callback(null, res.body);
-      }
-    });
-  };
-
-  async.waterfall([ getRippleTxt, getUser ], callback);
-};
-
-exports.AuthInfo = AuthInfo;

src/js/ripple/autobridgecalculator.js

@@ -0,0 +1,435 @@
+'use strict';
+
+var _ = require('lodash');
+var assert = require('assert');
+var UInt160 = require('./uint160').UInt160;
+var Amount = require('./amount').Amount;
+var Utils = require('./orderbookutils');
+
+function assertValidNumber(number, message) {
+  assert(!_.isNull(number) && !isNaN(number), message);
+}
+
+function assertValidLegOneOffer(legOneOffer, message) {
+  assert(legOneOffer);
+  assert.strictEqual(typeof legOneOffer, 'object', message);
+  assert.strictEqual(typeof legOneOffer.TakerPays, 'object', message);
+  assertValidNumber(legOneOffer.TakerGets, message);
+}
+
+function AutobridgeCalculator(currencyGets, currencyPays,
+  legOneOffers, legTwoOffers) {
+  this._currencyGets = currencyGets;
+  this._currencyPays = currencyPays;
+  this.legOneOffers = _.cloneDeep(legOneOffers);
+  this.legTwoOffers = _.cloneDeep(legTwoOffers);
+
+  this._ownerFundsLeftover = {};
+}
+
+/**
+ * Calculates an ordered array of autobridged offers by quality
+ *
+ * @return {Array}
+ */
+
+AutobridgeCalculator.prototype.calculate = function() {
+  var legOnePointer = 0;
+  var legTwoPointer = 0;
+
+  var offersAutobridged = [];
+
+  this.clearOwnerFundsLeftover();
+
+  while (this.legOneOffers[legOnePointer] && this.legTwoOffers[legTwoPointer]) {
+    var legOneOffer = this.legOneOffers[legOnePointer];
+    var legTwoOffer = this.legTwoOffers[legTwoPointer];
+    var leftoverFunds = this.getLeftoverOwnerFunds(legOneOffer.Account);
+    var autobridgedOffer;
+
+    if (legOneOffer.Account === legTwoOffer.Account) {
+      this.unclampLegOneOwnerFunds(legOneOffer);
+    } else if (!legOneOffer.is_fully_funded && !leftoverFunds.is_zero()) {
+      this.adjustLegOneFundedAmount(legOneOffer);
+    }
+
+    var legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+    var legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+
+    if (legOneTakerGetsFunded.is_zero()) {
+      legOnePointer++;
+
+      continue;
+    }
+
+    if (legTwoTakerPaysFunded.is_zero()) {
+      legTwoPointer++;
+
+      continue;
+    }
+
+    if (legOneTakerGetsFunded.compareTo(legTwoTakerPaysFunded) > 0) {
+      autobridgedOffer = this.getAutobridgedOfferWithClampedLegOne(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legTwoPointer++;
+    } else if (legTwoTakerPaysFunded.compareTo(legOneTakerGetsFunded) > 0) {
+      autobridgedOffer = this.getAutobridgedOfferWithClampedLegTwo(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legOnePointer++;
+    } else {
+      autobridgedOffer = this.getAutobridgedOfferWithoutClamps(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legOnePointer++;
+      legTwoPointer++;
+    }
+
+    offersAutobridged.push(autobridgedOffer);
+  }
+
+  return offersAutobridged;
+};
+
+/**
+ * In this case, the output from leg one is greater than the input to leg two.
+ * Therefore, we must effectively clamp leg one output to leg two input.
+ *
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegOne =
+function(legOneOffer, legTwoOffer) {
+  var legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+  var legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+  var legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+
+  var autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
+  var autobridgedTakerPays = legTwoTakerPaysFunded.multiply(legOneQuality);
+
+  if (legOneOffer.Account === legTwoOffer.Account) {
+    var legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    var updatedTakerGets = legOneTakerGets.subtract(legTwoTakerPaysFunded);
+
+    this.setLegOneTakerGets(legOneOffer, updatedTakerGets);
+
+    this.clampLegOneOwnerFunds(legOneOffer);
+  } else {
+    // Update funded amount since leg one offer was not completely consumed
+    var updatedTakerGetsFunded = legOneTakerGetsFunded
+      .subtract(legTwoTakerPaysFunded);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, updatedTakerGetsFunded);
+  }
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * In this case, the input from leg two is greater than the output to leg one.
+ * Therefore, we must effectively clamp leg two input to leg one output.
+ *
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegTwo =
+function(legOneOffer, legTwoOffer) {
+  var legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+  var legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+  var legTwoQuality = Utils.getOfferQuality(legTwoOffer, this._currencyGets);
+
+  var autobridgedTakerGets = legOneTakerGetsFunded.divide(legTwoQuality);
+  var autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+
+  // Update funded amount since leg two offer was not completely consumed
+  legTwoOffer.taker_gets_funded = Utils.getOfferTakerGetsFunded(legTwoOffer)
+    .subtract(autobridgedTakerGets)
+    .to_text();
+  legTwoOffer.taker_pays_funded = legTwoTakerPaysFunded
+    .subtract(legOneTakerGetsFunded)
+    .to_text();
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * In this case, the output from leg one and the input to leg two are the same.
+ * We do not need to clamp either.
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithoutClamps =
+function(legOneOffer, legTwoOffer) {
+  var autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
+  var autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * Clear owner funds leftovers
+ */
+
+AutobridgeCalculator.prototype.clearOwnerFundsLeftover = function() {
+  this._ownerFundsLeftover = {};
+};
+
+/**
+ * Reset owner funds leftovers for an account to 0
+ *
+ * @param {String} account
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.resetOwnerFundsLeftover = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+
+  this._ownerFundsLeftover[account] = Utils.normalizeAmount('0');
+
+  return this._ownerFundsLeftover[account];
+};
+
+/**
+ * Retrieve leftover funds found after clamping leg one by account
+ *
+ * @param {String} account
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.getLeftoverOwnerFunds = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+
+  var amount = this._ownerFundsLeftover[account];
+
+  if (!amount) {
+    amount = Utils.normalizeAmount('0');
+  }
+
+  return amount;
+};
+
+/**
+ * Add funds to account's leftover funds
+ *
+ * @param {String} account
+ * @param {Amount} amount
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.addLeftoverOwnerFunds =
+function(account, amount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(amount instanceof Amount, 'Amount is invalid');
+
+  this._ownerFundsLeftover[account] = this.getLeftoverOwnerFunds(account)
+    .add(amount);
+
+  return this._ownerFundsLeftover[account];
+};
+
+/**
+ * Set account's leftover funds
+ *
+ * @param {String} account
+ * @param {Amount} amount
+ */
+
+AutobridgeCalculator.prototype.setLeftoverOwnerFunds =
+function(account, amount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(amount instanceof Amount, 'Amount is invalid');
+
+  this._ownerFundsLeftover[account] = amount;
+};
+
+/**
+ * Format an autobridged offer and compute synthetic values (e.g. quality)
+ *
+ * @param {Amount} takerGets
+ * @param {Amount} takerPays
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.formatAutobridgedOffer =
+function(takerGets, takerPays) {
+  assert(takerGets instanceof Amount, 'Autobridged taker gets is invalid');
+  assert(takerPays instanceof Amount, 'Autobridged taker pays is invalid');
+
+  var autobridgedOffer = {};
+  var quality = takerPays.divide(takerGets);
+
+  autobridgedOffer.TakerGets = {
+    value: takerGets.to_text(),
+    currency: this._currencyGets.to_hex(),
+    issuer: this._issuerGets
+  };
+
+  autobridgedOffer.TakerPays = {
+    value: takerPays.to_text(),
+    currency: this._currencyPays.to_hex(),
+    issuer: this._issuerPays
+  };
+
+  autobridgedOffer.quality = quality.to_text();
+
+  autobridgedOffer.taker_gets_funded = autobridgedOffer.TakerGets.value;
+  autobridgedOffer.taker_pays_funded = autobridgedOffer.TakerPays.value;
+
+  autobridgedOffer.autobridged = true;
+
+  autobridgedOffer.BookDirectory = Utils.convertOfferQualityToHex(quality);
+
+  return autobridgedOffer;
+};
+
+/**
+ * Remove funds clamp on leg one offer. This is necessary when the two offers
+ * are owned by the same account. In this case, it doesn't matter if offer one
+ * is not fully funded. Leg one out goes to leg two in and since its the same
+ * account, an infinite amount can flow.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.unclampLegOneOwnerFunds = function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+
+  legOneOffer.initTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+
+  this.setLegOneTakerGetsFunded(
+    legOneOffer,
+    Utils.getOfferTakerGets(legOneOffer)
+  );
+};
+
+/**
+ * Apply clamp back on leg one offer after a round of autobridge calculation
+ * completes. We must reapply clamps that have been removed because we cannot
+ * guarantee that the next offer from leg two will also be from the same
+ * account.
+ *
+ * When we reapply, it could happen that the amount of TakerGets left after
+ * the autobridge calculation is less than the original funded amount. In this
+ * case, we have extra funds we can use towards unfunded offers with worse
+ * quality by the same owner.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.clampLegOneOwnerFunds = function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+
+  var takerGets = Utils.getOfferTakerGets(legOneOffer);
+
+  if (takerGets.compareTo(legOneOffer.initTakerGetsFunded) > 0) {
+    // After clamping, TakerGets is still greater than initial funded amount
+    this.setLegOneTakerGetsFunded(legOneOffer, legOneOffer.initTakerGetsFunded);
+  } else {
+    var updatedLeftover = legOneOffer.initTakerGetsFunded.subtract(takerGets);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, takerGets);
+    this.addLeftoverOwnerFunds(legOneOffer.Account, updatedLeftover);
+  }
+};
+
+/**
+ * Increase leg one offer funded amount with extra funds found after applying
+ * clamp.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.adjustLegOneFundedAmount =
+function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(!legOneOffer.is_fully_funded, 'Leg one offer cannot be fully funded');
+
+  var fundedSum = Utils.getOfferTakerGetsFunded(legOneOffer)
+    .add(this.getLeftoverOwnerFunds(legOneOffer.Account));
+
+  if (fundedSum.compareTo(Utils.getOfferTakerGets(legOneOffer)) >= 0) {
+    // There are enough extra funds to fully fund the offer
+    var legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    var updatedLeftover = fundedSum.subtract(legOneTakerGets);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, legOneTakerGets);
+    this.setLeftoverOwnerFunds(legOneOffer.Account, updatedLeftover);
+  } else {
+    // There are not enough extra funds to fully fund the offer
+    this.setLegOneTakerGetsFunded(legOneOffer, fundedSum);
+    this.resetOwnerFundsLeftover(legOneOffer.Account);
+  }
+};
+
+/**
+ * Set taker gets funded amount for a IOU:XRP offer. Also calculates taker
+ * pays funded using offer quality and updates is_fully_funded flag
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ * @param {Amount} takerGetsFunded
+ */
+
+AutobridgeCalculator.prototype.setLegOneTakerGetsFunded =
+function setLegOneTakerGetsFunded(legOneOffer, takerGetsFunded) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(takerGetsFunded instanceof Amount, 'Taker gets funded is invalid');
+
+  legOneOffer.taker_gets_funded = takerGetsFunded.to_text();
+  legOneOffer.taker_pays_funded = takerGetsFunded
+    .multiply(Utils.getOfferQuality(legOneOffer, this._currencyGets))
+    .to_text();
+
+  if (legOneOffer.taker_gets_funded === legOneOffer.TakerGets.value) {
+    legOneOffer.is_fully_funded = true;
+  }
+};
+
+/**
+ * Set taker gets amount for a IOU:XRP offer. Also calculates taker pays
+ * using offer quality
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ * @param {Amount} takerGets
+ */
+
+AutobridgeCalculator.prototype.setLegOneTakerGets =
+function(legOneOffer, takerGets) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(takerGets instanceof Amount, 'Taker gets funded is invalid');
+
+  var legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+
+  legOneOffer.TakerGets = takerGets.to_text();
+  legOneOffer.TakerPays = takerGets.multiply(legOneQuality);
+};
+
+module.exports = AutobridgeCalculator;

src/js/ripple/base.js

@@ -1,8 +1,9 @@
+'use strict';
+var _ = require('lodash');
 var sjcl = require('./utils').sjcl;
 var utils = require('./utils');
 var extend = require('extend');
-
-var BigInteger = utils.jsbn.BigInteger;
+var convertBase = require('./baseconverter');
 
 var Base = {};
 
@@ -13,110 +14,99 @@ var alphabets = Base.alphabets = {
 };
 
 extend(Base, {
-  VER_NONE              : 1,
-  VER_NODE_PUBLIC       : 28,
-  VER_NODE_PRIVATE      : 32,
-  VER_ACCOUNT_ID        : 0,
-  VER_ACCOUNT_PUBLIC    : 35,
-  VER_ACCOUNT_PRIVATE   : 34,
-  VER_FAMILY_GENERATOR  : 41,
-  VER_FAMILY_SEED       : 33
+  VER_NONE: 1,
+  VER_NODE_PUBLIC: 28,
+  VER_NODE_PRIVATE: 32,
+  VER_ACCOUNT_ID: 0,
+  VER_ACCOUNT_PUBLIC: 35,
+  VER_ACCOUNT_PRIVATE: 34,
+  VER_FAMILY_GENERATOR: 41,
+  VER_FAMILY_SEED: 33
 });
 
 function sha256(bytes) {
-  return sjcl.codec.bytes.fromBits(sjcl.hash.sha256.hash(sjcl.codec.bytes.toBits(bytes)));
-};
+  return sjcl.codec.bytes.fromBits(
+    sjcl.hash.sha256.hash(sjcl.codec.bytes.toBits(bytes)));
+}
 
-function sha256hash(bytes) {
-  return sha256(sha256(bytes));
-};
+function encodeString(alphabet, input) {
+  if (input.length === 0) {
+    return '';
+  }
+
+  var leadingZeros = _.takeWhile(input, function(d) {
+    return d === 0;
+  });
+  var out = convertBase(input, 256, 58).map(function(digit) {
+    if (digit < 0 || digit >= alphabet.length) {
+      throw new Error('Value ' + digit + ' is out of bounds for encoding');
+    }
+    return alphabet[digit];
+  });
+  var prefix = leadingZeros.map(function() {
+    return alphabet[0];
+  });
+  return prefix.concat(out).join('');
+}
+
+function decodeString(indexes, input) {
+  if (input.length === 0) {
+    return [];
+  }
+
+  var input58 = input.split('').map(function(c) {
+    var charCode = c.charCodeAt(0);
+    if (charCode >= indexes.length || indexes[charCode] === -1) {
+      throw new Error('Character ' + c + ' is not valid for encoding');
+    }
+    return indexes[charCode];
+  });
+  var leadingZeros = _.takeWhile(input58, function(d) {
+    return d === 0;
+  });
+  var out = convertBase(input58, 58, 256);
+  return leadingZeros.concat(out);
+}
+
+function Base58(alphabet) {
+  var indexes = utils.arraySet(128, -1);
+  for (var i = 0; i < alphabet.length; i++) {
+    indexes[alphabet.charCodeAt(i)] = i;
+  }
+  return {
+    decode: decodeString.bind(null, indexes),
+    encode: encodeString.bind(null, alphabet)
+  };
+}
+
+Base.encoders = {};
+Object.keys(alphabets).forEach(function(alphabet) {
+  Base.encoders[alphabet] = new Base58(alphabets[alphabet]);
+});
 
 // --> input: big-endian array of bytes.
 // <-- string at least as long as input.
 Base.encode = function(input, alpha) {
-  var alphabet = alphabets[alpha || 'ripple'];
-  var bi_base  = new BigInteger(String(alphabet.length));
-  var bi_q     = new BigInteger();
-  var bi_r     = new BigInteger();
-  var bi_value = new BigInteger(input);
-  var buffer   = [];
-
-  while (bi_value.compareTo(BigInteger.ZERO) > 0) {
-    bi_value.divRemTo(bi_base, bi_q, bi_r);
-    bi_q.copyTo(bi_value);
-    buffer.push(alphabet[bi_r.intValue()]);
-  }
-
-  for (var i=0; i !== input.length && !input[i]; i += 1) {
-    buffer.push(alphabet[0]);
-  }
-
-  return buffer.reverse().join('');
+  return this.encoders[alpha || 'ripple'].encode(input);
 };
 
 // --> input: String
 // <-- array of bytes or undefined.
 Base.decode = function(input, alpha) {
   if (typeof input !== 'string') {
-    return void(0);
+    return undefined;
   }
-
-  var alphabet = alphabets[alpha || 'ripple'];
-  var bi_base  = new BigInteger(String(alphabet.length));
-  var bi_value = new BigInteger();
-  var i;
-
-  for (i = 0; i !== input.length && input[i] === alphabet[0]; i += 1) {
+  try {
+    return this.encoders[alpha || 'ripple'].decode(input);
+  } catch (e) {
+    return undefined;
   }
-
-  for (; i !== input.length; i += 1) {
-    var v = alphabet.indexOf(input[i]);
-
-    if (v < 0) {
-      return void(0);
-    }
-
-    var r = new BigInteger();
-    r.fromInt(v);
-    bi_value  = bi_value.multiply(bi_base).add(r);
-  }
-
-  // toByteArray:
-  // - Returns leading zeros!
-  // - Returns signed bytes!
-  var bytes =  bi_value.toByteArray().map(function(b) { return b ? b < 0 ? 256+b : b : 0; });
-  var extra = 0;
-
-  while (extra !== bytes.length && !bytes[extra]) {
-    extra += 1;
-  }
-
-  if (extra) {
-    bytes = bytes.slice(extra);
-  }
-
-  var zeros = 0;
-
-  while (zeros !== input.length && input[zeros] === alphabet[0]) {
-    zeros += 1;
-  }
-
-  return [].concat(utils.arraySet(zeros, 0), bytes);
 };
 
 Base.verify_checksum = function(bytes) {
-  var computed = sha256hash(bytes.slice(0, -4)).slice(0, 4);
+  var computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
   var checksum = bytes.slice(-4);
-  var result = true;
-
-  for (var i=0; i<4; i++) {
-    if (computed[i] !== checksum[i]) {
-      result = false;
-      break;
-    }
-  }
-
-  return result;
+  return _.isEqual(computed, checksum);
 };
 
 // --> input: Array
@@ -129,7 +119,7 @@ Base.encode_check = function(version, input, alphabet) {
 };
 
 // --> input : String
-// <-- NaN || BigInteger
+// <-- NaN || sjcl.bn
 Base.decode_check = function(version, input, alphabet) {
   var buffer = Base.decode(input, alphabet);
 
@@ -143,17 +133,11 @@ Base.decode_check = function(version, input, alphabet) {
   }
 
   // Multiple allowed versions
-  if (Array.isArray(version)) {
-    var match = false;
-
-    for (var i=0, l=version.length; i<l; i++) {
-      match |= version[i] === buffer[0];
-    }
-
-    if (!match) {
+  if (Array.isArray(version) && _.every(version, function(v) {
+          return v !== buffer[0];
+      })) {
     return NaN;
   }
-  }
 
   if (!Base.verify_checksum(buffer)) {
     return NaN;
@@ -163,7 +147,8 @@ Base.decode_check = function(version, input, alphabet) {
   // intrepret the value as a negative number
   buffer[0] = 0;
 
-  return new BigInteger(buffer.slice(0, -4), 256);
+  return sjcl.bn.fromBits(
+      sjcl.codec.bytes.toBits(buffer.slice(0, -4)));
 };
 
 exports.Base = Base;

src/js/ripple/baseconverter.js

@@ -0,0 +1,32 @@
+'use strict';
+
+function normalize(digitArray) {
+  while (digitArray[0] === 0) {
+    digitArray.shift();
+  }
+  return digitArray;
+}
+
+function divmod(digitArray, base, divisor) {
+  var remainder = 0;
+  var quotient = [];
+  for (var j = 0; j < digitArray.length; j++) {
+    var temp = remainder * base + parseInt(digitArray[j], 10);
+    quotient.push(Math.floor(temp / divisor));
+    remainder = temp % divisor;
+  }
+  return {quotient: normalize(quotient), remainder: remainder};
+}
+
+function convertBase(digitArray, fromBase, toBase) {
+  var result = [];
+  var dividend = digitArray;
+  while (dividend.length > 0) {
+    var qr = divmod(dividend, fromBase, toBase);
+    result.unshift(qr.remainder);
+    dividend = qr.quotient;
+  }
+  return normalize(result);
+}
+
+module.exports = convertBase;

src/js/ripple/binformat.js

@@ -1,10 +1,19 @@
+'use strict';
+
+/*eslint no-multi-spaces:0,space-in-brackets:0,key-spacing:0,comma-spacing:0*/
+
 /**
  * Data type map.
  *
  * Mapping of type ids to data types. The type id is specified by the high
+ *
+ * For reference, see rippled's definition:
+ * https://github.com/ripple/rippled/blob/develop/src/ripple/data/protocol
+ *                                                              /SField.cpp
  */
-var TYPES_MAP = exports.types = [
-  void(0),
+
+exports.types = [
+  undefined,
 
   // Common
   'Int16',    // 1
@@ -17,11 +26,11 @@ var TYPES_MAP = exports.types = [
   'Account',  // 8
 
   // 9-13 reserved
-  void(0),    // 9
-  void(0),    // 10
-  void(0),    // 11
-  void(0),    // 12
-  void(0),    // 13
+  undefined,    // 9
+  undefined,    // 10
+  undefined,    // 11
+  undefined,    // 12
+  undefined,    // 13
 
   'Object',   // 14
   'Array',    // 15
@@ -148,7 +157,7 @@ var FIELDS_MAP = exports.fields = {
     8: 'RegularKey'
   },
   14: { // Object
-    1: void(0),  //end of Object
+    1: undefined,  // end of Object
     2: 'TransactionMetaData',
     3: 'CreatedNode',
     4: 'DeletedNode',
@@ -160,7 +169,7 @@ var FIELDS_MAP = exports.fields = {
     10: 'Memo'
   },
   15: { // Array
-    1: void(0),  //end of Array
+    1: undefined,  // end of Array
     2: 'SigningAccounts',
     3: 'TxnSignatures',
     4: 'Signatures',
@@ -201,7 +210,6 @@ Object.keys(FIELDS_MAP).forEach(function(k1) {
   });
 });
 
-
 var REQUIRED = exports.REQUIRED = 0,
     OPTIONAL = exports.OPTIONAL = 1,
     DEFAULT  = exports.DEFAULT  = 2;
@@ -226,7 +234,9 @@ exports.tx = {
     [ 'WalletSize'         , OPTIONAL ],
     [ 'MessageKey'         , OPTIONAL ],
     [ 'Domain'             , OPTIONAL ],
-    [ 'TransferRate'       , OPTIONAL ]
+    [ 'TransferRate'       , OPTIONAL ],
+    [ 'SetFlag'            , OPTIONAL ],
+    [ 'ClearFlag'          , OPTIONAL ]
   ]),
   TrustSet: [20].concat(base, [
     [ 'LimitAmount'        , OPTIONAL ],
@@ -236,13 +246,14 @@ exports.tx = {
   OfferCreate: [7].concat(base, [
     [ 'TakerPays'          , REQUIRED ],
     [ 'TakerGets'          , REQUIRED ],
-    [ 'Expiration'         , OPTIONAL ]
+    [ 'Expiration'         , OPTIONAL ],
+    [ 'OfferSequence'      , OPTIONAL ]
   ]),
   OfferCancel: [8].concat(base, [
     [ 'OfferSequence'      , REQUIRED ]
   ]),
   SetRegularKey: [5].concat(base, [
-    [ 'RegularKey'         , REQUIRED ]
+    [ 'RegularKey'         , OPTIONAL ]
   ]),
   Payment: [0].concat(base, [
     [ 'Destination'        , REQUIRED ],
@@ -268,12 +279,21 @@ exports.tx = {
   EnableFeature: [100].concat(base, [
     [ 'Feature'            , REQUIRED ]
   ]),
+  EnableAmendment: [100].concat(base, [
+    [ 'Amendment'          , REQUIRED ]
+  ]),
   SetFee: [101].concat(base, [
-    [ 'Features'           , REQUIRED ],
     [ 'BaseFee'            , REQUIRED ],
     [ 'ReferenceFeeUnits'  , REQUIRED ],
     [ 'ReserveBase'        , REQUIRED ],
     [ 'ReserveIncrement'   , REQUIRED ]
+  ]),
+  TicketCreate: [10].concat(base, [
+    [ 'Target'             , OPTIONAL ],
+    [ 'Expiration'         , OPTIONAL ]
+  ]),
+  TicketCancel: [11].concat(base, [
+    [ 'TicketID'           , REQUIRED ]
   ])
 };
 
@@ -375,7 +395,7 @@ exports.ledger = {
     ['Balance',             REQUIRED],
     ['LowLimit',            REQUIRED],
     ['HighLimit',           REQUIRED]])
-}
+};
 
 exports.metadata = [
   [ 'TransactionIndex'     , REQUIRED ],
@@ -411,5 +431,8 @@ exports.ter = {
   tecNO_TARGET             : 138,
   tecNO_PERMISSION         : 139,
   tecNO_ENTRY              : 140,
-  tecINSUFFICIENT_RESERVE  : 141
+  tecINSUFFICIENT_RESERVE  : 141,
+  tecNEED_MASTER_KEY       : 142,
+  tecDST_TAG_NEEDED        : 143,
+  tecINTERNAL              : 144
 };

src/js/ripple/config.js

@@ -1,10 +0,0 @@
-// This object serves as a singleton to store config options
-
-var extend = require('extend');
-
-var config = module.exports = {
-  load: function (newOpts) {
-    extend(config, newOpts);
-    return config;
-  }
-};

src/js/ripple/crypt.js

@@ -1,333 +0,0 @@
-var sjcl        = require('./utils').sjcl;
-var base        = require('./base').Base;
-var Seed        = require('./seed').Seed;
-var UInt160     = require('./uint160').UInt160;
-var UInt256     = require('./uint256').UInt256;
-var request     = require('superagent');
-var querystring = require('querystring');
-var extend      = require("extend");
-var parser      = require("url");
-var Crypt       = { };
-
-var cryptConfig = {
-  cipher : 'aes',
-  mode   : 'ccm',
-  ts     : 64,   // tag length
-  ks     : 256,  // key size
-  iter   : 1000  // iterations (key derivation)
-};
-
-/**
- * Full domain hash based on SHA512
- */
-
-function fdh(data, bytelen) {
-  var bitlen = bytelen << 3;
-
-  if (typeof data === 'string') {
-    data = sjcl.codec.utf8String.toBits(data);
-  }
-
-  // Add hashing rounds until we exceed desired length in bits
-  var counter = 0, output = [];
-
-  while (sjcl.bitArray.bitLength(output) < bitlen) {
-    var hash = sjcl.hash.sha512.hash(sjcl.bitArray.concat([counter], data));
-    output = sjcl.bitArray.concat(output, hash);
-    counter++;
-  }
-
-  // Truncate to desired length
-  output = sjcl.bitArray.clamp(output, bitlen);
-
-  return output;
-};
-
-/**
- * This is a function to derive different hashes from the same key. 
- * Each hash is derived as HMAC-SHA512HALF(key, token).
- *
- * @param {string} key
- * @param {string} hash
- */
-
-function keyHash(key, token) {
-  var hmac = new sjcl.misc.hmac(key, sjcl.hash.sha512);
-  return sjcl.codec.hex.fromBits(sjcl.bitArray.bitSlice(hmac.encrypt(token), 0, 256));
-};
-
-/**
- * add entropy at each call to get random words
- * @param {number} nWords
- */
-function randomWords (nWords) {
-  for (var i = 0; i < 8; i++) {
-    sjcl.random.addEntropy(Math.random(), 32, "Math.random()");
-  }  
-  
-  return sjcl.random.randomWords(nWords);  
-}
-
-/****** exposed functions ******/
-
-/**
- * KEY DERIVATION FUNCTION
- *
- * This service takes care of the key derivation, i.e. converting low-entropy
- * secret into higher entropy secret via either computationally expensive
- * processes or peer-assisted key derivation (PAKDF).
- *
- * @param {object}    opts
- * @param {string}    purpose - Key type/purpose
- * @param {string}    username
- * @param {string}    secret - Also known as passphrase/password
- * @param {function}  fn
- */
-
-Crypt.derive = function(opts, purpose, username, secret, fn) {
-  var tokens;
-
-  if (purpose === 'login') {
-    tokens = ['id', 'crypt'];
-  } else {
-    tokens = ['unlock'];
-  }
-
-  var iExponent = new sjcl.bn(String(opts.exponent));
-  var iModulus  = new sjcl.bn(String(opts.modulus));
-  var iAlpha    = new sjcl.bn(String(opts.alpha));
-
-  var publicInfo = [ 'PAKDF_1_0_0', opts.host.length, opts.host, username.length, username, purpose.length, purpose ].join(':') + ':';
-  var publicSize = Math.ceil(Math.min((7 + iModulus.bitLength()) >>> 3, 256) / 8);
-  var publicHash = fdh(publicInfo, publicSize);
-  var publicHex  = sjcl.codec.hex.fromBits(publicHash);
-  var iPublic    = new sjcl.bn(String(publicHex)).setBitM(0);
-  var secretInfo = [ publicInfo, secret.length, secret ].join(':') + ':';
-  var secretSize = (7 + iModulus.bitLength()) >>> 3;
-  var secretHash = fdh(secretInfo, secretSize);
-  var secretHex  = sjcl.codec.hex.fromBits(secretHash);
-  var iSecret    = new sjcl.bn(String(secretHex)).mod(iModulus);
-
-  if (iSecret.jacobi(iModulus) !== 1) {
-    iSecret = iSecret.mul(iAlpha).mod(iModulus);
-  }
-
-  var iRandom;
-
-  for (;;) {
-    iRandom = sjcl.bn.random(iModulus, 0);
-    if (iRandom.jacobi(iModulus) === 1) {
-      break;
-    }
-  }
-
-  var iBlind   = iRandom.powermodMontgomery(iPublic.mul(iExponent), iModulus);
-  var iSignreq = iSecret.mulmod(iBlind, iModulus);
-  var signreq  = sjcl.codec.hex.fromBits(iSignreq.toBits());
-
-  request.post(opts.url)
-    .send({ info: publicInfo, signreq: signreq })
-    .end(function(err, resp) {
-      if (err || !resp) {
-        return fn(new Error('Could not query PAKDF server ' + opts.host));
-      }
-
-      var data = resp.body || resp.text ? JSON.parse(resp.text) : {};
-
-      if (data.result !== 'success') {
-        return fn(new Error('Could not query PAKDF server '+opts.host));
-      }
-
-      var iSignres = new sjcl.bn(String(data.signres));
-      var iRandomInv = iRandom.inverseMod(iModulus);
-      var iSigned    = iSignres.mulmod(iRandomInv, iModulus);
-      var key        = iSigned.toBits();
-      var result     = { };
-
-      tokens.forEach(function(token) {
-        result[token] = keyHash(key, token);
-      });
-
-      fn(null, result);
-    });
-};
-
-/**
- * Imported from ripple-client
- */
-
-
-
-/**
- * Encrypt data
- *
- * @param {string} key
- * @param {string} data
- */
-
-Crypt.encrypt = function(key, data) {
-  key = sjcl.codec.hex.toBits(key);
-
-  var opts = extend(true, {}, cryptConfig);
-
-  var encryptedObj = JSON.parse(sjcl.encrypt(key, data, opts));
-  var version = [sjcl.bitArray.partial(8, 0)];
-  var initVector = sjcl.codec.base64.toBits(encryptedObj.iv);
-  var ciphertext = sjcl.codec.base64.toBits(encryptedObj.ct);
-
-  var encryptedBits = sjcl.bitArray.concat(version, initVector);
-  encryptedBits = sjcl.bitArray.concat(encryptedBits, ciphertext);
-
-  return sjcl.codec.base64.fromBits(encryptedBits);
-};
-
-/**
- * Decrypt data
- *
- * @param {string} key
- * @param {string} data
- */
-
-Crypt.decrypt = function (key, data) {
-  
-  key = sjcl.codec.hex.toBits(key);
-  var encryptedBits = sjcl.codec.base64.toBits(data);
-
-  var version = sjcl.bitArray.extract(encryptedBits, 0, 8);
-
-  if (version !== 0) {
-    throw new Error('Unsupported encryption version: '+version);
-  }
-
-  var encrypted = extend(true, {}, cryptConfig, {
-    iv: sjcl.codec.base64.fromBits(sjcl.bitArray.bitSlice(encryptedBits, 8, 8+128)),
-    ct: sjcl.codec.base64.fromBits(sjcl.bitArray.bitSlice(encryptedBits, 8+128))
-  });
-
-  return sjcl.decrypt(key, JSON.stringify(encrypted));
-};
-
-
-/**
- * Validate a ripple address
- *
- * @param {string} address
- */
-
-Crypt.isValidAddress = function (address) {
-  return UInt160.is_valid(address);
-};
-
-/**
- * Create an encryption key
- *
- * @param {integer} nWords - number of words
- */
-
-Crypt.createSecret = function (nWords) {
-  return sjcl.codec.hex.fromBits(randomWords(nWords));
-};
-
-/**
- * Create a new master key
- */
-
-Crypt.createMaster = function () {
-  return base.encode_check(33, sjcl.codec.bytes.fromBits(randomWords(4)));
-};
-
-
-/**
- * Create a ripple address from a master key
- *
- * @param {string} masterkey
- */
-
-Crypt.getAddress = function (masterkey) {
-  return Seed.from_json(masterkey).get_key().get_address().to_json();
-};
-
-/**
- * Hash data using SHA-512.
- *
- * @param {string|bitArray} data
- * @return {string} Hash of the data
- */
-
-Crypt.hashSha512 = function (data) {
-  // XXX Should return a UInt512
-  return sjcl.codec.hex.fromBits(sjcl.hash.sha512.hash(data)); 
-};
-
-/**
- * Hash data using SHA-512 and return the first 256 bits.
- *
- * @param {string|bitArray} data
- * @return {UInt256} Hash of the data
- */
-Crypt.hashSha512Half = function (data) {
-  return UInt256.from_hex(Crypt.hashSha512(data).substr(0, 64));
-};
-
-
-/**
- * Sign a data string with a secret key
- *
- * @param {string} secret
- * @param {string} data
- */
-
-Crypt.signString = function(secret, data) {
-  var hmac = new sjcl.misc.hmac(sjcl.codec.hex.toBits(secret), sjcl.hash.sha512);
-  return sjcl.codec.hex.fromBits(hmac.mac(data));
-};
-
-/**
- * Create an an accout recovery key
- *
- * @param {string} secret
- */
-
-Crypt.deriveRecoveryEncryptionKeyFromSecret = function(secret) {
-  var seed = Seed.from_json(secret).to_bits();
-  var hmac = new sjcl.misc.hmac(seed, sjcl.hash.sha512);
-  var key  = hmac.mac('ripple/hmac/recovery_encryption_key/v1');
-  key      = sjcl.bitArray.bitSlice(key, 0, 256);
-  return sjcl.codec.hex.fromBits(key);
-};
-
-/**
- * Convert base64 encoded data into base64url encoded data.
- *
- * @param {String} base64 Data
- */
-
-Crypt.base64ToBase64Url = function(encodedData) {
-  return encodedData.replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]+$/, '');
-};
-
-/**
- * Convert base64url encoded data into base64 encoded data.
- *
- * @param {String} base64 Data
- */
-
-Crypt.base64UrlToBase64 = function(encodedData) {
-  encodedData = encodedData.replace(/-/g, '+').replace(/_/g, '/');
-
-  while (encodedData.length % 4) {
-    encodedData += '=';
-  }
-
-  return encodedData;
-};
-
-/**
- * base64 to UTF8
- */
-
-Crypt.decodeBase64 = function (data) {
-  return sjcl.codec.utf8String.fromBits(sjcl.codec.base64.toBits(data));
-}
-
-exports.Crypt = Crypt;

src/js/ripple/currency.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var extend = require('extend');
 var UInt160 = require('./uint160').UInt160;
 var utils = require('./utils');
@@ -17,7 +19,6 @@ var Currency = extend(function() {
   // XXX Should support hex, C++ doesn't currently allow it.
 
   this._value = NaN;
-
   this._update();
 }, UInt160);
 
@@ -32,25 +33,37 @@ Currency.HEX_CURRENCY_BAD = '0000000000000000000000005852500000000000';
  * Examples:
  *
  *  USD                               => currency
- *  USD - Dollar                      => currency with optional full currency name
- *  XAU (-0.5%pa)                     => XAU with 0.5% effective demurrage rate per year
+ *  USD - Dollar                      => currency with optional full currency
+ *                                       name
+ *  XAU (-0.5%pa)                     => XAU with 0.5% effective demurrage rate
+ *                                       per year
  *  XAU - Gold (-0.5%pa)              => Optionally allowed full currency name
- *  USD (1%pa)                        => US dollars with 1% effective interest per year
+ *  USD (1%pa)                        => US dollars with 1% effective interest
+ *                                       per year
  *  INR - Indian Rupees               => Optional full currency name with spaces
- *  TYX - 30-Year Treasuries          => Optional full currency with numbers and a dash
- *  TYX - 30-Year Treasuries (1.5%pa) => Optional full currency with numbers, dash and interest rate
+ *  TYX - 30-Year Treasuries          => Optional full currency with numbers
+ *                                       and a dash
+ *  TYX - 30-Year Treasuries (1.5%pa) => Optional full currency with numbers,
+ *                                       dash and interest rate
  *
- *  The regular expression below matches above cases, broken down for better understanding:
+ *  The regular expression below matches above cases, broken down for better
+ *  understanding:
  *
  *  ^\s*                      // start with any amount of whitespace
- *  ([a-zA-Z]{3}|[0-9]{3})    // either 3 letter alphabetic currency-code or 3 digit numeric currency-code. See ISO 4217
- *  (\s*-\s*[- \w]+)          // optional full currency name following the dash after currency code,
- *                               full currency code can contain letters, numbers and dashes
- *  (\s*\(-?\d+\.?\d*%pa\))?  // optional demurrage rate, has optional - and . notation (-0.5%pa)
+ *  ([a-zA-Z]{3}|[0-9]{3})    // either 3 letter alphabetic currency-code or 3
+ *                               digit numeric currency-code. See ISO 4217
+ *  (\s*-\s*[- \w]+)          // optional full currency name following the dash
+ *                               after currency code, full currency code can
+ *                               contain letters, numbers and dashes
+ *  (\s*\(-?\d+\.?\d*%pa\))?  // optional demurrage rate, has optional - and
+ *                               . notation (-0.5%pa)
  *  \s*$                      // end with any amount of whitespace
  *
  */
-Currency.prototype.human_RE = /^\s*([a-zA-Z0-9]{3})(\s*-\s*[- \w]+)?(\s*\(-?\d+\.?\d*%pa\))?\s*$/;
+
+/*eslint-disable max-len*/
+Currency.prototype.human_RE = /^\s*([a-zA-Z0-9\<\>\(\)\{\}\[\]\|\?\!\@\#\$\%\^\&]{3})(\s*-\s*[- \w]+)?(\s*\(-?\d+\.?\d*%pa\))?\s*$/;
+/*eslint-enable max-len*/
 
 Currency.from_json = function(j, shouldInterpretXrpAsIou) {
     return (new Currency()).parse_json(j, shouldInterpretXrpAsIou);
@@ -58,39 +71,65 @@ Currency.from_json = function(j, shouldInterpretXrpAsIou) {
 
 Currency.from_human = function(j, opts) {
   return (new Currency().parse_human(j, opts));
-}
+};
 
 // this._value = NaN on error.
 Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
   this._value = NaN;
 
-  switch (typeof j) {
-    case 'string':
+  if (j instanceof Currency) {
+    this._value = j.copyTo({})._value;
+    this._update();
+    return this;
+  }
 
-      // if an empty string is given, fall back to XRP
+  switch (typeof j) {
+    case 'number':
+      if (!isNaN(j)) {
+        this.parse_number(j);
+      }
+      break;
+    case 'string':
       if (!j || j === '0') {
-        this.parse_hex(shouldInterpretXrpAsIou ? Currency.HEX_CURRENCY_BAD : Currency.HEX_ZERO);
+        // Empty string or XRP
+        this.parse_hex(shouldInterpretXrpAsIou
+          ? Currency.HEX_CURRENCY_BAD
+          : Currency.HEX_ZERO);
+        break;
+      }
+
+      if (j === '1') {
+        // 'no currency'
+        this.parse_hex(Currency.HEX_ONE);
+        break;
+      }
+
+      if (/^[A-F0-9]{40}$/.test(j)) {
+        // Hex format
+        this.parse_hex(j);
         break;
       }
 
       // match the given string to see if it's in an allowed format
-      var matches = String(j).match(this.human_RE);
+      var matches = j.match(this.human_RE);
 
       if (matches) {
-
         var currencyCode = matches[1];
 
         // for the currency 'XRP' case
         // we drop everything else that could have been provided
         // e.g. 'XRP - Ripple'
         if (!currencyCode || /^(0|XRP)$/.test(currencyCode)) {
-          this.parse_hex(shouldInterpretXrpAsIou ? Currency.HEX_CURRENCY_BAD : Currency.HEX_ZERO);
+          this.parse_hex(shouldInterpretXrpAsIou
+            ? Currency.HEX_CURRENCY_BAD
+            : Currency.HEX_ZERO);
 
           // early break, we can't have interest on XRP
           break;
         }
 
-        // the full currency is matched as it is part of the valid currency format, but not stored
+        // the full currency is matched as it is part of the valid currency
+        // format, but not stored
         // var full_currency = matches[2] || '';
         var interest = matches[3] || '';
 
@@ -117,25 +156,28 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
           currencyData[2] = currencyCode.charCodeAt(1) & 0xff;
           currencyData[3] = currencyCode.charCodeAt(2) & 0xff;
 
-          // byte 5-8 are for reference date, but should always be 0 so we won't fill it
+          // byte 5-8 are for reference date, but should always be 0 so we
+          // won't fill it
 
           // byte 9-16 are for the interest
           percentage = parseFloat(percentage[0]);
 
-          // the interest or demurrage is expressed as a yearly (per annum) value
+          // the interest or demurrage is expressed as a yearly (per annum)
+          // value
           var secondsPerYear = 31536000; // 60 * 60 * 24 * 365
 
           // Calculating the interest e-fold
           // 0.5% demurrage is expressed 0.995, 0.005 less than 1
           // 0.5% interest is expressed as 1.005, 0.005 more than 1
-          var interestEfold = secondsPerYear / Math.log(1 + percentage/100);
+          var interestEfold = secondsPerYear / Math.log(1 + percentage / 100);
           var bytes = Float.toIEEE754Double(interestEfold);
 
-          for (var i=0; i<=bytes.length; i++) {
+          for (var i = 0; i <= bytes.length; i++) {
             currencyData[8 + i] = bytes[i] & 0xff;
           }
 
-          // the last 4 bytes are reserved for future use, so we won't fill those
+          // the last 4 bytes are reserved for future use, so we won't fill
+          // those
 
         } else {
           currencyData[12] = currencyCode.charCodeAt(0) & 0xff;
@@ -144,21 +186,6 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
         }
 
         this.parse_bytes(currencyData);
-      } else {
-        this.parse_hex(j);
-      }
-      break;
-
-    case 'number':
-      if (!isNaN(j)) {
-        this.parse_number(j);
-      }
-      break;
-
-    case 'object':
-      if (j instanceof Currency) {
-        this._value = j.copyTo({})._value;
-        this._update();
       }
       break;
   }
@@ -166,7 +193,6 @@ Currency.prototype.parse_json = function(j, shouldInterpretXrpAsIou) {
   return this;
 };
 
-
 Currency.prototype.parse_human = function(j) {
   return this.parse_json(j);
 };
@@ -176,6 +202,7 @@ Currency.prototype.parse_human = function(j) {
  *
  * You should never need to call this.
  */
+
 Currency.prototype._update = function() {
   var bytes = this.to_bytes();
 
@@ -183,7 +210,7 @@ Currency.prototype._update = function() {
   var isZeroExceptInStandardPositions = true;
 
   if (!bytes) {
-    return 'XRP';
+    return;
   }
 
   this._native = false;
@@ -192,8 +219,9 @@ Currency.prototype._update = function() {
   this._interest_period = NaN;
   this._iso_code = '';
 
-  for (var i=0; i<20; i++) {
-    isZeroExceptInStandardPositions = isZeroExceptInStandardPositions && (i===12 || i===13 || i===14 || bytes[i]===0);
+  for (var i = 0; i < 20; i++) {
+    isZeroExceptInStandardPositions = isZeroExceptInStandardPositions
+    && (i === 12 || i === 13 || i === 14 || bytes[i] === 0);
   }
 
   if (isZeroExceptInStandardPositions) {
@@ -201,7 +229,7 @@ Currency.prototype._update = function() {
                    + String.fromCharCode(bytes[13])
                    + String.fromCharCode(bytes[14]);
 
-    if (this._iso_code === '\0\0\0') {
+    if (this._iso_code === '\u0000\u0000\u0000') {
       this._native = true;
       this._iso_code = 'XRP';
     }
@@ -216,7 +244,7 @@ Currency.prototype._update = function() {
     this._interest_start = (bytes[4] << 24) +
                            (bytes[5] << 16) +
                            (bytes[6] << 8) +
-                           (bytes[7]      );
+                           (bytes[7]);
     this._interest_period = Float.fromIEEE754Double(bytes.slice(8, 16));
   }
 };
@@ -230,7 +258,8 @@ Currency.prototype.parse_bytes = function(byte_array) {
     var isZeroExceptInStandardPositions = true;
 
     for (var i=0; i<20; i++) {
-      isZeroExceptInStandardPositions = isZeroExceptInStandardPositions && (i===12 || i===13 || i===14 || byte_array[0]===0)
+      isZeroExceptInStandardPositions = isZeroExceptInStandardPositions
+      && (i===12 || i===13 || i===14 || byte_array[0]===0)
     }
 
     if (isZeroExceptInStandardPositions) {
@@ -260,20 +289,25 @@ Currency.prototype.is_native = function() {
 };
 
 /**
- * Whether this currency is an interest-bearing/demurring currency.
+ * @return {Boolean} whether this currency is an interest-bearing currency
  */
+
 Currency.prototype.has_interest = function() {
-  return this._type === 1 && !isNaN(this._interest_start) && !isNaN(this._interest_period);
+  return this._type === 1
+  && !isNaN(this._interest_start)
+  && !isNaN(this._interest_period);
 };
 
 /**
  *
- * @param referenceDate - number of seconds since the Ripple Epoch (0:00 on January 1, 2000 UTC)
- *                        used to calculate the interest over provided interval
- *                        pass in one years worth of seconds to ge the yearly interest
- * @returns {number} - interest for provided interval, can be negative for demurred currencies
+ * @param {number} referenceDate number of seconds since the Ripple Epoch
+ * (0:00 on January 1, 2000 UTC) used to calculate the
+ * interest over provided interval pass in one years
+ * worth of seconds to ge the yearly interest
+ * @returns {number} interest for provided interval, can be negative for
+ * demurred currencies
  */
-Currency.prototype.get_interest_at = function(referenceDate, decimals) {
+Currency.prototype.get_interest_at = function(referenceDate) {
   if (!this.has_interest()) {
     return 0;
   }
@@ -288,18 +322,20 @@ Currency.prototype.get_interest_at = function(referenceDate, decimals) {
   }
 
   // calculate interest by e-fold number
-  return Math.exp((referenceDate - this._interest_start) / this._interest_period);
+  return Math.exp((referenceDate - this._interest_start)
+                / this._interest_period);
 };
 
-Currency.prototype.get_interest_percentage_at = function(referenceDate, decimals) {
+Currency.prototype.get_interest_percentage_at
+= function(referenceDate, decimals) {
   var interest = this.get_interest_at(referenceDate, decimals);
 
   // convert to percentage
-  var interest = (interest*100)-100;
-  var decimalMultiplier = decimals ? Math.pow(10,decimals) : 100;
+  interest = (interest * 100) - 100;
+  var decimalMultiplier = decimals ? Math.pow(10, decimals) : 100;
 
   // round to two decimals behind the dot
-  return Math.round(interest*decimalMultiplier) / decimalMultiplier;
+  return Math.round(interest * decimalMultiplier) / decimalMultiplier;
 };
 
 // XXX Currently we inherit UInt.prototype.is_valid, which is mostly fine.
@@ -307,9 +343,9 @@ Currency.prototype.get_interest_percentage_at = function(referenceDate, decimals
 //     We could be doing further checks into the internal format of the
 //     currency data, since there are some values that are invalid.
 //
-//Currency.prototype.is_valid = function() {
-//  return this._value instanceof BigInteger && ...;
-//};
+// Currency.prototype.is_valid = function() {
+//  return UInt.prototype.is_valid() && ...;
+// };
 
 Currency.prototype.to_json = function(opts) {
   if (!this.is_valid()) {
@@ -317,27 +353,34 @@ Currency.prototype.to_json = function(opts) {
     return 'XRP';
   }
 
-  var opts = opts || {};
+  if (!opts) {
+    opts = {};
+  }
 
   var currency;
   var fullName = opts && opts.full_name ? ' - ' + opts.full_name : '';
-  opts.show_interest = opts.show_interest !== void(0) ? opts.show_interest : this.has_interest();
+  opts.show_interest = opts.show_interest !== undefined
+  ? opts.show_interest
+  : this.has_interest();
 
   if (!opts.force_hex && /^[A-Z0-9]{3}$/.test(this._iso_code)) {
     currency = this._iso_code + fullName;
     if (opts.show_interest) {
-      var decimals = !isNaN(opts.decimals) ? opts.decimals : void(0);
-      var interestPercentage = this.has_interest() ? this.get_interest_percentage_at(this._interest_start + 3600 * 24 * 365, decimals) : 0;
+      var decimals = !isNaN(opts.decimals) ? opts.decimals : undefined;
+      var interestPercentage = this.has_interest()
+      ? this.get_interest_percentage_at(
+          this._interest_start + 3600 * 24 * 365, decimals
+        )
+      : 0;
       currency += ' (' + interestPercentage + '%pa)';
     }
 
   } else {
-
     // Fallback to returning the raw currency hex
     currency = this.to_hex();
 
-    // XXX This is to maintain backwards compatibility, but it is very, very odd
-    //     behavior, so we should deprecate it and get rid of it as soon as
+    // XXX This is to maintain backwards compatibility, but it is very, very
+    // odd behavior, so we should deprecate it and get rid of it as soon as
     //  possible.
     if (currency === Currency.HEX_ONE) {
       currency = 1;
@@ -357,5 +400,3 @@ Currency.prototype.get_iso = function() {
 };
 
 exports.Currency = Currency;
-
-// vim:sw=2:sts=2:ts=8:et

src/js/ripple/float.js

@@ -1,59 +0,0 @@
-/**
- * IEEE 754 floating-point.
- *
- * Supports single- or double-precision
- */
-var Float = exports.Float = {};
-
-var allZeros = /^0+$/;
-var allOnes = /^1+$/;
-
-Float.fromBytes = function(bytes) {
-  // Render in binary.  Hackish.
-  var b = '';
-
-  for (var i = 0, n = bytes.length; i < n; i++) {
-    var bits = (bytes[i] & 0xff).toString(2);
-
-    while (bits.length < 8) {
-      bits = '0' + bits;
-    }
-
-    b += bits;
-  }
-
-  // Determine configuration.  This could have all been precomputed but it is fast enough.
-  var exponentBits = bytes.length === 4 ? 4 : 11;
-  var mantissaBits = (bytes.length * 8) - exponentBits - 1;
-  var bias = Math.pow(2, exponentBits - 1) - 1;
-  var minExponent = 1 - bias - mantissaBits;
-
-  // Break up the binary representation into its pieces for easier processing.
-  var s = b[0];
-  var e = b.substring(1, exponentBits + 1);
-  var m = b.substring(exponentBits + 1);
-
-  var value = 0;
-  var multiplier = (s === '0' ? 1 : -1);
-
-  if (allZeros.test(e)) {
-    // Zero or denormalized
-    if (!allZeros.test(m)) {
-      value = parseInt(m, 2) * Math.pow(2, minExponent);
-    }
-  } else if (allOnes.test(e)) {
-    // Infinity or NaN
-    if (allZeros.test(m)) {
-      value = Infinity;
-    } else {
-      value = NaN;
-    }
-  } else {
-    // Normalized
-    var exponent = parseInt(e, 2) - bias;
-    var mantissa = parseInt(m, 2);
-    value = (1 + (mantissa * Math.pow(2, -mantissaBits))) * Math.pow(2, exponent);
-  }
-
-  return value * multiplier;
-};

src/js/ripple/index.js

@@ -1,3 +1,4 @@
+'use strict';
 exports.Remote = require('./remote').Remote;
 exports.Request = require('./request').Request;
 exports.Amount = require('./amount').Amount;
@@ -5,6 +6,7 @@ exports.Account          = require('./account').Account;
 exports.Transaction = require('./transaction').Transaction;
 exports.Currency = require('./currency').Currency;
 exports.Base = require('./base').Base;
+exports.UInt128 = require('./uint128').UInt128;
 exports.UInt160 = require('./uint160').UInt160;
 exports.UInt256 = require('./uint256').UInt256;
 exports.Seed = require('./seed').Seed;
@@ -12,13 +14,13 @@ exports.Meta             = require('./meta').Meta;
 exports.SerializedObject = require('./serializedobject').SerializedObject;
 exports.RippleError = require('./rippleerror').RippleError;
 exports.Message = require('./message').Message;
-exports.VaultClient      = require('./vaultclient').VaultClient;
-exports.AuthInfo         = require('./authinfo').AuthInfo;
-exports.RippleTxt        = require('./rippletxt').RippleTxt;
 exports.binformat = require('./binformat');
 exports.utils = require('./utils');
 exports.Server = require('./server').Server;
-exports.Wallet           = require('./wallet');
+exports.Ledger = require('./ledger').Ledger;
+exports.TransactionQueue = require('./transactionqueue').TransactionQueue;
+exports.RangeSet = require('./rangeset').RangeSet;
+exports.convertBase = require('./baseconverter');
 
 // Important: We do not guarantee any specific version of SJCL or for any
 // specific features to be included. The version and configuration may change at
@@ -28,12 +30,12 @@ exports.Wallet           = require('./wallet');
 // the official client, it makes sense to expose the SJCL instance so we don't
 // have to include it twice.
 exports.sjcl = require('./utils').sjcl;
-
-exports.config = require('./config');
+exports.Wallet = require('ripple-wallet-generator')({sjcl: exports.sjcl});
+exports.types = require('./serializedtypes');
 
 // camelCase to under_scored API conversion
-function attachUnderscored(c) {
-  var o = exports[c];
+function attachUnderscored(name) {
+  var o = exports[name];
 
   Object.keys(o.prototype).forEach(function(key) {
     var UPPERCASE = /([A-Z]{1})[a-z]+/g;
@@ -48,9 +50,9 @@ function attachUnderscored(c) {
 
     o.prototype[underscored] = o.prototype[key];
   });
-};
+}
 
-[ 'Remote',
+['Remote',
  'Request',
  'Transaction',
  'Account',

src/js/ripple/keypair.js

@@ -1,3 +1,7 @@
+'use strict';
+
+/*eslint new-cap: 1*/
+
 var sjcl = require('./utils').sjcl;
 
 var UInt160 = require('./uint160').UInt160;
@@ -5,30 +9,31 @@ var UInt256 = require('./uint256').UInt256;
 var Base = require('./base').Base;
 
 function KeyPair() {
-  this._curve  = sjcl.ecc.curves.c256;
+  this._curve = sjcl.ecc.curves.k256;
   this._secret = null;
   this._pubkey = null;
-};
+}
 
 KeyPair.from_bn_secret = function(j) {
   return (j instanceof this) ? j.clone() : (new this()).parse_bn_secret(j);
 };
 
 KeyPair.prototype.parse_bn_secret = function(j) {
-  this._secret = new sjcl.ecc.ecdsa.secretKey(sjcl.ecc.curves.c256, j);
+  this._secret = new sjcl.ecc.ecdsa.secretKey(sjcl.ecc.curves.k256, j);
   return this;
 };
 
 /**
- * Returns public key as sjcl public key.
- *
  * @private
+ *
+ * @return {sjcl.ecc.ecdsa.publicKey} public key
  */
 KeyPair.prototype._pub = function() {
   var curve = this._curve;
 
   if (!this._pubkey && this._secret) {
     var exponent = this._secret._exponent;
+
     this._pubkey = new sjcl.ecc.ecdsa.publicKey(curve, curve.G.mult(exponent));
   }
 
@@ -36,9 +41,9 @@ KeyPair.prototype._pub = function() {
 };
 
 /**
- * Returns public key in compressed format as bit array.
- *
  * @private
+ *
+ * @return {sjcl.bitArray} public key bits in compressed form
  */
 KeyPair.prototype._pub_bits = function() {
   var pub = this._pub();
@@ -56,9 +61,7 @@ KeyPair.prototype._pub_bits = function() {
 };
 
 /**
- * Returns public key as hex.
- *
- * Key will be returned as a compressed pubkey - 33 bytes converted to hex.
+ * @return {String} public key bytes in compressed form, hex encoded.
  */
 KeyPair.prototype.to_hex_pub = function() {
   var bits = this._pub_bits();
@@ -70,7 +73,7 @@ KeyPair.prototype.to_hex_pub = function() {
   return sjcl.codec.hex.fromBits(bits).toUpperCase();
 };
 
-function SHA256_RIPEMD160(bits) {
+function sha256_ripemd160(bits) {
   return sjcl.hash.ripemd160.hash(sjcl.hash.sha256.hash(bits));
 }
 
@@ -81,7 +84,7 @@ KeyPair.prototype.get_address = function() {
     return null;
   }
 
-  var hash = SHA256_RIPEMD160(bits);
+  var hash = sha256_ripemd160(bits);
 
   var address = UInt160.from_bits(hash);
   address.set_version(Base.VER_ACCOUNT_ID);
@@ -89,8 +92,9 @@ KeyPair.prototype.get_address = function() {
 };
 
 KeyPair.prototype.sign = function(hash) {
+  var PARANOIA_256_BITS = 6; // sjcl constant for ensuring 256 bits of entropy
   hash = UInt256.from_json(hash);
-  var sig = this._secret.sign(hash.to_bits(), 0);
+  var sig = this._secret.sign(hash.to_bits(), PARANOIA_256_BITS);
   sig = this._secret.canonicalizeSignature(sig);
   return this._secret.encodeDER(sig);
 };

src/js/ripple/ledger.js

@@ -1,5 +1,5 @@
-// Ledger
-
+/* eslint-disable valid-jsdoc */
+'use strict';
 var Transaction = require('./transaction').Transaction;
 var SHAMap = require('./shamap').SHAMap;
 var SHAMapTreeNode = require('./shamap').SHAMapTreeNode;
@@ -7,16 +7,12 @@ var SerializedObject = require('./serializedobject').SerializedObject;
 var stypes = require('./serializedtypes');
 var UInt160 = require('./uint160').UInt160;
 var Currency = require('./currency').Currency;
-var stypes = require('./serializedtypes');
-var sjcl  = require('./utils').sjcl;
-var Crypt = require('./crypt').Crypt;
 
-function Ledger()
-{
+function Ledger() {
   this.ledger_json = {};
 }
 
-Ledger.from_json = function (v) {
+Ledger.from_json = function(v) {
   var ledger = new Ledger();
   ledger.parse_json(v);
   return ledger;
@@ -31,7 +27,7 @@ Ledger.space = require('./ledgerspaces');
  * @return {UInt256}
  */
 Ledger.calcAccountRootEntryHash =
-Ledger.prototype.calcAccountRootEntryHash = function (account) {
+Ledger.prototype.calcAccountRootEntryHash = function(account) {
   account = UInt160.from_json(account);
 
   var index = new SerializedObject();
@@ -51,9 +47,9 @@ Ledger.prototype.calcAccountRootEntryHash = function (account) {
  * @return {UInt256}
  */
 Ledger.calcOfferEntryHash =
-Ledger.prototype.calcOfferEntryHash = function (account, sequence) {
+Ledger.prototype.calcOfferEntryHash = function(account, sequence) {
   account = UInt160.from_json(account);
-  sequence = parseInt(sequence);
+  sequence = parseInt(sequence, 10);
 
   var index = new SerializedObject();
 
@@ -75,19 +71,20 @@ Ledger.prototype.calcOfferEntryHash = function (account, sequence) {
  * @return {UInt256}
  */
 Ledger.calcRippleStateEntryHash =
-Ledger.prototype.calcRippleStateEntryHash = function (account1, account2, currency) {
+Ledger.prototype.calcRippleStateEntryHash = function(
+    account1, account2, currency) {
   currency = Currency.from_json(currency);
   account1 = UInt160.from_json(account1);
   account2 = UInt160.from_json(account2);
 
   if (!account1.is_valid()) {
-    throw new Error("Invalid first account");
+    throw new Error('Invalid first account');
   }
   if (!account2.is_valid()) {
-    throw new Error("Invalid second account");
+    throw new Error('Invalid second account');
   }
   if (!currency.is_valid()) {
-    throw new Error("Invalid currency");
+    throw new Error('Invalid currency');
   }
 
   // The lower ID has to come first
@@ -107,14 +104,14 @@ Ledger.prototype.calcRippleStateEntryHash = function (account1, account2, curren
   return index.hash();
 };
 
-Ledger.prototype.parse_json = function (v) {
+Ledger.prototype.parse_json = function(v) {
   this.ledger_json = v;
 };
 
-Ledger.prototype.calc_tx_hash = function () {
+Ledger.prototype.calc_tx_hash = function() {
   var tx_map = new SHAMap();
 
-  this.ledger_json.transactions.forEach(function (tx_json) {
+  this.ledger_json.transactions.forEach(function(tx_json) {
     var tx = Transaction.from_json(tx_json);
     var meta = SerializedObject.from_json(tx_json.metaData);
 
@@ -128,37 +125,39 @@ Ledger.prototype.calc_tx_hash = function () {
 };
 
 /**
-* @param options.sanity_test {Boolean}
+* @param options .sanity_test {Boolean}
+* @return hash of shamap
 *
 *   If `true`, will serialize each accountState item to binary and then back to
 *   json before finally serializing for hashing. This is mostly to expose any
 *   issues with ripple-lib's binary <--> json codecs.
 *
 */
-Ledger.prototype.calc_account_hash = function (options) {
+Ledger.prototype.calc_account_hash = function(options) {
   var account_map = new SHAMap();
   var erred;
 
-  this.ledger_json.accountState.forEach(function (le) {
+  this.ledger_json.accountState.forEach(function(le) {
     var data = SerializedObject.from_json(le);
 
-    if (options != null && options.sanity_test) {
+    var json;
+    if (options && options.sanity_test) {
       try {
-        var json = data.to_json();
+        json = data.to_json();
         data = SerializedObject.from_json(json);
       } catch (e) {
-        console.log("account state item: ", le);
-        console.log("to_json() ",json);
-        console.log("exception: ", e);
+        console.log('account state item: ', le);
+        console.log('to_json() ', json);
+        console.log('exception: ', e);
         erred = true;
       }
-    };
+    }
 
     account_map.add_item(le.index, data, SHAMapTreeNode.TYPE_ACCOUNT_STATE);
   });
 
   if (erred) {
-    throw new Error("There were errors with sanity_test"); // all logged above
+    throw new Error('There were errors with sanity_test'); // all logged above
   }
 
   return account_map.hash();

src/js/ripple/log.js

@@ -1,5 +1,10 @@
+'use strict';
+
 /**
  * Logging functionality for ripple-lib and any applications built on it.
+ *
+ * @param {String} namespace logging prefix
+ * @return {Void} this function does not return...
  */
 function Log(namespace) {
   if (!namespace) {
@@ -7,11 +12,11 @@ function Log(namespace) {
   } else if (Array.isArray(namespace)) {
     this._namespace = namespace;
   } else {
-    this._namespace = [''+namespace];
+    this._namespace = [String(namespace)];
   }
 
   this._prefix = this._namespace.concat(['']).join(': ');
-};
+}
 
 /**
  * Create a sub-logger.
@@ -24,6 +29,9 @@ function Log(namespace) {
  *
  *   log.info('connection successful');
  *   // prints: 'server: connection successful'
+ *
+ * @param {String} namespace logging prefix
+ * @return {Log} sub logger
  */
 Log.prototype.sub = function(namespace) {
   var subNamespace = this._namespace.slice();
@@ -43,9 +51,9 @@ Log.prototype._setParent = function(parentLogger) {
 
 Log.makeLevel = function(level) {
   return function() {
-    var args = Array.prototype.slice.call(arguments);
+    var args = Array.prototype.slice.apply(arguments);
     args[0] = this._prefix + args[0];
-    Log.engine.logObject.apply(Log, args);
+    Log.engine.logObject.apply(Log, [level].concat(args[0], [args.slice(2)]));
   };
 };
 
@@ -54,6 +62,46 @@ Log.prototype.info  = Log.makeLevel(2);
 Log.prototype.warn = Log.makeLevel(3);
 Log.prototype.error = Log.makeLevel(4);
 
+/**
+ * @param {String} message
+ * @param {Array} details
+ * @return {Array} prepared log info
+ */
+
+function getLogInfo(message, args) {
+  var stack = new Error().stack;
+
+  return [
+    // Timestamp
+    '[' + new Date().toISOString() + ']',
+    message,
+    '--',
+    // Location
+    (typeof stack === 'string') ? stack.split('\n')[4].replace(/^\s+/, '') : '',
+    '\n'
+  ].concat(args);
+}
+
+/**
+ * @param {Number} log level
+ * @param {Array} log info
+ */
+
+function logMessage(logLevel, args) {
+  switch (logLevel) {
+    case 1:
+    case 2:
+      console.log.apply(console, args);
+      break;
+    case 3:
+      console.warn.apply(console, args);
+      break;
+    case 4:
+      console.error.apply(console, args);
+      break;
+  }
+}
+
 /**
  * Basic logging connector.
  *
@@ -61,20 +109,33 @@ Log.prototype.error = Log.makeLevel(4);
  * implementations. This is the logging engine used in Node.js.
  */
 var BasicLogEngine = {
-  logObject: function logObject(msg) {
-    var args = Array.prototype.slice.call(arguments, 1);
-
+  logObject: function logObject(level, message, args) {
     args = args.map(function(arg) {
       return JSON.stringify(arg, null, 2);
     });
 
-    args.unshift(msg);
-    args.unshift('[' + new Date().toISOString() + ']');
-
-    console.log.apply(console, args);
+    logMessage(level, getLogInfo(message, args));
   }
 };
 
+/**
+ * Log engine for browser consoles.
+ *
+ * Browsers tend to have better consoles that support nicely formatted
+ * JavaScript objects. This connector passes objects through to the logging
+ * function without any stringification.
+ */
+var InteractiveLogEngine = {
+  logObject: function(level, message, args) {
+    args = args.map(function(arg) {
+      return /MSIE/.test(navigator.userAgent)
+      ? JSON.stringify(arg, null, 2)
+      : arg;
+    });
+
+    logMessage(level, getLogInfo(message, args));
+  }
+};
 /**
  * Null logging connector.
  *
@@ -85,10 +146,12 @@ var NullLogEngine = {
   logObject: function() {}
 };
 
-Log.engine = NullLogEngine;
-
-if (console && console.log) {
+if (typeof window !== 'undefined' && typeof console !== 'undefined') {
+  Log.engine = InteractiveLogEngine;
+} else if (typeof console !== 'undefined' && console.log) {
   Log.engine = BasicLogEngine;
+} else {
+  Log.engine = NullLogEngine;
 }
 
 /**

src/js/ripple/log.web.js

@@ -1,31 +0,0 @@
-var exports = module.exports = require('./log.js');
-
-/**
- * Log engine for browser consoles.
- *
- * Browsers tend to have better consoles that support nicely formatted
- * JavaScript objects. This connector passes objects through to the logging
- * function without any stringification.
- */
-var InteractiveLogEngine = {
-  logObject: function (msg, obj) {
-    var args = Array.prototype.slice.call(arguments, 1);
-
-    args = args.map(function(arg) {
-      if (/MSIE/.test(navigator.userAgent)) {
-        return JSON.stringify(arg, null, 2);
-      } else {
-        return arg;
-      }
-    });
-
-    args.unshift(msg);
-    args.unshift('[' + new Date().toISOString() + ']');
-
-    console.log.apply(console, args);
-  }
-};
-
-if (window.console && window.console.log) {
-  exports.Log.engine = InteractiveLogEngine;
-}

src/js/ripple/message.js

@@ -1,5 +1,6 @@
+/* eslint-disable valid-jsdoc */
+'use strict';
 var async = require('async');
-var crypto             = require('crypto');
 var sjcl = require('./utils').sjcl;
 var Remote = require('./remote').Remote;
 var Seed = require('./seed').Seed;
@@ -10,11 +11,12 @@ var UInt160            = require('./uint160').UInt160;
 // Message class (static)
 var Message = {};
 
-Message.HASH_FUNCTION  = sjcl.hash.sha512.hash;
+Message.hashFunction = sjcl.hash.sha512.hash;
 Message.MAGIC_BYTES = 'Ripple Signed Message:\n';
 
 var REGEX_HEX = /^[0-9a-fA-F]+$/;
-var REGEX_BASE64 = /^([A-Za-z0-9\+]{4})*([A-Za-z0-9\+]{2}==)|([A-Za-z0-9\+]{3}=)?$/;
+var REGEX_BASE64 =
+  /^([A-Za-z0-9\+]{4})*([A-Za-z0-9\+]{2}==)|([A-Za-z0-9\+]{3}=)?$/;
 
 /**
  *  Produce a Base64-encoded signature on the given message with
@@ -27,15 +29,16 @@ var REGEX_BASE64 = /^([A-Za-z0-9\+]{4})*([A-Za-z0-9\+]{2}==)|([A-Za-z0-9\+]{3}=)
  *  @static
  *
  *  @param {String} message
- *  @param {sjcl.ecc.ecdsa.secretKey|Any format accepted by Seed.from_json} secret_key
- *  @param {RippleAddress} [The first key] account Field to specify the signing account. 
- *    If this is omitted the first account produced by the secret generator will be used.
- *  @returns {Base64-encoded String} signature
+ *  @param {sjcl.ecc.ecdsa.secretKey|Any format accepted by Seed.from_json}
+ *         secret_key
+ *  @param {RippleAddress} [The first key] account Field to specify the signing
+ *      account. If this is omitted the first account produced by the secret
+ *      generator will be used.
+ *  @return {Base64-encoded String} signature
  */
 Message.signMessage = function(message, secret_key, account) {
-
-  return Message.signHash(Message.HASH_FUNCTION(Message.MAGIC_BYTES + message), secret_key, account);
-
+  return Message.signHash(Message.hashFunction(Message.MAGIC_BYTES + message),
+    secret_key, account);
 };
 
 /**
@@ -48,9 +51,11 @@ Message.signMessage = function(message, secret_key, account) {
  *  @static
  *
  *  @param {bitArray|Hex-encoded String} hash
- *  @param {sjcl.ecc.ecdsa.secretKey|Any format accepted by Seed.from_json} secret_key
- *  @param {RippleAddress} [The first key] account Field to specify the signing account. 
- *    If this is omitted the first account produced by the secret generator will be used.
+ *  @param {sjcl.ecc.ecdsa.secretKey|Any format accepted by Seed.from_json}
+ *          secret_key
+ *  @param {RippleAddress} [The first key] account Field to specify the
+ *          signing account. If this is omitted the first account produced by
+ *          the secret generator will be used.
  *  @returns {Base64-encoded String} signature
  */
 Message.signHash = function(hash, secret_key, account) {
@@ -59,7 +64,8 @@ Message.signHash = function(hash, secret_key, account) {
     hash = sjcl.codec.hex.toBits(hash);
   }
 
-  if (typeof hash !== 'object' || hash.length <= 0 || typeof hash[0] !== 'number') {
+  if (typeof hash !== 'object' || hash.length <= 0
+      || typeof hash[0] !== 'number') {
     throw new Error('Hash must be a bitArray or hex-encoded string');
   }
 
@@ -67,7 +73,9 @@ Message.signHash = function(hash, secret_key, account) {
     secret_key = Seed.from_json(secret_key).get_key(account)._secret;
   }
 
-  var signature_bits = secret_key.signWithRecoverablePublicKey(hash);
+  var PARANOIA_256_BITS = 6; // sjcl constant for ensuring 256 bits of entropy
+  var signature_bits = secret_key.signWithRecoverablePublicKey(hash,
+    PARANOIA_256_BITS);
   var signature_base64 = sjcl.codec.base64.fromBits(signature_bits);
 
   return signature_base64;
@@ -98,9 +106,10 @@ Message.signHash = function(hash, secret_key, account) {
 Message.verifyMessageSignature = function(data, remote, callback) {
 
   if (typeof data.message === 'string') {
-    data.hash = Message.HASH_FUNCTION(Message.MAGIC_BYTES + data.message);
+    data.hash = Message.hashFunction(Message.MAGIC_BYTES + data.message);
   } else {
-    return callback(new Error('Data object must contain message field to verify signature'));
+    return callback(new Error(
+      'Data object must contain message field to verify signature'));
   }
 
   return Message.verifyHashSignature(data, remote, callback);
@@ -134,7 +143,7 @@ Message.verifyHashSignature = function(data, remote, callback) {
     account,
     signature;
 
-  if(typeof callback !== 'function') {
+  if (typeof callback !== 'function') {
     throw new Error('Must supply callback function');
   }
 
@@ -143,7 +152,8 @@ Message.verifyHashSignature = function(data, remote, callback) {
     hash = sjcl.codec.hex.toBits(hash);
   }
 
-  if (typeof hash !== 'object' || hash.length <= 0 || typeof hash[0] !== 'number') {
+  if (typeof hash !== 'object' || hash.length <= 0
+      || typeof hash[0] !== 'number') {
     return callback(new Error('Hash must be a bitArray or hex-encoded string'));
   }
 
@@ -159,14 +169,16 @@ Message.verifyHashSignature = function(data, remote, callback) {
   signature = sjcl.codec.base64.toBits(signature);
 
   if (!(remote instanceof Remote) || remote.state !== 'online') {
-    return callback(new Error('Must supply connected Remote to verify signature'));
+    return callback(new Error(
+      'Must supply connected Remote to verify signature'));
   }
 
-  function recoverPublicKey (async_callback) {
+  function recoverPublicKey(async_callback) {
 
     var public_key;
     try {
-      public_key = sjcl.ecc.ecdsa.publicKey.recoverFromSignature(hash, signature);
+      public_key =
+        sjcl.ecc.ecdsa.publicKey.recoverFromSignature(hash, signature);
     } catch (err) {
       return async_callback(err);
     }
@@ -177,9 +189,9 @@ Message.verifyHashSignature = function(data, remote, callback) {
       async_callback(new Error('Could not recover public key from signature'));
     }
 
-  };
+  }
 
-  function checkPublicKeyIsValid (public_key, async_callback) {
+  function checkPublicKeyIsValid(public_key, async_callback) {
 
     // Get hex-encoded public key
     var key_pair = new KeyPair();
@@ -189,7 +201,7 @@ Message.verifyHashSignature = function(data, remote, callback) {
     var account_class_instance = new Account(remote, account);
     account_class_instance.publicKeyIsActive(public_key_hex, async_callback);
 
-  };
+  }
 
   var steps = [
     recoverPublicKey,

src/js/ripple/meta.js

@@ -26,28 +26,37 @@ function Meta(data) {
   data.AffectedNodes.forEach(this.addNode, this);
 };
 
-Meta.nodeTypes = [
+Meta.NODE_TYPES = [
   'CreatedNode',
   'ModifiedNode',
   'DeletedNode'
 ];
 
-Meta.amountFieldsAffectingIssuer = [
+Meta.AMOUNT_FIELDS_AFFECTING_ISSUER = [
   'LowLimit',
   'HighLimit',
   'TakerPays',
   'TakerGets'
 ];
 
+Meta.ACCOUNT_FIELDS = [
+  'Account',
+  'Owner',
+  'Destination',
+  'Issuer',
+  'Target'
+];
+
 /**
+ * @param {Object} node
  * @api private
  */
 
 Meta.prototype.getNodeType = function(node) {
   var result = null;
 
-  for (var i=0; i<Meta.nodeTypes.length; i++) {
-    var type = Meta.nodeTypes[i];
+  for (var i=0; i<Meta.NODE_TYPES.length; i++) {
+    var type = Meta.NODE_TYPES[i];
     if (node.hasOwnProperty(type)) {
       result = type;
       break;
@@ -57,6 +66,15 @@ Meta.prototype.getNodeType = function(node) {
   return result;
 };
 
+/**
+ * @param {String} field
+ * @api private
+ */
+
+Meta.prototype.isAccountField = function(field) {
+  return Meta.ACCOUNT_FIELDS.indexOf(field) !== -1;
+};
+
 /**
  * Add node to metadata
  *
@@ -72,7 +90,6 @@ Meta.prototype.addNode = function(node) {
 
   if ((result.nodeType = this.getNodeType(node))) {
     node = node[result.nodeType];
-
     result.diffType    = result.nodeType;
     result.entryType   = node.LedgerEntryType;
     result.ledgerIndex = node.LedgerIndex;
@@ -114,57 +131,6 @@ Meta.prototype.getNodes = function(options) {
   }
 };
 
-/**
- * Execute a function on each affected node.
- *
- * The callback is passed two parameters. The first is a node object which looks
- * like this:
- *
- *   {
- *     // Type of diff, e.g. CreatedNode, ModifiedNode
- *     nodeType: 'CreatedNode'
- *
- *     // Type of node affected, e.g. RippleState, AccountRoot
- *     entryType: 'RippleState',
- *
- *     // Index of the ledger this change occurred in
- *     ledgerIndex: '01AB01AB...',
- *
- *     // Contains all fields with later versions taking precedence
- *     //
- *     // This is a shorthand for doing things like checking which account
- *     // this affected without having to check the nodeType.
- *     fields: {...},
- *
- *     // Old fields (before the change)
- *     fieldsPrev: {...},
- *
- *     // New fields (that have been added)
- *     fieldsNew: {...},
- *
- *     // Changed fields
- *     fieldsFinal: {...}
- *   }
- *
- * The second parameter to the callback is the index of the node in the metadata
- * (first entry is index 0).
- */
-
-[
- 'forEach',
- 'map',
- 'filter',
- 'every',
- 'some',
- 'reduce'
-].forEach(function(fn) {
-  Meta.prototype[fn] = function() {
-    return Array.prototype[fn].apply(this.nodes, arguments);
-  };
-});
-
-Meta.prototype.each = Meta.prototype.forEach;
-
 Meta.prototype.getAffectedAccounts = function(from) {
   if (this._affectedAccounts) {
     return this._affectedAccounts;
@@ -176,12 +142,16 @@ Meta.prototype.getAffectedAccounts = function(from) {
   // TransactionMetaSet::getAffectedAccounts
   for (var i=0; i<this.nodes.length; i++) {
     var node = this.nodes[i];
-    var fields = (node.nodeType === 'CreatedNode') ? node.fieldsNew : node.fieldsFinal;
+    var fields = (node.nodeType === 'CreatedNode')
+    ? node.fieldsNew
+    : node.fieldsFinal;
+
     for (var fieldName in fields) {
       var field = fields[fieldName];
-      if (typeof field === 'string' && UInt160.is_valid(field)) {
+
+      if (this.isAccountField(fieldName) && UInt160.is_valid(field)) {
         accounts.push(field);
-      } else if (~Meta.amountFieldsAffectingIssuer.indexOf(fieldName)) {
+      } else if (~Meta.AMOUNT_FIELDS_AFFECTING_ISSUER.indexOf(fieldName)) {
         var amount = Amount.from_json(field);
         var issuer = amount.issuer();
         if (issuer.is_valid() && !issuer.is_zero()) {
@@ -238,4 +208,53 @@ Meta.prototype.getAffectedBooks = function() {
   return this._affectedBooks;
 };
 
+
+/**
+ * Execute a function on each affected node.
+ *
+ * The callback is passed two parameters. The first is a node object which looks
+ * like this:
+ *
+ *   {
+ *     // Type of diff, e.g. CreatedNode, ModifiedNode
+ *     nodeType: 'CreatedNode'
+ *
+ *     // Type of node affected, e.g. RippleState, AccountRoot
+ *     entryType: 'RippleState',
+ *
+ *     // Index of the ledger this change occurred in
+ *     ledgerIndex: '01AB01AB...',
+ *
+ *     // Contains all fields with later versions taking precedence
+ *     //
+ *     // This is a shorthand for doing things like checking which account
+ *     // this affected without having to check the nodeType.
+ *     fields: {...},
+ *
+ *     // Old fields (before the change)
+ *     fieldsPrev: {...},
+ *
+ *     // New fields (that have been added)
+ *     fieldsNew: {...},
+ *
+ *     // Changed fields
+ *     fieldsFinal: {...}
+ *   }
+ */
+
+[
+ 'forEach',
+ 'map',
+ 'filter',
+ 'every',
+ 'some',
+ 'reduce'
+].forEach(function(fn) {
+  Meta.prototype[fn] = function() {
+    return Array.prototype[fn].apply(this.nodes, arguments);
+  };
+});
+
+Meta.prototype.each = Meta.prototype.forEach;
+
 exports.Meta = Meta;

src/js/ripple/orderbookutils.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var _ = require('lodash');
+var assert = require('assert');
+var SerializedObject = require('./serializedobject').SerializedObject;
+var Types = require('./serializedtypes');
+var Amount = require('./amount').Amount;
+
+var IOU_SUFFIX = '/000/rrrrrrrrrrrrrrrrrrrrrhoLvTp';
+var OrderBookUtils = {};
+
+function assertValidNumber(number, message) {
+  assert(!_.isNull(number) && !isNaN(number), message);
+}
+
+/**
+ * Casts and returns offer's taker gets funded amount as a default IOU amount
+ *
+ * @param {Object} offer
+ * @return {Amount}
+ */
+
+OrderBookUtils.getOfferTakerGetsFunded = function(offer) {
+  assertValidNumber(offer.taker_gets_funded, 'Taker gets funded is invalid');
+
+  return Amount.from_json(offer.taker_gets_funded + IOU_SUFFIX);
+};
+
+/**
+ * Casts and returns offer's taker pays funded amount as a default IOU amount
+ *
+ * @param {Object} offer
+ * @return {Amount}
+ */
+
+OrderBookUtils.getOfferTakerPaysFunded = function(offer) {
+  assertValidNumber(offer.taker_pays_funded, 'Taker gets funded is invalid');
+
+  return Amount.from_json(offer.taker_pays_funded + IOU_SUFFIX);
+};
+
+/**
+ * Get offer taker gets amount
+ *
+ * @param {Object} offer
+ *
+ * @return {Amount}
+ */
+
+OrderBookUtils.getOfferTakerGets = function(offer) {
+  assert(typeof offer, 'object', 'Offer is invalid');
+
+  return Amount.from_json(offer.TakerGets + IOU_SUFFIX);
+};
+
+/**
+ * Retrieve offer quality
+ *
+ * @param {Object} offer
+ * @param {Currency} currencyGets
+ */
+
+OrderBookUtils.getOfferQuality = function(offer, currencyGets) {
+  var amount;
+
+  if (currencyGets.has_interest()) {
+    // XXX Should use Amount#from_quality
+    amount = Amount.from_json(
+      offer.TakerPays
+    ).ratio_human(offer.TakerGets, {
+      reference_date: new Date()
+    });
+  } else {
+    amount = Amount.from_json(offer.quality + IOU_SUFFIX);
+  }
+
+  return amount;
+};
+
+/**
+ * Formats an offer quality amount to a hex that can be parsed by
+ * Amount.parse_quality
+ *
+ * @param {Amount} quality
+ *
+ * @return {String}
+ */
+
+OrderBookUtils.convertOfferQualityToHex = function(quality) {
+  assert(quality instanceof Amount, 'Quality is not an amount');
+
+  var so = new SerializedObject();
+  Types.Quality.serialize(so, quality.to_text() + IOU_SUFFIX);
+
+  return so.to_hex();
+};
+
+/**
+ *
+ */
+
+OrderBookUtils.normalizeAmount = function(value) {
+  return Amount.from_json(value + IOU_SUFFIX);
+};
+
+module.exports = OrderBookUtils;

src/js/ripple/pathfind.js

@@ -35,28 +35,27 @@ util.inherits(PathFind, EventEmitter);
 PathFind.prototype.create = function () {
   var self = this;
 
-  var req = this.remote.request_path_find_create(this.src_account,
+  var req = this.remote.request_path_find_create(
+    this.src_account,
     this.dst_account,
     this.dst_amount,
-                                                 this.src_currencies,
-                                                 handleInitialPath);
+    this.src_currencies);
 
-  function handleInitialPath(err, msg) {
-    if (err) {
+  req.once('error', function(err) {
     self.emit('error', err);
-    } else {
+  });
+  req.once('success', function(msg) {
     self.notify_update(msg);
-    }
-  }
+  });
 
   // XXX We should add ourselves to prepare_subscribe or a similar mechanism so
   // that we can resubscribe after a reconnection.
 
-  req.request();
+  req.broadcast().request();
 };
 
 PathFind.prototype.close = function () {
-  this.remote.request_path_find_close().request();
+  this.remote.request_path_find_close().broadcast().request();
   this.emit('end');
   this.emit('close');
 };

src/js/ripple/rangeset.js

@@ -0,0 +1,67 @@
+var assert = require('assert');
+var lodash = require('lodash');
+
+function RangeSet() {
+  this._ranges = [ ];
+};
+
+/**
+ * Add a ledger range
+ *
+ * @param {Number|String} range string (n-n2,n3-n4)
+ */
+
+RangeSet.prototype.add = function(range) {
+  assert(typeof range !== 'number' || !isNaN(range), 'Ledger range malformed');
+
+  range = String(range).split(',');
+
+  if (range.length > 1) {
+    return range.forEach(this.add, this);
+  }
+
+  range = range[0].split('-').map(Number);
+
+  var lRange = {
+    start: range[0],
+    end: range[range.length === 1 ? 0 : 1]
+  };
+
+  // Comparisons on NaN should be falsy
+  assert(lRange.start <= lRange.end, 'Ledger range malformed');
+
+  var insertionPoint = lodash.sortedIndex(this._ranges, lRange, function(r) {
+    return r.start;
+  });
+
+  this._ranges.splice(insertionPoint, 0, lRange);
+};
+
+
+/*
+ * Check presence of ledger in range
+ *
+ * @param {Number|String} ledger
+ * @return Boolean
+ */
+
+RangeSet.prototype.has =
+RangeSet.prototype.contains = function(ledger) {
+  assert(ledger != null && !isNaN(ledger), 'Ledger must be a number');
+
+  ledger = Number(ledger);
+
+  return this._ranges.some(function(r) {
+    return ledger >= r.start && ledger <= r.end;
+  });
+};
+
+/**
+ * Reset ledger ranges
+ */
+
+RangeSet.prototype.reset = function() {
+  this._ranges = [ ];
+};
+
+exports.RangeSet = RangeSet;

src/js/ripple/request.js

@@ -1,5 +1,6 @@
 var EventEmitter = require('events').EventEmitter;
 var util         = require('util');
+var async        = require('async');
 var UInt160      = require('./uint160').UInt160;
 var Currency     = require('./currency').Currency;
 var RippleError  = require('./rippleerror').RippleError;
@@ -24,6 +25,9 @@ function Request(remote, command) {
 
   this.remote = remote;
   this.requested = false;
+  this.reconnectTimeout = 1000 * 3;
+  this.successEvent = 'success';
+  this.errorEvent = 'error';
   this.message = {
     command: command,
     id: void(0)
@@ -32,22 +36,20 @@ function Request(remote, command) {
 
 util.inherits(Request, EventEmitter);
 
-Request.prototype.broadcast = function() {
-  var connectedServers = this.remote.getConnectedServers();
-  this.request(connectedServers);
-  return connectedServers.length;
-};
-
 // Send the request to a remote.
 Request.prototype.request = function(servers, callback) {
-  if (this.requested) {
-    return this;
-  }
+  this.emit('before');
 
   if (typeof servers === 'function') {
     callback = servers;
   }
 
+  this.callback(callback);
+
+  if (this.requested) {
+    return this;
+  }
+
   this.requested = true;
   this.on('error', function(){});
   this.emit('request', this.remote);
@@ -61,7 +63,129 @@ Request.prototype.request = function(servers, callback) {
     this.remote.request(this);
   }
 
-  this.callback(callback);
+  return this;
+};
+
+/**
+ * Broadcast request to all servers, filter responses if a function is
+ * provided. Return first response that satisfies the filter. Pre-filter
+ * requests by ledger_index (if a ledger_index is set on the request), and
+ * automatically retry servers when they reconnect--if they are expected to
+ *
+ * Whew
+ *
+ * @param [Function] fn
+ */
+
+Request.prototype.filter =
+Request.prototype.addFilter =
+Request.prototype.broadcast = function(filterFn) {
+  var self = this;
+
+  if (!this.requested) {
+    // Defer until requested, and prevent the normal request() from executing
+    this.once('before', function() {
+      self.requested = true;
+      self.broadcast(filterFn);
+    });
+    return this;
+  }
+
+  var filterFn = typeof filterFn === 'function' ? filterFn : Boolean;
+  var lastResponse = new Error('No servers available');
+  var connectTimeouts = { };
+  var emit = this.emit;
+
+  this.emit = function(event, a, b) {
+    // Proxy success/error events
+    switch (event) {
+      case 'success':
+      case 'error':
+        emit.call(self, 'proposed', a, b);
+        break;
+      default:
+        emit.apply(self, arguments);
+    }
+  };
+
+  function iterator(server, callback) {
+    // Iterator is called in parallel
+
+    if (server.isConnected()) {
+      // Listen for proxied success/error event and apply filter
+      self.once('proposed', function(res) {
+        lastResponse = res;
+        callback(filterFn(res));
+      });
+
+      return server._request(self);
+    }
+
+    // Server is disconnected but should reconnect. Wait for it to reconnect,
+    // and abort after a timeout
+    var serverID = server.getServerID();
+
+    function serverReconnected() {
+      clearTimeout(connectTimeouts[serverID]);
+      connectTimeouts[serverID] = null;
+      iterator(server, callback);
+    };
+
+    connectTimeouts[serverID] = setTimeout(function() {
+      server.removeListener('connect', serverReconnected);
+      callback(false);
+    }, self.reconnectTimeout);
+
+    server.once('connect', serverReconnected);
+  };
+
+  function complete(success) {
+    // Emit success if the filter is satisfied by any server
+    // Emit error if the filter is not satisfied by any server
+    // Include the last response
+    emit.call(self, success ? 'success' : 'error', lastResponse);
+  };
+
+  var servers = this.remote._servers.filter(function(server) {
+    // Pre-filter servers that are disconnected and should not reconnect
+    return (server.isConnected() || server._shouldConnect)
+    // Pre-filter servers that do not contain the ledger in request
+    && (!self.message.hasOwnProperty('ledger_index')
+        || server.hasLedger(self.message.ledger_index))
+    && (!self.message.hasOwnProperty('ledger_index_min')
+      || self.message.ledger_index_min === -1
+      || server.hasLedger(self.message.ledger_index_min))
+    && (!self.message.hasOwnProperty('ledger_index_max')
+      || self.message.ledger_index_max === -1
+      || server.hasLedger(self.message.ledger_index_max))
+  });
+
+  // Apply iterator in parallel to connected servers, complete when the
+  // supplied filter function is satisfied once by a server's response
+  async.some(servers, iterator, complete);
+
+  return this;
+};
+
+Request.prototype.cancel = function() {
+  this.removeAllListeners();
+  this.on('error', function(){});
+
+  return this;
+};
+
+Request.prototype.setCallback = function(fn) {
+  if (typeof fn === 'function') {
+    this.callback(fn);
+  }
+
+  return this;
+};
+
+Request.prototype.setReconnectTimeout = function(timeout) {
+  if (typeof timeout === 'number' && !isNaN(timeout)) {
+    this.reconnectTimeout = timeout;
+  }
 
   return this;
 };
@@ -73,6 +197,13 @@ Request.prototype.callback = function(callback, successEvent, errorEvent) {
     return this;
   }
 
+  if (typeof successEvent === 'string') {
+    this.successEvent = successEvent;
+  }
+  if (typeof errorEvent === 'string') {
+    this.errorEvent = errorEvent;
+  }
+
   var called = false;
 
   function requestSuccess(message) {
@@ -94,8 +225,8 @@ Request.prototype.callback = function(callback, successEvent, errorEvent) {
     }
   };
 
-  this.once(successEvent || 'success', requestSuccess);
-  this.once(errorEvent   || 'error'  , requestError);
+  this.once(this.successEvent, requestSuccess);
+  this.once(this.errorEvent, requestError);
   this.request();
 
   return this;
@@ -124,6 +255,7 @@ Request.prototype.timeout = function(duration, callback) {
     }
 
     emit.call(self, 'timeout');
+    self.cancel();
   }, duration);
 
   this.emit = function() {
@@ -157,9 +289,7 @@ Request.prototype.setServer = function(server) {
       break;
   };
 
-  if (selected instanceof Server) {
   this.server = selected;
-  }
 
   return this;
 };
@@ -222,11 +352,10 @@ Request.prototype.ledgerSelect = function(ledger) {
     case 'validated':
       this.message.ledger_index = ledger;
       break;
-
     default:
-      if (Number(ledger)) {
+      if (Number(ledger) && isFinite(Number(ledger))) {
         this.message.ledger_index = Number(ledger);
-      } else if (/^[A-F0-9]+$/.test(ledger)) {
+      } else if (/^[A-F0-9]{64}$/.test(ledger)) {
         this.message.ledger_hash = ledger;
       }
       break;
@@ -286,8 +415,8 @@ Request.prototype.txBlob = function(json) {
 
 Request.prototype.rippleState = function(account, issuer, currency) {
   this.message.ripple_state = {
-    currency : currency,
-    accounts : [
+    currency: currency,
+    accounts: [
       UInt160.json_rewrite(account),
       UInt160.json_rewrite(issuer)
     ]
@@ -322,12 +451,8 @@ Request.prototype.addAccount = function(account, proposed) {
   }
 
   var processedAccount = UInt160.json_rewrite(account);
-
-  if (proposed === true) {
-    this.message.accounts_proposed = (this.message.accounts_proposed || []).concat(processedAccount);
-  } else {
-    this.message.accounts = (this.message.accounts || []).concat(processedAccount);
-  }
+  var prop = proposed === true ? 'accounts_proposed' : 'accounts';
+  this.message[prop] = (this.message[prop] || []).concat(processedAccount);
 
   return this;
 };

src/js/ripple/rippletxt.js

@@ -1,133 +0,0 @@
-var request   = require('superagent');
-var Currency  = require('./currency').Currency;
-
-var RippleTxt = {
-  txts : { }
-};
-
-RippleTxt.urlTemplates = [
-  'https://{{domain}}/ripple.txt',
-  'https://www.{{domain}}/ripple.txt',
-  'https://ripple.{{domain}}/ripple.txt',
-  'http://{{domain}}/ripple.txt',
-  'http://www.{{domain}}/ripple.txt',
-  'http://ripple.{{domain}}/ripple.txt'
-];
-
-/**
- * Gets the ripple.txt file for the given domain
- * @param {string}    domain - Domain to retrieve file from
- * @param {function}  fn - Callback function
- */
-
-RippleTxt.get = function(domain, fn) {
-  var self = this;
-
-  if (self.txts[domain]) {
-    return fn(null, self.txts[domain]);
-  }
-
-  ;(function nextUrl(i) {
-    var url = RippleTxt.urlTemplates[i];
-    
-    if (!url) {
-      return fn(new Error('No ripple.txt found'));
-    }
-
-    url = url.replace('{{domain}}', domain);
-    
-    request.get(url, function(err, resp) {
-      if (err || !resp.text) {
-        return nextUrl(++i);
-      }
-
-      var sections = self.parse(resp.text);
-      self.txts[domain] = sections;
-
-      fn(null, sections);
-    });
-  })(0);
-};
-
-/**
- * Parse a ripple.txt file
- * @param {string}  txt - Unparsed ripple.txt data
- */
-
-RippleTxt.parse = function(txt) {
-  var currentSection = '';
-  var sections = { };
-  
-  txt = txt.replace(/\r?\n/g, '\n').split('\n');
-
-  for (var i = 0, l = txt.length; i < l; i++) {
-    var line = txt[i];
-
-    if (!line.length || line[0] === '#') {
-      continue;
-    }
-
-    if (line[0] === '[' && line[line.length - 1] === ']') {
-      currentSection = line.slice(1, line.length - 1);
-      sections[currentSection] = [];
-    } else {
-      line = line.replace(/^\s+|\s+$/g, '');
-      if (sections[currentSection]) {
-        sections[currentSection].push(line);
-      }
-    }
-  }
-
-  return sections;
-};
-
-/**
- * extractDomain
- * attempt to extract the domain from a given url
- * returns the url if unsuccessful
- * @param {Object} url
- */
-
-RippleTxt.extractDomain = function (url) {
-  match = /[^.]*\.[^.]{2,3}(?:\.[^.]{2,3})?([^.\?][^\?.]+?)?$/.exec(url);
-  return match && match[0] ? match[0] : url;
-};
-
-/**
- * getCurrencies
- * returns domain, issuer account and currency object
- * for each currency found in the domain's ripple.txt file
- * @param {Object} domain
- * @param {Object} fn
- */
-
-RippleTxt.getCurrencies = function(domain, fn) {
-  domain = RippleTxt.extractDomain(domain);
-  this.get(domain, function(err, txt) {
-    if (err) {
-      return fn(err);  
-    }
-    
-    if (err || !txt.currencies || !txt.accounts) {
-      return fn(null, []);
-    }
-    
-    //NOTE: this won't be accurate if there are
-    //multiple issuer accounts with different 
-    //currencies associated with each.
-    var issuer     = txt.accounts[0];
-    var currencies = [];
-    
-    txt.currencies.forEach(function(currency) {
-      currencies.push({
-        issuer   : issuer,
-        currency : Currency.from_json(currency),
-        domain   : domain
-      });
-    });
-    
-    fn(null, currencies);
-  });
-}; 
-
-exports.RippleTxt = RippleTxt;

src/js/ripple/seed.js

@@ -1,3 +1,5 @@
+'use strict';
+
 //
 // Seed support
 //
@@ -6,17 +8,13 @@ var extend = require('extend');
 var utils = require('./utils');
 var sjcl = utils.sjcl;
 
-var BigInteger = utils.jsbn.BigInteger;
-
 var Base = require('./base').Base;
 var UInt = require('./uint').UInt;
-var UInt256 = require('./uint256').UInt256;
 var UInt160 = require('./uint160').UInt160;
 var KeyPair = require('./keypair').KeyPair;
 
-var Seed = extend(function () {
-  // Internal form: NaN or BigInteger
-  this._curve = sjcl.ecc.curves.c256;
+var Seed = extend(function() {
+  this._curve = sjcl.ecc.curves.k256;
   this._value = NaN;
 }, UInt);
 
@@ -26,7 +24,7 @@ Seed.prototype.constructor = Seed;
 
 // value = NaN on error.
 // One day this will support rfc1751 too.
-Seed.prototype.parse_json = function (j) {
+Seed.prototype.parse_json = function(j) {
   if (typeof j === 'string') {
     if (!j.length) {
       this._value = NaN;
@@ -46,7 +44,7 @@ Seed.prototype.parse_json = function (j) {
   return this;
 };
 
-Seed.prototype.parse_passphrase = function (j) {
+Seed.prototype.parse_passphrase = function(j) {
   if (typeof j !== 'string') {
     throw new Error('Passphrase must be a string');
   }
@@ -59,8 +57,8 @@ Seed.prototype.parse_passphrase = function (j) {
   return this;
 };
 
-Seed.prototype.to_json = function () {
-  if (!(this._value instanceof BigInteger)) {
+Seed.prototype.to_json = function() {
+  if (!(this.is_valid())) {
     return NaN;
   }
 
@@ -71,20 +69,18 @@ Seed.prototype.to_json = function () {
 
 function append_int(a, i) {
   return [].concat(a, i >> 24, (i >> 16) & 0xff, (i >> 8) & 0xff, i & 0xff);
-};
+}
 
 function firstHalfOfSHA512(bytes) {
   return sjcl.bitArray.bitSlice(
     sjcl.hash.sha512.hash(sjcl.codec.bytes.toBits(bytes)),
     0, 256
   );
-};
+}
 
-function SHA256_RIPEMD160(bits) {
-  return sjcl.hash.ripemd160.hash(sjcl.hash.sha256.hash(bits));
-};
-
-/**
+// Removed a `*` so this JSDoc-ish syntax is ignored.
+// This will soon all change anyway.
+/*
 * @param account
 *        {undefined}                 take first, default, KeyPair
 *
@@ -95,10 +91,11 @@ function SHA256_RIPEMD160(bits) {
 *                                    that is desired.
 *
 * @param maxLoops (optional)
-*        {Number}                    specifies the amount of attempts taken to generate
-*                                    a matching KeyPair
+*        {Number}                    specifies the amount of attempts taken
+*                                    to generate a matching KeyPair
+*
 */
-Seed.prototype.get_key = function (account, maxLoops) {
+Seed.prototype.get_key = function(account, maxLoops) {
   var account_number = 0, address;
   var max_loops = maxLoops || 1;
 
@@ -108,7 +105,7 @@ Seed.prototype.get_key = function (account, maxLoops) {
   if (account) {
     if (typeof account === 'number') {
       account_number = account;
-      max_loops = account_number+1;
+      max_loops = account_number + 1;
     } else {
       address = UInt160.from_json(account);
     }
@@ -119,7 +116,8 @@ Seed.prototype.get_key = function (account, maxLoops) {
   var i = 0;
 
   do {
-    private_gen = sjcl.bn.fromBits(firstHalfOfSHA512(append_int(this.to_bytes(), i)));
+    private_gen = sjcl.bn.fromBits(
+            firstHalfOfSHA512(append_int(this.to_bytes(), i)));
     i++;
   } while (!curve.r.greaterEquals(private_gen));
 
@@ -133,7 +131,13 @@ Seed.prototype.get_key = function (account, maxLoops) {
     i = 0;
 
     do {
-      sec = sjcl.bn.fromBits(firstHalfOfSHA512(append_int(append_int(public_gen.toBytesCompressed(), account_number), i)));
+      sec = sjcl.bn.fromBits(
+              firstHalfOfSHA512(
+                  append_int(
+                    append_int(public_gen.toBytesCompressed(), account_number)
+                    ,
+                    i
+                  )));
       i++;
     } while (!curve.r.greaterEquals(sec));
 
@@ -144,11 +148,12 @@ Seed.prototype.get_key = function (account, maxLoops) {
     if (max_loops-- <= 0) {
       // We are almost certainly looking for an account that would take same
       // value of $too_long {forever, ...}
-      throw new Error('Too many loops looking for KeyPair yielding '+
-                      address.to_json() +' from ' + this.to_json());
+      throw new Error('Too many loops looking for KeyPair yielding ' +
+                      address.to_json() + ' from ' + this.to_json());
     }
 
   } while (address && !key_pair.get_address().equals(address));
+
   return key_pair;
 };
 

src/js/ripple/serializedobject.js

@@ -1,13 +1,14 @@
+'use strict';
+
+var _ = require('lodash');
 var assert = require('assert');
 var extend = require('extend');
 var binformat = require('./binformat');
 var stypes = require('./serializedtypes');
-var UInt256   = require('./uint256').UInt256;
-var Crypt     = require('./crypt').Crypt;
 var utils = require('./utils');
+var UInt256 = require('./uint256').UInt256;
 
 var sjcl = utils.sjcl;
-var BigInteger = utils.jsbn.BigInteger;
 
 var TRANSACTION_TYPES = { };
 
@@ -27,8 +28,17 @@ Object.keys(binformat.ter).forEach(function(key) {
   TRANSACTION_RESULTS[binformat.ter[key]] = key;
 });
 
+function normalize_sjcl_bn_hex(string) {
+  var hex = string.slice(2);    // remove '0x' prefix
+  // now strip leading zeros
+  var i = _.findIndex(hex, function(c) {
+    return c !== '0';
+  });
+  return i >= 0 ? hex.slice(i) : '0';
+}
+
 function SerializedObject(buf) {
-  if (Array.isArray(buf) || (Buffer && Buffer.isBuffer(buf)) ) {
+  if (Array.isArray(buf) || (Buffer && Buffer.isBuffer(buf))) {
     this.buffer = buf;
   } else if (typeof buf === 'string') {
     this.buffer = sjcl.codec.bytes.fromBits(sjcl.codec.hex.toBits(buf));
@@ -38,11 +48,11 @@ function SerializedObject(buf) {
     throw new Error('Invalid buffer passed.');
   }
   this.pointer = 0;
-};
+}
 
 SerializedObject.from_json = function(obj) {
   // Create a copy of the object so we don't modify it
-  var obj = extend({}, obj);
+  obj = extend(true, {}, obj);
   var so = new SerializedObject();
   var typedef;
 
@@ -101,25 +111,25 @@ SerializedObject.check_no_missing_fields = function(typedef, obj) {
     var field = spec[0];
     var requirement = spec[1];
 
-    if (binformat.REQUIRED === requirement && obj[field] === void(0)) {
+    if (binformat.REQUIRED === requirement && obj[field] === undefined) {
       missing_fields.push(field);
-    };
-  };
+    }
+  }
 
   if (missing_fields.length > 0) {
     var object_name;
 
-    if (obj.TransactionType !== void(0)) {
+    if (obj.TransactionType !== undefined) {
       object_name = SerializedObject.lookup_type_tx(obj.TransactionType);
-    } else if (obj.LedgerEntryType != null){
+    } else if (obj.LedgerEntryType !== undefined) {
       object_name = SerializedObject.lookup_type_le(obj.LedgerEntryType);
     } else {
-      object_name = "TransactionMetaData";
+      object_name = 'TransactionMetaData';
     }
 
-    throw new Error(object_name + " is missing fields: " +
+    throw new Error(object_name + ' is missing fields: ' +
                     JSON.stringify(missing_fields));
-  };
+  }
 };
 
 SerializedObject.prototype.append = function(bytes) {
@@ -127,7 +137,17 @@ SerializedObject.prototype.append = function(bytes) {
     bytes = bytes.buffer;
   }
 
+  // Make sure both buffer and bytes are Array. Either could potentially be a
+  // Buffer.
+  if (Array.isArray(this.buffer) && Array.isArray(bytes)) {
+    // Array::concat is horribly slow where buffer length is 100 kbytes + One
+    // transaction with 1100 affected nodes took around 23 seconds to convert
+    // from json to bytes.
+    Array.prototype.push.apply(this.buffer, bytes);
+  } else {
     this.buffer = this.buffer.concat(bytes);
+  }
+
   this.pointer += bytes.length;
 };
 
@@ -152,7 +172,7 @@ function readOrPeek(advance) {
 
     return result;
   };
-};
+}
 
 SerializedObject.prototype.read = readOrPeek(true);
 
@@ -209,15 +229,18 @@ SerializedObject.jsonify_structure = function(structure, field_name) {
 
       if (typeof structure.to_json === 'function') {
         output = structure.to_json();
-      } else if (structure instanceof BigInteger) {
-        output = structure.toString(16).toUpperCase();
+      } else if (structure instanceof sjcl.bn) {
+        output = ('0000000000000000' +
+                   normalize_sjcl_bn_hex(structure.toString())
+                  .toUpperCase()
+                  ).slice(-16);
       } else {
-        //new Array or Object
+        // new Array or Object
         output = new structure.constructor();
 
         var keys = Object.keys(structure);
 
-        for (var i=0, l=keys.length; i<l; i++) {
+        for (var i = 0, l = keys.length; i < l; i++) {
           var key = keys[i];
           output[key] = SerializedObject.jsonify_structure(structure[key], key);
         }
@@ -250,16 +273,16 @@ SerializedObject.prototype.hash = function(prefix) {
   var sign_buffer = new SerializedObject();
 
   // Add hashing prefix
-  if ("undefined" !== typeof prefix) {
+  if (typeof prefix !== 'undefined') {
     stypes.Int32.serialize(sign_buffer, prefix);
   }
 
   // Copy buffer to temporary buffer
   sign_buffer.append(this.buffer);
 
-  // XXX We need a proper Buffer class then Crypt could accept that
   var bits = sjcl.codec.bytes.toBits(sign_buffer.buffer);
-  return Crypt.hashSha512Half(bits);
+  var sha512hex = sjcl.codec.hex.fromBits(sjcl.hash.sha512.hash(bits));
+  return UInt256.from_hex(sha512hex.substr(0, 64));
 };
 
 // DEPRECATED
@@ -268,15 +291,9 @@ SerializedObject.prototype.signing_hash = SerializedObject.prototype.hash;
 SerializedObject.prototype.serialize_field = function(spec, obj) {
   var name = spec[0];
   var presence = spec[1];
-  var field_id = spec[2];
-  var Type     = stypes[spec[3]];
 
   if (typeof obj[name] !== 'undefined') {
-    // ST: Old serialization code
-    //this.append(SerializedObject.get_field_header(Type.id, field_id));
     try {
-      // ST: Old serialization code
-      //Type.serialize(this, obj[name]);
       stypes.serialize(this, name, obj[name]);
     } catch (e) {
       // Add field name to message and rethrow
@@ -289,7 +306,7 @@ SerializedObject.prototype.serialize_field = function(spec, obj) {
 };
 
 SerializedObject.get_field_header = function(type_id, field_id) {
-  var buffer = [ 0 ];
+  var buffer = [0];
 
   if (type_id > 0xF) {
     buffer.push(type_id & 0xFF);
@@ -312,7 +329,7 @@ SerializedObject.sort_typedef = function(typedef) {
   function sort_field_compare(a, b) {
     // Sort by type id first, then by field id
     return a[3] !== b[3] ? stypes[a[3]].id - stypes[b[3]].id : a[2] - b[2];
-  };
+  }
 
   return typedef.sort(sort_field_compare);
 };
@@ -322,7 +339,7 @@ SerializedObject.lookup_type_tx = function(id) {
   return TRANSACTION_TYPES[id];
 };
 
-SerializedObject.lookup_type_le = function (id) {
+SerializedObject.lookup_type_le = function(id) {
   assert(typeof id === 'number');
   return LEDGER_ENTRY_TYPES[id];
 };

src/js/ripple/server.js

@@ -1,7 +1,9 @@
 var util         = require('util');
 var url          = require('url');
+var LRU          = require('lru-cache');
 var EventEmitter = require('events').EventEmitter;
 var Amount       = require('./amount').Amount;
+var RangeSet     = require('./rangeset').RangeSet;
 var log          = require('./log').internal.sub('server');
 
 /**
@@ -32,7 +34,7 @@ function Server(remote, opts) {
     throw new TypeError('Server configuration is not an Object');
   }
 
-  if (!Server.domainRE.test(opts.host)) {
+  if (!Server.DOMAIN_RE.test(opts.host)) {
     throw new Error('Server host is malformed, use "host" and "port" server configuration');
   }
 
@@ -56,6 +58,8 @@ function Server(remote, opts) {
   this._connected = false;
   this._shouldConnect = false;
   this._state = 'offline';
+  this._ledgerRanges = new RangeSet();
+  this._ledgerMap = LRU({ max: 200 });
 
   this._id = 0; // request ID
   this._retry = 0;
@@ -117,31 +121,29 @@ function Server(remote, opts) {
     self._updateScore('loadchange', load);
   });
 
-  // If server is not up-to-date, request server_info
-  // for getting pubkey_node & hostid information.
-  // Otherwise this information is available on the
-  // initial server subscribe response
-  this.on('connect', function requestServerID() {
-    if (self._pubkey_node) {
-      return;
-    }
-
-    self.on('response_server_info', function setServerID(message) {
-      try {
-        self._pubkey_node = message.info.pubkey_node;
-      } catch (e) {
-      }
-    });
-
-    var serverInfoRequest = self._remote.requestServerInfo();
-    serverInfoRequest.on('error', function() { });
-    self._request(serverInfoRequest);
+  this.on('connect', function() {
+    self.requestServerID();
   });
 };
 
 util.inherits(Server, EventEmitter);
 
-Server.domainRE = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|[-_]){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|[-_]){0,61}[0-9A-Za-z])?)*\.?$/;
+Server.DOMAIN_RE = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|[-_]){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|[-_]){0,61}[0-9A-Za-z])?)*\.?$/;
+
+Server.TLS_ERRORS = [
+  'UNABLE_TO_GET_ISSUER_CERT', 'UNABLE_TO_GET_CRL',
+  'UNABLE_TO_DECRYPT_CERT_SIGNATURE', 'UNABLE_TO_DECRYPT_CRL_SIGNATURE',
+  'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY', 'CERT_SIGNATURE_FAILURE',
+  'CRL_SIGNATURE_FAILURE', 'CERT_NOT_YET_VALID', 'CERT_HAS_EXPIRED',
+  'CRL_NOT_YET_VALID', 'CRL_HAS_EXPIRED', 'ERROR_IN_CERT_NOT_BEFORE_FIELD',
+  'ERROR_IN_CERT_NOT_AFTER_FIELD', 'ERROR_IN_CRL_LAST_UPDATE_FIELD',
+  'ERROR_IN_CRL_NEXT_UPDATE_FIELD', 'OUT_OF_MEM',
+  'DEPTH_ZERO_SELF_SIGNED_CERT', 'SELF_SIGNED_CERT_IN_CHAIN',
+  'UNABLE_TO_GET_ISSUER_CERT_LOCALLY', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+  'CERT_CHAIN_TOO_LONG', 'CERT_REVOKED', 'INVALID_CA',
+  'PATH_LENGTH_EXCEEDED', 'INVALID_PURPOSE', 'CERT_UNTRUSTED',
+  'CERT_REJECTED'
+];
 
 /**
  * Server states that we will treat as the server being online.
@@ -235,6 +237,31 @@ Server.prototype._checkActivity = function() {
   }
 };
 
+/**
+ * If server is not up-to-date, request server_info for getting pubkey_node
+ * & hostid information. Otherwise this information is available on the
+ * initial server subscribe response
+ */
+
+Server.prototype.requestServerID = function() {
+  var self = this;
+
+  if (this._pubkey_node) {
+    return;
+  }
+
+  this.on('response_server_info', function setServerID(message) {
+    try {
+      self._pubkey_node = message.info.pubkey_node;
+    } catch (e) {
+    }
+  });
+
+  var serverInfoRequest = this._remote.requestServerInfo();
+  serverInfoRequest.on('error', function() { });
+  this._request(serverInfoRequest);
+};
+
 /**
  * Server maintains a score for request prioritization.
  *
@@ -328,6 +355,8 @@ Server.prototype.disconnect = function() {
   this._lastLedgerClose = NaN;
   this._score = 0;
   this._shouldConnect = false;
+  this._ledgerRanges.reset();
+  this._ledgerMap.reset();
   this._setState('offline');
 
   if (this._ws) {
@@ -420,6 +449,11 @@ Server.prototype.connect = function() {
         log.info(self.getServerID(), 'onerror:',  e.data || e);
       }
 
+      if (Server.TLS_ERRORS.indexOf(e.message) !== -1) {
+        // Unrecoverable
+        throw e;
+      }
+
       // Most connection errors for WebSockets are conveyed as 'close' events with
       // code 1006. This is done for security purposes and therefore unlikely to
       // ever change.
@@ -545,6 +579,8 @@ Server.prototype._handleMessage = function(message) {
 Server.prototype._handleLedgerClosed = function(message) {
   this._lastLedgerIndex = message.ledger_index;
   this._lastLedgerClose = Date.now();
+  this._ledgerRanges.add(message.ledger_index);
+  this._ledgerMap.set(message.ledger_hash, message.ledger_index);
   this.emit('ledger_closed', message);
 };
 
@@ -620,24 +656,33 @@ Server.prototype._handlePathFind = function(message) {
 };
 
 /**
- * Handle subscription response messages. Subscription response
- * messages indicate that a connection to the server is ready
+ * Handle initial subscription response message. The server is considered
+ * `connected` after it has received a response to initial subscription to
+ * ledger and server streams
  *
  * @param {Object} message
  * @api private
  */
 
 Server.prototype._handleResponseSubscribe = function(message) {
-  if (!this._remote._allow_partial_history
+  if (this.isConnected()) {
+    // This function only concerns initializing the server's internal
+    // state after a connection
+    return;
+  }
+
+  if (!this._remote.allow_partial_history
       && !Server.hasFullLedgerHistory(message)) {
     // Server has partial history and Remote has been configured to disallow
     // servers with incomplete history
     return this.reconnect();
   }
+
   if (message.pubkey_node) {
     // pubkey_node is used to identify the server
     this._pubkey_node = message.pubkey_node;
   }
+
   if (Server.isLoadStatus(message)) {
     this._load_base = message.load_base || 256;
     this._load_factor = message.load_factor || 256;
@@ -646,6 +691,12 @@ Server.prototype._handleResponseSubscribe = function(message) {
     this._reserve_base = message.reserve_base;
     this._reserve_inc = message.reserve_inc;
   }
+
+  if (message.validated_ledgers) {
+    // Add validated ledgers to ledger range set
+    this._ledgerRanges.add(message.validated_ledgers);
+  }
+
   if (~Server.onlineStates.indexOf(message.server_status)) {
     this._setState('online');
   }
@@ -750,6 +801,12 @@ Server.prototype._request = function(request) {
   }
 };
 
+/**
+ * Get server connected status
+ *
+ * @return boolean
+ */
+
 Server.prototype.isConnected =
 Server.prototype._isConnected = function() {
   return this._connected;
@@ -824,6 +881,36 @@ Server.prototype._reserve = function(ownerCount) {
   return reserve_base.add(reserve_inc.product_human(owner_count));
 };
 
+/**
+ * Check that server has seen closed ledger
+ *
+ * @param {string|number} ledger hash or index
+ * @return boolean
+ */
+
+Server.prototype.hasLedger = function(ledger) {
+  var result = false;
+
+  if (typeof ledger === 'string' && /^[A-F0-9]{64}$/.test(ledger)) {
+    result = this._ledgerMap.has(ledger);
+  } else if (ledger != null && !isNaN(ledger)) {
+    result = this._ledgerRanges.has(ledger);
+  }
+
+  return result;
+};
+
+/**
+ * Get ledger index of last seen validated ledger
+ *
+ * @return number
+ */
+
+Server.prototype.getLastLedger =
+Server.prototype.getLastLedgerIndex = function() {
+  return this._lastLedgerIndex;
+};
+
 exports.Server = Server;
 
 // vim:sw=2:sts=2:ts=8:et

src/js/ripple/shamap.js

@@ -1,30 +1,19 @@
+'use strict';
+
 var util = require('util');
-var sjcl = require('./utils').sjcl;
-var stypes = require('./serializedtypes');
 var hashprefixes = require('./hashprefixes');
 
 var UInt256 = require('./uint256').UInt256;
 var SerializedObject = require('./serializedobject').SerializedObject;
 
-function SHAMap() {
-  this.root = new SHAMapTreeNodeInner(0);
-};
-
-SHAMap.prototype.add_item = function(tag, node, type) {
-  var node = new SHAMapTreeNodeLeaf(tag, node, type);
-  this.root.add_item(tag, node);
-};
-
-SHAMap.prototype.hash = function() {
-  return this.root.hash();
-};
-
 /**
  * Abstract class representing a node in a SHAMap tree.
  *
  * Can be either SHAMapTreeNodeInner or SHAMapTreeNodeLeaf.
+ *
+ * @class
  */
-function SHAMapTreeNode() { };
+function SHAMapTreeNode() { }
 
 SHAMapTreeNode.TYPE_INNER = 1;
 SHAMapTreeNode.TYPE_TRANSACTION_NM = 2;
@@ -32,11 +21,17 @@ SHAMapTreeNode.TYPE_TRANSACTION_MD = 3;
 SHAMapTreeNode.TYPE_ACCOUNT_STATE = 4;
 
 /**
-* @param tag {String} 64 hexadecimal characters
+* @param {String} tag (64 hexadecimal characters)
+* @param {SHAMapTreeNode} node
+* @return {void}
+* @virtual
 */
+/*eslint-disable no-unused-vars*/
 SHAMapTreeNode.prototype.add_item = function(tag, node) {
-  throw new Error('Called unimplemented virtual method SHAMapTreeNode#add_item.');
+  throw new Error(
+    'Called unimplemented virtual method SHAMapTreeNode#add_item.');
 };
+/*eslint-enable no-unused-vars*/
 
 SHAMapTreeNode.prototype.hash = function() {
   throw new Error('Called unimplemented virtual method SHAMapTreeNode#hash.');
@@ -44,6 +39,8 @@ SHAMapTreeNode.prototype.hash = function() {
 
 /**
  * Inner (non-leaf) node in a SHAMap tree.
+ * @param {Number} depth (i.e. how many parent inner nodes)
+ * @class
  */
 function SHAMapTreeNodeInner(depth) {
   SHAMapTreeNode.call(this);
@@ -51,7 +48,7 @@ function SHAMapTreeNodeInner(depth) {
   this.leaves = {};
 
   this.type = SHAMapTreeNode.INNER;
-  this.depth = depth == null ? 0 : depth;
+  this.depth = depth === undefined ? 0 : depth;
 
   this.empty = true;
 }
@@ -59,9 +56,11 @@ function SHAMapTreeNodeInner(depth) {
 util.inherits(SHAMapTreeNodeInner, SHAMapTreeNode);
 
 /**
- * @param tag {String} (equates to a ledger entries `index`)
+ * @param {String} tag (equates to a ledger entry `index`)
+ * @param {SHAMapTreeNode} node (to add)
+ * @return {void}
  */
-SHAMapTreeNodeInner.prototype.add_item = function (tag, node) {
+SHAMapTreeNodeInner.prototype.add_item = function(tag, node) {
   var depth = this.depth;
   var existing_node = this.get_node(tag[depth]);
 
@@ -72,7 +71,8 @@ SHAMapTreeNodeInner.prototype.add_item = function (tag, node) {
       existing_node.add_item(tag, node);
     } else if (existing_node.tag === tag) {
       // Collision
-      throw new Error('Tried to add a node to a SHAMap that was already in there.');
+      throw new Error(
+          'Tried to add a node to a SHAMap that was already in there.');
     } else {
       // Turn it into an inner node
       var new_inner_node = new SHAMapTreeNodeInner(depth + 1);
@@ -92,6 +92,9 @@ SHAMapTreeNodeInner.prototype.add_item = function (tag, node) {
 
 /**
  * Overwrite the node that is currently in a given slot.
+ * @param {String} slot (a character 0-F)
+ * @param {SHAMapTreeNode} node (to place)
+ * @return {void}
  */
 SHAMapTreeNodeInner.prototype.set_node = function(slot, node) {
   this.leaves[slot] = node;
@@ -108,9 +111,8 @@ SHAMapTreeNodeInner.prototype.hash = function() {
   }
 
   var hash_buffer = new SerializedObject();
-  var buffer = [ ];
 
-  for (var i=0; i<16; i++) {
+  for (var i = 0; i < 16; i++) {
     var leafHash = UInt256.from_hex(UInt256.HEX_ZERO);
     var slot = i.toString(16).toUpperCase();
 
@@ -128,6 +130,10 @@ SHAMapTreeNodeInner.prototype.hash = function() {
 
 /**
  * Leaf node in a SHAMap tree.
+ * @param {String} tag (equates to a ledger entry `index`)
+ * @param {SerializedObject} node (bytes of account state, transaction etc)
+ * @param {Number} type (one of TYPE_ACCOUNT_STATE, TYPE_TRANSACTION_MD etc)
+ * @class
  */
 function SHAMapTreeNodeLeaf(tag, node, type) {
   SHAMapTreeNode.call(this);
@@ -140,11 +146,11 @@ function SHAMapTreeNodeLeaf(tag, node, type) {
   this.tag_bytes = UInt256.from_hex(this.tag).to_bytes();
   this.type = type;
   this.node = node;
-};
+}
 
 util.inherits(SHAMapTreeNodeLeaf, SHAMapTreeNode);
 
-SHAMapTreeNodeLeaf.prototype.hash = function () {
+SHAMapTreeNodeLeaf.prototype.hash = function() {
   var buffer = new SerializedObject();
   switch (this.type) {
     case SHAMapTreeNode.TYPE_ACCOUNT_STATE:
@@ -162,6 +168,19 @@ SHAMapTreeNodeLeaf.prototype.hash = function () {
   }
 };
 
+function SHAMap() {
+  this.root = new SHAMapTreeNodeInner(0);
+}
+
+SHAMap.prototype.add_item = function(tag, node, type) {
+  node = new SHAMapTreeNodeLeaf(tag, node, type);
+  this.root.add_item(tag, node);
+};
+
+SHAMap.prototype.hash = function() {
+  return this.root.hash();
+};
+
 exports.SHAMap = SHAMap;
 exports.SHAMapTreeNode = SHAMapTreeNode;
 exports.SHAMapTreeNodeInner = SHAMapTreeNodeInner;

src/js/ripple/signedrequest.js

@@ -1,203 +0,0 @@
-var Crypt = require('./crypt').Crypt;
-var Message = require('./message').Message;
-var parser  = require("url");
-var querystring = require('querystring');
-var extend = require("extend");
-
-var SignedRequest = function (config) {
-  // XXX Constructor should be generalized and constructing from an Angular.js
-  //     $http config should be a SignedRequest.from... utility method.
-  this.config = extend(true, {}, config);
-  if (!this.config.data) this.config.data = {};
-};
-
-
-
-/**
- * Create a string from request parameters that
- * will be used to sign a request
- * @param {Object} parsed - parsed url
- * @param {Object} date 
- * @param {Object} mechanism - type of signing
- */
-SignedRequest.prototype.getStringToSign = function (parsed, date, mechanism) {
-  // XXX This method doesn't handle signing GET requests correctly. The data
-  //     field will be merged into the search string, not the request body.
-
-  // Sort the properties of the JSON object into canonical form
-  var canonicalData = JSON.stringify(copyObjectWithSortedKeys(this.config.data));
-
-  // Canonical request using Amazon's v4 signature format
-  // See: http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
-  var canonicalRequest = [
-    this.config.method || 'GET',
-    parsed.pathname || '',
-    parsed.search || '',
-    // XXX Headers signing not supported
-    '',
-    '',
-    Crypt.hashSha512(canonicalData).toLowerCase()
-  ].join('\n');
-
-  // String to sign inspired by Amazon's v4 signature format
-  // See: http://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html
-  //
-  // We don't have a credential scope, so we skip it.
-  //
-  // But that modifies the format, so the format ID is RIPPLE1, instead of AWS4.
-  return [
-    mechanism,
-    date,
-    Crypt.hashSha512(canonicalRequest).toLowerCase()
-  ].join('\n');
-};
-
-//prepare for signing
-function copyObjectWithSortedKeys(object) {
-  if (isPlainObject(object)) {
-    var newObj = {};
-    var keysSorted = Object.keys(object).sort();
-    var key;
-    for (var i in keysSorted) {
-      key = keysSorted[i];
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        newObj[key] = copyObjectWithSortedKeys(object[key]);
-      }
-    }
-    return newObj;
-  } else if (Array.isArray(object)) {
-    return object.map(copyObjectWithSortedKeys);
-  } else {
-    return object;
-  }
-}
-
-//from npm extend
-function isPlainObject(obj) {
-  var hasOwn = Object.prototype.hasOwnProperty;
-  var toString = Object.prototype.toString;
-
-  if (!obj || toString.call(obj) !== '[object Object]' || obj.nodeType || obj.setInterval)
-    return false;
-
-  var has_own_constructor = hasOwn.call(obj, 'constructor');
-  var has_is_property_of_method = hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
-  // Not own constructor property must be Object
-  if (obj.constructor && !has_own_constructor && !has_is_property_of_method)
-    return false;
-
-  // Own properties are enumerated firstly, so to speed up,
-  // if last one is own, then all properties are own.
-  var key;
-  for ( key in obj ) {}
-
-  return key === undefined || hasOwn.call( obj, key );
-};
-
-/**
- * HMAC signed request
- * @param {Object} config
- * @param {Object} auth_secret
- * @param {Object} blob_id
- */
-SignedRequest.prototype.signHmac = function (auth_secret, blob_id) {
-  var config = extend(true, {}, this.config);
-
-  // Parse URL
-  var parsed        = parser.parse(config.url);
-  var date          = dateAsIso8601();
-  var signatureType = 'RIPPLE1-HMAC-SHA512';
-  var stringToSign  = this.getStringToSign(parsed, date, signatureType);
-  var signature     = Crypt.signString(auth_secret, stringToSign);
-
-  var query = querystring.stringify({
-    signature: Crypt.base64ToBase64Url(signature),
-    signature_date: date,
-    signature_blob_id: blob_id,
-    signature_type: signatureType
-  });
-
-  config.url += (parsed.search ? '&' : '?') + query;
-  return config;
-};
-
-/**
- * Asymmetric signed request
- * @param {Object} config
- * @param {Object} secretKey
- * @param {Object} account
- * @param {Object} blob_id
- */
-SignedRequest.prototype.signAsymmetric = function (secretKey, account, blob_id) {
-  var config = extend(true, {}, this.config);
-
-  // Parse URL
-  var parsed        = parser.parse(config.url);
-  var date          = dateAsIso8601();
-  var signatureType = 'RIPPLE1-ECDSA-SHA512';
-  var stringToSign  = this.getStringToSign(parsed, date, signatureType);
-  var signature     = Message.signMessage(stringToSign, secretKey);
- 
-  var query = querystring.stringify({
-    signature: Crypt.base64ToBase64Url(signature),
-    signature_date: date,
-    signature_blob_id: blob_id,
-    signature_account: account,
-    signature_type: signatureType
-  });
-
-  config.url += (parsed.search ? '&' : '?') + query;
-
-  return config;
-};
-
-/**
- * Asymmetric signed request for vault recovery
- * @param {Object} config
- * @param {Object} secretKey
- * @param {Object} username
- */
-SignedRequest.prototype.signAsymmetricRecovery = function (secretKey, username) {
-  var config = extend(true, {}, this.config);
-
-  // Parse URL
-  var parsed        = parser.parse(config.url);
-  var date          = dateAsIso8601();
-  var signatureType = 'RIPPLE1-ECDSA-SHA512';
-  var stringToSign  = this.getStringToSign(parsed, date, signatureType);
-  var signature     = Message.signMessage(stringToSign, secretKey);
- 
-  var query = querystring.stringify({
-    signature: Crypt.base64ToBase64Url(signature),
-    signature_date: date,
-    signature_username: username,
-    signature_type: signatureType
-  });
-
-  config.url += (parsed.search ? '&' : '?') + query;
-
-  return config;
-};
-
-var dateAsIso8601 = (function () {
-  function pad(n) {
-    return (n < 0 || n > 9 ? "" : "0") + n;
-  }
-
-  return function dateAsIso8601() {
-    var date = new Date();
-    return date.getUTCFullYear() + "-" +
-      pad(date.getUTCMonth()     + 1)  + "-" +
-      pad(date.getUTCDate())     + "T" +
-      pad(date.getUTCHours())    + ":" +
-      pad(date.getUTCMinutes())  + ":" +
-      pad(date.getUTCSeconds())  + ".000Z";
-  };
-})();
-
-// XXX Add methods for verifying requests
-// SignedRequest.prototype.verifySignatureHmac
-// SignedRequest.prototype.verifySignatureAsymetric
-
-exports.SignedRequest = SignedRequest;
-

src/js/ripple/transactionqueue.js

@@ -1,19 +1,23 @@
+'use strict';
+
+var lodash = require('lodash');
+var LRU = require('lru-cache');
+var Transaction = require('./transaction').Transaction;
 
 /**
  * Manager for pending transactions
  */
 
-var LRU = require('lru-cache');
-var Transaction = require('./transaction').Transaction;
-
 function TransactionQueue() {
   this._queue = [ ];
-  this._idCache = LRU();
-  this._sequenceCache = LRU();
-};
+  this._idCache = new LRU({max: 200});
+  this._sequenceCache = new LRU({max: 200});
+}
 
 /**
  * Store received (validated) sequence
+ *
+ * @param {Number} sequence
  */
 
 TransactionQueue.prototype.addReceivedSequence = function(sequence) {
@@ -23,6 +27,9 @@ TransactionQueue.prototype.addReceivedSequence = function(sequence) {
 /**
  * Check that sequence number has been consumed by a validated
  * transaction
+ *
+ * @param {Number} sequence
+ * @return {Boolean}
  */
 
 TransactionQueue.prototype.hasSequence = function(sequence) {
@@ -31,6 +38,9 @@ TransactionQueue.prototype.hasSequence = function(sequence) {
 
 /**
  * Store received (validated) ID transaction
+ *
+ * @param {String} transaction id
+ * @param {Transaction} transaction
  */
 
 TransactionQueue.prototype.addReceivedId = function(id, transaction) {
@@ -39,6 +49,9 @@ TransactionQueue.prototype.addReceivedId = function(id, transaction) {
 
 /**
  * Get received (validated) transaction by ID
+ *
+ * @param {String} transaction id
+ * @return {Object}
  */
 
 TransactionQueue.prototype.getReceived = function(id) {
@@ -48,16 +61,38 @@ TransactionQueue.prototype.getReceived = function(id) {
 /**
  * Get a submitted transaction by ID. Transactions
  * may have multiple associated IDs.
+ *
+ * @param {String} transaction id
+ * @return {Transaction}
  */
 
 TransactionQueue.prototype.getSubmission = function(id) {
-  var result = void(0);
+  return lodash.find(this._queue, function(tx) {
+    return lodash.contains(tx.submittedIDs, id);
+  });
+};
 
-  for (var i=0, tx; (tx=this._queue[i]); i++) {
-    if (~tx.submittedIDs.indexOf(id)) {
-      result = tx;
-      break;
+/**
+ * Get earliest ledger in the pending queue
+ *
+ * @return {Number} ledger
+ */
+
+TransactionQueue.prototype.getMinLedger = function() {
+  if (this.length() < 1) {
+    return -1;
   }
+
+  var result = Infinity;
+
+  for (var i = 0; i < this.length(); i++) {
+    if (this._queue[i].initialSubmitIndex < result) {
+      result = this._queue[i].initialSubmitIndex;
+    }
+  }
+
+  if (!isFinite(result)) {
+    result = -1;
   }
 
   return result;
@@ -65,6 +100,8 @@ TransactionQueue.prototype.getSubmission = function(id) {
 
 /**
  * Remove a transaction from the queue
+ *
+ * @param {String|Transaction} transaction or id
  */
 
 TransactionQueue.prototype.remove = function(tx) {
@@ -87,17 +124,41 @@ TransactionQueue.prototype.remove = function(tx) {
   }
 };
 
+/**
+ * Add a transaction to pending queue
+ *
+ * @param {Transaction} transaction
+ */
+
 TransactionQueue.prototype.push = function(tx) {
   this._queue.push(tx);
 };
 
+/**
+ * Iterate over pending transactions
+ *
+ * @param {Function} iterator
+ */
+
 TransactionQueue.prototype.forEach = function(fn) {
   this._queue.forEach(fn);
 };
 
+/**
+ * @return {Number} length of pending queue
+ */
+
 TransactionQueue.prototype.length =
 TransactionQueue.prototype.getLength = function() {
   return this._queue.length;
 };
 
+/**
+ * @return {Array} pending queue
+ */
+
+TransactionQueue.prototype.getQueue = function() {
+  return this._queue;
+};
+
 exports.TransactionQueue = TransactionQueue;

src/js/ripple/uint.js

@@ -1,8 +1,9 @@
+'use strict';
+
+/*eslint new-cap: 1*/
+
 var utils = require('./utils');
 var sjcl = utils.sjcl;
-var config  = require('./config');
-
-var BigInteger = utils.jsbn.BigInteger;
 
 //
 // Abstract UInt class
@@ -10,12 +11,11 @@ var BigInteger = utils.jsbn.BigInteger;
 // Base class for UInt classes
 //
 
-var UInt = function() {
-  // Internal form: NaN or BigInteger
+function UInt() {
+  // Internal form: NaN or sjcl.bn
   this._value = NaN;
-
   this._update();
-};
+}
 
 UInt.json_rewrite = function(j, opts) {
   return this.from_json(j).to_json(opts);
@@ -25,63 +25,56 @@ UInt.json_rewrite = function(j, opts) {
 UInt.from_generic = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_generic(j);
   }
+  return (new this()).parse_generic(j);
 };
 
 // Return a new UInt from j.
 UInt.from_hex = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_hex(j);
   }
+  return (new this()).parse_hex(j);
 };
 
 // Return a new UInt from j.
 UInt.from_json = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_json(j);
   }
+  return (new this()).parse_json(j);
 };
 
 // Return a new UInt from j.
 UInt.from_bits = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_bits(j);
   }
+  return (new this()).parse_bits(j);
 };
 
 // Return a new UInt from j.
 UInt.from_bytes = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_bytes(j);
   }
+  return (new this()).parse_bytes(j);
 };
 
 // Return a new UInt from j.
 UInt.from_bn = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_bn(j);
   }
+  return (new this()).parse_bn(j);
 };
 
 // Return a new UInt from j.
 UInt.from_number = function(j) {
   if (j instanceof this) {
     return j.clone();
-  } else {
-    return (new this()).parse_number(j);
   }
+  return (new this()).parse_number(j);
 };
 
 UInt.is_valid = function(j) {
@@ -96,6 +89,10 @@ UInt.prototype.clone = function() {
 UInt.prototype.copyTo = function(d) {
   d._value = this._value;
 
+  if (this._version_byte !== undefined) {
+    d._version_byte = this._version_byte;
+  }
+
   if (typeof d._update === 'function') {
     d._update();
   }
@@ -104,15 +101,15 @@ UInt.prototype.copyTo = function(d) {
 };
 
 UInt.prototype.equals = function(d) {
-  return this._value instanceof BigInteger && d._value instanceof BigInteger && this._value.equals(d._value);
+  return this.is_valid() && d.is_valid() && this._value.equals(d._value);
 };
 
 UInt.prototype.is_valid = function() {
-  return this._value instanceof BigInteger;
+  return this._value instanceof sjcl.bn;
 };
 
 UInt.prototype.is_zero = function() {
-  return this._value.equals(BigInteger.ZERO);
+  return this.is_valid() && this._value.equals(new sjcl.bn(0));
 };
 
 /**
@@ -124,6 +121,8 @@ UInt.prototype.is_zero = function() {
  *
  * The reason for keeping this mechanism in this class is so every subclass can
  * call it whenever it modifies the internal state.
+ *
+ * @return {void}
  */
 UInt.prototype._update = function() {
   // Nothing to do by default. Subclasses will override this.
@@ -131,35 +130,31 @@ UInt.prototype._update = function() {
 
 // value = NaN on error.
 UInt.prototype.parse_generic = function(j) {
-  // Canonicalize and validate
-  if (config.accounts && (j in config.accounts)) {
-    j = config.accounts[j].account;
-  }
-
   switch (j) {
     case undefined:
     case '0':
     case this.constructor.STR_ZERO:
     case this.constructor.ACCOUNT_ZERO:
     case this.constructor.HEX_ZERO:
-      this._value  = BigInteger.valueOf();
+      this._value = new sjcl.bn(0);
       break;
 
     case '1':
     case this.constructor.STR_ONE:
     case this.constructor.ACCOUNT_ONE:
     case this.constructor.HEX_ONE:
-      this._value  = new BigInteger([1]);
+      this._value = new sjcl.bn(1);
       break;
 
     default:
         if (typeof j !== 'string') {
           this._value = NaN;
         } else if (this.constructor.width === j.length) {
-          this._value  = new BigInteger(utils.stringToArray(j), 256);
+          var hex = utils.arrayToHex(utils.stringToArray(j));
+          this._value = new sjcl.bn(hex, 16);
         } else if ((this.constructor.width * 2) === j.length) {
           // XXX Check char set!
-          this._value  = new BigInteger(j, 16);
+          this._value = new sjcl.bn(j, 16);
         } else {
           this._value = NaN;
         }
@@ -172,7 +167,7 @@ UInt.prototype.parse_generic = function(j) {
 
 UInt.prototype.parse_hex = function(j) {
   if (typeof j === 'string' && j.length === (this.constructor.width * 2)) {
-    this._value = new BigInteger(j, 16);
+    this._value = new sjcl.bn(j, 16);
   } else {
     this._value = NaN;
   }
@@ -186,8 +181,9 @@ UInt.prototype.parse_bits = function(j) {
   if (sjcl.bitArray.bitLength(j) !== this.constructor.width * 8) {
     this._value = NaN;
   } else {
-    var bytes = sjcl.codec.bytes.fromBits(j);
-    this.parse_bytes(bytes);
+    this._value = sjcl.bn.fromBits(j);
+    // var bytes = sjcl.codec.bytes.fromBits(j);
+    // this.parse_bytes(bytes);
   }
 
   this._update();
@@ -200,7 +196,8 @@ UInt.prototype.parse_bytes = function(j) {
   if (!Array.isArray(j) || j.length !== this.constructor.width) {
     this._value = NaN;
   } else {
-    this._value  = new BigInteger([0].concat(j), 256);
+    var bits = sjcl.codec.bytes.toBits(j);
+    this._value = sjcl.bn.fromBits(bits);
   }
 
   this._update();
@@ -212,9 +209,9 @@ UInt.prototype.parse_bytes = function(j) {
 UInt.prototype.parse_json = UInt.prototype.parse_hex;
 
 UInt.prototype.parse_bn = function(j) {
-  if ((j instanceof sjcl.bn) && j.bitLength() <= this.constructor.width * 8) {
-    var bytes = sjcl.codec.bytes.fromBits(j.toBits());
-    this._value  = new BigInteger(bytes, 256);
+  if ((j instanceof sjcl.bn) &&
+      j.bitLength() <= this.constructor.width * 8) {
+    this._value = new sjcl.bn(j);
   } else {
     this._value = NaN;
   }
@@ -228,7 +225,7 @@ UInt.prototype.parse_number = function(j) {
   this._value = NaN;
 
   if (typeof j === 'number' && isFinite(j) && j >= 0) {
-    this._value = new BigInteger(String(j));
+    this._value = new sjcl.bn(j);
   }
 
   this._update();
@@ -238,51 +235,31 @@ UInt.prototype.parse_number = function(j) {
 
 // Convert from internal form.
 UInt.prototype.to_bytes = function() {
-  if (!(this._value instanceof BigInteger)) {
+  if (!this.is_valid()) {
     return null;
   }
-
-  var bytes  = this._value.toByteArray();
-
-  bytes = bytes.map(function(b) {
-    return (b + 256) % 256;
-  });
-
-  var target = this.constructor.width;
-
-  // XXX Make sure only trim off leading zeros.
-  bytes = bytes.slice(-target);
-
-  while (bytes.length < target) {
-    bytes.unshift(0);
-  }
-
-  return bytes;
+  return sjcl.codec.bytes.fromBits(this.to_bits());
 };
 
 UInt.prototype.to_hex = function() {
-  if (!(this._value instanceof BigInteger)) {
+  if (!this.is_valid()) {
     return null;
   }
-
-  var bytes = this.to_bytes();
-  return sjcl.codec.hex.fromBits(sjcl.codec.bytes.toBits(bytes)).toUpperCase();
+  return sjcl.codec.hex.fromBits(this.to_bits()).toUpperCase();
 };
 
 UInt.prototype.to_json = UInt.prototype.to_hex;
 
 UInt.prototype.to_bits = function() {
-  if (!(this._value instanceof BigInteger)) {
+  if (!this.is_valid()) {
     return null;
   }
 
-  var bytes = this.to_bytes();
-
-  return sjcl.codec.bytes.toBits(bytes);
+  return this._value.toBits(this.constructor.width * 8);
 };
 
 UInt.prototype.to_bn = function() {
-  if (!(this._value instanceof BigInteger)) {
+  if (!this.is_valid()) {
     return null;
   }
 

src/js/ripple/uint128.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var utils = require('./utils');
 var extend = require('extend');
 var UInt = require('./uint').UInt;
@@ -6,8 +8,7 @@ var UInt   = require('./uint').UInt;
 // UInt128 support
 //
 
-var UInt128 = extend(function () {
-  // Internal form: NaN or BigInteger
+var UInt128 = extend(function() {
   this._value = NaN;
 }, UInt);
 
@@ -17,7 +18,8 @@ UInt128.prototype.constructor = UInt128;
 
 var HEX_ZERO = UInt128.HEX_ZERO = '00000000000000000000000000000000';
 var HEX_ONE = UInt128.HEX_ONE = '00000000000000000000000000000000';
-var STR_ZERO = UInt128.STR_ZERO = utils.hexToString(HEX_ZERO);
-var STR_ONE  = UInt128.STR_ONE  = utils.hexToString(HEX_ONE);
+
+UInt128.STR_ZERO = utils.hexToString(HEX_ZERO);
+UInt128.STR_ONE = utils.hexToString(HEX_ONE);
 
 exports.UInt128 = UInt128;

src/js/ripple/uint160.js

@@ -1,8 +1,7 @@
-var utils   = require('./utils');
-var config  = require('./config');
-var extend  = require('extend');
+'use strict';
 
-var BigInteger = utils.jsbn.BigInteger;
+var utils = require('./utils');
+var extend = require('extend');
 
 var UInt = require('./uint').UInt;
 var Base = require('./base').Base;
@@ -12,9 +11,8 @@ var Base = require('./base').Base;
 //
 
 var UInt160 = extend(function() {
-  // Internal form: NaN or BigInteger
   this._value = NaN;
-  this._version_byte = void(0);
+  this._version_byte = undefined;
   this._update();
 }, UInt);
 
@@ -22,12 +20,13 @@ UInt160.width = 20;
 UInt160.prototype = extend({}, UInt.prototype);
 UInt160.prototype.constructor = UInt160;
 
-var ACCOUNT_ZERO = UInt160.ACCOUNT_ZERO = 'rrrrrrrrrrrrrrrrrrrrrhoLvTp';
-var ACCOUNT_ONE  = UInt160.ACCOUNT_ONE  = 'rrrrrrrrrrrrrrrrrrrrBZbvji';
 var HEX_ZERO = UInt160.HEX_ZERO = '0000000000000000000000000000000000000000';
 var HEX_ONE = UInt160.HEX_ONE = '0000000000000000000000000000000000000001';
-var STR_ZERO     = UInt160.STR_ZERO     = utils.hexToString(HEX_ZERO);
-var STR_ONE      = UInt160.STR_ONE      = utils.hexToString(HEX_ONE);
+
+UInt160.ACCOUNT_ZERO = 'rrrrrrrrrrrrrrrrrrrrrhoLvTp';
+UInt160.ACCOUNT_ONE = 'rrrrrrrrrrrrrrrrrrrrBZbvji';
+UInt160.STR_ZERO = utils.hexToString(HEX_ZERO);
+UInt160.STR_ONE = utils.hexToString(HEX_ONE);
 
 UInt160.prototype.set_version = function(j) {
   this._version_byte = j;
@@ -40,16 +39,11 @@ UInt160.prototype.get_version = function() {
 
 // value = NaN on error.
 UInt160.prototype.parse_json = function(j) {
-  // Canonicalize and validate
-  if (config.accounts && (j in config.accounts)) {
-    j = config.accounts[j].account;
-  }
-
   if (typeof j === 'number' && !isNaN(j)) {
     // Allow raw numbers - DEPRECATED
     // This is used mostly by the test suite and is supported
     // as a legacy feature only. DO NOT RELY ON THIS BEHAVIOR.
-    this._value = new BigInteger(String(j));
+    this.parse_number(j);
     this._version_byte = Base.VER_ACCOUNT_ID;
   } else if (typeof j !== 'string') {
     this._value = NaN;
@@ -83,7 +77,7 @@ UInt160.prototype.parse_generic = function(j) {
 UInt160.prototype.to_json = function(opts) {
   opts = opts || {};
 
-  if (this._value instanceof BigInteger) {
+  if (this.is_valid()) {
     // If this value has a type, return a Base58 encoded string.
     if (typeof this._version_byte === 'number') {
       var output = Base.encode_check(this._version_byte, this.to_bytes());
@@ -93,9 +87,8 @@ UInt160.prototype.to_json = function(opts) {
       }
 
       return output;
-    } else {
-      return this.to_hex();
     }
+    return this.to_hex();
   }
   return NaN;
 };

src/js/ripple/uint256.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var utils = require('./utils');
 var extend = require('extend');
 var UInt = require('./uint').UInt;
@@ -7,7 +9,6 @@ var UInt   = require('./uint').UInt;
 //
 
 var UInt256 = extend(function() {
-  // Internal form: NaN or BigInteger
   this._value = NaN;
 }, UInt);
 
@@ -15,9 +16,13 @@ UInt256.width = 32;
 UInt256.prototype = extend({}, UInt.prototype);
 UInt256.prototype.constructor = UInt256;
 
-var HEX_ZERO = UInt256.HEX_ZERO = '00000000000000000000000000000000' + '00000000000000000000000000000000';
-var HEX_ONE  = UInt256.HEX_ONE  = '00000000000000000000000000000000' + '00000000000000000000000000000001';
-var STR_ZERO = UInt256.STR_ZERO = utils.hexToString(HEX_ZERO);
-var STR_ONE  = UInt256.STR_ONE  = utils.hexToString(HEX_ONE);
+var HEX_ZERO = UInt256.HEX_ZERO = '00000000000000000000000000000000' +
+                                  '00000000000000000000000000000000';
+
+var HEX_ONE = UInt256.HEX_ONE = '00000000000000000000000000000000' +
+                                '00000000000000000000000000000001';
+
+UInt256.STR_ZERO = utils.hexToString(HEX_ZERO);
+UInt256.STR_ONE = utils.hexToString(HEX_ONE);
 
 exports.UInt256 = UInt256;

src/js/ripple/utils.js

@@ -1,34 +1,32 @@
-function filterErr(code, done) {
-  return function(e) {
-    done(e.code !== code ? e : void(0));
-  };
-};
+'use strict';
 
-function throwErr(done) {
-  return function(e) {
-    if (e) {
-      throw e;
+function getMantissaDecimalString(bignum) {
+  var mantissa = bignum.toPrecision(16)
+    .replace(/\./, '')      // remove decimal point
+    .replace(/e.*/, '')     // remove scientific notation
+    .replace(/^0*/, '');    // remove leading zeroes
+  while (mantissa.length < 16) {
+    mantissa += '0';        // add trailing zeroes until length is 16
   }
-    done();
-  };
-};
+  return mantissa;
+}
 
 function trace(comment, func) {
   return function() {
     console.log('%s: %s', trace, arguments.toString);
     func(arguments);
   };
-};
+}
 
 function arraySet(count, value) {
   var a = new Array(count);
 
-  for (var i=0; i<count; i++) {
+  for (var i = 0; i < count; i++) {
     a[i] = value;
   }
 
   return a;
-};
+}
 
 function hexToString(h) {
   var a = [];
@@ -39,39 +37,46 @@ function hexToString(h) {
     i = 1;
   }
 
-  for (; i<h.length; i+=2) {
-    a.push(String.fromCharCode(parseInt(h.substring(i, i+2), 16)));
+  for (; i < h.length; i += 2) {
+    a.push(String.fromCharCode(parseInt(h.substring(i, i + 2), 16)));
   }
 
   return a.join('');
-};
+}
 
 function stringToHex(s) {
   var result = '';
-  for (var i=0; i<s.length; i++) {
+  for (var i = 0; i < s.length; i++) {
     var b = s.charCodeAt(i);
     result += b < 16 ? '0' + b.toString(16) : b.toString(16);
   }
   return result;
-};
+}
 
 function stringToArray(s) {
   var a = new Array(s.length);
 
-  for (var i=0; i<a.length; i+=1) {
+  for (var i = 0; i < a.length; i += 1) {
     a[i] = s.charCodeAt(i);
   }
 
   return a;
-};
+}
 
 function hexToArray(h) {
   return stringToArray(hexToString(h));
-};
+}
+
+function arrayToHex(a) {
+  return a.map(function(byteValue) {
+    var hex = byteValue.toString(16);
+    return hex.length > 1 ? hex : '0' + hex;
+  }).join('');
+}
 
 function chunkString(str, n, leftAlign) {
   var ret = [];
-  var i=0, len=str.length;
+  var i = 0, len = str.length;
 
   if (leftAlign) {
     i = str.length % n;
@@ -80,26 +85,27 @@ function chunkString(str, n, leftAlign) {
     }
   }
 
-  for(; i<len; i+=n) {
+  for (; i < len; i += n) {
     ret.push(str.slice(i, n + i));
   }
 
   return ret;
-};
+}
 
 function assert(assertion, msg) {
   if (!assertion) {
     throw new Error('Assertion failed' + (msg ? ': ' + msg : '.'));
   }
-};
+}
 
 /**
- * Return unique values in array.
+ * @param {Array} arr (values)
+ * @return {Array} unique values (for string representation of value) in `arr`
  */
 function arrayUnique(arr) {
   var u = {}, a = [];
 
-  for (var i=0, l=arr.length; i<l; i++){
+  for (var i = 0, l = arr.length; i < l; i++) {
     var k = arr[i];
     if (u[k]) {
       continue;
@@ -109,29 +115,28 @@ function arrayUnique(arr) {
   }
 
   return a;
-};
+}
 
 /**
- * Convert a ripple epoch to a JavaScript timestamp.
+ * @param {Number} rpepoch (seconds since 1/1/2000 GMT)
+ * @return {Number} ms since unix epoch
  *
- * JavaScript timestamps are unix epoch in milliseconds.
  */
 function toTimestamp(rpepoch) {
   return (rpepoch + 0x386D4380) * 1000;
-};
+}
 
 /**
- * Convert a JavaScript timestamp or Date to a Ripple epoch.
- *
- * JavaScript timestamps are unix epoch in milliseconds.
+ * @param {Number|Date} timestamp (ms since unix epoch)
+ * @return {Number} seconds since ripple epoch ( 1/1/2000 GMT)
  */
-function fromTimestamp(rpepoch) {
-  if (rpepoch instanceof Date) {
-    rpepoch = rpepoch.getTime();
+function fromTimestamp(timestamp) {
+  if (timestamp instanceof Date) {
+    timestamp = timestamp.getTime();
   }
 
-  return Math.round(rpepoch / 1000) - 0x386D4380;
-};
+  return Math.round(timestamp / 1000) - 0x386D4380;
+}
 
 exports.time = {
   fromRipple: toTimestamp,
@@ -144,15 +149,16 @@ exports.hexToString   = hexToString;
 exports.hexToArray = hexToArray;
 exports.stringToArray = stringToArray;
 exports.stringToHex = stringToHex;
+exports.arrayToHex = arrayToHex;
 exports.chunkString = chunkString;
 exports.assert = assert;
 exports.arrayUnique = arrayUnique;
 exports.toTimestamp = toTimestamp;
 exports.fromTimestamp = fromTimestamp;
+exports.getMantissaDecimalString = getMantissaDecimalString;
 
 // Going up three levels is needed to escape the src-cov folder used for the
 // test coverage stuff.
 exports.sjcl = require('../../../build/sjcl');
-exports.jsbn = require('../../../src/js/jsbn/jsbn');
 
 // vim:sw=2:sts=2:ts=8:et

src/js/ripple/vaultclient.js

@@ -1,593 +0,0 @@
-var async      = require('async');
-var blobClient = require('./blob').BlobClient;
-var AuthInfo   = require('./authinfo').AuthInfo;
-var crypt      = require('./crypt').Crypt;
-var log        = require('./log').sub('vault');
-function VaultClient(opts) {
-  
-  var self = this;
-  
-  if (!opts) {
-    opts = { };
-  }
-
-  if (typeof opts === 'string') {
-    opts = { domain: opts };
-  }
-
-  this.domain   = opts.domain || 'ripple.com';
-  this.infos    = { };
-};
-
-/**
- * getAuthInfo
- * gets auth info for a username. returns authinfo
- * even if user does not exists (with exist set to false)
- * @param {string} username
- * @param {function} callback
- */
-VaultClient.prototype.getAuthInfo = function (username, callback) {
-
-  AuthInfo.get(this.domain, username, function(err, authInfo) {
-    if (err) {
-      return callback(err);
-    }
-
-    if (authInfo.version !== 3) {
-      return callback(new Error('This wallet is incompatible with this version of the vault-client.'));
-    }
-
-    if (!authInfo.pakdf) {
-      return callback(new Error('No settings for PAKDF in auth packet.'));
-    }
-
-    if (typeof authInfo.blobvault !== 'string') {
-      return callback(new Error('No blobvault specified in the authinfo.'));
-    }
-
-    callback(null, authInfo);
-  });  
-};
-
-/**
- * _deriveLoginKeys
- * method designed for asnyc waterfall
- */
-
-VaultClient.prototype._deriveLoginKeys = function (authInfo, password, callback) {
-  var normalizedUsername = authInfo.username.toLowerCase().replace(/-/g, '');
-  
-  //derive login keys
-  crypt.derive(authInfo.pakdf, 'login', normalizedUsername, password, function(err, keys) {
-    if (err) {
-      callback(err);
-    } else {
-      callback(null, authInfo, password, keys);
-    }
-  });
-};
-
-
-
-/**
- * _deriveUnlockKey
- * method designed for asnyc waterfall
- */
-
-VaultClient.prototype._deriveUnlockKey = function (authInfo, password, keys, callback) {
-  var normalizedUsername = authInfo.username.toLowerCase().replace(/-/g, '');
-  
-  //derive unlock key
-  crypt.derive(authInfo.pakdf, 'unlock', normalizedUsername, password, function(err, unlock) {
-    if (err) {
-      log.error('derive:', err);
-      return callback(err);
-    }
-
-    if (!keys) {
-      keys = { };
-    }
-    
-    keys.unlock = unlock.unlock;
-    callback(null, authInfo, keys);
-  });
-};
-  
-/**
- * Get a ripple name from a given account address, if it has one
- * @param {string} address - Account address to query
- * @param {string} url     - Url of blob vault
- */
-
-VaultClient.prototype.getRippleName = function(address, url, callback) {
-  //use the url from previously retrieved authInfo, if necessary
-  if (!url) {
-    callback(new Error('Blob vault URL is required'));
-  } else {
-    blobClient.getRippleName(url, address, callback);
-  }
-};
-
-/**
- * Check blobvault for existance of username
- *
- * @param {string}    username
- * @param {function}  fn - Callback function
- */
-
-VaultClient.prototype.exists = function(username, callback) {
-  AuthInfo.get(this.domain, username.toLowerCase(), function(err, authInfo) {
-    if (err) {
-      callback(err);
-    } else {
-      callback(null, !!authInfo.exists);
-    }
-  });
-};
-
-/**
- * Authenticate and retrieve a decrypted blob using a ripple name and password
- *
- * @param {string}    username
- * @param {string}    password
- * @param {function}  fn - Callback function
- */
-
-VaultClient.prototype.login = function(username, password, device_id, callback) {
-  var self = this;
-  
-  var steps = [
-    getAuthInfo,
-    self._deriveLoginKeys,
-    getBlob
-  ];
-
-  async.waterfall(steps, callback);
-    
-  function getAuthInfo(callback) {
-    self.getAuthInfo(username, function(err, authInfo){
-      
-      if (authInfo && !authInfo.exists) {
-        return callback(new Error('User does not exist.'));
-      }
-            
-      return callback (err, authInfo, password);
-    });  
-  }
-  
-  function getBlob(authInfo, password, keys, callback) {
-    var options = {
-      url       : authInfo.blobvault,
-      blob_id   : keys.id,
-      key       : keys.crypt,
-      device_id : device_id
-    };
-    
-    blobClient.get(options, function(err, blob) {
-      if (err) {
-        return callback(err);
-      }
-
-      //save for relogin
-      self.infos[keys.id] = authInfo;
-
-      //migrate missing fields
-      if (blob.missing_fields) {
-        if (blob.missing_fields.encrypted_blobdecrypt_key) {     
-          log.info('migration: saving encrypted blob decrypt key');
-          authInfo.blob = blob;
-          //get the key to unlock the secret, then update the blob keys          
-          self._deriveUnlockKey(authInfo, password, keys, updateKeys);
-        }
-      }
-         
-      callback(null, {
-        blob      : blob,
-        username  : authInfo.username,
-        verified  : authInfo.emailVerified
-      });
-    });
-  };
-  
-  function updateKeys (err, params, keys) {
-    if (err || !keys.unlock) {
-      return; //unable to unlock
-    }
-    
-    var secret;
-    try {
-      secret = crypt.decrypt(keys.unlock, params.blob.encrypted_secret);
-    } catch (error) {
-      return log.error('decrypt:', error);
-    } 
-    
-    options = {
-      username  : params.username,
-      blob      : params.blob,
-      masterkey : secret,
-      keys      : keys
-    };
-    
-    blobClient.updateKeys(options, function(err, resp){
-      if (err) {
-        log.error('updateKeys:', err);
-      }
-    });     
-  } 
-};
-
-/**
- * Retreive and decrypt blob using a blob url, id and crypt derived previously.
- *
- * @param {string}   url - Blob vault url
- * @param {string}   id  - Blob id from previously retreived blob
- * @param {string}   key - Blob decryption key
- * @param {function} fn  - Callback function
- */
-
-VaultClient.prototype.relogin = function(url, id, key, device_id, callback) {
-  //use the url from previously retrieved authInfo, if necessary
-  if (!url && this.infos[id]) {
-    url = this.infos[id].blobvault;
-  }
-
-  if (!url) {
-    return callback(new Error('Blob vault URL is required'));
-  }
-
-  var options = {
-    url       : url,
-    blob_id   : id,
-    key       : key,
-    device_id : device_id
-  };
-    
-  blobClient.get(options, function(err, blob) {
-    if (err) {
-      callback(err);
-    } else {
-      callback (null, { blob: blob });
-    }
-  });
-};
-
-/**
- * Decrypt the secret key using a username and password
- *
- * @param {string}    username
- * @param {string}    password
- * @param {string}    encryptSecret
- * @param {function}  fn - Callback function
- */
-
-VaultClient.prototype.unlock = function(username, password, encryptSecret, fn) {
-  var self = this;
-  
-  var steps = [
-    getAuthInfo,
-    self._deriveUnlockKey,
-    unlockSecret
-  ];
-
-  async.waterfall(steps, fn);
-  
-  function getAuthInfo(callback) {
-    self.getAuthInfo(username, function(err, authInfo){
-      
-      if (authInfo && !authInfo.exists) {
-        return callback(new Error('User does not exist.'));
-      }
-            
-      return callback (err, authInfo, password, {});
-    });  
-  }
-  
-  function unlockSecret (authinfo, keys, callback) {
-
-    var secret;
-    try {
-      secret = crypt.decrypt(keys.unlock, encryptSecret);
-    } catch (error) {
-      return callback(error);
-    }  
-    
-    callback(null, {
-      keys   : keys,
-      secret : secret
-    });      
-  }
-};
-
-/**
- * Retrieve the decrypted blob and secret key in one step using
- * the username and password
- *
- * @param {string}    username
- * @param {string}    password
- * @param {function}  fn - Callback function
- */
-
-VaultClient.prototype.loginAndUnlock = function(username, password, device_id, fn) {
-  var self = this;
-
-  var steps = [
-    login,
-    deriveUnlockKey,
-    unlockSecret
-  ];
-
-  async.waterfall(steps, fn);  
-  
-  function login (callback) {
-    self.login(username, password, device_id, function(err, resp) {
-
-      if (err) {
-        return callback(err);
-      }
-  
-      if (!resp.blob || !resp.blob.encrypted_secret) {
-        return callback(new Error('Unable to retrieve blob and secret.'));
-      }
-  
-      if (!resp.blob.id || !resp.blob.key) {
-        return callback(new Error('Unable to retrieve keys.'));
-      }
-  
-      //get authInfo via id - would have been saved from login
-      var authInfo = self.infos[resp.blob.id];
-  
-      if (!authInfo) {
-        return callback(new Error('Unable to find authInfo'));
-      }
-    
-      callback(null, authInfo, password, resp.blob);
-    });    
-  };
-
-  function deriveUnlockKey (authInfo, password, blob, callback) {
-    self._deriveUnlockKey(authInfo, password, null, function(err, authInfo, keys){
-      callback(err, keys.unlock, authInfo, blob);
-    });
-  };
-  
-  function unlockSecret (unlock, authInfo, blob, callback) {
-    var secret;
-    try {
-      secret = crypt.decrypt(unlock, blob.encrypted_secret);
-    } catch (error) {
-      return callback(error);
-    }     
-    
-    callback(null, {
-      blob      : blob,
-      unlock    : unlock,
-      secret    : secret,
-      username  : authInfo.username,
-      verified  : authInfo.emailVerified
-    });    
-  };  
-};
-
-/**
- * Verify an email address for an existing user
- *
- * @param {string}    username
- * @param {string}    token - Verification token
- * @param {function}  fn - Callback function
- */
-
-VaultClient.prototype.verify = function(username, token, callback) {
-  var self = this;
-
-  self.getAuthInfo(username, function (err, authInfo){
-    if (err) {
-      return callback(err);
-    }
-    
-    blobClient.verify(authInfo.blobvault, username.toLowerCase(), token, callback);     
-  });
-};
-
-/*
- * changePassword
- * @param {object} options
- * @param {string} options.username
- * @param {string} options.password
- * @param {string} options.masterkey
- * @param {object} options.blob
- */
-
-VaultClient.prototype.changePassword = function (options, fn) {
-  var self     = this;
-  var password = String(options.password).trim();
-  
-  var steps = [
-    getAuthInfo,
-    self._deriveLoginKeys,
-    self._deriveUnlockKey,
-    changePassword
-  ];
-  
-  async.waterfall(steps, fn);
-    
-  function getAuthInfo(callback) {
-    self.getAuthInfo(options.username, function(err, authInfo) { 
-      return callback (err, authInfo, password);      
-    });
-  };
-  
-  function changePassword (authInfo, keys, callback) {
-    options.keys = keys;
-    blobClient.updateKeys(options, callback); 
-  };
-};
-
-/**
- * rename
- * rename a ripple account
- * @param {object} options
- * @param {string} options.username
- * @param {string} options.new_username
- * @param {string} options.password
- * @param {string} options.masterkey
- * @param {object} options.blob
- * @param {function} fn
- */
-
-VaultClient.prototype.rename = function (options, fn) {
-  var self         = this;
-  var new_username = String(options.new_username).trim();
-  var password     = String(options.password).trim();
-  
-  var steps = [
-    getAuthInfo,
-    self._deriveLoginKeys,
-    self._deriveUnlockKey,
-    renameBlob
-  ];
-
-  async.waterfall(steps, fn);
-    
-  function getAuthInfo(callback) {
-    self.getAuthInfo(new_username, function(err, authInfo){
-      
-      if (authInfo && authInfo.exists) {
-        return callback(new Error('username already taken.'));
-      } else {
-        authInfo.username = new_username;
-      }
-            
-      return callback (err, authInfo, password);
-    });  
-  };
-  
-  function renameBlob (authInfo, keys, callback) {
-    options.keys = keys;
-    blobClient.rename(options, callback);    
-  };
-};
-
-/**
- * Register a new user and save to the blob vault
- *
- * @param {object} options
- * @param {string} options.username
- * @param {string} options.password
- * @param {string} options.masterkey   //optional, will create if absent
- * @param {string} options.email
- * @param {string} options.activateLink
- * @param {object} options.oldUserBlob //optional
- * @param {function} fn
- */
-
-VaultClient.prototype.register = function(options, fn) {
-  var self     = this;
-  var username = String(options.username).trim();
-  var password = String(options.password).trim();
-  var result   = self.validateUsername(username);
-  
-  if (!result.valid) {
-    return fn(new Error('invalid username.'));  
-  }
-  
-  var steps = [
-    getAuthInfo,
-    self._deriveLoginKeys,
-    self._deriveUnlockKey,
-    create
-  ];
-  
-  async.waterfall(steps, fn);
-  
-  function getAuthInfo(callback) {
-    self.getAuthInfo(username, function(err, authInfo){      
-      return callback (err, authInfo, password);
-    });  
-  };
-
-  function create(authInfo, keys, callback) {
-    var params = {
-      url          : authInfo.blobvault,
-      id           : keys.id,
-      crypt        : keys.crypt,
-      unlock       : keys.unlock,
-      username     : username,
-      email        : options.email,
-      masterkey    : options.masterkey || crypt.createMaster(),
-      activateLink : options.activateLink,
-      oldUserBlob  : options.oldUserBlob,
-      domain       : options.domain
-    };
-        
-    blobClient.create(params, function(err, blob) {
-      if (err) {
-        callback(err);
-      } else {
-        callback(null, {
-          blob     : blob, 
-          username : username
-        });
-      }
-    });
-  };
-};
-
-/**
- * validateUsername
- * check username for validity 
- */
-
-VaultClient.prototype.validateUsername = function (username) {
-  username   = String(username).trim();
-  var result = {
-    valid  : false,
-    reason : ''
-  };
-  
-  if (username.length < 2) {
-    result.reason = 'tooshort';
-  } else if (username.length > 20) {
-    result.reason = 'toolong'; 
-  } else if (!/^[a-zA-Z0-9\-]+$/.exec(username)) {
-    result.reason = 'charset'; 
-  } else if (/^-/.exec(username)) {
-    result.reason = 'starthyphen'; 
-  } else if (/-$/.exec(username)) {
-    result.reason = 'endhyphen'; 
-  } else if (/--/.exec(username)) {
-    result.reason = 'multhyphen'; 
-  } else {
-    result.valid = true;
-  }
-  
-  return result;
-};
-
-/**
- * generateDeviceID
- * create a new random device ID for 2FA
- */
-VaultClient.prototype.generateDeviceID = function () {
-  return crypt.createSecret(4);
-};
-
-/*** pass thru some blob client function ***/
-
-VaultClient.prototype.resendEmail   = blobClient.resendEmail;
-
-VaultClient.prototype.recoverBlob   = blobClient.recoverBlob;
-
-VaultClient.prototype.deleteBlob    = blobClient.deleteBlob;
-
-VaultClient.prototype.requestToken  = blobClient.requestToken;
-
-VaultClient.prototype.verifyToken   = blobClient.verifyToken;
-
-VaultClient.prototype.getAttestation = blobClient.getAttestation;
-
-VaultClient.prototype.updateAttestation = blobClient.updateAttestation;
-
-VaultClient.prototype.getAttestationSummary = blobClient.getAttestationSummary;
-
-//export by name
-exports.VaultClient = VaultClient;

src/js/ripple/wallet.js

@@ -1,8 +0,0 @@
-var sjcl = require('./utils').sjcl;
-
-var WalletGenerator = require('ripple-wallet-generator')({
-  sjcl: sjcl
-});
-
-module.exports = WalletGenerator;
-

src/js/sjcl-custom/sjcl-ecdsa-recoverablepublickey.js

@@ -65,7 +65,7 @@ sjcl.ecc.ecdsa.secretKey.prototype.signWithRecoverablePublicKey = function(hash,
  *
  *  @param {bitArray} hash
  *  @param {bitArray} signature
- *  @param {sjcl.ecc.curve} [sjcl.ecc.curves['c256']] curve
+ *  @param {sjcl.ecc.curve} [sjcl.ecc.curves['k256']] curve
  *  @returns {sjcl.ecc.ecdsa.publicKey} Public key
  */
 sjcl.ecc.ecdsa.publicKey.recoverFromSignature = function(hash, signature, curve) {
@@ -75,7 +75,7 @@ sjcl.ecc.ecdsa.publicKey.recoverFromSignature = function(hash, signature, curve)
   }
 
   if (!curve) {
-    curve = sjcl.ecc.curves['c256'];
+    curve = sjcl.ecc.curves['k256'];
   }
 
   // Convert hash to bits and determine encoding for output

src/js/sjcl-custom/sjcl-secp256k1.js

@@ -1,17 +1,16 @@
 // ----- for secp256k1 ------
 
-// Overwrite NIST-P256 with secp256k1
-sjcl.ecc.curves.c256 = new sjcl.ecc.curve(
-    sjcl.bn.pseudoMersennePrime(256, [[0,-1],[4,-1],[6,-1],[7,-1],[8,-1],[9,-1],[32,-1]]),
-    "0x14551231950b75fc4402da1722fc9baee",
-    0,
-    7,
-    "0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-    "0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
-);
+sjcl.ecc.point.prototype.toBytesCompressed = function () {
+  var header = this.y.mod(2).toString() == "0x0" ? 0x02 : 0x03;
+  return [header].concat(sjcl.codec.bytes.fromBits(this.x.toBits()))
+};
 
 // Replace point addition and doubling algorithms
 // NIST-P256 is a=-3, we need algorithms for a=0
+//
+// This is a custom point addition formula that
+// only works for a=-3 Jacobian curve. It's much
+// faster than the generic implementation
 sjcl.ecc.pointJac.prototype.add = function(T) {
   var S = this;
   if (S.curve !== T.curve) {
@@ -51,6 +50,9 @@ sjcl.ecc.pointJac.prototype.add = function(T) {
   return new sjcl.ecc.pointJac(this.curve,x,y,z);
 };
 
+// This is a custom doubling algorithm that
+// only works for a=-3 Jacobian curve. It's much
+// faster than the generic implementation
 sjcl.ecc.pointJac.prototype.doubl = function () {
   if (this.isIdentity) { return this; }
 
@@ -66,7 +68,9 @@ sjcl.ecc.pointJac.prototype.doubl = function () {
   return new sjcl.ecc.pointJac(this.curve, x, y, z);
 };
 
-sjcl.ecc.point.prototype.toBytesCompressed = function () {
-  var header = this.y.mod(2).toString() == "0x0" ? 0x02 : 0x03;
-  return [header].concat(sjcl.codec.bytes.fromBits(this.x.toBits()))
-};
+// DEPRECATED:
+// previously the c256 curve was overridden with the secp256k1 curve
+// since then, sjcl has been updated to support k256
+// this override exist to keep supporting the old c256 with k256 behavior
+// this will be removed in future release
+sjcl.ecc.curves.c256 = sjcl.ecc.curves.k256;

src/js/sjcl/.gitignore

@@ -0,0 +1,2 @@
+core.js
+core_closure.js

src/js/sjcl/.travis.yml

@@ -0,0 +1,9 @@
+before_script: ./configure --with-all
+
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+  - "0.8"
+# 0.6 appears to be unreliable on Travis at the moment.
+#  - "0.6"

src/js/sjcl/Makefile

@@ -54,10 +54,11 @@ lint: core.js core/*.js test/*.js browserTest/*.js lint/coding_guidelines.pl
 	lint/coding_guidelines.pl core/*.js test/*.js browserTest/*.js
 
 
-TEST_COMMON=  browserTest/rhinoUtil.js test/test.js
+TEST_COMMON=  browserTest/nodeUtil.js test/test.js
 
 TEST_SCRIPTS= $(TEST_COMMON) \
               test/aes_vectors.js test/aes_test.js \
+              test/bitArray_vectors.js test/bitArray_test.js \
               test/ocb2_vectors.js test/ocb2_test.js  \
               test/ccm_vectors.js test/ccm_test.js  \
               test/cbc_vectors.js test/cbc_test.js  \
@@ -70,18 +71,14 @@ TEST_SCRIPTS= $(TEST_COMMON) \
               test/hmac_vectors.js test/hmac_test.js \
               test/pbkdf2_test.js \
               test/bn_vectors.js test/bn_test.js \
-              test/ecdsa_test.js test/ecdsa_vectors.js test/ecdh_test.js
+              test/ecdsa_test.js test/ecdsa_vectors.js test/ecdh_test.js \
+              test/srp_vectors.js test/srp_test.js \
+              test/json_test.js
 
-TEST_SCRIPTS_OPT= $(TEST_COMMON) \
-              test/srp_vectors.js test/srp_test.js
+# Run all tests in node.js.
 
-# Rhino fails at -O 0.  Probably because the big files full of test vectors blow the
-# bytecode limit. So, run most tests with -O -1. But modular exponentiation is
-# currently very slow (on Rhino), so run the SRP test with optimizations on.
-
-test: sjcl.js $(TEST_SCRIPTS) test/run_tests_rhino.js
-	@rhino -O -1 -w test/run_tests_rhino.js $< $(TEST_SCRIPTS)
-	@rhino -O 9 -w test/run_tests_rhino.js $< $(TEST_SCRIPTS_OPT)
+test: sjcl.js $(TEST_SCRIPTS) test/run_tests_node.js
+	node test/run_tests_node.js $< $(TEST_SCRIPTS)
 
 tidy:
 	find . -name '*~' -delete

src/js/sjcl/README.md

@@ -0,0 +1,21 @@
+sjcl
+====
+
+[![Build Status](https://travis-ci.org/bitwiseshiftleft/sjcl.png)](https://travis-ci.org/bitwiseshiftleft/sjcl)
+
+Stanford Javascript Crypto Library
+
+Security Advisories
+===
+* 12.02.2014: the current development version has a paranoia bug in the ecc module. The bug was introduced in commit [ac0b3fe0](https://github.com/bitwiseshiftleft/sjcl/commit/ac0b3fe0) and might affect ecc key generation on platforms without a platform random number generator.
+* 
+
+Security Contact
+====
+Security Mail: sjcl@ovt.me  
+OpenPGP-Key Fingerprint: 0D54 3E52 87B4 EC06 3FA9 0115 72ED A6C7 7AAF 48ED  
+Keyserver: pool.sks-keyservers.net  
+
+Documentation
+====
+The documentation is available [here](http://bitwiseshiftleft.github.io/sjcl/doc/)

src/js/sjcl/bower.json

@@ -0,0 +1,12 @@
+{
+	"name": "sjcl",
+	"version": "1.0.0",
+	"main": ["./sjcl.js"],
+	"ignore": [
+		"**/*",
+		"!README.md",
+		"!README/*",
+		"!bower.json",
+		"!sjcl.js"
+	]
+}

src/js/sjcl/browserTest/browserUtil.js

@@ -1,6 +1,6 @@
 browserUtil = {};
 
-browserUtil.isRhino = (typeof(window) === 'undefined');
+browserUtil.isNodeJS = (typeof(window) === 'undefined');
 
 /**
  * Pause (for the graphics to update and the script timer to clear), then run the

src/js/sjcl/browserTest/entropy.html

@@ -0,0 +1,88 @@
+<html>
+<head>
+
+<title>Entropy Generator Progress</title>
+<!-- ProgressBar source: http://stackoverflow.com/questions/7190898/progress-bar-with-html-and-css -->
+
+<style>
+#progressbar {
+  background-color: black;
+  border-radius: 13px; /* (height of inner div) / 2 + padding */
+  padding: 3px;
+}
+#progressbar > div {
+   background-color: orange;
+   width: 0%; /* Adjust with JavaScript */
+   height: 20px;
+   border-radius: 10px;
+}
+</style>
+
+<script type="text/javascript" src="../sjcl.js">
+</script>
+
+<script type="text/javascript">
+
+var busy = 0;
+var collecting = 0;
+
+function showprogress () {
+	var barwidth = document.getElementById ("progresswidth");
+	var paranoia = parseInt (document.getElementById ("paranoialevel").value);
+	var progress = 100 * sjcl.random.getProgress (paranoia);
+	barwidth.style.width = progress+"%";
+	if (!sjcl.random.isReady (paranoia)) {
+		setTimeout ("showprogress()", 10, "JavaScript");
+	} else {
+		busy = 0;
+		document.getElementById ("startbutton").style.disabled = 1;
+	}
+}
+
+function startup () {
+	if (collecting == 0) {
+		sjcl.random.startCollectors ();
+		collecting = 1;
+	}
+	if (busy == 0) {
+		busy = 1;
+		document.getElementById ("startbutton").style.disabled = 1;
+		showprogress ();
+	}
+}
+
+function consume (numbits) {
+	var collector = document.getElementById ("collector");
+	collector.value = "retrieving random data";
+	var paranoia = document.getElementById ("paranoialevel").value;
+	var numwords = Math.ceil (numbits / 32);
+	var bits = sjcl.random.randomWords (numwords, paranoia);
+	collector.value = '';
+	for (var i=0; i<numwords; i++) {
+		var hi = (bits [i] >> 16) & 0x0000ffff;
+		var lo =  bits [i]        & 0x0000ffff;
+		collector.value = collector.value + hi.toString (16) + lo.toString (16);
+	}
+	startup ();
+}
+
+</script>
+
+</head>
+<body>
+<h1>Entropy Generator Progress</h1>
+
+<p>Target: 192 bits, available at paranoia level 5.</p>
+
+<p>Corresponding paranoia level from [0,1..10]: <input type="text" value="5" id="paranoialevel"/> <input type=button onclick="startup ()" id="startbutton" value=" Start &gt;&gt; "> (the idea being that you can see the progress bar advance gently from empty/black to full/yellow after you press this)</p>
+
+<p><input type=button onclick="consume (192)" value=" Consume 192 bits &gt;&gt; "><input type=text id=collector size=50 value="" onkeypress="consume (192)"> (also consumes 192 bits with every keypress in the text field; use key repeat to consume swiftly)</p>
+
+<div id="progressbar">
+  <div id="progresswidth"></div>
+</div>
+
+<p>Please move your mouse, play around and generally introduce entropy into your environment.</p>
+
+</body>
+</html>

src/js/sjcl/browserTest/nodeUtil.js

@@ -0,0 +1,44 @@
+browserUtil = {
+  isNodeJS: true,
+  
+  pauseAndThen: function (cb) { cb(); },
+  
+  cpsIterate: function (f, start, end, pause, callback) {
+    function go() {
+      var called = false;
+      if (start >= end) {
+        callback && callback();
+      } else {
+        f(start, function () {
+          if (!called) { called = true; start++; go(); }
+        });
+      }
+    }
+    go (start);
+  },
+  
+  cpsMap: function (map, list, pause, callback) {
+    browserUtil.cpsIterate(function (i, cb) { map(list[i], i, list.length, cb); },
+                           0, list.length, pause, callback);
+  },
+
+  loadScripts: function(scriptNames, callback) {
+    for (i=0; i<scriptNames.length; i++) {
+      load(scriptNames[i]);
+      callback && callback();
+    }
+  },
+  
+  write: function(type, message) {
+    console.log(message);
+    return { update: function (type2, message2) {
+      if (type2 === 'pass') { console.log("  + " + message2); }
+      else if (type2 === 'unimplemented') { console.log("  ? " + message2); }
+      else { console.log("  - " + message2); }
+    }};
+  },
+  
+  writeNewline: function () { console.log(""); },
+  
+  status: function(message) {}
+};

src/js/sjcl/compress/digitize.pl

@@ -16,7 +16,7 @@ sub digitize {
 }
 
 while (<>) {
-    s/([^a-zA-Z0-9_])(\d+)/$1 . digitize $2/eg;
+    s/([^a-zA-Z0-9_"])(\d+)/$1 . digitize $2/eg;
     print;
 }
 

src/js/sjcl/configure

@@ -4,12 +4,13 @@ use strict;
 
 my ($arg, $i, $j, $targ);
 
-my @targets = qw/sjcl aes bitArray codecString codecHex codecBase64 codecBytes sha256 sha512 sha1 ccm cbc ocb2 gcm hmac pbkdf2 random convenience bn ecc srp/;
+my @targets = qw/sjcl aes bitArray codecString codecHex codecBase32 codecBase64 codecBytes sha256 sha512 sha1 ccm cbc ocb2 gcm hmac pbkdf2 random convenience bn ecc srp/;
 my %deps = ('aes'=>'sjcl',
             'bitArray'=>'sjcl',
             'codecString'=>'bitArray',
             'codecHex'=>'bitArray',
             'codecBase64'=>'bitArray',
+            'codecBase32'=>'bitArray',
             'codecBytes'=>'bitArray',
             'sha256'=>'codecString',
             'sha512'=>'codecString',
@@ -32,10 +33,10 @@ my %enabled = ();
 $enabled{$_} = 0 foreach (@targets);
 
 # by default, all but codecBytes, srp, bn
-$enabled{$_} = 1 foreach (qw/aes bitArray codecString codecHex codecBase64 sha256 ccm ocb2 gcm hmac pbkdf2 random convenience/);
+$enabled{$_} = 1 foreach (qw/aes bitArray codecString codecHex codecBase32 codecBase64 sha256 ccm ocb2 gcm hmac pbkdf2 random convenience/);
 
 # argument parsing
-while ($arg = shift @ARGV) {
+while (my $arg = shift @ARGV) {
   if ($arg =~ /^--?with-all$/) {
     foreach (@targets) {
       if ($enabled{$_} == 0) {
@@ -97,7 +98,7 @@ my $config = '';
 my $pconfig;
 
 # dependency analysis: forbidden
-foreach $i (@targets) {
+foreach my $i (@targets) {
   if ($enabled{$i} > 0) {
     foreach $j (split /,/, $deps{$i}) {
       if ($enabled{$j} == -1) {
@@ -114,7 +115,7 @@ foreach $i (@targets) {
 }
 
 # reverse
-foreach $i (reverse @targets) {
+foreach my $i (reverse @targets) {
   if ($enabled{$i} > 0) {
     foreach $j (split /,/, $deps{$i}) {
       if ($enabled{$j} < $enabled{$i}) {

src/js/sjcl/core/bitArray.js

@@ -74,7 +74,7 @@ sjcl.bitArray = {
       return a1.concat(a2);
     }
     
-    var out, i, last = a1[a1.length-1], shift = sjcl.bitArray.getPartial(last);
+    var last = a1[a1.length-1], shift = sjcl.bitArray.getPartial(last);
     if (shift === 32) {
       return a1.concat(a2);
     } else {
@@ -183,5 +183,19 @@ sjcl.bitArray = {
    */
   _xor4: function(x,y) {
     return [x[0]^y[0],x[1]^y[1],x[2]^y[2],x[3]^y[3]];
+  },
+
+  /** byteswap a word array inplace.
+   * (does not handle partial words)
+   * @param {sjcl.bitArray} a word array
+   * @return {sjcl.bitArray} byteswapped array
+   */
+  byteswapM: function(a) {
+    var i, v, m = 0xff00;
+    for (i = 0; i < a.length; ++i) {
+      v = a[i];
+      a[i] = (v >>> 24) | ((v >>> 8) & m) | ((v & m) << 8) | (v << 24);
+    }
+    return a;
   }
 };

src/js/sjcl/core/bn.js

@@ -19,7 +19,7 @@ sjcl.bn.prototype = {
    * Initializes this with it, either as a bn, a number, or a hex string.
    */
   initWith: function(it) {
-    var i=0, k, n, l;
+    var i=0, k;
     switch(typeof it) {
     case "object":
       this.limbs = it.limbs.slice(0);
@@ -328,7 +328,7 @@ sjcl.bn.prototype = {
       carry = (l-m)*ipv;
     }
     if (carry === -1) {
-      limbs[i-1] -= this.placeVal;
+      limbs[i-1] -= pv;
     }
     return this;
   },
@@ -370,7 +370,9 @@ sjcl.bn.prototype = {
   }
 };
 
-/** @this { sjcl.bn } */
+/** @memberOf sjcl.bn
+* @this { sjcl.bn }
+*/
 sjcl.bn.fromBits = function(bits) {
   var Class = this, out = new Class(), words=[], w=sjcl.bitArray, t = this.prototype,
       l = Math.min(this.bitLength || 0x100000000, w.bitLength(bits)), e = l % t.radix || t.radix;
@@ -394,7 +396,9 @@ sjcl.bn.prototype.radixMask = (1 << sjcl.bn.prototype.radix) - 1;
  * i.e. a prime of the form 2^e + sum(a * 2^b),where the sum is negative and sparse.
  */
 sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
-  /** @constructor */
+  /** @constructor 
+  * @private
+  */
   function p(it) {
     this.initWith(it);
     /*if (this.limbs[this.modOffset]) {
@@ -427,10 +431,11 @@ sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
   ppr.modulus.cnormalize();
 
   /** Approximate reduction mod p.  May leave a number which is negative or slightly larger than p.
-   * @this {sjcl.bn}
+   * @memberof sjcl.bn
+   * @this { sjcl.bn }
    */
   ppr.reduce = function() {
-    var i, k, l, mo = this.modOffset, limbs = this.limbs, aff, off = this.offset, ol = this.offset.length, fac = this.factor, ll;
+    var i, k, l, mo = this.modOffset, limbs = this.limbs, off = this.offset, ol = this.offset.length, fac = this.factor, ll;
 
     i = this.minOffset;
     while (limbs.length > mo) {
@@ -452,7 +457,9 @@ sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
     return this;
   };
   
-  /** @this {sjcl.bn} */
+  /** @memberof sjcl.bn
+  * @this { sjcl.bn }
+  */
   ppr._strongReduce = (ppr.fullMask === -1) ? ppr.reduce : function() {
     var limbs = this.limbs, i = limbs.length - 1, k, l;
     this.reduce();
@@ -467,7 +474,8 @@ sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
   };
 
   /** mostly constant-time, very expensive full reduction.
-   * @this {sjcl.bn}
+   * @memberof sjcl.bn
+   * @this { sjcl.bn }
    */
   ppr.fullReduce = function() {
     var greater, i;
@@ -501,7 +509,9 @@ sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
   };
 
 
-  /** @this {sjcl.bn} */
+  /** @memberof sjcl.bn
+  * @this { sjcl.bn }
+  */
   ppr.inverse = function() {
     return (this.power(this.modulus.sub(2)));
   };
@@ -512,18 +522,24 @@ sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
 };
 
 // a small Mersenne prime
+var sbp = sjcl.bn.pseudoMersennePrime;
 sjcl.bn.prime = {
-  p127: sjcl.bn.pseudoMersennePrime(127, [[0,-1]]),
+  p127: sbp(127, [[0,-1]]),
 
   // Bernstein's prime for Curve25519
-  p25519: sjcl.bn.pseudoMersennePrime(255, [[0,-19]]),
+  p25519: sbp(255, [[0,-19]]),
+
+  // Koblitz primes
+  p192k: sbp(192, [[32,-1],[12,-1],[8,-1],[7,-1],[6,-1],[3,-1],[0,-1]]),
+  p224k: sbp(224, [[32,-1],[12,-1],[11,-1],[9,-1],[7,-1],[4,-1],[1,-1],[0,-1]]),
+  p256k: sbp(256, [[32,-1],[9,-1],[8,-1],[7,-1],[6,-1],[4,-1],[0,-1]]),
 
   // NIST primes
-  p192: sjcl.bn.pseudoMersennePrime(192, [[0,-1],[64,-1]]),
-  p224: sjcl.bn.pseudoMersennePrime(224, [[0,1],[96,-1]]),
-  p256: sjcl.bn.pseudoMersennePrime(256, [[0,-1],[96,1],[192,1],[224,-1]]),
-  p384: sjcl.bn.pseudoMersennePrime(384, [[0,-1],[32,1],[96,-1],[128,-1]]),
-  p521: sjcl.bn.pseudoMersennePrime(521, [[0,-1]])
+  p192: sbp(192, [[0,-1],[64,-1]]),
+  p224: sbp(224, [[0,1],[96,-1]]),
+  p256: sbp(256, [[0,-1],[96,1],[192,1],[224,-1]]),
+  p384: sbp(384, [[0,-1],[32,1],[96,-1],[128,-1]]),
+  p521: sbp(521, [[0,-1]])
 };
 
 sjcl.bn.random = function(modulus, paranoia) {

src/js/sjcl/core/cbc.js

@@ -5,18 +5,18 @@
  * @author Dan Boneh
  */
 
-/** @namespace
+if (sjcl.beware === undefined) {
+  sjcl.beware = {};
+}
+sjcl.beware["CBC mode is dangerous because it doesn't protect message integrity."
+] = function() {
+  /** @namespace
    * Dangerous: CBC mode with PKCS#5 padding.
    *
    * @author Emily Stark
    * @author Mike Hamburg
    * @author Dan Boneh
    */
-if (sjcl.beware === undefined) {
-  sjcl.beware = {};
-}
-sjcl.beware["CBC mode is dangerous because it doesn't protect message integrity."
-] = function() {
   sjcl.mode.cbc = {
     /** The name of the mode.
      * @constant
@@ -100,7 +100,7 @@ sjcl.beware["CBC mode is dangerous because it doesn't protect message integrity.
 
       /* check and remove the pad */
       bi = output[i-1] & 255;
-      if (bi == 0 || bi > 16) {
+      if (bi === 0 || bi > 16) {
         throw new sjcl.exception.corrupt("pkcs#5 padding corrupt");
       }
       bo = bi * 0x1010101;

src/js/sjcl/core/ccm.js

@@ -25,7 +25,7 @@ sjcl.mode.ccm = {
    * @return {bitArray} The encrypted data, an array of bytes.
    */
   encrypt: function(prf, plaintext, iv, adata, tlen) {
-    var L, i, out = plaintext.slice(0), tag, w=sjcl.bitArray, ivl = w.bitLength(iv) / 8, ol = w.bitLength(out) / 8;
+    var L, out = plaintext.slice(0), tag, w=sjcl.bitArray, ivl = w.bitLength(iv) / 8, ol = w.bitLength(out) / 8;
     tlen = tlen || 64;
     adata = adata || [];
     
@@ -59,7 +59,7 @@ sjcl.mode.ccm = {
   decrypt: function(prf, ciphertext, iv, adata, tlen) {
     tlen = tlen || 64;
     adata = adata || [];
-    var L, i, 
+    var L,
         w=sjcl.bitArray,
         ivl = w.bitLength(iv) / 8,
         ol = w.bitLength(ciphertext), 
@@ -101,7 +101,7 @@ sjcl.mode.ccm = {
    */
   _computeTag: function(prf, plaintext, iv, adata, tlen, L) {
     // compute B[0]
-    var q, mac, field = 0, offset = 24, tmp, i, macData = [], w=sjcl.bitArray, xor = w._xor4;
+    var mac, tmp, i, macData = [], w=sjcl.bitArray, xor = w._xor4;
 
     tlen /= 8;
   
@@ -161,7 +161,7 @@ sjcl.mode.ccm = {
    * @private
    */
   _ctrMode: function(prf, data, iv, tag, tlen, L) {
-    var enc, i, w=sjcl.bitArray, xor = w._xor4, ctr, b, l = data.length, bl=w.bitLength(data);
+    var enc, i, w=sjcl.bitArray, xor = w._xor4, ctr, l = data.length, bl=w.bitLength(data);
 
     // start the ctr
     ctr = w.concat([w.partial(8,L-1)],iv).concat([0,0,0]).slice(0,4);

src/js/sjcl/core/codecBase32.js

@@ -0,0 +1,64 @@
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Nils Kenneweg
+ */
+
+/** @namespace Base32 encoding/decoding */
+sjcl.codec.base32 = {
+  /** The base32 alphabet.
+   * @private
+   */
+  _chars: "0123456789abcdefghjkmnpqrstvwxyz",
+
+  /* bits in an array */
+  BITS: 32,
+  /* base to encode at (2^x) */
+  BASE: 5,
+  /* bits - base */
+  REMAINING: 27,
+  
+  /** Convert from a bitArray to a base32 string. */
+  fromBits: function (arr, _noEquals) {
+    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
+    var out = "", i, bits=0, c = sjcl.codec.base32._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
+
+    for (i=0; out.length * BASE <= bl; ) {
+      out += c.charAt((ta ^ arr[i]>>>bits) >>> REMAINING);
+      if (bits < BASE) {
+        ta = arr[i] << (BASE-bits);
+        bits += REMAINING;
+        i++;
+      } else {
+        ta <<= BASE;
+        bits -= BASE;
+      }
+    }
+
+    return out;
+  },
+  
+  /** Convert from a base32 string to a bitArray */
+  toBits: function(str) {
+    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
+    var out = [], i, bits=0, c = sjcl.codec.base32._chars, ta=0, x;
+
+    for (i=0; i<str.length; i++) {
+      x = c.indexOf(str.charAt(i));
+      if (x < 0) {
+        throw new sjcl.exception.invalid("this isn't base32!");
+      }
+      if (bits > REMAINING) {
+        bits -= REMAINING;
+        out.push(ta ^ x>>>bits);
+        ta  = x << (BITS-bits);
+      } else {
+        bits += BASE;
+        ta ^= x << (BITS-bits);
+      }
+    }
+    if (bits&56) {
+      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
+    }
+    return out;
+  }
+};

src/js/sjcl/core/codecBase64.js

@@ -15,7 +15,9 @@ sjcl.codec.base64 = {
   /** Convert from a bitArray to a base64 string. */
   fromBits: function (arr, _noEquals, _url) {
     var out = "", i, bits=0, c = sjcl.codec.base64._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
-    if (_url) c = c.substr(0,62) + '-_';
+    if (_url) {
+      c = c.substr(0,62) + '-_';
+    }
     for (i=0; out.length * 6 < bl; ) {
       out += c.charAt((ta ^ arr[i]>>>bits) >>> 26);
       if (bits < 6) {
@@ -35,7 +37,9 @@ sjcl.codec.base64 = {
   toBits: function(str, _url) {
     str = str.replace(/\s|=/g,'');
     var out = [], i, bits=0, c = sjcl.codec.base64._chars, ta=0, x;
-    if (_url) c = c.substr(0,62) + '-_';
+    if (_url) {
+      c = c.substr(0,62) + '-_';
+    }
     for (i=0; i<str.length; i++) {
       x = c.indexOf(str.charAt(i));
       if (x < 0) {

src/js/sjcl/core/codecHex.js

@@ -9,7 +9,7 @@
 sjcl.codec.hex = {
   /** Convert from a bitArray to a hex string. */
   fromBits: function (arr) {
-    var out = "", i, x;
+    var out = "", i;
     for (i=0; i<arr.length; i++) {
       out += ((arr[i]|0)+0xF00000000000).toString(16).substr(4);
     }

src/js/sjcl/core/convenience.js

@@ -15,10 +15,10 @@
    * @param {String} plaintext The data to encrypt.
    * @param {Object} [params] The parameters including tag, iv and salt.
    * @param {Object} [rp] A returned version with filled-in parameters.
-   * @return {String} The ciphertext.
+   * @return {Object} The cipher raw data.
    * @throws {sjcl.exception.invalid} if a parameter is invalid.
    */
-  encrypt: function (password, plaintext, params, rp) {
+  _encrypt: function (password, plaintext, params, rp) {
     params = params || {};
     rp = rp || {};
 
@@ -67,23 +67,36 @@
     p.ct = sjcl.mode[p.mode].encrypt(prp, plaintext, p.iv, adata, p.ts);
 
     //return j.encode(j._subtract(p, j.defaults));
+    return p;
+  },
+
+  /** Simple encryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {String} plaintext The data to encrypt.
+   * @param {Object} [params] The parameters including tag, iv and salt.
+   * @param {Object} [rp] A returned version with filled-in parameters.
+   * @return {String} The ciphertext serialized data.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   */
+  encrypt: function (password, plaintext, params, rp) {
+    var j = sjcl.json, p = j._encrypt.apply(j, arguments);
     return j.encode(p);
   },
 
   /** Simple decryption function.
    * @param {String|bitArray} password The password or key.
-   * @param {String} ciphertext The ciphertext to decrypt.
+   * @param {Object} ciphertext The cipher raw data to decrypt.
    * @param {Object} [params] Additional non-default parameters.
    * @param {Object} [rp] A returned object with filled parameters.
    * @return {String} The plaintext.
    * @throws {sjcl.exception.invalid} if a parameter is invalid.
    * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
    */
-  decrypt: function (password, ciphertext, params, rp) {
+  _decrypt: function (password, ciphertext, params, rp) {
     params = params || {};
     rp = rp || {};
 
-    var j = sjcl.json, p = j._add(j._add(j._add({},j.defaults),j.decode(ciphertext)), params, true), ct, tmp, prp, adata=p.adata;
+    var j = sjcl.json, p = j._add(j._add(j._add({},j.defaults),ciphertext), params, true), ct, tmp, prp, adata=p.adata;
     if (typeof p.salt === "string") {
       p.salt = sjcl.codec.base64.toBits(p.salt);
     }
@@ -120,7 +133,25 @@
     j._add(rp, p);
     rp.key = password;
 
+    if (params.raw === 1) {
+      return ct;
+    } else {
       return sjcl.codec.utf8String.fromBits(ct);
+    }
+  },
+
+  /** Simple decryption function.
+   * @param {String|bitArray} password The password or key.
+   * @param {String} ciphertext The ciphertext to decrypt.
+   * @param {Object} [params] Additional non-default parameters.
+   * @param {Object} [rp] A returned object with filled parameters.
+   * @return {String} The plaintext.
+   * @throws {sjcl.exception.invalid} if a parameter is invalid.
+   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
+   */
+  decrypt: function (password, ciphertext, params, rp) {
+    var j = sjcl.json;
+    return j._decrypt(password, j.decode(ciphertext), params, rp);
   },
   
   /** Encode a flat structure into a JSON string.
@@ -174,13 +205,15 @@
     }
     var a = str.replace(/^\{|\}$/g, '').split(/,/), out={}, i, m;
     for (i=0; i<a.length; i++) {
-      if (!(m=a[i].match(/^(?:(["']?)([a-z][a-z0-9]*)\1):(?:(\d+)|"([a-z0-9+\/%*_.@=\-]*)")$/i))) {
+      if (!(m=a[i].match(/^\s*(?:(["']?)([a-z][a-z0-9]*)\1)\s*:\s*(?:(-?\d+)|"([a-z0-9+\/%*_.@=\-]*)"|(true|false))$/i))) {
         throw new sjcl.exception.invalid("json decode: this isn't json!");
       }
       if (m[3]) {
         out[m[2]] = parseInt(m[3],10);
-      } else {
+      } else if (m[4]) {
         out[m[2]] = m[2].match(/^(ct|salt|iv)$/) ? sjcl.codec.base64.toBits(m[4]) : unescape(m[4]);
+      } else if (m[5]) {
+        out[m[2]] = m[5] === 'true';
       }
     }
     return out;
@@ -262,7 +295,7 @@ sjcl.misc._pbkdf2Cache = {};
 
 /** Cached PBKDF2 key derivation.
  * @param {String} password The password.
- * @param {Object} [params] The derivation params (iteration count and optional salt).
+ * @param {Object} [obj] The derivation params (iteration count and optional salt).
  * @return {Object} The derived data in key, the salt in salt.
  */
 sjcl.misc.cachedPbkdf2 = function (password, obj) {

src/js/sjcl/core/ecc.js

@@ -1,3 +1,6 @@
+/**
+ * base class for all ecc operations.
+ */
 sjcl.ecc = {};
 
 /**
@@ -152,7 +155,9 @@ sjcl.ecc.pointJac.prototype = {
       a  = y2.mul(this.x.mul(4)),
       b  = y2.square().mul(8),
       z2 = this.z.square(),
-      c  = this.x.sub(z2).mul(3).mul(this.x.add(z2)),
+      c  = this.curve.a.toString() == (new sjcl.bn(-3)).toString() ?
+                this.x.sub(z2).mul(3).mul(this.x.add(z2)) :
+                this.x.square().mul(3).add(z2.square().mul(this.curve.a)),
       x  = c.square().subM(a).subM(a),
       y  = a.sub(x).mul(c).subM(b),
       z  = this.y.add(this.y).mul(this.z);
@@ -250,7 +255,7 @@ sjcl.ecc.pointJac.prototype = {
  */
 sjcl.ecc.curve = function(Field, r, a, b, x, y) {
   this.field = Field;
-  this.r = Field.prototype.modulus.sub(r);
+  this.r = new sjcl.bn(r);
   this.a = new Field(a);
   this.b = new Field(b);
   this.G = new sjcl.ecc.point(this, new Field(x), new Field(y));
@@ -269,7 +274,7 @@ sjcl.ecc.curve.prototype.fromBits = function (bits) {
 sjcl.ecc.curves = {
   c192: new sjcl.ecc.curve(
     sjcl.bn.prime.p192,
-    "0x662107c8eb94364e4b2dd7ce",
+    "0xffffffffffffffffffffffff99def836146bc9b1b4d22831",
     -3,
     "0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
     "0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
@@ -277,7 +282,7 @@ sjcl.ecc.curves = {
 
   c224: new sjcl.ecc.curve(
     sjcl.bn.prime.p224,
-    "0xe95c1f470fc1ec22d6baa3a3d5c4",
+    "0xffffffffffffffffffffffffffff16a2e0b8f03e13dd29455c5c2a3d",
     -3,
     "0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4",
     "0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
@@ -285,7 +290,7 @@ sjcl.ecc.curves = {
 
   c256: new sjcl.ecc.curve(
     sjcl.bn.prime.p256,
-    "0x4319055358e8617b0c46353d039cdaae",
+    "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
     -3,
     "0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
     "0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
@@ -293,18 +298,46 @@ sjcl.ecc.curves = {
 
   c384: new sjcl.ecc.curve(
     sjcl.bn.prime.p384,
-    "0x389cb27e0bc8d21fa7e5f24cb74f58851313e696333ad68c",
+    "0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973",
     -3,
     "0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef",
     "0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7",
-    "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f")
+    "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f"),
+
+  k192: new sjcl.ecc.curve(
+    sjcl.bn.prime.p192k,
+    "0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d",
+    0,
+    3,
+    "0xdb4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
+    "0x9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"),
+
+  k224: new sjcl.ecc.curve(
+    sjcl.bn.prime.p224k,
+    "0x010000000000000000000000000001dce8d2ec6184caf0a971769fb1f7",
+    0,
+    5,
+    "0xa1455b334df099df30fc28a169a467e9e47075a90f7e650eb6b7a45c",
+    "0x7e089fed7fba344282cafbd6f7e319f7c0b0bd59e2ca4bdb556d61a5"),
+
+  k256: new sjcl.ecc.curve(
+    sjcl.bn.prime.p256k,
+    "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
+    0,
+    7,
+    "0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+    "0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+
 };
 
-
-/* Diffie-Hellman-like public-key system */
-sjcl.ecc._dh = function(cn) {
-  sjcl.ecc[cn] = {
-    /** @constructor */
+/** our basicKey classes
+*/
+sjcl.ecc.basicKey = {
+  /** ecc publicKey. 
+  * @constructor
+  * @param {curve} curve the elliptic curve
+  * @param {point} point the point on the curve
+  */
   publicKey: function(curve, point) {
     this._curve = curve;
     this._curveBitLength = curve.r.bitLength();
@@ -314,50 +347,86 @@ sjcl.ecc._dh = function(cn) {
       this._point = point;
     }
 
+    /** get this keys point data
+    * @return x and y as bitArrays
+    */
     this.get = function() {
       var pointbits = this._point.toBits();
       var len = sjcl.bitArray.bitLength(pointbits);
       var x = sjcl.bitArray.bitSlice(pointbits, 0, len/2);
       var y = sjcl.bitArray.bitSlice(pointbits, len/2);
       return { x: x, y: y };
-      }
+    };
   },
 
-    /** @constructor */
+  /** ecc secretKey
+  * @constructor
+  * @param {curve} curve the elliptic curve
+  * @param exponent
+  */
   secretKey: function(curve, exponent) {
     this._curve = curve;
     this._curveBitLength = curve.r.bitLength();
     this._exponent = exponent;
 
-      this.get = function() {
+    /** get this keys exponent data
+    * @return {bitArray} exponent
+    */
+    this.get = function () {
       return this._exponent.toBits();
+    };
   }
-    },
+};
+
+/** @private */
+sjcl.ecc.basicKey.generateKeys = function(cn) {
+  return function generateKeys(curve, paranoia, sec) {
+    curve = curve || 256;
 
-    /** @constructor */
-    generateKeys: function(curve, paranoia, sec) {
-      if (curve === undefined) {
-        curve = 256;
-      }
     if (typeof curve === "number") {
       curve = sjcl.ecc.curves['c'+curve];
       if (curve === undefined) {
         throw new sjcl.exception.invalid("no such curve");
       }
     }
-      if (sec === undefined) {
-        var sec = sjcl.bn.random(curve.r, paranoia);
-      }
+    sec = sec || sjcl.bn.random(curve.r, paranoia);
+
     var pub = curve.G.mult(sec);
     return { pub: new sjcl.ecc[cn].publicKey(curve, pub),
              sec: new sjcl.ecc[cn].secretKey(curve, sec) };
-    }
   };
 };
 
-sjcl.ecc._dh("elGamal");
+/** elGamal keys */
+sjcl.ecc.elGamal = {
+  /** generate keys
+  * @function
+  * @param curve
+  * @param {int} paranoia Paranoia for generation (default 6)
+  * @param {secretKey} sec secret Key to use. used to get the publicKey for ones secretKey
+  */
+  generateKeys: sjcl.ecc.basicKey.generateKeys("elGamal"),
+  /** elGamal publicKey. 
+  * @constructor
+  * @augments sjcl.ecc.basicKey.publicKey
+  */
+  publicKey: function (curve, point) {
+    sjcl.ecc.basicKey.publicKey.apply(this, arguments);
+  },
+  /** elGamal secretKey
+  * @constructor
+  * @augments sjcl.ecc.basicKey.secretKey
+  */
+  secretKey: function (curve, exponent) {
+    sjcl.ecc.basicKey.secretKey.apply(this, arguments);
+  }
+};
 
 sjcl.ecc.elGamal.publicKey.prototype = {
+  /** Kem function of elGamal Public Key
+  * @param paranoia paranoia to use for randomization.
+  * @return {object} key and tag. unkem(tag) with the corresponding secret key results in the key returned.
+  */
   kem: function(paranoia) {
     var sec = sjcl.bn.random(this._curve.r, paranoia),
         tag = this._curve.G.mult(sec).toBits(),
@@ -367,34 +436,58 @@ sjcl.ecc.elGamal.publicKey.prototype = {
 };
 
 sjcl.ecc.elGamal.secretKey.prototype = {
+  /** UnKem function of elGamal Secret Key
+  * @param {bitArray} tag The Tag to decrypt.
+  * @return {bitArray} decrypted key.
+  */
   unkem: function(tag) {
     return sjcl.hash.sha256.hash(this._curve.fromBits(tag).mult(this._exponent).toBits());
   },
 
+  /** Diffie-Hellmann function
+  * @param {elGamal.publicKey} pk The Public Key to do Diffie-Hellmann with
+  * @return {bitArray} diffie-hellmann result for this key combination.
+  */
   dh: function(pk) {
     return sjcl.hash.sha256.hash(pk._point.mult(this._exponent).toBits());
+  },
+  
+  /** Diffie-Hellmann function, compatible with Java generateSecret
+   * @param {elGamal.publicKey} pk The Public Key to do Diffie-Hellmann with
+   * @return {bitArray} undigested X value, diffie-hellmann result for this key combination,
+   * compatible with Java generateSecret().
+   */
+   dhJavaEc: function(pk) {
+     return pk._point.mult(this._exponent).x.toBits();
    }
 };
 
-sjcl.ecc._dh("ecdsa");
-
-sjcl.ecc.ecdsa.secretKey.prototype = {
-  sign: function(hash, paranoia, fakeLegacyVersion, fixedKForTesting) {
-    if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {
-      hash = sjcl.bitArray.clamp(hash, this._curveBitLength);
-    }
-    var R  = this._curve.r,
-        l  = R.bitLength(),
-        k  = fixedKForTesting || sjcl.bn.random(R.sub(1), paranoia).add(1),
-        r  = this._curve.G.mult(k).x.mod(R),
-        ss = sjcl.bn.fromBits(hash).add(r.mul(this._exponent)),
-        s  = fakeLegacyVersion ? ss.inverseMod(R).mul(k).mod(R)
-             : ss.mul(k.inverseMod(R)).mod(R);
-    return sjcl.bitArray.concat(r.toBits(l), s.toBits(l));
-  }
+/** ecdsa keys */
+sjcl.ecc.ecdsa = {
+  /** generate keys
+  * @function
+  * @param curve
+  * @param {int} paranoia Paranoia for generation (default 6)
+  * @param {secretKey} sec secret Key to use. used to get the publicKey for ones secretKey
+  */
+  generateKeys: sjcl.ecc.basicKey.generateKeys("ecdsa")
 };
 
+/** ecdsa publicKey. 
+* @constructor
+* @augments sjcl.ecc.basicKey.publicKey
+*/
+sjcl.ecc.ecdsa.publicKey = function (curve, point) {
+  sjcl.ecc.basicKey.publicKey.apply(this, arguments);
+};
+
+/** specific functions for ecdsa publicKey. */
 sjcl.ecc.ecdsa.publicKey.prototype = {
+  /** Diffie-Hellmann function
+  * @param {bitArray} hash hash to verify. 
+  * @param {bitArray} rs signature bitArray.
+  * @param {boolean}  fakeLegacyVersion use old legacy version
+  */
   verify: function(hash, rs, fakeLegacyVersion) {
     if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {
       hash = sjcl.bitArray.clamp(hash, this._curveBitLength);
@@ -418,3 +511,33 @@ sjcl.ecc.ecdsa.publicKey.prototype = {
     return true;
   }
 };
+
+/** ecdsa secretKey
+* @constructor
+* @augments sjcl.ecc.basicKey.publicKey
+*/
+sjcl.ecc.ecdsa.secretKey = function (curve, exponent) {
+  sjcl.ecc.basicKey.secretKey.apply(this, arguments);
+};
+
+/** specific functions for ecdsa secretKey. */
+sjcl.ecc.ecdsa.secretKey.prototype = {
+  /** Diffie-Hellmann function
+  * @param {bitArray} hash hash to sign. 
+  * @param {int} paranoia paranoia for random number generation
+  * @param {boolean} fakeLegacyVersion use old legacy version
+  */
+  sign: function(hash, paranoia, fakeLegacyVersion, fixedKForTesting) {
+    if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {
+      hash = sjcl.bitArray.clamp(hash, this._curveBitLength);
+    }
+    var R  = this._curve.r,
+        l  = R.bitLength(),
+        k  = fixedKForTesting || sjcl.bn.random(R.sub(1), paranoia).add(1),
+        r  = this._curve.G.mult(k).x.mod(R),
+        ss = sjcl.bn.fromBits(hash).add(r.mul(this._exponent)),
+        s  = fakeLegacyVersion ? ss.inverseMod(R).mul(k).mod(R)
+             : ss.mul(k.inverseMod(R)).mod(R);
+    return sjcl.bitArray.concat(r.toBits(l), s.toBits(l));
+  }
+};

src/js/sjcl/core/gcm.js

@@ -120,7 +120,7 @@ sjcl.mode.gcm = {
    * @param {Number} tlen The length of the tag, in bits.
    */
   _ctrMode: function(encrypt, prf, data, adata, iv, tlen) {
-    var H, J0, S0, enc, i, ctr, tag, last, l, bl, abl, ivbl, w=sjcl.bitArray, xor=w._xor4;
+    var H, J0, S0, enc, i, ctr, tag, last, l, bl, abl, ivbl, w=sjcl.bitArray;
 
     // Calculate data lengths
     l = data.length;

src/js/sjcl/core/hmac.js

@@ -27,13 +27,35 @@ sjcl.misc.hmac = function (key, Hash) {
   
   this._baseHash[0].update(exKey[0]);
   this._baseHash[1].update(exKey[1]);
+  this._resultHash = new Hash(this._baseHash[0]);
 };
 
 /** HMAC with the specified hash function.  Also called encrypt since it's a prf.
  * @param {bitArray|String} data The data to mac.
  */
 sjcl.misc.hmac.prototype.encrypt = sjcl.misc.hmac.prototype.mac = function (data) {
-  var w = new (this._hash)(this._baseHash[0]).update(data).finalize();
-  return new (this._hash)(this._baseHash[1]).update(w).finalize();
+  if (!this._updated) {
+    this.update(data);
+    return this.digest(data);
+  } else {
+    throw new sjcl.exception.invalid("encrypt on already updated hmac called!");
+  }
 };
 
+sjcl.misc.hmac.prototype.reset = function () {
+  this._resultHash = new this._hash(this._baseHash[0]);
+  this._updated = false;
+};
+
+sjcl.misc.hmac.prototype.update = function (data) {
+  this._updated = true;
+  this._resultHash.update(data);
+};
+
+sjcl.misc.hmac.prototype.digest = function () {
+  var w = this._resultHash.finalize(), result = new (this._hash)(this._baseHash[1]).update(w).finalize();
+
+  this.reset();
+
+  return result;
+};

src/js/sjcl/core/pbkdf2.js

@@ -12,7 +12,7 @@
  * This is the method specified by RSA's PKCS #5 standard.
  *
  * @param {bitArray|String} password  The password.
- * @param {bitArray} salt The salt.  Should have lots of entropy.
+ * @param {bitArray|String} salt The salt.  Should have lots of entropy.
  * @param {Number} [count=1000] The number of iterations.  Higher numbers make the function slower but more secure.
  * @param {Number} [length] The length of the derived key.  Defaults to the
                             output size of the hash function.
@@ -30,6 +30,10 @@ sjcl.misc.pbkdf2 = function (password, salt, count, length, Prff) {
     password = sjcl.codec.utf8String.toBits(password);
   }
   
+  if (typeof salt === "string") {
+    salt = sjcl.codec.utf8String.toBits(salt);
+  }
+  
   Prff = Prff || sjcl.misc.hmac;
   
   var prf = new Prff(password),

src/js/sjcl/core/random.js

@@ -3,12 +3,13 @@
  * @author Emily Stark
  * @author Mike Hamburg
  * @author Dan Boneh
+ * @author Michael Brooks
  */
 
 /** @constructor
  * @class Random number generator
- *
  * @description
+ * <b>Use sjcl.random as a singleton for this class!</b>
  * <p>
  * This random number generator is a derivative of Ferguson and Schneier's
  * generator Fortuna.  It collects entropy from various events into several
@@ -74,10 +75,11 @@ sjcl.prng = function(defaultParanoia) {
   this._PARANOIA_LEVELS         = [0,48,64,96,128,192,256,384,512,768,1024];
   this._MILLISECONDS_PER_RESEED = 30000;
   this._BITS_PER_RESEED         = 80;
-}
+};
  
 sjcl.prng.prototype = {
-  /** Generate several random words, and return them in an array
+  /** Generate several random words, and return them in an array.
+   * A word consists of 32 bits (4 bytes)
    * @param {Number} nwords The number of words to generate.
    */
   randomWords: function (nwords, paranoia) {
@@ -102,7 +104,11 @@ sjcl.prng.prototype = {
     return out.slice(0,nwords);
   },
   
-  setDefaultParanoia: function (paranoia) {
+  setDefaultParanoia: function (paranoia, allowZeroParanoia) {
+    if (paranoia === 0 && allowZeroParanoia !== "Setting paranoia=0 will ruin your security; use it only for testing") {
+      throw "Setting paranoia=0 will ruin your security; use it only for testing";
+    }
+
     this._defaultParanoia = paranoia;
   },
   
@@ -119,7 +125,7 @@ sjcl.prng.prototype = {
       i, tmp,
       t = (new Date()).valueOf(),
       robin = this._robins[source],
-      oldReady = this.isReady(), err = 0;
+      oldReady = this.isReady(), err = 0, objName;
       
     id = this._collectorIds[source];
     if (id === undefined) { id = this._collectorIds[source] = this._collectorIdNext ++; }
@@ -137,7 +143,7 @@ sjcl.prng.prototype = {
       break;
       
     case "object":
-      var objName = Object.prototype.toString.call(data);
+      objName = Object.prototype.toString.call(data);
       if (objName === "[object Uint32Array]") {
         tmp = [];
         for (i = 0; i < data.length; i++) {
@@ -149,7 +155,7 @@ sjcl.prng.prototype = {
           err = 1;
         }
         for (i=0; i<data.length && !err; i++) {
-          if (typeof(data[i]) != "number") {
+          if (typeof(data[i]) !== "number") {
             err = 1;
           }
         }
@@ -234,14 +240,25 @@ sjcl.prng.prototype = {
   startCollectors: function () {
     if (this._collectorsStarted) { return; }
   
+    this._eventListener = {
+      loadTimeCollector: this._bind(this._loadTimeCollector),
+      mouseCollector: this._bind(this._mouseCollector),
+      keyboardCollector: this._bind(this._keyboardCollector),
+      accelerometerCollector: this._bind(this._accelerometerCollector),
+      touchCollector: this._bind(this._touchCollector)
+    };
+
     if (window.addEventListener) {
-      window.addEventListener("load", this._loadTimeCollector, false);
-      window.addEventListener("mousemove", this._mouseCollector, false);
+      window.addEventListener("load", this._eventListener.loadTimeCollector, false);
+      window.addEventListener("mousemove", this._eventListener.mouseCollector, false);
+      window.addEventListener("keypress", this._eventListener.keyboardCollector, false);
+      window.addEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
+      window.addEventListener("touchmove", this._eventListener.touchCollector, false);
     } else if (document.attachEvent) {
-      document.attachEvent("onload", this._loadTimeCollector);
-      document.attachEvent("onmousemove", this._mouseCollector);
-    }
-    else {
+      document.attachEvent("onload", this._eventListener.loadTimeCollector);
+      document.attachEvent("onmousemove", this._eventListener.mouseCollector);
+      document.attachEvent("keypress", this._eventListener.keyboardCollector);
+    } else {
       throw new sjcl.exception.bug("can't attach event");
     }
   
@@ -253,12 +270,17 @@ sjcl.prng.prototype = {
     if (!this._collectorsStarted) { return; }
   
     if (window.removeEventListener) {
-      window.removeEventListener("load", this._loadTimeCollector, false);
-      window.removeEventListener("mousemove", this._mouseCollector, false);
-    } else if (window.detachEvent) {
-      window.detachEvent("onload", this._loadTimeCollector);
-      window.detachEvent("onmousemove", this._mouseCollector);
+      window.removeEventListener("load", this._eventListener.loadTimeCollector, false);
+      window.removeEventListener("mousemove", this._eventListener.mouseCollector, false);
+      window.removeEventListener("keypress", this._eventListener.keyboardCollector, false);
+      window.removeEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
+      window.removeEventListener("touchmove", this._eventListener.touchCollector, false);
+    } else if (document.detachEvent) {
+      document.detachEvent("onload", this._eventListener.loadTimeCollector);
+      document.detachEvent("onmousemove", this._eventListener.mouseCollector);
+      document.detachEvent("keypress", this._eventListener.keyboardCollector);
     }
+
     this._collectorsStarted = false;
   },
   
@@ -292,6 +314,13 @@ sjcl.prng.prototype = {
     }
   },
   
+  _bind: function (func) {
+    var that = this;
+    return function () {
+      func.apply(that, arguments);
+    };
+  },
+
   /** Generate 4 random words, no reseed, no gate.
    * @private
    */
@@ -363,13 +392,63 @@ sjcl.prng.prototype = {
     this._reseed(reseedData);
   },
   
-  _mouseCollector: function (ev) {
-    var x = ev.x || ev.clientX || ev.offsetX || 0, y = ev.y || ev.clientY || ev.offsetY || 0;
-    sjcl.random.addEntropy([x,y], 2, "mouse");
+  _keyboardCollector: function () {
+    this._addCurrentTimeToEntropy(1);
   },
   
-  _loadTimeCollector: function (ev) {
-    sjcl.random.addEntropy((new Date()).valueOf(), 2, "loadtime");
+  _mouseCollector: function (ev) {
+    var x, y;
+
+    try {
+      x = ev.x || ev.clientX || ev.offsetX || 0;
+      y = ev.y || ev.clientY || ev.offsetY || 0;
+    } catch (err) {
+      // Event originated from a secure element. No mouse position available.
+      x = 0;
+      y = 0;
+    }
+
+    if (x != 0 && y!= 0) {
+      sjcl.random.addEntropy([x,y], 2, "mouse");
+    }
+
+    this._addCurrentTimeToEntropy(0);
+  },
+
+  _touchCollector: function(ev) {
+    var touch = ev.touches[0] || ev.changedTouches[0];
+    var x = touch.pageX || touch.clientX,
+        y = touch.pageY || touch.clientY;
+
+    sjcl.random.addEntropy([x,y],1,"touch");
+
+    this._addCurrentTimeToEntropy(0);
+  },
+  
+  _loadTimeCollector: function () {
+    this._addCurrentTimeToEntropy(2);
+  },
+
+  _addCurrentTimeToEntropy: function (estimatedEntropy) {
+    if (typeof window !== 'undefined' && window.performance && typeof window.performance.now === "function") {
+      //how much entropy do we want to add here?
+      sjcl.random.addEntropy(window.performance.now(), estimatedEntropy, "loadtime");
+    } else {
+      sjcl.random.addEntropy((new Date()).valueOf(), estimatedEntropy, "loadtime");
+    }
+  },
+  _accelerometerCollector: function (ev) {
+    var ac = ev.accelerationIncludingGravity.x||ev.accelerationIncludingGravity.y||ev.accelerationIncludingGravity.z;
+    if(window.orientation){
+      var or = window.orientation;
+      if (typeof or === "number") {
+        sjcl.random.addEntropy(or, 1, "accelerometer");
+      }
+    }
+    if (ac) {
+      sjcl.random.addEntropy(ac, 2, "accelerometer");
+    }
+    this._addCurrentTimeToEntropy(0);
   },
 
   _fireEvent: function (name, arg) {
@@ -392,15 +471,52 @@ sjcl.prng.prototype = {
   }
 };
 
+/** an instance for the prng.
+* @see sjcl.prng
+*/
 sjcl.random = new sjcl.prng(6);
 
 (function(){
+  // function for getting nodejs crypto module. catches and ignores errors.
+  function getCryptoModule() {
     try {
+      return require('crypto');
+    }
+    catch (e) {
+      return null;
+    }
+  }
+
+  try {
+    var buf, crypt, ab;
+
+    // get cryptographically strong entropy depending on runtime environment
+    if (typeof module !== 'undefined' && module.exports && (crypt = getCryptoModule()) && crypt.randomBytes) {
+      buf = crypt.randomBytes(1024/8);
+      buf = new Uint32Array(new Uint8Array(buf).buffer);
+      sjcl.random.addEntropy(buf, 1024, "crypto.randomBytes");
+
+    } else if (typeof window !== 'undefined' && typeof Uint32Array !== 'undefined') {
+      ab = new Uint32Array(32);
+      if (window.crypto && window.crypto.getRandomValues) {
+        window.crypto.getRandomValues(ab);
+      } else if (window.msCrypto && window.msCrypto.getRandomValues) {
+        window.msCrypto.getRandomValues(ab);
+      } else {
+        return;
+      }
+
       // get cryptographically strong entropy in Webkit
-    var ab = new Uint32Array(32);
-    crypto.getRandomValues(ab);
       sjcl.random.addEntropy(ab, 1024, "crypto.getRandomValues");
-  } catch (e) {
+
+    } else {
       // no getRandomValues :-(
     }
-})();
+  } catch (e) {
+    if (typeof window !== 'undefined' && window.console) {
+      console.log("There was an error collecting entropy from the browser:");
+      console.log(e);
+      //we do not want the library to fail due to randomness not being maintained.
+    }
+  }
+}());

src/js/sjcl/core/sha1.js

@@ -138,8 +138,7 @@ sjcl.hash.sha1.prototype = {
   _block:function (words) {  
     var t, tmp, a, b, c, d, e,
     w = words.slice(0),
-    h = this._h,
-    k = this._key;
+    h = this._h;
    
     a = h[0]; b = h[1]; c = h[2]; d = h[3]; e = h[4]; 
 

src/js/sjcl/core/sha512.js

@@ -299,7 +299,7 @@ sjcl.hash.sha512.prototype = {
       t1h += chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
       t1l += krl;
       t1h += krh + ((t1l >>> 0) < (krl >>> 0) ? 1 : 0);
-      t1l += wrl;
+      t1l = t1l + wrl|0;   // FF32..FF34 perf issue https://bugzilla.mozilla.org/show_bug.cgi?id=1054972
       t1h += wrh + ((t1l >>> 0) < (wrl >>> 0) ? 1 : 0);
 
       // t2 = sigma0 + maj

src/js/sjcl/core/sjcl.js

@@ -10,7 +10,7 @@
 
 "use strict";
 /*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
-/*global document, window, escape, unescape */
+/*global document, window, escape, unescape, module, require, Uint32Array */
 
 /** @namespace The Stanford Javascript Crypto Library, top-level namespace. */
 var sjcl = {
@@ -68,6 +68,11 @@ var sjcl = {
   }
 };
 
-if(typeof module != 'undefined' && module.exports){
+if(typeof module !== 'undefined' && module.exports){
   module.exports = sjcl;
 }
+if (typeof define === "function") {
+    define([], function () {
+        return sjcl;
+    });
+}

src/js/sjcl/demo/index.html

@@ -36,7 +36,7 @@
       <h2>Key Derivation</h2>
       <div class="section">
         <div>
-          <label for="salt"">Salt:</label>
+          <label for="salt">Salt:</label>
           <a class="random floatright" href="javascript:randomize('salt',2,0)">random</a>
         </div>
         <input type="text" id="salt" class="wide hex" autocomplete="off" size="17" maxlength="35"/>

src/js/sjcl/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "sjcl",
+    "version": "1.0.1",
+    "description": "Stanford Javascript Crypto Library",
+    "main": "sjcl.js",
+    "author": "bitwiseshiftleft",
+    "keywords": ["encryption", "high-level", "crypto"],
+    "repository" : {
+        "type": "git",
+        "url": "https://github.com/bitwiseshiftleft/sjcl.git"
+    },
+    "scripts": {
+      "test": "make test"
+    },
+    "engines": { "node": "*" }
+}

src/js/sjcl/sjcl.js

@@ -1,48 +1,54 @@
 "use strict";function q(a){throw a;}var t=void 0,u=!1;var sjcl={cipher:{},hash:{},keyexchange:{},mode:{},misc:{},codec:{},exception:{corrupt:function(a){this.toString=function(){return"CORRUPT: "+this.message};this.message=a},invalid:function(a){this.toString=function(){return"INVALID: "+this.message};this.message=a},bug:function(a){this.toString=function(){return"BUG: "+this.message};this.message=a},notReady:function(a){this.toString=function(){return"NOT READY: "+this.message};this.message=a}}};
-"undefined"!=typeof module&&module.exports&&(module.exports=sjcl);
-sjcl.cipher.aes=function(a){this.j[0][0][0]||this.D();var b,c,d,e,f=this.j[0][4],g=this.j[1];b=a.length;var h=1;4!==b&&(6!==b&&8!==b)&&q(new sjcl.exception.invalid("invalid aes key size"));this.a=[d=a.slice(0),e=[]];for(a=b;a<4*b+28;a++){c=d[a-1];if(0===a%b||8===b&&4===a%b)c=f[c>>>24]<<24^f[c>>16&255]<<16^f[c>>8&255]<<8^f[c&255],0===a%b&&(c=c<<8^c>>>24^h<<24,h=h<<1^283*(h>>7));d[a]=d[a-b]^c}for(b=0;a;b++,a--)c=d[b&3?a:a-4],e[b]=4>=a||4>b?c:g[0][f[c>>>24]]^g[1][f[c>>16&255]]^g[2][f[c>>8&255]]^g[3][f[c&
+"undefined"!==typeof module&&module.exports&&(module.exports=sjcl);"function"===typeof define&&define([],function(){return sjcl});
+sjcl.cipher.aes=function(a){this.k[0][0][0]||this.D();var b,c,d,e,f=this.k[0][4],g=this.k[1];b=a.length;var h=1;4!==b&&(6!==b&&8!==b)&&q(new sjcl.exception.invalid("invalid aes key size"));this.b=[d=a.slice(0),e=[]];for(a=b;a<4*b+28;a++){c=d[a-1];if(0===a%b||8===b&&4===a%b)c=f[c>>>24]<<24^f[c>>16&255]<<16^f[c>>8&255]<<8^f[c&255],0===a%b&&(c=c<<8^c>>>24^h<<24,h=h<<1^283*(h>>7));d[a]=d[a-b]^c}for(b=0;a;b++,a--)c=d[b&3?a:a-4],e[b]=4>=a||4>b?c:g[0][f[c>>>24]]^g[1][f[c>>16&255]]^g[2][f[c>>8&255]]^g[3][f[c&
 255]]};
-sjcl.cipher.aes.prototype={encrypt:function(a){return y(this,a,0)},decrypt:function(a){return y(this,a,1)},j:[[[],[],[],[],[]],[[],[],[],[],[]]],D:function(){var a=this.j[0],b=this.j[1],c=a[4],d=b[4],e,f,g,h=[],l=[],k,n,m,p;for(e=0;0x100>e;e++)l[(h[e]=e<<1^283*(e>>7))^e]=e;for(f=g=0;!c[f];f^=k||1,g=l[g]||1){m=g^g<<1^g<<2^g<<3^g<<4;m=m>>8^m&255^99;c[f]=m;d[m]=f;n=h[e=h[k=h[f]]];p=0x1010101*n^0x10001*e^0x101*k^0x1010100*f;n=0x101*h[m]^0x1010100*m;for(e=0;4>e;e++)a[e][f]=n=n<<24^n>>>8,b[e][m]=p=p<<24^p>>>8}for(e=
+sjcl.cipher.aes.prototype={encrypt:function(a){return y(this,a,0)},decrypt:function(a){return y(this,a,1)},k:[[[],[],[],[],[]],[[],[],[],[],[]]],D:function(){var a=this.k[0],b=this.k[1],c=a[4],d=b[4],e,f,g,h=[],l=[],k,n,m,p;for(e=0;0x100>e;e++)l[(h[e]=e<<1^283*(e>>7))^e]=e;for(f=g=0;!c[f];f^=k||1,g=l[g]||1){m=g^g<<1^g<<2^g<<3^g<<4;m=m>>8^m&255^99;c[f]=m;d[m]=f;n=h[e=h[k=h[f]]];p=0x1010101*n^0x10001*e^0x101*k^0x1010100*f;n=0x101*h[m]^0x1010100*m;for(e=0;4>e;e++)a[e][f]=n=n<<24^n>>>8,b[e][m]=p=p<<24^p>>>8}for(e=
 0;5>e;e++)a[e]=a[e].slice(0),b[e]=b[e].slice(0)}};
-function y(a,b,c){4!==b.length&&q(new sjcl.exception.invalid("invalid aes block size"));var d=a.a[c],e=b[0]^d[0],f=b[c?3:1]^d[1],g=b[2]^d[2];b=b[c?1:3]^d[3];var h,l,k,n=d.length/4-2,m,p=4,s=[0,0,0,0];h=a.j[c];a=h[0];var r=h[1],v=h[2],w=h[3],x=h[4];for(m=0;m<n;m++)h=a[e>>>24]^r[f>>16&255]^v[g>>8&255]^w[b&255]^d[p],l=a[f>>>24]^r[g>>16&255]^v[b>>8&255]^w[e&255]^d[p+1],k=a[g>>>24]^r[b>>16&255]^v[e>>8&255]^w[f&255]^d[p+2],b=a[b>>>24]^r[e>>16&255]^v[f>>8&255]^w[g&255]^d[p+3],p+=4,e=h,f=l,g=k;for(m=0;4>
+function y(a,b,c){4!==b.length&&q(new sjcl.exception.invalid("invalid aes block size"));var d=a.b[c],e=b[0]^d[0],f=b[c?3:1]^d[1],g=b[2]^d[2];b=b[c?1:3]^d[3];var h,l,k,n=d.length/4-2,m,p=4,s=[0,0,0,0];h=a.k[c];a=h[0];var r=h[1],v=h[2],w=h[3],x=h[4];for(m=0;m<n;m++)h=a[e>>>24]^r[f>>16&255]^v[g>>8&255]^w[b&255]^d[p],l=a[f>>>24]^r[g>>16&255]^v[b>>8&255]^w[e&255]^d[p+1],k=a[g>>>24]^r[b>>16&255]^v[e>>8&255]^w[f&255]^d[p+2],b=a[b>>>24]^r[e>>16&255]^v[f>>8&255]^w[g&255]^d[p+3],p+=4,e=h,f=l,g=k;for(m=0;4>
 m;m++)s[c?3&-m:m]=x[e>>>24]<<24^x[f>>16&255]<<16^x[g>>8&255]<<8^x[b&255]^d[p++],h=e,e=f,f=g,g=b,b=h;return s}
-sjcl.bitArray={bitSlice:function(a,b,c){a=sjcl.bitArray.O(a.slice(b/32),32-(b&31)).slice(1);return c===t?a:sjcl.bitArray.clamp(a,c-b)},extract:function(a,b,c){var d=Math.floor(-b-c&31);return((b+c-1^b)&-32?a[b/32|0]<<32-d^a[b/32+1|0]>>>d:a[b/32|0]>>>d)&(1<<c)-1},concat:function(a,b){if(0===a.length||0===b.length)return a.concat(b);var c=a[a.length-1],d=sjcl.bitArray.getPartial(c);return 32===d?a.concat(b):sjcl.bitArray.O(b,d,c|0,a.slice(0,a.length-1))},bitLength:function(a){var b=a.length;return 0===
+sjcl.bitArray={bitSlice:function(a,b,c){a=sjcl.bitArray.P(a.slice(b/32),32-(b&31)).slice(1);return c===t?a:sjcl.bitArray.clamp(a,c-b)},extract:function(a,b,c){var d=Math.floor(-b-c&31);return((b+c-1^b)&-32?a[b/32|0]<<32-d^a[b/32+1|0]>>>d:a[b/32|0]>>>d)&(1<<c)-1},concat:function(a,b){if(0===a.length||0===b.length)return a.concat(b);var c=a[a.length-1],d=sjcl.bitArray.getPartial(c);return 32===d?a.concat(b):sjcl.bitArray.P(b,d,c|0,a.slice(0,a.length-1))},bitLength:function(a){var b=a.length;return 0===
 b?0:32*(b-1)+sjcl.bitArray.getPartial(a[b-1])},clamp:function(a,b){if(32*a.length<b)return a;a=a.slice(0,Math.ceil(b/32));var c=a.length;b&=31;0<c&&b&&(a[c-1]=sjcl.bitArray.partial(b,a[c-1]&2147483648>>b-1,1));return a},partial:function(a,b,c){return 32===a?b:(c?b|0:b<<32-a)+0x10000000000*a},getPartial:function(a){return Math.round(a/0x10000000000)||32},equal:function(a,b){if(sjcl.bitArray.bitLength(a)!==sjcl.bitArray.bitLength(b))return u;var c=0,d;for(d=0;d<a.length;d++)c|=a[d]^b[d];return 0===
-c},O:function(a,b,c,d){var e;e=0;for(d===t&&(d=[]);32<=b;b-=32)d.push(c),c=0;if(0===b)return d.concat(a);for(e=0;e<a.length;e++)d.push(c|a[e]>>>b),c=a[e]<<32-b;e=a.length?a[a.length-1]:0;a=sjcl.bitArray.getPartial(e);d.push(sjcl.bitArray.partial(b+a&31,32<b+a?c:d.pop(),1));return d},k:function(a,b){return[a[0]^b[0],a[1]^b[1],a[2]^b[2],a[3]^b[3]]}};
+c},P:function(a,b,c,d){var e;e=0;for(d===t&&(d=[]);32<=b;b-=32)d.push(c),c=0;if(0===b)return d.concat(a);for(e=0;e<a.length;e++)d.push(c|a[e]>>>b),c=a[e]<<32-b;e=a.length?a[a.length-1]:0;a=sjcl.bitArray.getPartial(e);d.push(sjcl.bitArray.partial(b+a&31,32<b+a?c:d.pop(),1));return d},l:function(a,b){return[a[0]^b[0],a[1]^b[1],a[2]^b[2],a[3]^b[3]]},byteswapM:function(a){var b,c;for(b=0;b<a.length;++b)c=a[b],a[b]=c>>>24|c>>>8&0xff00|(c&0xff00)<<8|c<<24;return a}};
 sjcl.codec.utf8String={fromBits:function(a){var b="",c=sjcl.bitArray.bitLength(a),d,e;for(d=0;d<c/8;d++)0===(d&3)&&(e=a[d/4]),b+=String.fromCharCode(e>>>24),e<<=8;return decodeURIComponent(escape(b))},toBits:function(a){a=unescape(encodeURIComponent(a));var b=[],c,d=0;for(c=0;c<a.length;c++)d=d<<8|a.charCodeAt(c),3===(c&3)&&(b.push(d),d=0);c&3&&b.push(sjcl.bitArray.partial(8*(c&3),d));return b}};
 sjcl.codec.hex={fromBits:function(a){var b="",c;for(c=0;c<a.length;c++)b+=((a[c]|0)+0xf00000000000).toString(16).substr(4);return b.substr(0,sjcl.bitArray.bitLength(a)/4)},toBits:function(a){var b,c=[],d;a=a.replace(/\s|0x/g,"");d=a.length;a+="00000000";for(b=0;b<a.length;b+=8)c.push(parseInt(a.substr(b,8),16)^0);return sjcl.bitArray.clamp(c,4*d)}};
-sjcl.codec.base64={I:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",fromBits:function(a,b,c){var d="",e=0,f=sjcl.codec.base64.I,g=0,h=sjcl.bitArray.bitLength(a);c&&(f=f.substr(0,62)+"-_");for(c=0;6*d.length<h;)d+=f.charAt((g^a[c]>>>e)>>>26),6>e?(g=a[c]<<6-e,e+=26,c++):(g<<=6,e-=6);for(;d.length&3&&!b;)d+="=";return d},toBits:function(a,b){a=a.replace(/\s|=/g,"");var c=[],d,e=0,f=sjcl.codec.base64.I,g=0,h;b&&(f=f.substr(0,62)+"-_");for(d=0;d<a.length;d++)h=f.indexOf(a.charAt(d)),
-0>h&&q(new sjcl.exception.invalid("this isn't base64!")),26<e?(e-=26,c.push(g^h>>>e),g=h<<32-e):(e+=6,g^=h<<32-e);e&56&&c.push(sjcl.bitArray.partial(e&56,g,1));return c}};sjcl.codec.base64url={fromBits:function(a){return sjcl.codec.base64.fromBits(a,1,1)},toBits:function(a){return sjcl.codec.base64.toBits(a,1)}};sjcl.hash.sha256=function(a){this.a[0]||this.D();a?(this.q=a.q.slice(0),this.m=a.m.slice(0),this.g=a.g):this.reset()};sjcl.hash.sha256.hash=function(a){return(new sjcl.hash.sha256).update(a).finalize()};
-sjcl.hash.sha256.prototype={blockSize:512,reset:function(){this.q=this.M.slice(0);this.m=[];this.g=0;return this},update:function(a){"string"===typeof a&&(a=sjcl.codec.utf8String.toBits(a));var b,c=this.m=sjcl.bitArray.concat(this.m,a);b=this.g;a=this.g=b+sjcl.bitArray.bitLength(a);for(b=512+b&-512;b<=a;b+=512)z(this,c.splice(0,16));return this},finalize:function(){var a,b=this.m,c=this.q,b=sjcl.bitArray.concat(b,[sjcl.bitArray.partial(1,1)]);for(a=b.length+2;a&15;a++)b.push(0);b.push(Math.floor(this.g/
-4294967296));for(b.push(this.g|0);b.length;)z(this,b.splice(0,16));this.reset();return c},M:[],a:[],D:function(){function a(a){return 0x100000000*(a-Math.floor(a))|0}var b=0,c=2,d;a:for(;64>b;c++){for(d=2;d*d<=c;d++)if(0===c%d)continue a;8>b&&(this.M[b]=a(Math.pow(c,0.5)));this.a[b]=a(Math.pow(c,1/3));b++}}};
-function z(a,b){var c,d,e,f=b.slice(0),g=a.q,h=a.a,l=g[0],k=g[1],n=g[2],m=g[3],p=g[4],s=g[5],r=g[6],v=g[7];for(c=0;64>c;c++)16>c?d=f[c]:(d=f[c+1&15],e=f[c+14&15],d=f[c&15]=(d>>>7^d>>>18^d>>>3^d<<25^d<<14)+(e>>>17^e>>>19^e>>>10^e<<15^e<<13)+f[c&15]+f[c+9&15]|0),d=d+v+(p>>>6^p>>>11^p>>>25^p<<26^p<<21^p<<7)+(r^p&(s^r))+h[c],v=r,r=s,s=p,p=m+d|0,m=n,n=k,k=l,l=d+(k&n^m&(k^n))+(k>>>2^k>>>13^k>>>22^k<<30^k<<19^k<<10)|0;g[0]=g[0]+l|0;g[1]=g[1]+k|0;g[2]=g[2]+n|0;g[3]=g[3]+m|0;g[4]=g[4]+p|0;g[5]=g[5]+s|0;g[6]=
+sjcl.codec.base64={J:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",fromBits:function(a,b,c){var d="",e=0,f=sjcl.codec.base64.J,g=0,h=sjcl.bitArray.bitLength(a);c&&(f=f.substr(0,62)+"-_");for(c=0;6*d.length<h;)d+=f.charAt((g^a[c]>>>e)>>>26),6>e?(g=a[c]<<6-e,e+=26,c++):(g<<=6,e-=6);for(;d.length&3&&!b;)d+="=";return d},toBits:function(a,b){a=a.replace(/\s|=/g,"");var c=[],d,e=0,f=sjcl.codec.base64.J,g=0,h;b&&(f=f.substr(0,62)+"-_");for(d=0;d<a.length;d++)h=f.indexOf(a.charAt(d)),
+0>h&&q(new sjcl.exception.invalid("this isn't base64!")),26<e?(e-=26,c.push(g^h>>>e),g=h<<32-e):(e+=6,g^=h<<32-e);e&56&&c.push(sjcl.bitArray.partial(e&56,g,1));return c}};sjcl.codec.base64url={fromBits:function(a){return sjcl.codec.base64.fromBits(a,1,1)},toBits:function(a){return sjcl.codec.base64.toBits(a,1)}};sjcl.hash.sha256=function(a){this.b[0]||this.D();a?(this.r=a.r.slice(0),this.o=a.o.slice(0),this.h=a.h):this.reset()};sjcl.hash.sha256.hash=function(a){return(new sjcl.hash.sha256).update(a).finalize()};
+sjcl.hash.sha256.prototype={blockSize:512,reset:function(){this.r=this.N.slice(0);this.o=[];this.h=0;return this},update:function(a){"string"===typeof a&&(a=sjcl.codec.utf8String.toBits(a));var b,c=this.o=sjcl.bitArray.concat(this.o,a);b=this.h;a=this.h=b+sjcl.bitArray.bitLength(a);for(b=512+b&-512;b<=a;b+=512)z(this,c.splice(0,16));return this},finalize:function(){var a,b=this.o,c=this.r,b=sjcl.bitArray.concat(b,[sjcl.bitArray.partial(1,1)]);for(a=b.length+2;a&15;a++)b.push(0);b.push(Math.floor(this.h/
+4294967296));for(b.push(this.h|0);b.length;)z(this,b.splice(0,16));this.reset();return c},N:[],b:[],D:function(){function a(a){return 0x100000000*(a-Math.floor(a))|0}var b=0,c=2,d;a:for(;64>b;c++){for(d=2;d*d<=c;d++)if(0===c%d)continue a;8>b&&(this.N[b]=a(Math.pow(c,0.5)));this.b[b]=a(Math.pow(c,1/3));b++}}};
+function z(a,b){var c,d,e,f=b.slice(0),g=a.r,h=a.b,l=g[0],k=g[1],n=g[2],m=g[3],p=g[4],s=g[5],r=g[6],v=g[7];for(c=0;64>c;c++)16>c?d=f[c]:(d=f[c+1&15],e=f[c+14&15],d=f[c&15]=(d>>>7^d>>>18^d>>>3^d<<25^d<<14)+(e>>>17^e>>>19^e>>>10^e<<15^e<<13)+f[c&15]+f[c+9&15]|0),d=d+v+(p>>>6^p>>>11^p>>>25^p<<26^p<<21^p<<7)+(r^p&(s^r))+h[c],v=r,r=s,s=p,p=m+d|0,m=n,n=k,k=l,l=d+(k&n^m&(k^n))+(k>>>2^k>>>13^k>>>22^k<<30^k<<19^k<<10)|0;g[0]=g[0]+l|0;g[1]=g[1]+k|0;g[2]=g[2]+n|0;g[3]=g[3]+m|0;g[4]=g[4]+p|0;g[5]=g[5]+s|0;g[6]=
 g[6]+r|0;g[7]=g[7]+v|0}
-sjcl.mode.ccm={name:"ccm",encrypt:function(a,b,c,d,e){var f,g=b.slice(0),h=sjcl.bitArray,l=h.bitLength(c)/8,k=h.bitLength(g)/8;e=e||64;d=d||[];7>l&&q(new sjcl.exception.invalid("ccm: iv must be at least 7 bytes"));for(f=2;4>f&&k>>>8*f;f++);f<15-l&&(f=15-l);c=h.clamp(c,8*(15-f));b=sjcl.mode.ccm.K(a,b,c,d,e,f);g=sjcl.mode.ccm.n(a,g,c,b,e,f);return h.concat(g.data,g.tag)},decrypt:function(a,b,c,d,e){e=e||64;d=d||[];var f=sjcl.bitArray,g=f.bitLength(c)/8,h=f.bitLength(b),l=f.clamp(b,h-e),k=f.bitSlice(b,
-h-e),h=(h-e)/8;7>g&&q(new sjcl.exception.invalid("ccm: iv must be at least 7 bytes"));for(b=2;4>b&&h>>>8*b;b++);b<15-g&&(b=15-g);c=f.clamp(c,8*(15-b));l=sjcl.mode.ccm.n(a,l,c,k,e,b);a=sjcl.mode.ccm.K(a,l.data,c,d,e,b);f.equal(l.tag,a)||q(new sjcl.exception.corrupt("ccm: tag doesn't match"));return l.data},K:function(a,b,c,d,e,f){var g=[],h=sjcl.bitArray,l=h.k;e/=8;(e%2||4>e||16<e)&&q(new sjcl.exception.invalid("ccm: invalid tag length"));(0xffffffff<d.length||0xffffffff<b.length)&&q(new sjcl.exception.bug("ccm: can't deal with 4GiB or more data"));
-f=[h.partial(8,(d.length?64:0)|e-2<<2|f-1)];f=h.concat(f,c);f[3]|=h.bitLength(b)/8;f=a.encrypt(f);if(d.length){c=h.bitLength(d)/8;65279>=c?g=[h.partial(16,c)]:0xffffffff>=c&&(g=h.concat([h.partial(16,65534)],[c]));g=h.concat(g,d);for(d=0;d<g.length;d+=4)f=a.encrypt(l(f,g.slice(d,d+4).concat([0,0,0])))}for(d=0;d<b.length;d+=4)f=a.encrypt(l(f,b.slice(d,d+4).concat([0,0,0])));return h.clamp(f,8*e)},n:function(a,b,c,d,e,f){var g,h=sjcl.bitArray;g=h.k;var l=b.length,k=h.bitLength(b);c=h.concat([h.partial(8,
+sjcl.mode.ccm={name:"ccm",encrypt:function(a,b,c,d,e){var f,g=b.slice(0),h=sjcl.bitArray,l=h.bitLength(c)/8,k=h.bitLength(g)/8;e=e||64;d=d||[];7>l&&q(new sjcl.exception.invalid("ccm: iv must be at least 7 bytes"));for(f=2;4>f&&k>>>8*f;f++);f<15-l&&(f=15-l);c=h.clamp(c,8*(15-f));b=sjcl.mode.ccm.L(a,b,c,d,e,f);g=sjcl.mode.ccm.p(a,g,c,b,e,f);return h.concat(g.data,g.tag)},decrypt:function(a,b,c,d,e){e=e||64;d=d||[];var f=sjcl.bitArray,g=f.bitLength(c)/8,h=f.bitLength(b),l=f.clamp(b,h-e),k=f.bitSlice(b,
+h-e),h=(h-e)/8;7>g&&q(new sjcl.exception.invalid("ccm: iv must be at least 7 bytes"));for(b=2;4>b&&h>>>8*b;b++);b<15-g&&(b=15-g);c=f.clamp(c,8*(15-b));l=sjcl.mode.ccm.p(a,l,c,k,e,b);a=sjcl.mode.ccm.L(a,l.data,c,d,e,b);f.equal(l.tag,a)||q(new sjcl.exception.corrupt("ccm: tag doesn't match"));return l.data},L:function(a,b,c,d,e,f){var g=[],h=sjcl.bitArray,l=h.l;e/=8;(e%2||4>e||16<e)&&q(new sjcl.exception.invalid("ccm: invalid tag length"));(0xffffffff<d.length||0xffffffff<b.length)&&q(new sjcl.exception.bug("ccm: can't deal with 4GiB or more data"));
+f=[h.partial(8,(d.length?64:0)|e-2<<2|f-1)];f=h.concat(f,c);f[3]|=h.bitLength(b)/8;f=a.encrypt(f);if(d.length){c=h.bitLength(d)/8;65279>=c?g=[h.partial(16,c)]:0xffffffff>=c&&(g=h.concat([h.partial(16,65534)],[c]));g=h.concat(g,d);for(d=0;d<g.length;d+=4)f=a.encrypt(l(f,g.slice(d,d+4).concat([0,0,0])))}for(d=0;d<b.length;d+=4)f=a.encrypt(l(f,b.slice(d,d+4).concat([0,0,0])));return h.clamp(f,8*e)},p:function(a,b,c,d,e,f){var g,h=sjcl.bitArray;g=h.l;var l=b.length,k=h.bitLength(b);c=h.concat([h.partial(8,
 f-1)],c).concat([0,0,0]).slice(0,4);d=h.bitSlice(g(d,a.encrypt(c)),0,e);if(!l)return{tag:d,data:[]};for(g=0;g<l;g+=4)c[3]++,e=a.encrypt(c),b[g]^=e[0],b[g+1]^=e[1],b[g+2]^=e[2],b[g+3]^=e[3];return{tag:d,data:h.clamp(b,k)}}};
-sjcl.mode.ocb2={name:"ocb2",encrypt:function(a,b,c,d,e,f){128!==sjcl.bitArray.bitLength(c)&&q(new sjcl.exception.invalid("ocb iv must be 128 bits"));var g,h=sjcl.mode.ocb2.G,l=sjcl.bitArray,k=l.k,n=[0,0,0,0];c=h(a.encrypt(c));var m,p=[];d=d||[];e=e||64;for(g=0;g+4<b.length;g+=4)m=b.slice(g,g+4),n=k(n,m),p=p.concat(k(c,a.encrypt(k(c,m)))),c=h(c);m=b.slice(g);b=l.bitLength(m);g=a.encrypt(k(c,[0,0,0,b]));m=l.clamp(k(m.concat([0,0,0]),g),b);n=k(n,k(m.concat([0,0,0]),g));n=a.encrypt(k(n,k(c,h(c))));d.length&&
-(n=k(n,f?d:sjcl.mode.ocb2.pmac(a,d)));return p.concat(l.concat(m,l.clamp(n,e)))},decrypt:function(a,b,c,d,e,f){128!==sjcl.bitArray.bitLength(c)&&q(new sjcl.exception.invalid("ocb iv must be 128 bits"));e=e||64;var g=sjcl.mode.ocb2.G,h=sjcl.bitArray,l=h.k,k=[0,0,0,0],n=g(a.encrypt(c)),m,p,s=sjcl.bitArray.bitLength(b)-e,r=[];d=d||[];for(c=0;c+4<s/32;c+=4)m=l(n,a.decrypt(l(n,b.slice(c,c+4)))),k=l(k,m),r=r.concat(m),n=g(n);p=s-32*c;m=a.encrypt(l(n,[0,0,0,p]));m=l(m,h.clamp(b.slice(c),p).concat([0,0,0]));
-k=l(k,m);k=a.encrypt(l(k,l(n,g(n))));d.length&&(k=l(k,f?d:sjcl.mode.ocb2.pmac(a,d)));h.equal(h.clamp(k,e),h.bitSlice(b,s))||q(new sjcl.exception.corrupt("ocb: tag doesn't match"));return r.concat(h.clamp(m,p))},pmac:function(a,b){var c,d=sjcl.mode.ocb2.G,e=sjcl.bitArray,f=e.k,g=[0,0,0,0],h=a.encrypt([0,0,0,0]),h=f(h,d(d(h)));for(c=0;c+4<b.length;c+=4)h=d(h),g=f(g,a.encrypt(f(h,b.slice(c,c+4))));c=b.slice(c);128>e.bitLength(c)&&(h=f(h,d(h)),c=e.concat(c,[-2147483648,0,0,0]));g=f(g,c);return a.encrypt(f(d(f(h,
-d(h))),g))},G:function(a){return[a[0]<<1^a[1]>>>31,a[1]<<1^a[2]>>>31,a[2]<<1^a[3]>>>31,a[3]<<1^135*(a[0]>>>31)]}};
-sjcl.mode.gcm={name:"gcm",encrypt:function(a,b,c,d,e){var f=b.slice(0);b=sjcl.bitArray;d=d||[];a=sjcl.mode.gcm.n(!0,a,f,d,c,e||128);return b.concat(a.data,a.tag)},decrypt:function(a,b,c,d,e){var f=b.slice(0),g=sjcl.bitArray,h=g.bitLength(f);e=e||128;d=d||[];e<=h?(b=g.bitSlice(f,h-e),f=g.bitSlice(f,0,h-e)):(b=f,f=[]);a=sjcl.mode.gcm.n(u,a,f,d,c,e);g.equal(a.tag,b)||q(new sjcl.exception.corrupt("gcm: tag doesn't match"));return a.data},U:function(a,b){var c,d,e,f,g,h=sjcl.bitArray.k;e=[0,0,0,0];f=b.slice(0);
-for(c=0;128>c;c++){(d=0!==(a[Math.floor(c/32)]&1<<31-c%32))&&(e=h(e,f));g=0!==(f[3]&1);for(d=3;0<d;d--)f[d]=f[d]>>>1|(f[d-1]&1)<<31;f[0]>>>=1;g&&(f[0]^=-0x1f000000)}return e},f:function(a,b,c){var d,e=c.length;b=b.slice(0);for(d=0;d<e;d+=4)b[0]^=0xffffffff&c[d],b[1]^=0xffffffff&c[d+1],b[2]^=0xffffffff&c[d+2],b[3]^=0xffffffff&c[d+3],b=sjcl.mode.gcm.U(b,a);return b},n:function(a,b,c,d,e,f){var g,h,l,k,n,m,p,s,r=sjcl.bitArray;m=c.length;p=r.bitLength(c);s=r.bitLength(d);h=r.bitLength(e);g=b.encrypt([0,
-0,0,0]);96===h?(e=e.slice(0),e=r.concat(e,[1])):(e=sjcl.mode.gcm.f(g,[0,0,0,0],e),e=sjcl.mode.gcm.f(g,e,[0,0,Math.floor(h/0x100000000),h&0xffffffff]));h=sjcl.mode.gcm.f(g,[0,0,0,0],d);n=e.slice(0);d=h.slice(0);a||(d=sjcl.mode.gcm.f(g,h,c));for(k=0;k<m;k+=4)n[3]++,l=b.encrypt(n),c[k]^=l[0],c[k+1]^=l[1],c[k+2]^=l[2],c[k+3]^=l[3];c=r.clamp(c,p);a&&(d=sjcl.mode.gcm.f(g,h,c));a=[Math.floor(s/0x100000000),s&0xffffffff,Math.floor(p/0x100000000),p&0xffffffff];d=sjcl.mode.gcm.f(g,d,a);l=b.encrypt(e);d[0]^=l[0];
-d[1]^=l[1];d[2]^=l[2];d[3]^=l[3];return{tag:r.bitSlice(d,0,f),data:c}}};sjcl.misc.hmac=function(a,b){this.L=b=b||sjcl.hash.sha256;var c=[[],[]],d,e=b.prototype.blockSize/32;this.o=[new b,new b];a.length>e&&(a=b.hash(a));for(d=0;d<e;d++)c[0][d]=a[d]^909522486,c[1][d]=a[d]^1549556828;this.o[0].update(c[0]);this.o[1].update(c[1])};sjcl.misc.hmac.prototype.encrypt=sjcl.misc.hmac.prototype.mac=function(a){a=(new this.L(this.o[0])).update(a).finalize();return(new this.L(this.o[1])).update(a).finalize()};
-sjcl.misc.pbkdf2=function(a,b,c,d,e){c=c||1E3;(0>d||0>c)&&q(sjcl.exception.invalid("invalid params to pbkdf2"));"string"===typeof a&&(a=sjcl.codec.utf8String.toBits(a));e=e||sjcl.misc.hmac;a=new e(a);var f,g,h,l,k=[],n=sjcl.bitArray;for(l=1;32*k.length<(d||1);l++){e=f=a.encrypt(n.concat(b,[l]));for(g=1;g<c;g++){f=a.encrypt(f);for(h=0;h<f.length;h++)e[h]^=f[h]}k=k.concat(e)}d&&(k=n.clamp(k,d));return k};
-sjcl.prng=function(a){this.b=[new sjcl.hash.sha256];this.h=[0];this.F=0;this.t={};this.C=0;this.J={};this.N=this.c=this.i=this.T=0;this.a=[0,0,0,0,0,0,0,0];this.e=[0,0,0,0];this.A=t;this.B=a;this.p=u;this.z={progress:{},seeded:{}};this.l=this.S=0;this.u=1;this.w=2;this.Q=0x10000;this.H=[0,48,64,96,128,192,0x100,384,512,768,1024];this.R=3E4;this.P=80};
-sjcl.prng.prototype={randomWords:function(a,b){var c=[],d;d=this.isReady(b);var e;d===this.l&&q(new sjcl.exception.notReady("generator isn't seeded"));if(d&this.w){d=!(d&this.u);e=[];var f=0,g;this.N=e[0]=(new Date).valueOf()+this.R;for(g=0;16>g;g++)e.push(0x100000000*Math.random()|0);for(g=0;g<this.b.length&&!(e=e.concat(this.b[g].finalize()),f+=this.h[g],this.h[g]=0,!d&&this.F&1<<g);g++);this.F>=1<<this.b.length&&(this.b.push(new sjcl.hash.sha256),this.h.push(0));this.c-=f;f>this.i&&(this.i=f);this.F++;
-this.a=sjcl.hash.sha256.hash(this.a.concat(e));this.A=new sjcl.cipher.aes(this.a);for(d=0;4>d&&!(this.e[d]=this.e[d]+1|0,this.e[d]);d++);}for(d=0;d<a;d+=4)0===(d+1)%this.Q&&A(this),e=B(this),c.push(e[0],e[1],e[2],e[3]);A(this);return c.slice(0,a)},setDefaultParanoia:function(a){this.B=a},addEntropy:function(a,b,c){c=c||"user";var d,e,f=(new Date).valueOf(),g=this.t[c],h=this.isReady(),l=0;d=this.J[c];d===t&&(d=this.J[c]=this.T++);g===t&&(g=this.t[c]=0);this.t[c]=(this.t[c]+1)%this.b.length;switch(typeof a){case "number":b===
-t&&(b=1);this.b[g].update([d,this.C++,1,b,f,1,a|0]);break;case "object":c=Object.prototype.toString.call(a);if("[object Uint32Array]"===c){e=[];for(c=0;c<a.length;c++)e.push(a[c]);a=e}else{"[object Array]"!==c&&(l=1);for(c=0;c<a.length&&!l;c++)"number"!=typeof a[c]&&(l=1)}if(!l){if(b===t)for(c=b=0;c<a.length;c++)for(e=a[c];0<e;)b++,e>>>=1;this.b[g].update([d,this.C++,2,b,f,a.length].concat(a))}break;case "string":b===t&&(b=a.length);this.b[g].update([d,this.C++,3,b,f,a.length]);this.b[g].update(a);
-break;default:l=1}l&&q(new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string"));this.h[g]+=b;this.c+=b;h===this.l&&(this.isReady()!==this.l&&C("seeded",Math.max(this.i,this.c)),C("progress",this.getProgress()))},isReady:function(a){a=this.H[a!==t?a:this.B];return this.i&&this.i>=a?this.h[0]>this.P&&(new Date).valueOf()>this.N?this.w|this.u:this.u:this.c>=a?this.w|this.l:this.l},getProgress:function(a){a=this.H[a?a:this.B];return this.i>=a?1:this.c>a?1:this.c/
-a},startCollectors:function(){this.p||(window.addEventListener?(window.addEventListener("load",this.r,u),window.addEventListener("mousemove",this.s,u)):document.attachEvent?(document.attachEvent("onload",this.r),document.attachEvent("onmousemove",this.s)):q(new sjcl.exception.bug("can't attach event")),this.p=!0)},stopCollectors:function(){this.p&&(window.removeEventListener?(window.removeEventListener("load",this.r,u),window.removeEventListener("mousemove",this.s,u)):window.detachEvent&&(window.detachEvent("onload",
-this.r),window.detachEvent("onmousemove",this.s)),this.p=u)},addEventListener:function(a,b){this.z[a][this.S++]=b},removeEventListener:function(a,b){var c,d,e=this.z[a],f=[];for(d in e)e.hasOwnProperty(d)&&e[d]===b&&f.push(d);for(c=0;c<f.length;c++)d=f[c],delete e[d]},s:function(a){sjcl.random.addEntropy([a.x||a.clientX||a.offsetX||0,a.y||a.clientY||a.offsetY||0],2,"mouse")},r:function(){sjcl.random.addEntropy((new Date).valueOf(),2,"loadtime")}};
-function C(a,b){var c,d=sjcl.random.z[a],e=[];for(c in d)d.hasOwnProperty(c)&&e.push(d[c]);for(c=0;c<e.length;c++)e[c](b)}function A(a){a.a=B(a).concat(B(a));a.A=new sjcl.cipher.aes(a.a)}function B(a){for(var b=0;4>b&&!(a.e[b]=a.e[b]+1|0,a.e[b]);b++);return a.A.encrypt(a.e)}sjcl.random=new sjcl.prng(6);try{var D=new Uint32Array(32);crypto.getRandomValues(D);sjcl.random.addEntropy(D,1024,"crypto['getRandomValues']")}catch(E){}
-sjcl.json={defaults:{v:1,iter:1E3,ks:128,ts:64,mode:"ccm",adata:"",cipher:"aes"},encrypt:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json,f=e.d({iv:sjcl.random.randomWords(4,0)},e.defaults),g;e.d(f,c);c=f.adata;"string"===typeof f.salt&&(f.salt=sjcl.codec.base64.toBits(f.salt));"string"===typeof f.iv&&(f.iv=sjcl.codec.base64.toBits(f.iv));(!sjcl.mode[f.mode]||!sjcl.cipher[f.cipher]||"string"===typeof a&&100>=f.iter||64!==f.ts&&96!==f.ts&&128!==f.ts||128!==f.ks&&192!==f.ks&&0x100!==f.ks||2>f.iv.length||
-4<f.iv.length)&&q(new sjcl.exception.invalid("json encrypt: invalid parameters"));"string"===typeof a?(g=sjcl.misc.cachedPbkdf2(a,f),a=g.key.slice(0,f.ks/32),f.salt=g.salt):sjcl.ecc&&a instanceof sjcl.ecc.elGamal.publicKey&&(g=a.kem(),f.kemtag=g.tag,a=g.key.slice(0,f.ks/32));"string"===typeof b&&(b=sjcl.codec.utf8String.toBits(b));"string"===typeof c&&(c=sjcl.codec.utf8String.toBits(c));g=new sjcl.cipher[f.cipher](a);e.d(d,f);d.key=a;f.ct=sjcl.mode[f.mode].encrypt(g,b,f.iv,c,f.ts);return e.encode(f)},
-decrypt:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json;b=e.d(e.d(e.d({},e.defaults),e.decode(b)),c,!0);var f;c=b.adata;"string"===typeof b.salt&&(b.salt=sjcl.codec.base64.toBits(b.salt));"string"===typeof b.iv&&(b.iv=sjcl.codec.base64.toBits(b.iv));(!sjcl.mode[b.mode]||!sjcl.cipher[b.cipher]||"string"===typeof a&&100>=b.iter||64!==b.ts&&96!==b.ts&&128!==b.ts||128!==b.ks&&192!==b.ks&&0x100!==b.ks||!b.iv||2>b.iv.length||4<b.iv.length)&&q(new sjcl.exception.invalid("json decrypt: invalid parameters"));
-"string"===typeof a?(f=sjcl.misc.cachedPbkdf2(a,b),a=f.key.slice(0,b.ks/32),b.salt=f.salt):sjcl.ecc&&a instanceof sjcl.ecc.elGamal.secretKey&&(a=a.unkem(sjcl.codec.base64.toBits(b.kemtag)).slice(0,b.ks/32));"string"===typeof c&&(c=sjcl.codec.utf8String.toBits(c));f=new sjcl.cipher[b.cipher](a);c=sjcl.mode[b.mode].decrypt(f,b.ct,b.iv,c,b.ts);e.d(d,b);d.key=a;return sjcl.codec.utf8String.fromBits(c)},encode:function(a){var b,c="{",d="";for(b in a)if(a.hasOwnProperty(b))switch(b.match(/^[a-z0-9]+$/i)||
-q(new sjcl.exception.invalid("json encode: invalid property name")),c+=d+'"'+b+'":',d=",",typeof a[b]){case "number":case "boolean":c+=a[b];break;case "string":c+='"'+escape(a[b])+'"';break;case "object":c+='"'+sjcl.codec.base64.fromBits(a[b],0)+'"';break;default:q(new sjcl.exception.bug("json encode: unsupported type"))}return c+"}"},decode:function(a){a=a.replace(/\s/g,"");a.match(/^\{.*\}$/)||q(new sjcl.exception.invalid("json decode: this isn't json!"));a=a.replace(/^\{|\}$/g,"").split(/,/);var b=
-{},c,d;for(c=0;c<a.length;c++)(d=a[c].match(/^(?:(["']?)([a-z][a-z0-9]*)\1):(?:(\d+)|"([a-z0-9+\/%*_.@=\-]*)")$/i))||q(new sjcl.exception.invalid("json decode: this isn't json!")),b[d[2]]=d[3]?parseInt(d[3],10):d[2].match(/^(ct|salt|iv)$/)?sjcl.codec.base64.toBits(d[4]):unescape(d[4]);return b},d:function(a,b,c){a===t&&(a={});if(b===t)return a;for(var d in b)b.hasOwnProperty(d)&&(c&&(a[d]!==t&&a[d]!==b[d])&&q(new sjcl.exception.invalid("required parameter overridden")),a[d]=b[d]);return a},X:function(a,
-b){var c={},d;for(d in a)a.hasOwnProperty(d)&&a[d]!==b[d]&&(c[d]=a[d]);return c},W:function(a,b){var c={},d;for(d=0;d<b.length;d++)a[b[d]]!==t&&(c[b[d]]=a[b[d]]);return c}};sjcl.encrypt=sjcl.json.encrypt;sjcl.decrypt=sjcl.json.decrypt;sjcl.misc.V={};
-sjcl.misc.cachedPbkdf2=function(a,b){var c=sjcl.misc.V,d;b=b||{};d=b.iter||1E3;c=c[a]=c[a]||{};d=c[d]=c[d]||{firstSalt:b.salt&&b.salt.length?b.salt.slice(0):sjcl.random.randomWords(2,0)};c=b.salt===t?d.firstSalt:b.salt;d[c]=d[c]||sjcl.misc.pbkdf2(a,c,b.iter);return{key:d[c].slice(0),salt:c.slice(0)}};
+sjcl.mode.ocb2={name:"ocb2",encrypt:function(a,b,c,d,e,f){128!==sjcl.bitArray.bitLength(c)&&q(new sjcl.exception.invalid("ocb iv must be 128 bits"));var g,h=sjcl.mode.ocb2.H,l=sjcl.bitArray,k=l.l,n=[0,0,0,0];c=h(a.encrypt(c));var m,p=[];d=d||[];e=e||64;for(g=0;g+4<b.length;g+=4)m=b.slice(g,g+4),n=k(n,m),p=p.concat(k(c,a.encrypt(k(c,m)))),c=h(c);m=b.slice(g);b=l.bitLength(m);g=a.encrypt(k(c,[0,0,0,b]));m=l.clamp(k(m.concat([0,0,0]),g),b);n=k(n,k(m.concat([0,0,0]),g));n=a.encrypt(k(n,k(c,h(c))));d.length&&
+(n=k(n,f?d:sjcl.mode.ocb2.pmac(a,d)));return p.concat(l.concat(m,l.clamp(n,e)))},decrypt:function(a,b,c,d,e,f){128!==sjcl.bitArray.bitLength(c)&&q(new sjcl.exception.invalid("ocb iv must be 128 bits"));e=e||64;var g=sjcl.mode.ocb2.H,h=sjcl.bitArray,l=h.l,k=[0,0,0,0],n=g(a.encrypt(c)),m,p,s=sjcl.bitArray.bitLength(b)-e,r=[];d=d||[];for(c=0;c+4<s/32;c+=4)m=l(n,a.decrypt(l(n,b.slice(c,c+4)))),k=l(k,m),r=r.concat(m),n=g(n);p=s-32*c;m=a.encrypt(l(n,[0,0,0,p]));m=l(m,h.clamp(b.slice(c),p).concat([0,0,0]));
+k=l(k,m);k=a.encrypt(l(k,l(n,g(n))));d.length&&(k=l(k,f?d:sjcl.mode.ocb2.pmac(a,d)));h.equal(h.clamp(k,e),h.bitSlice(b,s))||q(new sjcl.exception.corrupt("ocb: tag doesn't match"));return r.concat(h.clamp(m,p))},pmac:function(a,b){var c,d=sjcl.mode.ocb2.H,e=sjcl.bitArray,f=e.l,g=[0,0,0,0],h=a.encrypt([0,0,0,0]),h=f(h,d(d(h)));for(c=0;c+4<b.length;c+=4)h=d(h),g=f(g,a.encrypt(f(h,b.slice(c,c+4))));c=b.slice(c);128>e.bitLength(c)&&(h=f(h,d(h)),c=e.concat(c,[-2147483648,0,0,0]));g=f(g,c);return a.encrypt(f(d(f(h,
+d(h))),g))},H:function(a){return[a[0]<<1^a[1]>>>31,a[1]<<1^a[2]>>>31,a[2]<<1^a[3]>>>31,a[3]<<1^135*(a[0]>>>31)]}};
+sjcl.mode.gcm={name:"gcm",encrypt:function(a,b,c,d,e){var f=b.slice(0);b=sjcl.bitArray;d=d||[];a=sjcl.mode.gcm.p(!0,a,f,d,c,e||128);return b.concat(a.data,a.tag)},decrypt:function(a,b,c,d,e){var f=b.slice(0),g=sjcl.bitArray,h=g.bitLength(f);e=e||128;d=d||[];e<=h?(b=g.bitSlice(f,h-e),f=g.bitSlice(f,0,h-e)):(b=f,f=[]);a=sjcl.mode.gcm.p(u,a,f,d,c,e);g.equal(a.tag,b)||q(new sjcl.exception.corrupt("gcm: tag doesn't match"));return a.data},Z:function(a,b){var c,d,e,f,g,h=sjcl.bitArray.l;e=[0,0,0,0];f=b.slice(0);
+for(c=0;128>c;c++){(d=0!==(a[Math.floor(c/32)]&1<<31-c%32))&&(e=h(e,f));g=0!==(f[3]&1);for(d=3;0<d;d--)f[d]=f[d]>>>1|(f[d-1]&1)<<31;f[0]>>>=1;g&&(f[0]^=-0x1f000000)}return e},g:function(a,b,c){var d,e=c.length;b=b.slice(0);for(d=0;d<e;d+=4)b[0]^=0xffffffff&c[d],b[1]^=0xffffffff&c[d+1],b[2]^=0xffffffff&c[d+2],b[3]^=0xffffffff&c[d+3],b=sjcl.mode.gcm.Z(b,a);return b},p:function(a,b,c,d,e,f){var g,h,l,k,n,m,p,s,r=sjcl.bitArray;m=c.length;p=r.bitLength(c);s=r.bitLength(d);h=r.bitLength(e);g=b.encrypt([0,
+0,0,0]);96===h?(e=e.slice(0),e=r.concat(e,[1])):(e=sjcl.mode.gcm.g(g,[0,0,0,0],e),e=sjcl.mode.gcm.g(g,e,[0,0,Math.floor(h/0x100000000),h&0xffffffff]));h=sjcl.mode.gcm.g(g,[0,0,0,0],d);n=e.slice(0);d=h.slice(0);a||(d=sjcl.mode.gcm.g(g,h,c));for(k=0;k<m;k+=4)n[3]++,l=b.encrypt(n),c[k]^=l[0],c[k+1]^=l[1],c[k+2]^=l[2],c[k+3]^=l[3];c=r.clamp(c,p);a&&(d=sjcl.mode.gcm.g(g,h,c));a=[Math.floor(s/0x100000000),s&0xffffffff,Math.floor(p/0x100000000),p&0xffffffff];d=sjcl.mode.gcm.g(g,d,a);l=b.encrypt(e);d[0]^=l[0];
+d[1]^=l[1];d[2]^=l[2];d[3]^=l[3];return{tag:r.bitSlice(d,0,f),data:c}}};sjcl.misc.hmac=function(a,b){this.M=b=b||sjcl.hash.sha256;var c=[[],[]],d,e=b.prototype.blockSize/32;this.n=[new b,new b];a.length>e&&(a=b.hash(a));for(d=0;d<e;d++)c[0][d]=a[d]^909522486,c[1][d]=a[d]^1549556828;this.n[0].update(c[0]);this.n[1].update(c[1]);this.G=new b(this.n[0])};
+sjcl.misc.hmac.prototype.encrypt=sjcl.misc.hmac.prototype.mac=function(a){this.Q&&q(new sjcl.exception.invalid("encrypt on already updated hmac called!"));this.update(a);return this.digest(a)};sjcl.misc.hmac.prototype.reset=function(){this.G=new this.M(this.n[0]);this.Q=u};sjcl.misc.hmac.prototype.update=function(a){this.Q=!0;this.G.update(a)};sjcl.misc.hmac.prototype.digest=function(){var a=this.G.finalize(),a=(new this.M(this.n[1])).update(a).finalize();this.reset();return a};
+sjcl.misc.pbkdf2=function(a,b,c,d,e){c=c||1E3;(0>d||0>c)&&q(sjcl.exception.invalid("invalid params to pbkdf2"));"string"===typeof a&&(a=sjcl.codec.utf8String.toBits(a));"string"===typeof b&&(b=sjcl.codec.utf8String.toBits(b));e=e||sjcl.misc.hmac;a=new e(a);var f,g,h,l,k=[],n=sjcl.bitArray;for(l=1;32*k.length<(d||1);l++){e=f=a.encrypt(n.concat(b,[l]));for(g=1;g<c;g++){f=a.encrypt(f);for(h=0;h<f.length;h++)e[h]^=f[h]}k=k.concat(e)}d&&(k=n.clamp(k,d));return k};
+sjcl.prng=function(a){this.c=[new sjcl.hash.sha256];this.i=[0];this.F=0;this.s={};this.C=0;this.K={};this.O=this.d=this.j=this.W=0;this.b=[0,0,0,0,0,0,0,0];this.f=[0,0,0,0];this.A=t;this.B=a;this.q=u;this.w={progress:{},seeded:{}};this.m=this.V=0;this.t=1;this.u=2;this.S=0x10000;this.I=[0,48,64,96,128,192,0x100,384,512,768,1024];this.T=3E4;this.R=80};
+sjcl.prng.prototype={randomWords:function(a,b){var c=[],d;d=this.isReady(b);var e;d===this.m&&q(new sjcl.exception.notReady("generator isn't seeded"));if(d&this.u){d=!(d&this.t);e=[];var f=0,g;this.O=e[0]=(new Date).valueOf()+this.T;for(g=0;16>g;g++)e.push(0x100000000*Math.random()|0);for(g=0;g<this.c.length&&!(e=e.concat(this.c[g].finalize()),f+=this.i[g],this.i[g]=0,!d&&this.F&1<<g);g++);this.F>=1<<this.c.length&&(this.c.push(new sjcl.hash.sha256),this.i.push(0));this.d-=f;f>this.j&&(this.j=f);this.F++;
+this.b=sjcl.hash.sha256.hash(this.b.concat(e));this.A=new sjcl.cipher.aes(this.b);for(d=0;4>d&&!(this.f[d]=this.f[d]+1|0,this.f[d]);d++);}for(d=0;d<a;d+=4)0===(d+1)%this.S&&A(this),e=B(this),c.push(e[0],e[1],e[2],e[3]);A(this);return c.slice(0,a)},setDefaultParanoia:function(a,b){0===a&&"Setting paranoia=0 will ruin your security; use it only for testing"!==b&&q("Setting paranoia=0 will ruin your security; use it only for testing");this.B=a},addEntropy:function(a,b,c){c=c||"user";var d,e,f=(new Date).valueOf(),
+g=this.s[c],h=this.isReady(),l=0;d=this.K[c];d===t&&(d=this.K[c]=this.W++);g===t&&(g=this.s[c]=0);this.s[c]=(this.s[c]+1)%this.c.length;switch(typeof a){case "number":b===t&&(b=1);this.c[g].update([d,this.C++,1,b,f,1,a|0]);break;case "object":c=Object.prototype.toString.call(a);if("[object Uint32Array]"===c){e=[];for(c=0;c<a.length;c++)e.push(a[c]);a=e}else{"[object Array]"!==c&&(l=1);for(c=0;c<a.length&&!l;c++)"number"!==typeof a[c]&&(l=1)}if(!l){if(b===t)for(c=b=0;c<a.length;c++)for(e=a[c];0<e;)b++,
+e>>>=1;this.c[g].update([d,this.C++,2,b,f,a.length].concat(a))}break;case "string":b===t&&(b=a.length);this.c[g].update([d,this.C++,3,b,f,a.length]);this.c[g].update(a);break;default:l=1}l&&q(new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string"));this.i[g]+=b;this.d+=b;h===this.m&&(this.isReady()!==this.m&&C("seeded",Math.max(this.j,this.d)),C("progress",this.getProgress()))},isReady:function(a){a=this.I[a!==t?a:this.B];return this.j&&this.j>=a?this.i[0]>this.R&&
+(new Date).valueOf()>this.O?this.u|this.t:this.t:this.d>=a?this.u|this.m:this.m},getProgress:function(a){a=this.I[a?a:this.B];return this.j>=a?1:this.d>a?1:this.d/a},startCollectors:function(){this.q||(this.a={loadTimeCollector:D(this,this.aa),mouseCollector:D(this,this.ba),keyboardCollector:D(this,this.$),accelerometerCollector:D(this,this.U)},window.addEventListener?(window.addEventListener("load",this.a.loadTimeCollector,u),window.addEventListener("mousemove",this.a.mouseCollector,u),window.addEventListener("keypress",
+this.a.keyboardCollector,u),window.addEventListener("devicemotion",this.a.accelerometerCollector,u)):document.attachEvent?(document.attachEvent("onload",this.a.loadTimeCollector),document.attachEvent("onmousemove",this.a.mouseCollector),document.attachEvent("keypress",this.a.keyboardCollector)):q(new sjcl.exception.bug("can't attach event")),this.q=!0)},stopCollectors:function(){this.q&&(window.removeEventListener?(window.removeEventListener("load",this.a.loadTimeCollector,u),window.removeEventListener("mousemove",
+this.a.mouseCollector,u),window.removeEventListener("keypress",this.a.keyboardCollector,u),window.removeEventListener("devicemotion",this.a.accelerometerCollector,u)):document.detachEvent&&(document.detachEvent("onload",this.a.loadTimeCollector),document.detachEvent("onmousemove",this.a.mouseCollector),document.detachEvent("keypress",this.a.keyboardCollector)),this.q=u)},addEventListener:function(a,b){this.w[a][this.V++]=b},removeEventListener:function(a,b){var c,d,e=this.w[a],f=[];for(d in e)e.hasOwnProperty(d)&&
+e[d]===b&&f.push(d);for(c=0;c<f.length;c++)d=f[c],delete e[d]},$:function(){E(1)},ba:function(a){var b,c;try{b=a.x||a.clientX||a.offsetX||0,c=a.y||a.clientY||a.offsetY||0}catch(d){c=b=0}0!=b&&0!=c&&sjcl.random.addEntropy([b,c],2,"mouse");E(0)},aa:function(){E(2)},U:function(a){a=a.accelerationIncludingGravity.x||a.accelerationIncludingGravity.y||a.accelerationIncludingGravity.z;if(window.orientation){var b=window.orientation;"number"===typeof b&&sjcl.random.addEntropy(b,1,"accelerometer")}a&&sjcl.random.addEntropy(a,
+2,"accelerometer");E(0)}};function C(a,b){var c,d=sjcl.random.w[a],e=[];for(c in d)d.hasOwnProperty(c)&&e.push(d[c]);for(c=0;c<e.length;c++)e[c](b)}function E(a){"undefined"!==typeof window&&window.performance&&"function"===typeof window.performance.now?sjcl.random.addEntropy(window.performance.now(),a,"loadtime"):sjcl.random.addEntropy((new Date).valueOf(),a,"loadtime")}function A(a){a.b=B(a).concat(B(a));a.A=new sjcl.cipher.aes(a.b)}
+function B(a){for(var b=0;4>b&&!(a.f[b]=a.f[b]+1|0,a.f[b]);b++);return a.A.encrypt(a.f)}function D(a,b){return function(){b.apply(a,arguments)}}sjcl.random=new sjcl.prng(6);
+a:try{var F,G,H,I;if(I="undefined"!==typeof module){var J;if(J=module.exports){var K;try{K=require("crypto")}catch(L){K=null}J=(G=K)&&G.randomBytes}I=J}if(I)F=G.randomBytes(128),F=new Uint32Array((new Uint8Array(F)).buffer),sjcl.random.addEntropy(F,1024,"crypto['randomBytes']");else if("undefined"!==typeof window&&"undefined"!==typeof Uint32Array){H=new Uint32Array(32);if(window.crypto&&window.crypto.getRandomValues)window.crypto.getRandomValues(H);else if(window.msCrypto&&window.msCrypto.getRandomValues)window.msCrypto.getRandomValues(H);
+else break a;sjcl.random.addEntropy(H,1024,"crypto['getRandomValues']")}}catch(M){"undefined"!==typeof window&&window.console&&(console.log("There was an error collecting entropy from the browser:"),console.log(M))}
+sjcl.json={defaults:{v:1,iter:1E3,ks:128,ts:64,mode:"ccm",adata:"",cipher:"aes"},Y:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json,f=e.e({iv:sjcl.random.randomWords(4,0)},e.defaults),g;e.e(f,c);c=f.adata;"string"===typeof f.salt&&(f.salt=sjcl.codec.base64.toBits(f.salt));"string"===typeof f.iv&&(f.iv=sjcl.codec.base64.toBits(f.iv));(!sjcl.mode[f.mode]||!sjcl.cipher[f.cipher]||"string"===typeof a&&100>=f.iter||64!==f.ts&&96!==f.ts&&128!==f.ts||128!==f.ks&&192!==f.ks&&0x100!==f.ks||2>f.iv.length||4<
+f.iv.length)&&q(new sjcl.exception.invalid("json encrypt: invalid parameters"));"string"===typeof a?(g=sjcl.misc.cachedPbkdf2(a,f),a=g.key.slice(0,f.ks/32),f.salt=g.salt):sjcl.ecc&&a instanceof sjcl.ecc.elGamal.publicKey&&(g=a.kem(),f.kemtag=g.tag,a=g.key.slice(0,f.ks/32));"string"===typeof b&&(b=sjcl.codec.utf8String.toBits(b));"string"===typeof c&&(c=sjcl.codec.utf8String.toBits(c));g=new sjcl.cipher[f.cipher](a);e.e(d,f);d.key=a;f.ct=sjcl.mode[f.mode].encrypt(g,b,f.iv,c,f.ts);return f},encrypt:function(a,
+b,c,d){var e=sjcl.json,f=e.Y.apply(e,arguments);return e.encode(f)},X:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json;b=e.e(e.e(e.e({},e.defaults),b),c,!0);var f,g;f=b.adata;"string"===typeof b.salt&&(b.salt=sjcl.codec.base64.toBits(b.salt));"string"===typeof b.iv&&(b.iv=sjcl.codec.base64.toBits(b.iv));(!sjcl.mode[b.mode]||!sjcl.cipher[b.cipher]||"string"===typeof a&&100>=b.iter||64!==b.ts&&96!==b.ts&&128!==b.ts||128!==b.ks&&192!==b.ks&&0x100!==b.ks||!b.iv||2>b.iv.length||4<b.iv.length)&&q(new sjcl.exception.invalid("json decrypt: invalid parameters"));
+"string"===typeof a?(g=sjcl.misc.cachedPbkdf2(a,b),a=g.key.slice(0,b.ks/32),b.salt=g.salt):sjcl.ecc&&a instanceof sjcl.ecc.elGamal.secretKey&&(a=a.unkem(sjcl.codec.base64.toBits(b.kemtag)).slice(0,b.ks/32));"string"===typeof f&&(f=sjcl.codec.utf8String.toBits(f));g=new sjcl.cipher[b.cipher](a);f=sjcl.mode[b.mode].decrypt(g,b.ct,b.iv,f,b.ts);e.e(d,b);d.key=a;return 1===c.raw?f:sjcl.codec.utf8String.fromBits(f)},decrypt:function(a,b,c,d){var e=sjcl.json;return e.X(a,e.decode(b),c,d)},encode:function(a){var b,
+c="{",d="";for(b in a)if(a.hasOwnProperty(b))switch(b.match(/^[a-z0-9]+$/i)||q(new sjcl.exception.invalid("json encode: invalid property name")),c+=d+'"'+b+'":',d=",",typeof a[b]){case "number":case "boolean":c+=a[b];break;case "string":c+='"'+escape(a[b])+'"';break;case "object":c+='"'+sjcl.codec.base64.fromBits(a[b],0)+'"';break;default:q(new sjcl.exception.bug("json encode: unsupported type"))}return c+"}"},decode:function(a){a=a.replace(/\s/g,"");a.match(/^\{.*\}$/)||q(new sjcl.exception.invalid("json decode: this isn't json!"));
+a=a.replace(/^\{|\}$/g,"").split(/,/);var b={},c,d;for(c=0;c<a.length;c++)(d=a[c].match(/^(?:(["']?)([a-z][a-z0-9]*)\1):(?:(\d+)|"([a-z0-9+\/%*_.@=\-]*)")$/i))||q(new sjcl.exception.invalid("json decode: this isn't json!")),b[d[2]]=d[3]?parseInt(d[3],10):d[2].match(/^(ct|salt|iv)$/)?sjcl.codec.base64.toBits(d[4]):unescape(d[4]);return b},e:function(a,b,c){a===t&&(a={});if(b===t)return a;for(var d in b)b.hasOwnProperty(d)&&(c&&(a[d]!==t&&a[d]!==b[d])&&q(new sjcl.exception.invalid("required parameter overridden")),
+a[d]=b[d]);return a},ea:function(a,b){var c={},d;for(d in a)a.hasOwnProperty(d)&&a[d]!==b[d]&&(c[d]=a[d]);return c},da:function(a,b){var c={},d;for(d=0;d<b.length;d++)a[b[d]]!==t&&(c[b[d]]=a[b[d]]);return c}};sjcl.encrypt=sjcl.json.encrypt;sjcl.decrypt=sjcl.json.decrypt;sjcl.misc.ca={};
+sjcl.misc.cachedPbkdf2=function(a,b){var c=sjcl.misc.ca,d;b=b||{};d=b.iter||1E3;c=c[a]=c[a]||{};d=c[d]=c[d]||{firstSalt:b.salt&&b.salt.length?b.salt.slice(0):sjcl.random.randomWords(2,0)};c=b.salt===t?d.firstSalt:b.salt;d[c]=d[c]||sjcl.misc.pbkdf2(a,c,b.iter);return{key:d[c].slice(0),salt:c.slice(0)}};

src/js/sjcl/test/bitArray_test.js

@@ -0,0 +1,115 @@
+(function() {
+
+  function word2hex(w) {
+    return "0x" + ((w|0)+0xF00000000000).toString(16).substr(4);
+  }
+
+  var b0 = sjcl.bitArray.partial(1, 0);
+  var b1 = sjcl.bitArray.partial(1, 1);
+
+  function concatbits(s) {
+    var j, b, a = [];
+    for (j = 0; j < s.length; ++j) {
+      b = (s[j] == '1' ? b1 : b0);
+      a = sjcl.bitArray.concat(a, [b]);
+    }
+    return a;
+  }
+
+  new sjcl.test.TestCase("bitArray single bits", function (cb) {
+    if (!sjcl.bitArray) {
+      this.unimplemented();
+      cb && cb();
+      return;
+    }
+
+    this.require((b0|0) === (0x00000000|0), "bitstring '0': " + word2hex(b0));
+    this.require((b1|0) === (0x80000000|0), "bitstring '1': " + word2hex(b1));
+
+    cb && cb();
+  });
+
+  new sjcl.test.TestCase("bitArray concat small bitstrings", function (cb) {
+    if (!sjcl.bitArray) {
+      this.unimplemented();
+      cb && cb();
+      return;
+    }
+
+    var i, kat = sjcl.test.vector.bitArray.bits, tv, a, b, bitlen, t;
+    for (i=0; i<kat.length; i++) {
+      tv = kat[i];
+      a = concatbits(tv[0]);
+      bitlen = sjcl.bitArray.bitLength(a);
+      t = "bitstring '" + tv[0] + "': ";
+      this.require(1 === a.length, t + "array length is 1: " + a.length);
+      this.require(bitlen === tv[0].length, t + "length " + bitlen + " matches input length " + tv[0].length);
+      b = sjcl.bitArray.partial(tv[0].length, tv[1]);
+      this.require(a[0] === b, t + "array matches shifted number: " + word2hex(a[0]) + " == " + word2hex(b));
+      b = 0 | (a[0] >>> (32 - tv[0].length)); // unsigned shift, convert to signed word
+      this.require(b === (tv[1]|0), t + "array entry shifted is number: " + word2hex(b) + " == " + word2hex(tv[1]));
+    }
+
+    cb && cb();
+  });
+
+
+  new sjcl.test.TestCase("bitArray concat, slicing, shifting and clamping", function (cb) {
+    if (!sjcl.bitArray) {
+      this.unimplemented();
+      cb && cb();
+      return;
+    }
+
+    var i, j, kat = sjcl.test.vector.bitArray.slices, tv, a, a1, b, bitlen, t;
+    for (i=0; i<kat.length; i++) {
+      tv = kat[i];
+      a = [];
+      b = [];
+
+      bitlen = 0;
+      for (j=0; j<tv[0].length; j++) {
+        b[j] = concatbits(tv[0][j]);
+        a = sjcl.bitArray.concat(a, b[j]);
+        bitlen += tv[0][j].length;
+      }
+
+      // shift last array entry and set partial length on it
+      a1 = tv[1]; a1 = a1.slice(0, a1.length);
+      bitlen &= 31;
+      if (0 !== bitlen) a1[a1.length-1] = sjcl.bitArray.partial(bitlen, a1[a1.length-1]);
+
+      this.require(sjcl.bitArray.equal(a, a1), "concat: [" + a + "] == [" + a1 + "]");
+
+      t = 0;
+      for (j=0; j<tv[0].length; j++) {
+        bitlen = sjcl.bitArray.bitLength(b[j]);
+        this.require(bitlen === tv[0][j].length, "bitstring length");
+        a1 = sjcl.bitArray.bitSlice(a, t, t + bitlen);
+        this.require(sjcl.bitArray.equal(b[j], a1), "slice after concat: [" + b[j] + "] == [" + a1 + "]");
+        t += bitlen;
+      }
+    }
+
+    cb && cb();
+  });
+
+  new sjcl.test.TestCase("bitArray byteswap", function (cb) {
+    if (!sjcl.bitArray) {
+      this.unimplemented();
+      cb && cb();
+      return;
+    }
+
+    var i, kat = sjcl.test.vector.bitArray.byteswap, tv, a;
+    for (i=0; i<kat.length; i++) {
+      tv = kat[i];
+
+      a = tv[1];
+      this.require(sjcl.bitArray.equal(tv[0], sjcl.bitArray.byteswapM(a.slice(0, a.length))));
+    }
+
+    cb && cb();
+  });
+
+})();

src/js/sjcl/test/bitArray_vectors.js

@@ -0,0 +1,163 @@
+sjcl.test.vector.bitArray = {};
+
+// random test cases generated with ruby String#to_i(radix) and Fixnum#to_s(radix)
+
+// bitstrings (<= 32 bits) encoding a number
+sjcl.test.vector.bitArray.bits = [
+[ "00"                              , 0|0x0         ],
+[ "01"                              , 0|0x1         ],
+[ "10"                              , 0|0x2         ],
+[ "11"                              , 0|0x3         ],
+[ "000"                             , 0|0x0         ],
+[ "011"                             , 0|0x3         ],
+[ "101"                             , 0|0x5         ],
+[ "110"                             , 0|0x6         ],
+[ "0100"                            , 0|0x4         ],
+[ "0101"                            , 0|0x5         ],
+[ "1000"                            , 0|0x8         ],
+[ "1100"                            , 0|0xc         ],
+[ "00101"                           , 0|0x5         ],
+[ "01010"                           , 0|0xa         ],
+[ "10011"                           , 0|0x13        ],
+[ "11010"                           , 0|0x1a        ],
+[ "001100"                          , 0|0xc         ],
+[ "001110"                          , 0|0xe         ],
+[ "010100"                          , 0|0x14        ],
+[ "100111"                          , 0|0x27        ],
+[ "0001011"                         , 0|0xb         ],
+[ "0001101"                         , 0|0xd         ],
+[ "1000100"                         , 0|0x44        ],
+[ "1101011"                         , 0|0x6b        ],
+[ "00100001"                        , 0|0x21        ],
+[ "00100111"                        , 0|0x27        ],
+[ "00101000"                        , 0|0x28        ],
+[ "10101111"                        , 0|0xaf        ],
+[ "000100000"                       , 0|0x20        ],
+[ "100100011"                       , 0|0x123       ],
+[ "100111001"                       , 0|0x139       ],
+[ "111010011"                       , 0|0x1d3       ],
+[ "0001001011"                      , 0|0x4b        ],
+[ "0001100110"                      , 0|0x66        ],
+[ "0010110111"                      , 0|0xb7        ],
+[ "1011101111"                      , 0|0x2ef       ],
+[ "01000010110"                     , 0|0x216       ],
+[ "01001101000"                     , 0|0x268       ],
+[ "10111101001"                     , 0|0x5e9       ],
+[ "11111100000"                     , 0|0x7e0       ],
+[ "000101010001"                    , 0|0x151       ],
+[ "010101111111"                    , 0|0x57f       ],
+[ "101010001110"                    , 0|0xa8e       ],
+[ "110101100010"                    , 0|0xd62       ],
+[ "0010001111010"                   , 0|0x47a       ],
+[ "1000000001100"                   , 0|0x100c      ],
+[ "1100011000000"                   , 0|0x18c0      ],
+[ "1110011000011"                   , 0|0x1cc3      ],
+[ "00111101111110"                  , 0|0xf7e       ],
+[ "01101011001001"                  , 0|0x1ac9      ],
+[ "10111000111101"                  , 0|0x2e3d      ],
+[ "11101010011110"                  , 0|0x3a9e      ],
+[ "010111101010110"                 , 0|0x2f56      ],
+[ "100011010110000"                 , 0|0x46b0      ],
+[ "110001001100100"                 , 0|0x6264      ],
+[ "111011000100110"                 , 0|0x7626      ],
+[ "0100101111001100"                , 0|0x4bcc      ],
+[ "1000000001101100"                , 0|0x806c      ],
+[ "1001000100110110"                , 0|0x9136      ],
+[ "1101010000100011"                , 0|0xd423      ],
+[ "01001001001101110"               , 0|0x926e      ],
+[ "01111001111000010"               , 0|0xf3c2      ],
+[ "10011011011000011"               , 0|0x136c3     ],
+[ "10101011001110000"               , 0|0x15670     ],
+[ "010000000101000110"              , 0|0x10146     ],
+[ "011000100101110001"              , 0|0x18971     ],
+[ "101100100110110111"              , 0|0x2c9b7     ],
+[ "101110100100101111"              , 0|0x2e92f     ],
+[ "0010101100101000000"             , 0|0x15940     ],
+[ "1011010010000101010"             , 0|0x5a42a     ],
+[ "1011100111011011000"             , 0|0x5ced8     ],
+[ "1111011110011111110"             , 0|0x7bcfe     ],
+[ "00101000011011111111"            , 0|0x286ff     ],
+[ "01111001100011000100"            , 0|0x798c4     ],
+[ "11111001001110101011"            , 0|0xf93ab     ],
+[ "11111001111001101001"            , 0|0xf9e69     ],
+[ "000110100000110010101"           , 0|0x34195     ],
+[ "011110000101101101111"           , 0|0xf0b6f     ],
+[ "101111010011001100110"           , 0|0x17a666    ],
+[ "111101001011110010001"           , 0|0x1e9791    ],
+[ "1001111100011011100001"          , 0|0x27c6e1    ],
+[ "1011110101000101010110"          , 0|0x2f5156    ],
+[ "1100000100011110001011"          , 0|0x30478b    ],
+[ "1100001010010110111111"          , 0|0x30a5bf    ],
+[ "01001111001101000111101"         , 0|0x279a3d    ],
+[ "10110011101111110000001"         , 0|0x59df81    ],
+[ "11000001101100110100011"         , 0|0x60d9a3    ],
+[ "11011000010110110010110"         , 0|0x6c2d96    ],
+[ "010011110100100110010100"        , 0|0x4f4994    ],
+[ "011101110001100111111110"        , 0|0x7719fe    ],
+[ "011110001010011011100011"        , 0|0x78a6e3    ],
+[ "111100010001011101111110"        , 0|0xf1177e    ],
+[ "0010110000010110001000010"       , 0|0x582c42    ],
+[ "0100100011001001101110000"       , 0|0x919370    ],
+[ "1000111001010110111010110"       , 0|0x11cadd6   ],
+[ "1111001100101000010010101"       , 0|0x1e65095   ],
+[ "00110010011100010101111111"      , 0|0xc9c57f    ],
+[ "00111101011011010100111110"      , 0|0xf5b53e    ],
+[ "01100000111011111010011100"      , 0|0x183be9c   ],
+[ "11010001100110101111010111"      , 0|0x3466bd7   ],
+[ "010000001111100110000110011"     , 0|0x207cc33   ],
+[ "011010010000110000101011111"     , 0|0x348615f   ],
+[ "011010110001110110001110010"     , 0|0x358ec72   ],
+[ "110110100001001001001110000"     , 0|0x6d09270   ],
+[ "0101000000000001000011100101"    , 0|0x50010e5   ],
+[ "0110011001001100011111111100"    , 0|0x664c7fc   ],
+[ "1001011010000001100110111101"    , 0|0x96819bd   ],
+[ "1011011101000000111000000010"    , 0|0xb740e02   ],
+[ "00100111111011011111010101101"   , 0|0x4fdbead   ],
+[ "00110000011001110110101110010"   , 0|0x60ced72   ],
+[ "10111110111000010010010111101"   , 0|0x17dc24bd  ],
+[ "11010001000001110010101000010"   , 0|0x1a20e542  ],
+[ "001001010001010111111101010111"  , 0|0x9457f57   ],
+[ "100110011101100000110111111010"  , 0|0x26760dfa  ],
+[ "100111000100011001010011111011"  , 0|0x271194fb  ],
+[ "111011110110101110110111010101"  , 0|0x3bdaedd5  ],
+[ "0111100111010100101010000111100" , 0|0x3cea543c  ],
+[ "1000010011010100111001110000100" , 0|0x426a7384  ],
+[ "1001110000000100001011010001010" , 0|0x4e02168a  ],
+[ "1101000000000110110010011010100" , 0|0x680364d4  ],
+[ "00000011100100001011101011100111", 0|0x390bae7   ],
+[ "10011110110111111000010010010011", 0|0x9edf8493  ],
+[ "11000101100000110001011010111100", 0|0xc58316bc  ],
+[ "11111010101110011001010001011000", 0|0xfab99458  ]
+];
+
+// concat some bitstrings into an array (the last array entry here is not "high" shifted yet)
+sjcl.test.vector.bitArray.slices = [
+// lengths: 17, 16, 15, 14, 13
+[ ["00100010111010110", "0010000111100001", "101111111100010", "10111011110000", "1100100100001" ], [0|0x22eb10f0, 0|0xdfe2bbc3, 0|0x121] ],
+[ ["00001010100110010", "0000100011110001", "111110101100100", "10110111000101", "0000100111011" ], [0|0x0a990478, 0|0xfd64b714, 0|0x13b] ],
+[ ["10110101101100001", "0000110110010100", "110100011010100", "01011010010111", "0101101011011" ], [0|0xb5b086ca, 0|0x68d45a5d, 0|0x35b] ],
+[ ["01010010001010110", "1110010000100111", "001010110101110", "10110111101000", "0100000010100" ], [0|0x522b7213, 0|0x95aeb7a1, 0|0x014] ],
+[ ["10011001001100110", "0100100011100010", "000110011001001", "00101101101000", "0001111101100" ], [0|0x99332471, 0|0x0cc92da0, 0|0x3ec] ],
+[ ["01111100000110000", "1000101001000010", "110101001111111", "01001010110110", "0111100000001" ], [0|0x7c184521, 0|0x6a7f4ad9, 0|0x701] ],
+[ ["00110011010100110", "0100101101110000", "110101110100100", "00111010010110", "0110011011100" ], [0|0x335325b8, 0|0x6ba43a59, 0|0x4dc] ],
+[ ["11111110011100100", "1111101001010011", "001000100110010", "01101101100001", "0001011101011" ], [0|0xfe727d29, 0|0x91326d84, 0|0x2eb] ],
+[ ["00100011001001000", "1001010100000100", "010111001100111", "11011111000000", "0100111101110" ], [0|0x23244a82, 0|0x2e67df01, 0|0x1ee] ],
+[ ["10111111100000010", "0111110011010001", "001000101001110", "11101010011001", "0101111101110" ], [0|0xbf813e68, 0|0x914eea65, 0|0x3ee] ],
+// lengths: 17, 15, 32, 10, 20
+[ ["00001111000110001", "110100011111001", "10010110001110010011011000011111", "1001101101", "01110010001111001110" ], [0|0x0f18e8f9, 0|0x9639361f, 0|0x26d723ce] ],
+[ ["11011111010101100", "101010100101100", "11101101011001011011010111101011", "0010110010", "11110011110110000010" ], [0|0xdf56552c, 0|0xed65b5eb, 0|0x0b2f3d82] ],
+[ ["10100100001000101", "100111001100011", "00111100101000110010000011101001", "1001110001", "11000000001111111110" ], [0|0xa422ce63, 0|0x3ca320e9, 0|0x271c03fe] ],
+[ ["01110001111111010", "000101001101110", "00001100011010100100001011111001", "1011111010", "00011001110111111001" ], [0|0x71fd0a6e, 0|0x0c6a42f9, 0|0x2fa19df9] ],
+[ ["01001100010011001", "000111011000100", "10100000110101110110011110001100", "0011000001", "11001101010101011100" ], [0|0x4c4c8ec4, 0|0xa0d7678c, 0|0x0c1cd55c] ],
+[ ["01010010100110110", "110111110001000", "10011100001100010100000110000000", "1100111101", "00010001110100111101" ], [0|0x529b6f88, 0|0x9c314180, 0|0x33d11d3d] ],
+[ ["11010100011101101", "110101011011010", "01000110000011001111101110100001", "0001001110", "01001100010010001010" ], [0|0xd476eada, 0|0x460cfba1, 0|0x04e4c48a] ],
+[ ["11000001010001101", "001111011110111", "10000010100111010111011000100001", "0011000011", "11011110110000101000" ], [0|0xc1469ef7, 0|0x829d7621, 0|0x0c3dec28] ],
+[ ["11000101100010100", "000110111111110", "11111011110010001100001100010000", "0000101010", "10000011010011100011" ], [0|0xc58a0dfe, 0|0xfbc8c310, 0|0x02a834e3] ],
+[ ["11111111110100101", "110101000011001", "10101010010100111010100010110100", "0010011000", "10100110001000000010" ], [0|0xffd2ea19, 0|0xaa53a8b4, 0|0x098a6202] ]
+];
+
+sjcl.test.vector.bitArray.byteswap = [
+  [ [ 0xdab1a44e, 0x73fdc3de, 0xed6e6f00, 0x5d221b85, 0xadb987a4, 0xc20eda76, 0xa0d40d0c, 0xd1da9657, 0xd85eebf0, 0xd3f9c06d, 0xca1e39b0, 0xccd7eaeb, 0xb1dd6bd0, 0x7315a9e6, 0x77cfcac4, 0xf7914c19, 0x1bc15354, 0x935afabc, 0x3ee9d375, 0xd18a095f]
+  , [ 0x4ea4b1da, 0xdec3fd73, 0x006f6eed, 0x851b225d, 0xa487b9ad, 0x76da0ec2, 0x0c0dd4a0, 0x5796dad1, 0xf0eb5ed8, 0x6dc0f9d3, 0xb0391eca, 0xebead7cc, 0xd06bddb1, 0xe6a91573, 0xc4cacf77, 0x194c91f7, 0x5453c11b, 0xbcfa5a93, 0x75d3e93e, 0x5f098ad1]
+  ]
+];

src/js/sjcl/test/hmac_test.js

@@ -5,11 +5,23 @@ new sjcl.test.TestCase("HMAC official test vectors", function (cb) {
     return;
   }
   
-  var i, kat = sjcl.test.vector.hmac, tv, h=sjcl.codec.hex, out;
+  var i, kat = sjcl.test.vector.hmac, tv, h=sjcl.codec.hex, out, data, mac;
   for (i=0; i<kat.length; i++) {
     tv = kat[i];
-    out = h.fromBits((new sjcl.misc.hmac(h.toBits(tv.key))).mac(h.toBits(tv.data)));
+    data = h.toBits(tv.data);
+    mac = new sjcl.misc.hmac(h.toBits(tv.key));
+
+    out = h.fromBits(mac.mac(data));
     this.require (out.substr(0,tv.mac.length) == tv.mac, "hmac #"+i);
+
+    out = h.fromBits(mac.mac(data));
+    this.require (out.substr(0,tv.mac.length) == tv.mac, "hmac reset #"+i);
+
+    mac.update(sjcl.bitArray.bitSlice(data, 0, sjcl.bitArray.bitLength(data)/2));
+    mac.update(sjcl.bitArray.bitSlice(data, sjcl.bitArray.bitLength(data)/2));
+
+    out = h.fromBits(mac.digest());
+    this.require (out.substr(0,tv.mac.length) == tv.mac, "hmac reset #"+i);
   }
   cb && cb();
 });

src/js/sjcl/test/hmac_vectors.js

@@ -1,4 +1,5 @@
 /* Official HMAC test vectors. */
+//Nilos: http://tools.ietf.org/html/draft-nystrom-smime-hmac-sha-02 for
 sjcl.test.vector.hmac = [
 { key:  "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
   data: "4869205468657265",

src/js/sjcl/test/json_test.js

@@ -0,0 +1,126 @@
+/*
+ * Asserts that an object can be encoded to an expected string.
+ */
+new sjcl.test.TestCase("JSON Encode Test", function (cb) {
+	if(!sjcl.json) {
+		this.unimplemented();
+		cb && cb();
+		return;
+	}
+
+	//Build up a standard object for encoding, this includes a nice wide variety of properties.
+	var obj = new Object();
+	obj.int = 4;
+	obj.nint = -5;
+	obj.str = 'string';
+	obj.iv = [ -95577995, -949876189, 1443400017, 697058741 ];
+	obj.truth = true;
+	obj.lie = false;
+
+	try {
+		var str = sjcl.json.encode(obj);
+		this.require(!(!str)); //Check for non-'falsey'
+	}
+	catch (e) {
+		//The standard object should encode just fine, so this is out of place. Fail.
+		this.fail(e);
+	}
+	cb && cb();
+});
+
+
+/*
+ * Asserts that a JSON string can be decoded to an expected object.
+ */
+new sjcl.test.TestCase("JSON Decode Test", function (cb) {
+	if(!sjcl.json) {
+		this.unimplemented();
+		cb && cb();
+		return;
+	}
+	
+	var str = ''; var i;
+	str = '{"int":4,"nint":-5,"str":"string","iv":"/////wAAAAAAAAABAAAAAg==","truth":true,"lie":false}';
+
+	try { 
+		var obj = sjcl.json.decode(str);
+		this.require(obj.int === 4);
+		this.require(obj.nint === -5);
+		this.require(obj.str === 'string');
+		this.require(obj.truth === true);
+		this.require(obj.lie === false);
+		for(i in obj.iv) {
+			this.require(obj.iv[i] == (i-1)); //Array in iv is [-1,0,1,2]
+		}
+	} catch (e) { this.fail(e); }
+
+	str = '{ "int" : 4,  "nint"  :  -5,"str":"string",  "iv":  "/////wAAAAAAAAABAAAAAg==","truth": true,"lie":  false  }';
+	try { 
+		var obj = sjcl.json.decode(str);
+		this.require(obj.int === 4);
+		this.require(obj.nint === -5);
+		this.require(obj.str === 'string');
+		this.require(obj.truth === true);
+		this.require(obj.lie === false);
+		for(i in obj.iv) {
+			this.require(obj.iv[i] == (i-1)); //Array in iv is [-1,0,1,2]
+		}
+	} catch (e) { this.fail(e); }
+	
+	//Tests passed, return.
+	cb && cb();
+});
+
+
+/*
+ * Asserts that an Object can be Encoded to a string that can be decoded to an equivalent object
+ * as well as the converse.
+ */
+new sjcl.test.TestCase("JSON Commutative Test", function (cb) {
+	if(!sjcl.json) {
+		this.unimplemented();
+		cb && cb();
+		return;
+	}
+
+	var obj1 = new Object();
+	obj1.int = 4;
+	obj1.nint = -5;
+	obj1.str = 'string';
+	obj1.iv = [ -95577995, -949876189, 1443400017, 697058741 ];
+	obj1.truth = true;
+	obj1.lie = false;
+
+	var str1 = '';
+	var str2 = '';
+	var obj2;
+	try {
+		str1 = sjcl.json.encode(obj1);
+		obj2 = sjcl.json.decode(str1);
+		str2 = sjcl.json.encode(obj2);
+	}
+	catch (e) {
+		this.fail(e);
+	}
+
+	try {
+		this.require(str1 === str2);
+		this.require(obj1.int == obj2.int);
+		this.require(obj1.str == obj2.str);
+		this.require(obj1.lie == obj2.lie);
+		this.require(obj1.nint == obj2.nint);
+		this.require(obj1.truth == obj2.truth);
+
+		var i;
+		for(i in obj1.iv)
+		{
+			this.require(obj1.iv[i] == obj2.iv[i]);
+		}
+	}
+	catch (e) {
+		this.fail(e);
+	}
+
+	//Tests passed.
+	cb && cb();
+});

src/js/sjcl/test/run_tests_node.js

@@ -0,0 +1,16 @@
+var fs = require('fs');
+var vm = require('vm');
+
+var load = function(path) {
+    vm.runInThisContext(fs.readFileSync(path));
+};
+
+// Assume we're run using `make test`.
+// That means argv[0] is `node` and argv[1] is this file.
+process.argv.slice(2).map(load);
+
+sjcl.test.run(undefined, function(){
+  if(!browserUtil.allPassed) {
+    process.exit(1);
+  }
+});

test/account-test.js

@@ -1,5 +1,5 @@
 var assert = require('assert');
-var Account = require('../src/js/ripple/account').Account;
+var Account = require('ripple-lib').Account;
 
 describe('Account', function(){
 

test/base-test.js

@@ -0,0 +1,66 @@
+'use strict';
+var assert = require('assert');
+var Base = require('ripple-lib').Base;
+var fixtures = require('./fixtures/base58.json');
+
+function digitArray(str) {
+  return str.split('').map(function(d) {
+    return parseInt(d, 10);
+  });
+}
+
+function hexToByteArray(hex) {
+  var byteArray = [];
+  for (var i = 0; i < hex.length / 2; i++) {
+    byteArray.push(parseInt(hex.slice(2 * i, 2 * i + 2), 16));
+  }
+  return byteArray;
+}
+
+describe('Base', function() {
+  describe('encode_check', function() {
+    it('0', function () {
+      var encoded = Base.encode_check(0, digitArray('00000000000000000000'));
+      assert.strictEqual(encoded, 'rrrrrrrrrrrrrrrrrrrrrhoLvTp');
+    });
+    it('1', function () {
+      var encoded = Base.encode_check(0, digitArray('00000000000000000001'));
+      assert.strictEqual(encoded, 'rrrrrrrrrrrrrrrrrrrrBZbvji');
+    });
+  });
+  describe('decode_check', function() {
+    it('rrrrrrrrrrrrrrrrrrrrrhoLvTp', function() {
+      var decoded = Base.decode_check(0, 'rrrrrrrrrrrrrrrrrrrrrhoLvTp');
+      assert(decoded.equals(0));
+    });
+    it('rrrrrrrrrrrrrrrrrrrrBZbvji', function() {
+      var decoded = Base.decode_check(0, 'rrrrrrrrrrrrrrrrrrrrBZbvji');
+      assert(decoded.equals(1));
+    });
+  });
+  describe('decode-encode identity', function() {
+    it('rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh', function() {
+      var decoded = Base.decode('rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+      var encoded = Base.encode(decoded);
+      assert.strictEqual(encoded, 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh');
+    });
+  });
+  describe('encode', function() {
+    it('fixtures', function() {
+      for (var i = 0; i < fixtures.ripple.length; i++) {
+        var testCase = fixtures.ripple[i];
+        var encoded = Base.encode(hexToByteArray(testCase.hex));
+        assert.strictEqual(encoded, testCase.string);
+      }
+    });
+  });
+  describe('decode', function() {
+    it('fixtures', function() {
+      for (var i = 0; i < fixtures.ripple.length; i++) {
+        var testCase = fixtures.ripple[i];
+        var decoded = Base.decode(testCase.string);
+        assert.deepEqual(decoded, hexToByteArray(testCase.hex));
+      }
+    });
+  });
+});

test/base58-test.js

@@ -1,19 +0,0 @@
-var assert = require('assert');
-var utils  = require('./testutils');
-var Seed   = utils.load_module('seed').Seed;
-var config = require('./testutils').get_config();
-
-describe('Base58', function() {
-  describe('Seed', function() {
-    it('saESc82Vun7Ta5EJRzGJbrXb5HNYk', function () {
-      var seed = Seed.from_json('saESc82Vun7Ta5EJRzGJbrXb5HNYk');
-      assert.strictEqual(seed.to_hex(), 'FF1CF838D02B2CF7B45BAC27F5F24F4F');
-    });
-    it('sp6iDHnmiPN7tQFHm5sCW59ax3hfE',  function () {
-      var seed = Seed.from_json('sp6iDHnmiPN7tQFHm5sCW59ax3hfE');
-      assert.strictEqual(seed.to_hex(), '00AD8DA764C3C8AF5F9B8D51C94B9E49');
-    });
-  });
-});
-
-// vim:sw=2:sts=2:ts=8:et

test/baseconverter-test.js

@@ -0,0 +1,53 @@
+'use strict';
+var assert = require('assert');
+var convertBase = require('ripple-lib').convertBase;
+
+// Test cases from RFC-1924 (a joke RFC)
+var BASE85 = ('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+              + 'abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~');
+var BASE10 = BASE85.slice(0, 10);
+var BASE16 = BASE85.slice(0, 16);
+
+var DATA16 = '108000000000000000080800200C417A';
+var DATA10 = '21932261930451111902915077091070067066';
+var DATA85 = '4)+k&C#VzJ4br>0wv%Yp';
+
+function encode(digitArray, encoding) {
+  return digitArray.map(function(i) {
+    return encoding.charAt(i);
+  }).join('');
+}
+
+function decode(encoded, encoding) {
+  return encoded.split('').map(function(c) {
+    return encoding.indexOf(c);
+  });
+}
+
+function convertBaseEncoded(value, fromEncoding, toEncoding) {
+  var digitArray = decode(value, fromEncoding);
+  var converted = convertBase(digitArray, fromEncoding.length,
+    toEncoding.length);
+  return encode(converted, toEncoding);
+}
+
+describe('convertBase', function() {
+  it('DEC -> HEX', function () {
+    assert.strictEqual(convertBaseEncoded(DATA10, BASE10, BASE16), DATA16);
+  });
+  it('HEX -> DEC', function () {
+    assert.strictEqual(convertBaseEncoded(DATA16, BASE16, BASE10), DATA10);
+  });
+  it('DEC -> B85', function () {
+    assert.strictEqual(convertBaseEncoded(DATA10, BASE10, BASE85), DATA85);
+  });
+  it('HEX -> B85', function () {
+    assert.strictEqual(convertBaseEncoded(DATA16, BASE16, BASE85), DATA85);
+  });
+  it('B85 -> DEC', function () {
+    assert.strictEqual(convertBaseEncoded(DATA85, BASE85, BASE10), DATA10);
+  });
+  it('B85 -> HEX', function () {
+    assert.strictEqual(convertBaseEncoded(DATA85, BASE85, BASE16), DATA16);
+  });
+});

test/currency-test.js

@@ -1,7 +1,8 @@
+/*eslint-disable */
+
 var assert   = require('assert');
-var utils    = require('./testutils');
-var currency = utils.load_module('currency').Currency;
-var timeUtil = utils.load_module('utils').time;
+var currency = require('ripple-lib').Currency;
+var timeUtil = require('ripple-lib').utils.time;
 
 describe('Currency', function() {
   describe('json_rewrite', function() {
@@ -55,6 +56,16 @@ describe('Currency', function() {
       assert(r.is_valid());
       assert.strictEqual('1D2', r.to_json());
     });
+    it('from_json("1").to_human()', function() {
+      var r = currency.from_json('1');
+      assert(r.is_valid());
+      assert.strictEqual(1, r.to_json());
+    });
+    it('from_json("#$%").to_human()', function() {
+      var r = currency.from_json('#$%');
+      assert(r.is_valid());
+      assert.strictEqual('0000000000000000000000002324250000000000', r.to_json());
+    });
     it('from_json("XAU").to_json() hex', function() {
       var r = currency.from_json("XAU");
       assert.strictEqual('0000000000000000000000005841550000000000', r.to_json({force_hex: true}));

test/fixtures/addresses.js

@@ -0,0 +1,5 @@
+module.exports.ACCOUNT = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+module.exports.OTHER_ACCOUNT = 'rpZc4mVfWUif9CRoHRKKcmhu1nx2xktxBo';
+module.exports.THIRD_ACCOUNT = 'rwBYyfufTzk77zUSKEu4MvixfarC35av1J';
+module.exports.FOURTH_ACCOUNT = 'rJnZ4YHCUsHvQu7R6mZohevKJDHFzVD6Zr';
+module.exports.ISSUER = 'rMH4UxPrbuMa1spCBR98hLLyNJp4d8p4tM';

test/fixtures/base58.json

@@ -0,0 +1,141 @@
+{
+  "ripple": [
+    {
+      "hex": "",
+      "string": ""
+    },
+    {
+      "hex": "61",
+      "string": "pg"
+    },
+    {
+      "hex": "626262",
+      "string": "2sgV"
+    },
+    {
+      "hex": "636363",
+      "string": "2PNi"
+    },
+    {
+      "hex": "73696d706c792061206c6f6e6720737472696e67",
+      "string": "pcEuFj68N1S8n9qHX1tmKpCCFLvp"
+    },
+    {
+      "hex": "00eb15231dfceb60925886b67d065299925915aeb172c06647",
+      "string": "r4Srf52g9jJgTHDrVXjvLUN8ZuQsiJDN9L"
+    },
+    {
+      "hex": "516b6fcd0f",
+      "string": "wB8LTmg"
+    },
+    {
+      "hex": "bf4f89001e670274dd",
+      "string": "sSNosLWLoP8tU"
+    },
+    {
+      "hex": "572e4794",
+      "string": "sNE7fm"
+    },
+    {
+      "hex": "ecac89cad93923c02321",
+      "string": "NJDM3diCXwauyw"
+    },
+    {
+      "hex": "10c8511e",
+      "string": "Rtnzm"
+    },
+    {
+      "hex": "00000000000000000000",
+      "string": "rrrrrrrrrr"
+    },
+    {
+      "hex": "801184cd2cdd640ca42cfc3a091c51d549b2f016d454b2774019c2b2d2e08529fd206ec97e",
+      "string": "nHxrnHEGyeFpUCPx1JKepCXJ1UV8nDN5yoeGGEaJZjGbTR8qC5D"
+    },
+    {
+      "hex": "003c176e659bea0f29a3e9bf7880c112b1b31b4dc826268187",
+      "string": "ra7jcY4BG9GTKhuqpCfyYNbu5CqUzoLMGS"
+    }
+  ],
+  "bitcoin": [
+    {
+      "hex": "",
+      "string": ""
+    },
+    {
+      "hex": "61",
+      "string": "2g"
+    },
+    {
+      "hex": "626262",
+      "string": "a3gV"
+    },
+    {
+      "hex": "636363",
+      "string": "aPEr"
+    },
+    {
+      "hex": "73696d706c792061206c6f6e6720737472696e67",
+      "string": "2cFupjhnEsSn59qHXstmK2ffpLv2"
+    },
+    {
+      "hex": "00eb15231dfceb60925886b67d065299925915aeb172c06647",
+      "string": "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"
+    },
+    {
+      "hex": "516b6fcd0f",
+      "string": "ABnLTmg"
+    },
+    {
+      "hex": "bf4f89001e670274dd",
+      "string": "3SEo3LWLoPntC"
+    },
+    {
+      "hex": "572e4794",
+      "string": "3EFU7m"
+    },
+    {
+      "hex": "ecac89cad93923c02321",
+      "string": "EJDM8drfXA6uyA"
+    },
+    {
+      "hex": "10c8511e",
+      "string": "Rt5zm"
+    },
+    {
+      "hex": "00000000000000000000",
+      "string": "1111111111"
+    },
+    {
+      "hex": "801184cd2cdd640ca42cfc3a091c51d549b2f016d454b2774019c2b2d2e08529fd206ec97e",
+      "string": "5Hx15HFGyep2CfPxsJKe2fXJsCVn5DEiyoeGGF6JZjGbTRnqfiD"
+    },
+    {
+      "hex": "003c176e659bea0f29a3e9bf7880c112b1b31b4dc826268187",
+      "string": "16UjcYNBG9GTK4uq2f7yYEbuifqCzoLMGS"
+    }
+  ],
+  "invalid": [
+    {
+      "description": "non-base58 string",
+      "string": "invalid"
+    },
+    {
+      "description": "non-base58 alphabet",
+      "string": "c2F0b3NoaQo="
+    },
+    {
+      "description": "leading whitespace",
+      "string": " 1111111111"
+    },
+    {
+      "description": "trailing whitespace",
+      "string": "1111111111 "
+    },
+    {
+      "description": "unexpected character after whitespace",
+      "string": " \t\n\u000b\f\r skip \r\f\u000b\n\t a"
+    }
+  ]
+
+}