Bump version to 0.13.0-rc6

Add schema for RippleAPI constructor options

.flowconfig

@@ -0,0 +1,14 @@
+[ignore]
+.*/src/api/.*
+.*/src/core/.*
+.*/dist/.*
+.*/test/fixtures/.*
+.*/node_modules/flow-bin/.*
+
+[include]
+./node_modules/
+
+[libs]
+
+[options]
+module.system=node

.gitignore

@@ -17,7 +17,7 @@
 
 # Ignore object files.
 *.o
-build
+build/
 tags
 bin/rippled
 Debug/*.*
@@ -25,6 +25,7 @@ Release/*.*
 
 # Ignore locally installed node_modules
 node_modules
+!test/node_modules
 
 # Ignore tmp directory.
 tmp
@@ -37,3 +38,26 @@ db/*.db-*
 rippled.cfg
 validators.txt
 test/config.js
+
+# Ignore coverage files
+/lib-cov
+/src-cov
+/coverage.html
+/coverage
+
+# Ignore IntelliJ files
+.idea
+
+# Ignore npm-debug
+npm-debug.log
+
+# Ignore dist folder, build for bower
+dist/
+
+# Ignore flow output directory
+out/
+
+# Ignore perf test cache
+scripts/cache
+
+eslintrc

.npmignore

@@ -1,2 +1,4 @@
-build
-deploy
+lib-cov
+coverage.html
+src
+dist/bower

.travis.yml

@@ -0,0 +1,9 @@
+sudo: false       # use faster docker containers
+language: node_js
+node_js:
+  - "0.12"
+before_script:
+  - sh -c "git log | head -12"
+script: bin/ci.sh
+notifications:
+  email: false

Gruntfile.js

@@ -1,100 +0,0 @@
-module.exports = function(grunt) {
-  grunt.loadNpmTasks('grunt-webpack');
-  grunt.loadNpmTasks('grunt-dox');
-  grunt.loadNpmTasks('grunt-contrib-concat');
-  grunt.loadNpmTasks('grunt-contrib-watch');
-
-  grunt.initConfig({
-    pkg: grunt.file.readJSON('package.json'),
-    meta: {
-      banner: '/*! <%= pkg.name %> - v<%= pkg.version %> - ' +
-        '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
-        '<%= pkg.homepage ? "* " + pkg.homepage + "\n" : "" %>' +
-        '* Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author.name %>;' +
-        ' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */'
-    },
-    concat: {
-      sjcl: {
-        src: [
-          "src/js/sjcl/core/sjcl.js",
-          "src/js/sjcl/core/aes.js",
-          "src/js/sjcl/core/bitArray.js",
-          "src/js/sjcl/core/codecString.js",
-          "src/js/sjcl/core/codecHex.js",
-          "src/js/sjcl/core/codecBase64.js",
-          "src/js/sjcl/core/codecBytes.js",
-          "src/js/sjcl/core/sha256.js",
-          "src/js/sjcl/core/sha512.js",
-          "src/js/sjcl/core/sha1.js",
-          "src/js/sjcl/core/ccm.js",
-//          "src/js/sjcl/core/cbc.js",
-//          "src/js/sjcl/core/ocb2.js",
-          "src/js/sjcl/core/hmac.js",
-          "src/js/sjcl/core/pbkdf2.js",
-          "src/js/sjcl/core/random.js",
-          "src/js/sjcl/core/convenience.js",
-          "src/js/sjcl/core/bn.js",
-          "src/js/sjcl/core/ecc.js",
-          "src/js/sjcl/core/srp.js",
-          "src/js/sjcl-custom/sjcl-secp256k1.js",
-          "src/js/sjcl-custom/sjcl-ripemd160.js",
-          "src/js/sjcl-custom/sjcl-extramath.js",
-          "src/js/sjcl-custom/sjcl-validecc.js",
-          "src/js/sjcl-custom/sjcl-ecdsa-der.js"
-        ],
-        dest: 'build/sjcl.js'
-      }
-    },
-    webpack: {
-      options: {
-        entry: "./src/js/ripple/index.js",
-        output: {
-          library: "ripple"
-        }
-      },
-      lib: {
-        output: {
-          filename: "build/ripple-<%= pkg.version %>.js"
-        }
-      },
-      lib_debug: {
-        output: {
-          filename: "build/ripple-<%= pkg.version %>-debug.js"
-        },
-        debug: true,
-        devtool: 'eval'
-      },
-      lib_min: {
-        output: {
-          filename: "build/ripple-<%= pkg.version %>-min.js"
-        },
-        optimize: {
-          minimize: true
-        }
-      }
-    },
-    watch: {
-      sjcl: {
-        files: ['<%= concat.sjcl.src %>'],
-        tasks: 'concat:sjcl'
-      },
-      lib: {
-        files: 'src/js/*.js',
-        tasks: 'webpack'
-      }
-    },
-    dox: {
-      libdocs: {
-        options: {
-          title: "Test"
-        },
-        src: ['src/js/ripple/'],
-        dest: 'build/docs'
-      }
-    }
-  });
-
-  // Tasks
-  grunt.registerTask('default', ['concat:sjcl', 'webpack']);
-
-};

Gulpfile.js

@@ -0,0 +1,126 @@
+/* eslint-disable no-var, no-param-reassign */
+/* these eslint rules are disabled because gulp does not support babel yet */
+'use strict';
+var _ = require('lodash');
+var gulp = require('gulp');
+var uglify = require('gulp-uglify');
+var rename = require('gulp-rename');
+var webpack = require('webpack');
+var bump = require('gulp-bump');
+var argv = require('yargs').argv;
+
+var pkg = require('./package.json');
+
+function webpackConfig(extension, overrides) {
+  overrides = overrides || {};
+  var defaults = {
+    cache: true,
+    entry: './src/index.js',
+    output: {
+      library: 'ripple',
+      path: './build/',
+      filename: ['ripple-', extension].join(pkg.version)
+    },
+    module: {
+      loaders: [{
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: 'babel-loader?optional=runtime'
+      }]
+    }
+  };
+  return _.assign({}, defaults, overrides);
+}
+
+gulp.task('build', function(callback) {
+  webpack(webpackConfig('.js'), callback);
+});
+
+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(gulp.dest('./build/'));
+});
+
+gulp.task('build-debug', function(callback) {
+  var configOverrides = {debug: true, devtool: 'eval'};
+  webpack(webpackConfig('-debug.js', configOverrides), callback);
+});
+
+/**
+ * Generate a WebPack external for a given unavailable module which replaces
+ * that module's constructor with an error-thrower
+ */
+
+function buildUseError(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', function(callback) {
+  var configOverrides = {
+    cache: false,
+    entry: './src/remote.js',
+    externals: [{
+      './transaction': buildUseError('Transaction'),
+      './orderbook': buildUseError('OrderBook'),
+      './account': buildUseError('Account'),
+      './serializedobject': buildUseError('SerializedObject')
+    }],
+    plugins: [
+      new webpack.optimize.UglifyJsPlugin()
+    ]
+  };
+  webpack(webpackConfig('-core.js', configOverrides), callback);
+});
+
+gulp.task('bower-build', ['build'], function() {
+  return gulp.src(['./build/ripple-', '.js'].join(pkg.version))
+  .pipe(rename('ripple.js'))
+  .pipe(gulp.dest('./dist/bower'));
+});
+
+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/bower'));
+});
+
+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/bower'));
+});
+
+gulp.task('bower-version', function() {
+  gulp.src('./dist/bower/bower.json')
+  .pipe(bump({version: pkg.version}))
+  .pipe(gulp.dest('./dist/bower'));
+});
+
+gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug',
+                    'bower-version']);
+
+gulp.task('watch', function() {
+  gulp.watch('src/*', ['build-debug']);
+});
+
+gulp.task('version-bump', function() {
+  if (!argv.type) {
+    throw new Error('No type found, pass it in using the --type argument');
+  }
+
+  gulp.src('./package.json')
+  .pipe(bump({type: argv.type}))
+  .pipe(gulp.dest('./'));
+});
+
+gulp.task('version-beta', function() {
+  gulp.src('./package.json')
+  .pipe(bump({version: pkg.version + '-beta'}))
+  .pipe(gulp.dest('./'));
+});
+
+gulp.task('default', ['build', 'build-debug', 'build-min']);

HISTORY.md

@@ -0,0 +1,421 @@
+##0.13.0 (release candidate)
+
++ [Fix: Emit error events and return error on pathfind](https://github.com/ripple/ripple-lib/commit/1ccbaf677631a1944eb05d90f7afc5f3690a03dd)
++ [Deprecate core and remove snake case method copying](https://github.com/ripple/ripple-lib/commit/fb8dc44ec1d49bb05cd0cdbe6dd4ab211195868a)
++ Add new RippleAPI interface
+    - [RippleAPI README and samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples)
+    - [Method documentation](https://rawgit.com/ripple/ripple-lib/develop/docs/api.html)
++ [Fix RangeSet for validated_ledger as single ledger](https://github.com/ripple/ripple-lib/commit/9f9e76f8b933201651af59307135f67cfa7d60e8)
++ [Fix bug where the paths would be set with an empty array](https://github.com/ripple/ripple-lib/commit/83874ec0962da311b76f2385623e51c68bc39035)
++ [Fix reserve calculation](https://github.com/ripple/ripple-lib/commit/52879febb92d876f01f2e4d70871baa07af631fb)
+
+##0.12.6
+
++ [Fix webpack require failure due to "./" notation](https://github.com/ripple/ripple-lib/commit/8d9746d7b10be203ee613df523c2522012ff1baf)
+
+##0.12.15
+
++ [Add offer autobridging](https://github.com/ripple/ripple-lib/commit/c7bbce83719c1e8c6a4fae5ca850e7515db1a4a5)
+
++ [Prevent crash when listening for "model" events on the OrderBook class](https://github.com/ripple/ripple-lib/commit/5824c3cb7cb6bd834d6e037f69943aebf3d83351)
+
++ [Fix empty order edgecase](https://github.com/ripple/ripple-lib/commit/64809d9ae23dc24f47accd4b4788b48f49880d3e)
+
++ [Fix AutobridgeCalculator (RT-3445)](https://github.com/ripple/ripple-lib/commit/1fff5ea6dcbcee856536df26f3b9cf1aec3c3b55)
+
++ [Update sjcl and delete custom ripemd160, montgomery, and jacobi](https://github.com/ripple/ripple-lib/commit/50cda426eb83599c38c0b725e1524a01fc415da2)
+
++ [Fix transaction summary for transactions that fail with remoteError](https://github.com/ripple/ripple-lib/commit/5e714f6143464d7912f42537acaa553b88eaf6dc)
+
++ [Fix serializedobject append for excessively large bytes length](https://github.com/ripple/ripple-lib/commit/e93f1ab6f4aaad347450aee75a169af0faa2121c)
+
++ [Switch to sjcl npm module](https://github.com/ripple/ripple-lib/commit/9a502580fd89ec6a9aa55f4e5847f6a4a2cb5bba)
+
++ [Add babel transpiler](https://github.com/ripple/ripple-lib/commit/398f8d001f758bf575b959537a17e79e4042d17b)
+
++ [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)
+
++ [Add a "core" browser build of ripple-lib which has a subset of features and smaller file size](https://github.com/ripple/ripple-lib/pull/205)
+
++ [Update binformat with missing fields from rippled](https://github.com/ripple/ripple-lib/commit/cae980788efb00191bfd0988ed836d60cdf7a9a2)
+
++ [Wait for transaction validation before returning `tec` error](https://github.com/ripple/ripple-lib/commit/6bdd4b2670906588852fc4dda457607b4aac08e4)
+
++ [Change default `max_fee` on `Remote` to `1 XRP`](https://github.com/ripple/ripple-lib/commit/d6b1728c23ff85c3cc791bed6982a750641fd95f)
+
++ [Fix: Request ledger_accept should return the Remote](https://github.com/ripple/ripple-lib/pull/209)
+
+##0.9.2
+
++ [**Breaking change**: Change accountRequest method signature](https://github.com/ripple/ripple-lib/commit/6f5d1104aa3eb440c518ec4f39e264fdce15fa15)
+
++ [Add paging behavior for account requests, `account_lines` and `account_offers`](https://github.com/ripple/ripple-lib/commit/722f4e175dbbf378e51b49142d0285f87acb22d7)
+
++ [Add max_fee setter to transactions to set max fee the submitter is willing to pay] (https://github.com/ripple/ripple-lib/commit/24587fab9c8ad3840d7aa345a7037b48839e09d7)
+
++ [Fix: cap IOU Amounts to their max and min value] (https://github.com/ripple/ripple-lib/commit/f05941fbc46fdb7c6fe7ad72927af02d527ffeed)
+
+Example on how to use paging with `account_offers`:
+```
+// A valid `ledger_index` or `ledger_hash` is required to provide a reliable result.
+// Results can change between ledger closes, so the provided ledger will be used as base.
+var options = {
+    account: < rippleAccount >,
+    limit: < Number between 10 and 400 >,
+    ledger: < valid ledger_index or ledger_hash >
+}
+
+// The `marker` comes back in an account request if there are more results than are returned
+// in the current response. The amount of results per response are determined by the `limit`.
+if (marker) {
+    options.marker = < marker >;
+}
+
+var request = remote.requestAccountOffers(options);
+```
+
+[Full working example](https://github.com/geertweening/ripple-lib-scripts/blob/master/account_offers_paging.js)
+
+
+##0.9.1
+
++ Switch account requests to use ledgerSelect rather than ledgerChoose ([278df90](https://github.com/ripple/ripple-lib/commit/278df9025a20228de22379a53c76ca12d40fa591))
+
++ **Deprecated** setting `ident` and `account_index` on account requests ([278df90](https://github.com/ripple/ripple-lib/commit/278df9025a20228de22379a53c76ca12d40fa591))
+
++ Change initial account transaction sequence to 1 ([a3c1d06](https://github.com/ripple/ripple-lib/commit/a3c1d06eba883dc84fe2bfe700e4309795c84cac))
+
++ Fix: instance transaction withoute remote ([d3b6b81](https://github.com/ripple/ripple-lib/commit/d3b6b8127c7b01e416b400c25abf1719bdd008ca))
+
++ Fix: account root request ledger argument ([bc1f9f8](https://github.com/ripple/ripple-lib/commit/bc1f9f8a286b187d36ebaf552694e31e73742293))
+
++ Fix: rsign.js local signing and example ([d3b6b81](https://github.com/ripple/ripple-lib/commit/d3b6b8127c7b01e416b400c25abf1719bdd008ca) and [f1004c6](https://github.com/ripple/ripple-lib/commit/f1004c6db2a0ce59bbabbb8f2b355a9fd9995fd8))
+
+
+##0.9.0
+
++ Add routes to the vault client for KYC attestations ([ed2da574](https://github.com/ripple/ripple-lib/commit/ed2da57475acf5e9d2cf3373858f4274832bd83f))
+
++ Currency: add `show_interest` flag to show or hide interest in `Currency.to_human()` and `Currency.to_json()` [Example use in tests](https://github.com/ripple/ripple-lib/blob/947ec3edc2e7c8f1ef097e496bf552c74366e749/test/currency-test.js#L123)
+
++ Configurable maxAttempts for transaction submission ([d107092](https://github.com/ripple/ripple-lib/commit/d10709254061e9e4416d2cb78b5cac1ec0d7ffa5))
+
++ Binformat: added missing TransactionResult options ([6abed8d](https://github.com/ripple/ripple-lib/commit/6abed8dd5311765b2eb70505dadbdf5121439ca8))
+
++ **Breaking change:** make maxLoops in seed.get_key optional. [Example use in tests](https://github.com/ripple/ripple-lib/blob/23e473b6886c457781949c825b3ff48b3984e51f/test/seed-test.js) ([23e473b](https://github.com/ripple/ripple-lib/commit/23e473b6886c457781949c825b3ff48b3984e51f))
+
++ Shrinkwrap packages for dependency locking ([2dcd5f9](2dcd5f94fbc71200eb08a5044c76ef94f7971913))
+
++ Fix: Amount.to_human() precision bugs ([4be209e](https://github.com/ripple/ripple-lib/commit/4be209e286b5b209bec7bcd1212098985e15ff2f) and [7708c64](https://github.com/ripple/ripple-lib/commit/7708c64576e70ce3ac190442daceb30e4446aab7))
+
++ Fix: change handling of requestLedger options ([57b7030](https://github.com/ripple/ripple-lib/commit/57b70300f5f0c7534ede118ddbb5d8762668a4f8))
+
+
+##0.8.2
+
++ Currency: Allow mixed letters and numbers in currencies
+
++ Deprecate account_tx map/reduce/filterg
+
++ Fix: correct requestLedger arguments
+
++ Fix: missing subscription on error events for some server methods
+
++ Fix: orderbook reset on reconnect
+
++ Fix: ripple-lib crashing. Add potential missing error handlers
+
+
+##0.8.1
+
++ Wallet: Add Wallet class that generates wallets
+
++ Make npm test runnable in Windows.
+
++ Fix several stability issues, see merged PR's for details
+
++ Fix bug in Amount.to_human_full()
+
++ Fix undefined fee states when connecting to a rippled that is syncing
+
+
+##0.8.0
+
++ Orderbook: Added tracking of offer funds for determining when offers are not funded
+
++ Orderbook: Added tests
+
++ Orderbook: Update owner funds
+
++ Transactions: If transaction errs with `tefALREADY`, wait until all possible submissions err with the same before emitting `error`. Fixes a client "Transaction malformed" bug.
+
++ Transactions: Track submissions, don't bother submitting to unconnected servers
+
++ Request: `request.request()` now accepts an array of servers as first argument. Servers can be represented with URL, or the server object itself.
+
++ Request: `request.broadcast()` now returns the number of servers request was sent to
+
++ Server: Acquire host information from server without additional request
+
++ Amount: Add a constant for the maximum canonical value that can be expressed as a Ripple value
+
++ Amount: Make Constants static fields on the class, instead of a seperate export
+
+
+##0.7.39
+
++ Improvements to multi-server support. Fixed an issue where a server's score was not reset and connections would keep dropping after being connected for a significant amount of time.
+
++ Improvements in order book support. Added support for currency pairs with interest bearing currencies. You can request an order book with hex, ISO code or full name for the currency.
+
++ Fix value parsing for amount/currency order pairs, e.g. `Amount.from_human("XAU 12345.6789")`
+
++ Improved Amount parsing from human readable string given a hex currency, e.g. `Amount.from_human("10 015841551A748AD2C1F76FF6ECB0CCCD00000000")`
+
++ Improvements to username normalization in the vault client
+
++ Add 2-factor authentication support for vault client
+
++ Removed vestiges of Grunt, switched to Gulp
+
+
+##0.7.37
+
++ **Deprecations**
+
+    1. Removed humanistic amount detection in `transaction.payment`. Passing `1XRP` as the payment amount no longer works.
+    2. `remote.setServer` uses full server URL rather than hostname. Example: `remote.setServer('wss://s`.ripple.com:443')`
+    3. Removed constructors for deprecated transaction types from `transaction.js`.
+    4. Removed `invoiceID` option from `transaction.payment`. Instead, use the `transaction.invoiceID` method.
+    5. Removed `transaction.transactionManager` getter.
+
++ Improved multi-server support. Servers are now ranked dynamically, and transactions are broadcasted to all connected servers.
+
++ Automatically ping connected servers. Client configuration now should contain `ping: <seconds>` to specify the ping interval.
+
++ Added `transaction.lastLedger` to specify `LastLedgerSequence`. Setting it this way also ensures that the sequence is not bumped on subsequent requests.
+
++ Added optional `remote.accountTx` binary parsing.
+    ```js
+      {
+        binary: true,
+        parseBinary: false
+      }
+    ```
++ Added full currency name support, e.g. `Currency.from_json('XRP').to_human({full_name:'Ripples'})` will return `XRP - Ripples`
+
++ Improved interest bearing currency support, e.g. `Currency.from_human('USD - US Dollar (2.5%pa)')`
+
++ Improve test coverage
+
++ Added blob vault client.  The vault client facilitates interaction with ripple's namespace and blob vault or 3rd party blob vaults using ripple's blob vault software (https://github.com/ripple/ripple-blobvault). A list of the available functions can be found at [docs/VAULTCLIENT.md](docs/VAULTCLIENT.md)
+
+
+##0.7.35
+
++ `LastLedgerSequence` is set by default on outgoing transactions. This refers to the last valid ledger index (AKA sequence) for a transaction. By default, this index is set to the current index (at submission time) plus 8. In theory, this allows ripple-lib to deterministically fail a transaction whose submission request timed out, but whose associated server continues to emit ledger_closed events.
+
++ Transactions that err with `telINSUF_FEE_P` will be automatically resubmitted. This error indicates that the `Fee` supplied in the transaction submission request was inadquate. Ideally, the `Fee` is tracked by ripple-lib in real-time, and the resubmitted transaction will most likely succeed.
+
++ Added Transaction.iff(function(callback) { }). Callback expects first argument to be an Error or null, second argument is a boolean which indicates whether or not to proceed with the transaction submission. If an `iff` function is specified, it will be executed prior to every submission of the transaction (including resubmissions).
+
++ Transactions will now emit `presubmit` and `postsubmit` events. They will be emitted before and after a transaction is submitted, respectively.
+
++ Added Transaction.summary(). Returns a summary of a transaction in semi-human-readable form. JSON-stringifiable.
+
++ Remote.requestAccountTx() with `binary: true` will automatically parse transactions.
+
++ Added Remote.requestAccountTx filter, map, and reduce.
+
+```js
+  remote.requestAccountTx({
+    account: 'retc',
+    ledger_index_min: -1,
+    ledger_index_max: -1,
+    limit: 100,
+    binary: true,
+
+    filter: function(transaction) {
+      return transaction.tx.TransactionType === 'Payment';
+    },
+
+    map: function(transaction) {
+      return Number(transaction.tx.Amount);
+    },
+
+    reduce: function(a, b) {
+      return a + b;
+    },
+
+    pluck: 'transactions'
+  }, console.log)
+```
+
++ Added persistence hooks.
+
++ General performance improvements, especially for long-running processes.
+

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012,2013 OpenCoin, Inc.
+Copyright (c) 2012,2013,2014 Ripple Labs Inc.
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
@@ -12,39 +12,39 @@ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+--------------------------------------
+
 Some code from Tom Wu:
 This software is covered under the following copyright:
 
-/*
- * Copyright (c) 2003-2005  Tom Wu
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
- * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
- * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
- *
- * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
- * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
- * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
- * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
- * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * In addition, the following condition applies:
- *
- * All redistributions must retain an intact copy of this copyright notice
- * and disclaimer.
- */
+Copyright (c) 2003-2005  Tom Wu
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+
+IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+In addition, the following condition applies:
+
+All redistributions must retain an intact copy of this copyright notice
+and disclaimer.
 
 Address all questions regarding this license to:
 

README.md

@@ -1,123 +1,100 @@
-Ripple JavaScript Library - ripple-lib
-======================================
+#ripple-lib
 
-This library can connect to the Ripple network via the WebSocket protocol and runs in Node.js as well as in the browser.
+A JavaScript API for interacting with Ripple in Node.js and the browser
 
-* https://ripple.com/wiki/Ripple_JavaScript_library
-* https://ripple.com
-* https://ripple.com/wiki
+[![Circle CI](https://circleci.com/gh/ripple/ripple-lib/tree/develop.svg?style=svg)](https://circleci.com/gh/ripple/ripple-lib/tree/develop) [![Coverage Status](https://coveralls.io/repos/ripple/ripple-lib/badge.png?branch=develop)](https://coveralls.io/r/ripple/ripple-lib?branch=develop)
 
-##Initializing a remote connection
+[![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)
 
-[ripple-lib.remote](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/remote.js) is responsible for managing connections to rippled servers.
+###Features
+
++ Connect to a rippled server in JavaScript (Node.js or browser)
++ 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
+
+###In this file
+
+1. [Installation](#installation)
+2. [Quick start](#quick-start)
+3. [Running tests](#running-tests)
+
+###Additional documentation
+
+1. [Guides](docs/GUIDES.md)
+2. [API Reference](docs/REFERENCE.md)
+3. [Wiki](https://ripple.com/wiki/Ripple_JavaScript_library)
+
+###Also see
+
++ [The Ripple wiki](https://ripple.com/wiki)
++ [ripple.com](https://ripple.com)
+
+##Installation
+
+**Via npm for Node.js**
+
+```
+  $ npm install ripple-lib
+```
+
+**Via bower (for browser use)**
+
+```
+  $ bower install ripple
+```
+
+See the [bower-ripple repo](https://github.com/ripple/bower-ripple) for additional bower instructions.
+
+
+**Building ripple-lib for browser environments**
+
+ripple-lib uses Gulp to generate browser builds. These steps will generate minified and non-minified builds of ripple-lib in the `build/` directory.
+
+```
+  $ git clone https://github.com/ripple/ripple-lib
+  $ npm install
+  $ npm run build
+```
+
+**Restricted browser builds**
+
+You may generate browser builds that contain a subset of features. To do this, run `./node_modules/.bin/gulp build-<name>`
+
++ `build-core` Contains the functionality to make requests and listen for events such as `ledgerClose`. Only `ripple.Remote` is currently exposed. Advanced features like transaction submission and orderbook tracking are excluded from this build.
+
+##Quick start
+
+`Remote.js` ([remote.js](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/remote.js)) is the point of entry for interacting with rippled
 
 ```js
+/* Loading ripple-lib with Node.js */
 var Remote = require('ripple-lib').Remote;
 
+/* Loading ripple-lib in a webpage */
+// var Remote = ripple.Remote;
+
 var remote = new Remote({
-  trusted: false,
-  servers: [ 
-    { 
-        host: ''
-      , port: 1111,
-      , secure: true
-    } 
-  ]
+  // see the API Reference for available options
+  servers: [ 'wss://s1.ripple.com:443' ]
 });
 
-remote.connect();
-```
-
-Once a connection is formed to any of the supplied servers, a `connect` event is emitted, indicating that the remote is ready to begin fulfilling requests. When there are no more connected servers to fulfill requests, a `disconnect` event is emitted. If you send requests before ripple-lib is connected to any servers, requests are deferred until the `connect` event is received.
-
-```js
-var remote = new Remote({ /* options */ }).connect();
-remote.request_server_info(function(err, info) { }); // will defer until connected
-```
-
-##Remote functions
-
-Each remote function returns a `Request` object. is object is an `EventEmitter`. You may listen for success or failure events from each request, or provide a callback. Example:
-
-```js
-var request = remote.request_server_info();
-request.on('success', function(res) { 
-  //handle success conditions
-});
-request.on('error', function(err) { 
-  //handle error conditions
-});
-request.request();
-```
-
-Or:
-
-```js
-remote.request_server_info(function(err, res) {
-  
+remote.connect(function() {
+  /* remote connected */
+  remote.requestServerInfo(function(err, info) {
+    // process err and info
+  });
 });
 ```
 
-**request_server_info([callback])**
+##Running tests
 
-**request_ledger(ledger, [opts], [callback])**
+1. Clone the repository
 
-**request_ledger_hash([callback])**
+2. `cd` into the repository and install dependencies with `npm install`
 
-**request_ledger_header([callback])**
+3. `npm test`
 
-**request_ledger_current([callback])**
+**Generating code coverage**
 
-**request_ledger_entry(type, [callback])**
-
-**request_subscribe(streams, [callback])**
-
-**request_unsubscribe(streams, [callback])**
-
-**request_transaction_entry(hash, [callback])**
-
-**request_tx(hash, [callback])**
-
-**request_account_info(accountID, [callback])**
-
-**request_account_lines(accountID, account_index, current, [callback])**
-
-**request_account_offers(accountID, account_index, current, [callback])**
-
-**request_account_tx(opts, [callback])**
-
-**request_book_offers(gets, pays, taker, [callback])**
-
-**request_wallet_accounts(seed, [callback])**
-
-+ requires trusted **remote
-
-**request_sign(secret, tx_json, [callback])**
-
-+ requires trusted **remote
-
-**request_submit([callback])**
-
-**request_account_balance(account, current, [callback])**
-
-**request_account_flags(account, current, [callback])**
-
-**request_owner_count(account, current, [callback])**
-
-**request_ripple_balance(account, issuer, currency, current, [callback])**
-
-**request_ripple_path_find(src_account, dst_account, dst_amount, src_currencies, [callback])**
-
-**request_unl_list([callback])**
-
-**request_unl_add(addr, comment, [callback])**
-
-**request_unl_delete(node, [callback])**
-
-**request_peers([callback])**
-
-**request_connect(ip, port, [callback])**
-
-**transaction()**
-
-+ returns a [Transaction](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/transaction.js) object
+ripple-lib uses `istanbul` to generate code coverage. To create a code coverage report, run `npm test --coverage`. The report will be created in `coverage/lcov-report/`.

bin/ci.sh

@@ -0,0 +1,61 @@
+#!/bin/bash -ex
+
+NODE_INDEX="$1"
+TOTAL_NODES="$2"
+
+typecheck() {
+  npm install -g flow-bin
+  flow --version
+  npm run typecheck
+}
+
+lint() {
+  echo "eslint $(node_modules/.bin/eslint --version)"
+  npm list babel-eslint | grep babel-eslint
+  REPO_URL="https://raw.githubusercontent.com/ripple/javascript-style-guide"
+  curl "$REPO_URL/es6/eslintrc" > ./eslintrc
+  echo "parser: babel-eslint" >> ./eslintrc
+  node_modules/.bin/eslint -c ./eslintrc $(git --no-pager diff --name-only -M100% --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
+}
+
+unittest() {
+  # test "src"
+  npm test --coverage
+  npm run coveralls
+
+  # test compiled version in "dist/npm"
+  ln -nfs ../../dist/npm/core test/node_modules/ripple-lib
+  ln -nfs ../../dist/npm test/node_modules/ripple-api
+  npm test
+}
+
+oneNode() {
+  lint
+  typecheck
+  unittest
+}
+
+twoNodes() {
+  case "$NODE_INDEX" in
+    0) lint && unittest;;
+    1) typecheck;;
+    *) echo "ERROR: invalid usage"; exit 2;;
+  esac
+}
+
+threeNodes() {
+  case "$NODE_INDEX" in
+    0) lint;;
+    1) typecheck;;
+    2) unittest;;
+    *) echo "ERROR: invalid usage"; exit 2;;
+  esac
+}
+
+case "$TOTAL_NODES" in
+  "") oneNode;;
+  1) oneNode;;
+  2) twoNodes;;
+  3) threeNodes;;
+  *) echo "ERROR: invalid usage"; exit 2;;
+esac

bin/decode_binary.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/* eslint-disable no-var */
+'use strict';
+var SerializedObject = require('..').SerializedObject;
+
+function main() {
+  var argv = process.argv.slice(2);
+  var blob = argv.shift();
+
+  if (blob === '-') {
+    read_input(ready);
+  } else {
+    ready(blob);
+  }
+}
+
+function read_input(callback) {
+  var tx_json = '';
+  process.stdin.on('data', function(data) {
+    tx_json += data;
+  });
+  process.stdin.on('end', callback);
+  process.stdin.resume();
+}
+
+function ready(blob) {
+  var valid_arguments = blob;
+
+  if (!valid_arguments) {
+    console.error('Invalid arguments\n');
+    print_usage();
+  } else {
+    decode(blob);
+  }
+}
+
+function print_usage() {
+  /* eslint-disable max-len */
+  console.log(
+    'Usage: decode_binary.js <hex_blob>\n\n',
+    'Example: decode_binary.js 120000240000000161D6871AFD498D00000000000000000000000000005553440000000000550FC62003E785DC231A1058A05E56E3F09CF4E668400000000000000A732102AE75B908F0A95F740A7BFA96057637E5C2170BC8DAD13B2F7B52AE75FAEBEFCF811450F97A072F1C4357F1AD84566A609479D927C9428314550FC62003E785DC231A1058A05E56E3F09CF4E6'
+  );
+  /* eslint-enable max-len */
+}
+
+function decode(blob) {
+  var buffer = new SerializedObject(blob);
+  console.log(buffer.to_json());
+}
+
+main();
+// vim:sw=2:sts=2:ts=8:et

bin/rsign.js

@@ -1,65 +1,97 @@
-#!/usr/bin/node
+#!/usr/bin/env node
+/* eslint-disable no-var */
+'use strict';
+var Transaction = require('..').Transaction;
 
-var Transaction = require('../src/js/ripple/transaction').Transaction;
+function read_input(callback) {
+  var stdin = '';
+  process.stdin.on('data', function(data) {
+    stdin += data;
+  });
+  process.stdin.on('end', function() {
+    callback(stdin);
+  });
+  process.stdin.resume();
+}
 
-var cursor      = 2;
-var verbose;
-var secret;
-var tx_json;
-
-var usage = function () {
+function print_usage() {
   console.log(
-    "Usage: rsign.js <secret> <json>\n"
-    + "  Example: rsign.js ssq55ueDob4yV3kPVnNQLHB6icwpC '{ \"TransactionType\" : \"Payment\", \"Account\" : \"r3P9vH81KBayazSTrQj6S25jW6kDb779Gi\", \"Destination\" : \"r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV\", \"Amount\" : \"200000000\", \"Fee\" : \"10\", \"Sequence\" : \"1\" }'"
-    );
-};
-
-if (process.argv.length > cursor && process.argv[cursor] === "-v")
-{
-  verbose = true;
-  cursor++;
+    'Usage: rsign.js <secret> <json>\n\n',
+    'Example: rsign.js ssq55ueDob4yV3kPVnNQLHB6icwpC', '\'' +
+    JSON.stringify({
+      TransactionType: 'Payment',
+      Account: 'r3P9vH81KBayazSTrQj6S25jW6kDb779Gi',
+      Destination: 'r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV',
+      Amount: '200000000',
+      Fee: '10',
+      Sequence: 1
+    }) + '\''
+  );
 }
 
-if (process.argv.length > cursor)
-{
-  secret = process.argv[cursor++];
+function sign_transaction(tx_json_object, secret, verbose) {
+  var tx = new Transaction();
+
+  tx.tx_json = tx_json_object;
+  tx._secret = secret;
+  tx.complete();
+
+  var unsigned_blob = tx.serialize().to_hex();
+  var unsigned_hash = tx.signingHash();
+  tx.sign();
+
+  if (verbose) {
+    var sim = { };
+    sim.tx_blob = tx.serialize().to_hex();
+    sim.tx_json = tx.tx_json;
+    sim.tx_signing_hash = unsigned_hash;
+    sim.tx_unsigned = unsigned_blob;
+    console.log(JSON.stringify(sim, null, 2));
+  } else {
+    console.log(tx.serialize().to_hex());
+  }
 }
 
-if (process.argv.length > cursor)
-{
-  tx_json = JSON.parse(process.argv[cursor++]);
+function ready(tx_json, secret, verbose) {
+  if (!(tx_json && secret)) {
+    console.error('Invalid arguments\n');
+    print_usage();
+    return;
+  }
+
+  var tx_json_object;
+  try {
+    tx_json_object = JSON.parse(tx_json);
+  } catch(exception) {
+    console.error('Invalid JSON\n');
+    print_usage();
+    return;
+  }
+  sign_transaction(tx_json_object, secret, verbose);
 }
 
-if (process.argv.length !== cursor || !secret || !tx_json)
-{
-  usage();
-}
-else
-{
-    var tx = new Transaction();
+function main() {
+  var argv = process.argv.slice(2);
+  var verbose;
+  var secret;
+  var tx_json;
 
-    tx.tx_json        = tx_json;
-    tx._secret        = secret;
-    tx.complete();
+  if (~argv.indexOf('-v')) {
+    argv.splice(argv.indexOf('-v'), 1);
+    verbose = true;
+  }
 
-    var unsigned      = tx.serialize().to_hex();
-    tx.sign();
+  secret = argv.shift();
+  tx_json = argv.shift();
 
-    if (verbose)
-    {
-      var sim = {};
-
-      sim.tx_blob         = tx.serialize().to_hex();
-      sim.tx_json         = tx.tx_json;
-      sim.tx_signing_hash = tx.signing_hash().to_hex();
-      sim.tx_unsigned     = unsigned;
-
-      console.log(JSON.stringify(sim, undefined, 2));
-    }
-    else
-    {
-      console.log(tx.serialize().to_hex());
-    }
+  if (tx_json === '-') {
+    read_input(function(stdin) {
+      ready(stdin, secret, verbose);
+    });
+  } else {
+    ready(tx_json, secret, verbose);
+  }
 }
 
+main();
 // vim:sw=2:sts=2:ts=8:et

bin/validate_address.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/* eslint-disable no-var */
+'use strict';
+var UInt160 = require('..').UInt160;
+
+function main() {
+  var address = process.argv[2];
+
+  if (address === '-') {
+    readInput(validateAddress);
+  } else {
+    validateAddress(address);
+  }
+}
+
+function readInput(callback) {
+  var result = '';
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', function(data) {
+    result += data;
+  });
+  process.stdin.on('end', function() {
+    callback(result);
+  });
+}
+
+function validateAddress(address) {
+  process.stdout.write((UInt160.is_valid(address.trim()) ? '0' : '1') + '\r\n');
+}
+
+main();

circle.yml

@@ -0,0 +1,7 @@
+machine:
+  node:
+    version: 0.12.0
+test:
+  override:
+    - bin/ci.sh "$CIRCLE_NODE_INDEX" "$CIRCLE_NODE_TOTAL":
+        parallel: true

deploy/start rippled.bat

@@ -1,3 +0,0 @@
-start newcoin
-sleep 4
-start index.html

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

@@ -0,0 +1,252 @@
+#Guides
+
+This file provides step-by-step walkthroughs for some of the most common usages of `ripple-lib`.
+
+###In this document
+
+1. [Connecting to the Ripple network with `Remote`](GUIDES.md#connecting-to-the-ripple-network)
+2. [Using `Remote` functions and `Request` objects](GUIDES.md#sending-rippled-API-requests)
+3. [Listening to the network](GUIDES.md#listening-to-the-network)
+4. [Submitting a payment to the network](GUIDES.md#submitting-a-payment-to-the-network)
+   * [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees)
+5. [Submitting a trade offer to the network](GUIDES.md#submitting-a-trade-offer-to-the-network)
+
+###Also see
+
+1. [The ripple-lib README](../README.md)
+2. [The ripple-lib API Reference](REFERENCE.md)
+
+##Connecting to the Ripple network
+
+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 */
+  var Remote = require('ripple-lib').Remote;
+
+  /* Loading ripple-lib in a webpage */
+  // var Remote = ripple.Remote;
+  ```
+3. Create a new `Remote` and connect to the network:
+  ```js
+
+  var options = {
+    trace :         false,
+    trusted:        true,
+    local_signing:  true,
+    servers: [
+      { host: 's-west.ripple.com', port: 443, secure: true }
+    ]
+  };
+
+  var remote = new Remote(options);
+
+  remote.connect(function(err, res) {
+    /* remote connected, use some remote functions here */
+  });
+  ```
+  __NOTE:__ See the API Reference for available [`Remote` options](REFERENCE.md#1-remote-options)
+
+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
+
+`Remote` contains functions for constructing a `Request` object.
+
+A `Request` is an `EventEmitter` so you can listen for success or failure events -- or, instead, you can provide a callback.
+
+Here is an example, using [requestServerInfo](https://ripple.com/wiki/JSON_Messages#server_info).
+
++ Constructing a `Request` with event listeners
+```js
+var request = remote.requestServerInfo();
+
+request.on('success', function onSuccess(res) {
+  //handle success
+});
+
+request.on('error', function onError(err) {
+  //handle error
+});
+
+request.request();
+```
+
++ Using a callback:
+```js
+remote.request('server_info', function(err, res) {
+  if (err) {
+    //handle error
+  } else {
+    //handle success
+  }
+});
+```
+
+__NOTE:__ See the API Reference for available [`Remote` functions](REFERENCE.md#2-remote-functions)
+
+
+##Listening to the network
+
+See the [wiki](https://ripple.com/wiki/JSON_Messages#subscribe) for details on subscription requests.
+
+```js
+ /* Loading ripple-lib with Node.js */
+  var Remote = require('ripple-lib').Remote;
+
+  /* Loading ripple-lib in a webpage */
+  // var Remote = ripple.Remote;
+
+  var remote = new Remote({options});
+
+  remote.connect(function() {
+    var remote = new Remote({
+      // see the API Reference for available options
+      servers: [ 'wss://s1.ripple.com:443' ]
+    });
+
+    remote.connect(function() {
+      console.log('Remote connected');
+
+      var streams = [
+        'ledger',
+        'transactions'
+      ];
+
+      var request = remote.requestSubscribe(streams);
+
+      request.on('error', function(error) {
+        console.log('request error: ', error);
+      });
+
+
+      // the `ledger_closed` and `transaction` will come in on the remote
+      // since the request for subscribe is finalized after the success return
+      // the streaming events will still come in, but not on the initial request
+      remote.on('ledger_closed', function(ledger) {
+        console.log('ledger_closed: ', JSON.stringify(ledger, null, 2));
+      });
+
+      remote.on('transaction', function(transaction) {
+        console.log('transaction: ', JSON.stringify(transaction, null, 2));
+      });
+
+      remote.on('error', function(error) {
+        console.log('remote error: ', error);
+      });
+
+      // fire the request
+      request.request();
+    });
+  });
+```
+* https://ripple.com/wiki/RPC_API#transactions_stream_messages
+* https://ripple.com/wiki/RPC_API#ledger_stream_messages
+
+##Submitting a payment to the network
+
+Submitting a payment transaction to the Ripple network involves connecting to a `Remote`, creating a transaction, signing it with the user's secret, and submitting it to the `rippled` server. Note that the `Amount` module is used to convert human-readable amounts like '1 XRP' or '10.50 USD' to the type of Amount object used by the Ripple network.
+
+```js
+/* Loading ripple-lib Remote and Amount modules in Node.js */
+var Remote = require('ripple-lib').Remote;
+var Amount = require('ripple-lib').Amount;
+
+/* Loading ripple-lib Remote and Amount modules in a webpage */
+// var Remote = ripple.Remote;
+// var Amount = ripple.Amount;
+
+var MY_ADDRESS = 'rrrMyAddress';
+var MY_SECRET  = 'secret';
+var RECIPIENT  = 'rrrRecipient';
+var AMOUNT     = Amount.from_human('1 USD').set_issuer('rrrIssuer');
+
+var remote = new Remote({ /* Remote options */ });
+
+remote.connect(function() {
+  remote.setSecret(MY_ADDRESS, MY_SECRET);
+
+  var transaction = remote.createTransaction('Payment', {
+    account: MY_ADDRESS,
+    destination: RECIPIENT,
+    amount: AMOUNT
+  });
+
+  transaction.submit(function(err, res) {
+    /* handle submission errors / success */
+  });
+});
+```
+
+###A note on transaction fees
+
+A full description of network transaction fees can be found on the [Ripple Wiki](https://ripple.com/wiki/Transaction_Fee).
+
+In short, transaction fees are very small amounts (on the order of ~10) of [XRP drops](https://ripple.com/wiki/Ripple_credits#Notes_on_drops) spent and destroyed with every transaction. They are largely used to account for network load and prevent spam. With `ripple-lib`, transaction fees are calculated locally by default and the fee you are willing to pay is submitted along with your transaction.
+
+Since the fee required for a transaction may change between the time when the original fee was calculated and the time when the transaction is submitted, it is wise to use the [`fee_cushion`](REFERENCE.md#1-remote-options) to ensure that the transaction will go through. For example, suppose the original fee calculated for a transaction was 10 XRP drops but at the instant the transaction is submitted the server is experiencing a higher load and it has raised its minimum fee to 12 XRP drops. Without a `fee_cusion`, this transaction would not be processed by the server, but with a `fee_cusion` of, say, 1.5 it would be processed and you would just pay the 2 extra XRP drops.
+
+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.
+
+
+##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 offering to sell 1 USD in exchange for 100 XRP:
+
+```js
+/* Loading ripple-lib Remote and Amount modules in Node.js */
+var Remote = require('ripple-lib').Remote;
+var Amount = require('ripple-lib').Amount;
+
+/* Loading ripple-lib Remote and Amount modules in a webpage */
+// var Remote = ripple.Remote;
+// var Amount = ripple.Amount;
+
+var MY_ADDRESS = 'rrrMyAddress';
+var MY_SECRET  = 'secret';
+var GATEWAY = 'rrrGateWay';
+
+var remote = new Remote({ /* Remote options */ });
+
+remote.connect(function() {
+  remote.setSecret(MY_ADDRESS, MY_SECRET);
+
+  var transaction = remote.createTransaction('OfferCreate', {
+    account: MY_ADDRESS,
+    taker_pays: '100',
+    taker_gets: '1/USD/' + GATEWAY
+  });
+
+  transaction.submit(function(err, res) {
+    /* handle submission errors / success */
+  });
+});
+```

docs/REFERENCE.md

@@ -0,0 +1,354 @@
+#API Reference
+
+__(More examples coming soon!)__
+
+###In this document:
+
+1. [`Remote` options](REFERENCE.md#remote-options)
+2. [`Request` constructors](REFERENCE.md#request-constructor-functions)
+  + [Server requests](REFERENCE.md#server-requests)
+  + [Ledger requests](REFERENCE.md#ledger-requests)
+  + [Transaction requests](REFERENCE.md#transaction-requests)
+  + [Account requests](REFERENCE.md#account-requests)
+  + [Orderbook requests](REFERENCE.md#orderbook-requests)
+  + [Transaction requests](REFERENCE.md#transaction-requests)
+3. [`Transaction` constructors](REFERENCE.md#transaction-constructors)
+  + [Transaction events](REFERENCE.md#transaction-events)
+
+###Also see:
+
+1. [The ripple-lib README](../README.md)
+2. [The ripple-lib GUIDES](GUIDES.md)a
+
+#Remote options
+
+```js
+/* Loading ripple-lib with Node.js */
+var Remote = require('ripple-lib').Remote;
+
+/* Loading ripple-lib in a webpage */
+// var Remote = ripple.Remote;
+
+var options = { };
+
+var remote = new Remote(options);
+```
+
+A new `Remote` can be created with the following options:
+
++ `trace` *boolean default: false* Log all of the events emitted
++ `max_listeners` *number default: 0* Set maxListeners for servers
++ `trusted` *boolean default: false*, if remote is trusted (boolean)
++ `local_signing` *boolean default: true*
++ `local_fee` *boolean default: true* Set whether the transaction fee range will be set locally, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees))
++ `fee_cushion` *number default: 1.2* Extra fee multiplier to account for async fee changes, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees))
++ `max_fee` *number default: Infinity* Maximum acceptable transaction fee, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees)
++ `servers` *array* Array of server objects of the following form:
+
+```js
+{
+  host:    <string>,
+  port:    <number>,
+  secure:  <boolean>
+}
+```
+
+or
+
+```js
+ 'wss://host:port'
+```
+
+#Request constructor functions
+
+Some requests have helper methods to construct the requests object and set properties on the message object. These will often be the more used requests and the helper methods is the preferred way of constructing these requests.
+Other request can still be made, but the type will have to be passed in directly to request constructor. See examples below.
+
+If the method is camelCased and starts with `request`, it's a helper method that wraps the request constructor.
+
+##Server requests
+
+**[requestServerInfo([callback])](https://ripple.com/wiki/JSON_Messages#server_info)**
+
+Returns information about the state of the server. If you are connected to multiple servers and want to select by a particular host, use `request.setServer`. Example:
+
+```js
+var request = remote.requestServerInfo();
+
+request.setServer('wss://s1.ripple.com');
+
+request.request(function(err, res) {
+
+});
+```
+**[requestPeers([callback])](https://ripple.com/wiki/JSON_Messages#peers)**
+
+**[requestConnect(ip, port, [callback])](https://ripple.com/wiki/JSON_Messages#connect)**
+
+**[unl_list([callback])](https://ripple.com/wiki/JSON_Messages#unl_list)**
+
+```js
+var request = remote.request('un_list');
+
+request.setServer('wss://s1.ripple.com');
+
+request.request(function(err, res) {
+
+});
+```
+
+**[unl_add(addr, comment, [callback])](https://ripple.com/wiki/JSON_Messages#unl_add)**
+
+**[unl_delete(node, [callback])](https://ripple.com/wiki/JSON_Messages#unl_delete)**
+
+
+
+##Ledger requests
+
+**[requestLedger([opts], [callback])](https://ripple.com/wiki/JSON_Messages#ledger)**
+
+**[requestLedgerHeader([callback])](https://wiki.ripple.com/JSON_Messages#ledger_data)**
+
+**[requestLedgerCurrent([callback])](https://ripple.com/wiki/JSON_Messages#ledger_current)**
+
+**[requestLedgerEntry(type, [callback])](https://ripple.com/wiki/JSON_Messages#ledger_entry)**
+
+**[requestSubscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#subscribe)**
+
+Start receiving selected streams from the server.
+
+**[requestUnsubscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#unsubscribe)**
+
+Stop receiving selected streams from the server.
+
+##Account requests
+
+**[requestAccountInfo(options, [callback])](https://ripple.com/wiki/JSON_Messages#account_info)**
+
+Return information about the specified account.
+
+```
+var options = {
+  account: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+  ledger: 'validated'
+};
+
+var request = remote.requestAccountInfo(options, function(err, info) {
+  /* process info */
+});
+
+
+// response
+{
+  ledger_current_index: <number>,
+  account_data: {
+    Account:            <string>,
+    Balance:            <number>,
+    Flags:              <number>,
+    LedgerEntryType:    <string>,
+    OwnerCount:         <number>,
+    PreviousTxnID:      <string>,
+    PreviousTxnLgrSeq:  <number>,
+    Sequence:           <number> ,
+    index:              <string>
+  }
+}
+```
+
+**[requestAccountLines(options, [callback])](https://ripple.com/wiki/JSON_Messages#account_lines)**
+
+**[requestAccountOffers(options, [callback])](https://ripple.com/wiki/JSON_Messages#account_offers)**
+
+Return the specified account's outstanding offers.
+
+Requests for both `account_lines` and `account_offers` support paging. The amount of results per response can be configured with the `limit`.
+The responses can be paged through by using the `marker`.
+
+```
+// A valid `ledger_index` or `ledger_hash` is required to provide a reliable result.
+// Results can change between ledger closes, so the provided ledger will be used as base.
+var options = {
+    account: < rippleAccount >,
+    limit: < Number between 10 and 400 >,
+    ledger: < valid ledger_index or ledger_hash >
+}
+
+// The `marker` comes back in an account request if there are more results than are returned 
+// in the current response. The amount of results per response are determined by the `limit`.
+if (marker) {
+    options.marker = < marker >;
+}
+
+var request = remote.requestAccountOffers(options);
+```
+
+
+**[requestAccountTransactions(options, [callback])](https://ripple.com/wiki/JSON_Messages#account_tx)**
+
+Fetch a list of transactions that applied to this account.
+
+Options:
+
++ `account`
++ `ledger_index_min`
++ `ledger_index_max`
++  `binary` *false*
++ `count` *false*
++  `descending` *false*
++  `offset` *0*
++  `limit`
++ `forward` *false*
++ `fwd_marker`
++ `rev_marker`
+
+**[requestWalletAccounts(seed, [callback])](https://ripple.com/wiki/JSON_Messages#wallet_accounts)**
+
+Return a list of accounts for a wallet. *Requires trusted remote*
+
+**requestAccountBalance(account, [ledger], [callback])**
+
+Get the balance for an account. Returns an [Amount](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/amount.js) object.
+
+**requestAccountFlags(account, [ledger], [callback])**
+
+Return the flags for an account.
+
+**requestOwnerCount(account, [ledger], [callback])**
+
+Return the owner count for an account.
+
+**requestRippleBalance(account, issuer, currency, [ledger], [callback])**
+
+Return a request to get a ripple balance
+
+##Orderbook requests
+
+**[requestBookOffers(options, [callback])](https://ripple.com/wiki/JSON_Messages#book_offers)**
+
+Return the offers for an order book, also called a *snapshot*
+
+```js
+var options = {
+  gets: {
+    issuer: < issuer >,
+    currency: < currency >
+  },
+  pays: {
+    issuer: < issuer >,
+    currency: < currency >
+  },
+  limit: < limit >
+};
+
+var request = remote.requestBookOffers(options);
+
+request.request(function(err, offers) {
+  //handle offers
+});
+```
+
+##Transaction requests
+
+**[requestTransactionEntry(hash, [ledger_hash], [callback])](https://ripple.com/wiki/JSON_Messages#transaction_entry)**
+
+Searches a particular ledger for a transaction hash. Default ledger is the open ledger.
+
+**[requestTransaction(hash, [callback])](https://ripple.com/wiki/JSON_Messages#tx)**
+
+Searches ledger history for validated transaction hashes.
+
+**[requestSign(secret, tx_json, [callback])](https://ripple.com/wiki/JSON_Messages#sign)**
+
+Sign a transaction. *Requires trusted remote*
+
+**[requestSubmit([callback])](https://ripple.com/wiki/JSON_Messages#submit)**
+
+Submit a transaction to the network. This command is used internally to submit transactions with a greater degree of reliability. See [Submitting a payment to the network](GUIDES.md#3-submitting-a-payment-to-the-network) for details.
+
+**[pathFind(src_account, dst_account, dst_amount, src_currencies)](https://ripple.com/wiki/JSON_Messages#path_find)**
+
+#Transaction constructors
+
+Use `remote.createTransaction('TransactionType', [options])` to construct a transaction. To submit, use `transaction.submit([callback])`.
+
+**Payment**
+
+```js
+var transaction = remote.createTransaction('Payment', {
+  account: MY_ADDRESS,
+  destination: DEST_ADDRESS,
+  amount: AMOUNT
+});
+```
+
+**AccountSet**
+
+```js
+var transaction = remote.createTransaction('AccountSet', {
+  account: MY_ADDRESS,
+  set: 'RequireDest',
+  clear: 'RequireAuth'
+});
+```
+
+**TrustSet**
+
+```js
+var transaction = remote.createTransaction('TrustSet', {
+  account: MY_ADDRESS,
+  limit: '1/USD/rrrrrrrrrrrrrrrrrrrrBZbvji'
+});
+```
+
+**OfferCreate**
+
+```js
+var transaction = remote.createTransaction('OfferCreate', {
+  account: MY_ADDRESS,
+  taker_pays: '1',
+  taker_gets: '1/USD/rrrrrrrrrrrrrrrrrrrrBZbvji'
+});
+```
+
+##Transaction events
+
+[Transaction](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/transaction.js) objects are EventEmitters. They may emit the following events.
+
++ `final` Transaction has erred or succeeded. This event indicates that the transaction has finished processing.
++ `error` Transaction has erred. This event is a final state.
++ `success` Transaction succeeded. This event is a final state.
++ `presubmit` Immediately before transaction is submitted
++ `postsubmit` Immediately after transaction is submitted
++ `submitted` Transaction has been submitted to the network. The submission may result in a remote error or success.
++ `resubmitted` Transaction is beginning resubmission.
++ `proposed` Transaction has been submitted *successfully* to the network. The transaction at this point is awaiting validation in a ledger.
++ `timeout` Transaction submission timed out. The transaction will be resubmitted.
++ `fee_adjusted` Transaction fee has been adjusted during its pending state. The transaction fee will only be adjusted if the remote is configured for local fees, which it is by default.
++ `abort` Transaction has been aborted. Transactions are only aborted by manual calls to `#abort`.
++ `missing` Four ledgers have closed without detecting validated transaction
++ `lost` Eight ledgers have closed without detecting validated transaction. Consider the transaction lost and err/finalize.
+
+##Complete payment example
+
+```js
+remote.setSecret(MY_ADDRESS, MY_SECRET);
+
+var transaction = remote.createTransaction('Payment', {
+  account: MY_ADDRESS,
+  destination: DEST_ADDRESS,
+  amount: AMOUNT
+});
+
+transaction.on('resubmitted', function() {
+  // initial submission failed, resubmitting
+});
+
+transaction.submit(function(err, res) {
+ // submission has finalized with either an error or success.
+ // the transaction will not be retried after this point
+});
+```
+
+#Amount objects
+
+Coming Soon

docs/VAULTCLIENT.md

@@ -0,0 +1,168 @@
+ripple-vault-client
+===================
+
+A javascript / http client to interact with Ripple Vault servers.
+
+The purpose of this tool is to enable applications in any javascript
+environment to login with the ripple vault and access the decrypted
+data stored using credentials originally obtained at ripple.com
+     
+        
+## Vault Client Usage
+
+    vaultClient = new ripple.VaultClient(domain);
+    
+    vaultClient.getAuthInfo(username, callback);
+    
+    vaultClient.getRippleName(address, url, callback);
+
+    vaultClient.exists(username, callback);
+    
+        
+
+    vaultClient.login(username, password, callback);
+
+    vaultClient.relogin(id, cryptKey, callback);
+
+    vaultClient.unlock(username, password, encryptSecret, callback);
+
+    vaultClient.loginAndUnlock(username, password, callback);
+    
+    
+    
+    vaultClient.register(options, callback);
+    
+    vaultClient.deleteBlob(options, callback);
+    
+    vaultClient.recoverBlob(options, callback);
+        
+    vaultClient.rename(options, callback);
+    
+    vaultClient.changePassword(options, callback);
+     
+    vaultClient.verify(username, token, callback);
+    
+    vaultClient.resendEmail(options, callback);
+    
+    vaultClient.updateProfile(options, fn);
+    
+
+# Blob Methods
+    
+    blob.encrypt();
+    
+    blob.decrypt(encryptedBlob);
+    
+    blob.encryptSecret(encryptionKey);
+    
+    blob.decryptSecret(encryptionKey, secret);
+    
+    blob.set(pointer, value, callback);
+    
+    blob.unset(pointer, callback);
+    
+    blob.extend(pointer, value, callback);
+    
+    blob.unshift(pointer, value, callback);
+    
+    blob.filter(pointer, field, value, subcommands, callback);
+    
+    
+## Identity Vault
+
+  The identity vault stores identity information inside the encrypted 
+  blob vault.  The identity fields can be additionally encrypted with the 
+  unlock key, that encrypts the secret, for added security. Methods are 
+  accessed from the 'identity' property of the blob object.
+
+
+# Identity fields
+  + name
+  + entityType (individual, corporation, organization)
+  + email
+  + phone
+  + address
+    + contact
+    + line1
+    + line2
+    + city
+    + postalCode
+    + region - state/province/region
+    + country
+  + nationalID
+    + number
+    + type (ssn, taxID, passport, driversLicense, other)
+    + country - issuing country
+  + birthday
+  + birthplace
+  
+  
+# Identity Methods
+
+    blob.identity.set(pointer, key, value, callback);
+    
+    blob.identity.unset(pointer, key, callback);
+    
+    blob.identity.get(pointer, key);
+    
+    blob.identity.getAll(key);
+    
+    blob.identity.getFullAddress(key);  //get text string of full address
+    
+
+## Spec Tests
+
+Run `npm test` to test the high-level behavior specs 
+
+  Ripple Txt
+    ✓ should get the content of a ripple.txt file from a given domain 
+    ✓ should get currencies from a ripple.txt file for a given domain
+    ✓ should get the domain from a given url 
+
+  AuthInfo
+    ✓ should get auth info 
+
+  VaultClient
+    #initialization
+      ✓ should be initialized with a domain 
+      ✓ should default to ripple.com without a domain 
+    #exists
+      ✓ should determine if a username exists on the domain 
+    #login
+      ✓ with username and password should retrive the blob, crypt key, and id
+    #relogin
+      ✓ should retrieve the decrypted blob with blob vault url, id, and crypt key 
+    #unlock
+      ✓ should access the wallet secret using encryption secret, username and password
+    #loginAndUnlock
+      ✓ should get the decrypted blob and decrypted secret given name and password
+    #register
+      ✓ should create a new blob
+    #deleteBlob
+      ✓ should remove an existing blob
+    #updateProfile
+      ✓ should update profile parameters associated with a blob 
+
+  Blob
+    ✓ #set 
+    ✓ #extend 
+    ✓ #unset 
+    ✓ #unshift 
+    ✓ #filter 
+    ✓ #consolidate 
+    #rename
+      ✓ should change the username of a blob
+    #changePassword
+      ✓ should change the password and keys of a blob
+    #recoverBlob
+      ✓ should recover the blob given a username and secret
+    #verifyEmail
+      ✓ should verify an email given a username and token 
+    #resendVerifcationEmail
+      ✓ should resend a verification given options
+    identity
+      ✓ #identity_set 
+      ✓ #identity_get 
+      ✓ #identity_getAll 
+      ✓ #identity_getFullAddress 
+      ✓ #identity_unset 

docs/api.html

@@ -0,0 +1,358 @@
+<html>
+<head>
+<style>
+a {
+  text-decoration: none;
+}
+.method {
+  margin-bottom: 10px;
+}
+.details {
+  font-family: "Courier New", monospace;
+  white-space: pre;
+  display: none;
+}
+</style>
+<script type="text/javascript">
+function toggle(element) {
+  var results = element.parentElement.getElementsByClassName('details');
+  if (results.length > 0) {
+    var style = results[0].style;
+    style.display = (style.display === 'block') ? 'none' : 'block';
+  }
+}
+</script>
+</head>
+<body>
+
+<h2><a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/index.js">RippleAPI</a></h2>
+
+<div class="method">
+connect()
+</div>
+
+<div class="method">
+disconnect()
+</div>
+
+<div class="method">
+isConnected()
+</div>
+
+<div class="method">
+getServerInfo()
+</div>
+
+<div class="method">
+getFee()
+</div>
+
+<div class="method">
+getLedgerVersion()
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-transaction.json">getTransaction</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/hash256.json">identifier</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transaction-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  identifier: txhash
+  options: {minLedgerVersion: int, maxLedgerVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-transactions.json">getTransactions</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/transactions-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {
+    start: txhash,
+    limit: int,
+    minLedgerVersion: int,
+    maxLedgerVersion: int,
+    earliestFirst: bool,
+    excludeFailures: bool,
+    initiated: bool,
+    counterparty: address,
+    types: [string],
+    binary: bool
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-trustlines.json">getTrustlines</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {counterparty: address, currency: string, limit: int, ledgerVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-balances.json">getBalances</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustlines-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {counterparty: address, currency: string, limit: int, ledgerVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-paths.json">getPaths</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/pathfind.json">pathfind</a>
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  pathfind: {
+    source: {
+      address: address,
+      currencies: [{
+        currency: string,
+        counterparty: address
+      }]
+    },
+    destination: adjustment
+  }
+
+  adjustment = {address: address, amount: amount, tag?: int}
+  amount = {currency: string, counterparty: address, value: floatstr}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-orders.json">getOrders</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {limit: int, ledverVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-orderbook.json">getOrderbook</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orderbook.json">orderbook</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/orders-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  orderbook: {
+    base: {
+      currency,
+      counterparty
+    },
+    counter: {
+      currency,
+      counterparty
+    }
+  }
+  options: {limit: int, ledverVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-settings.json">getSettings</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {ledgerVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/get-account-info.json">getAccountInfo</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings-options.json">options</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  options: {ledgerVersion: int}
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">preparePayment</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/payment.json">payment</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  payment: {
+    source: adjustment,
+    destination: adjustment,
+    paths?: string,
+    slippage?: strfloat,
+    memos?: [{
+      type: string,
+      format: string,
+      data: string
+    }],
+    invoiceID?: hash256,
+    allowPartialPayment?: bool,
+    noDirectRipple?: bool,
+    limitQuality?: bool
+  }
+
+  adjustment = {address: address, amount: amount, tag?: int}
+  amount = {currency: string, counterparty: address, value: floatstr}
+
+  instructions: {
+    sequence: int,
+    fee: floatstr,
+    maxFee: floatstr,
+    maxLedgerVersion: int,
+    maxLedgerVersionOffset: int
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareTrustline</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/trustline.json">trustline</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  trustline: {
+    currency: string,
+    counterparty: address,
+    limit: strfloat,
+    qualityIn?: float,
+    qualityOut?: float,
+    allowRippling?: bool,
+    authorized?: bool,
+    frozen?: bool
+  }
+
+  instructions: {
+    sequence: int,
+    fee: floatstr,
+    maxFee: floatstr,
+    maxLedgerVersion: int,
+    maxLedgerVersionOffset: int
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareOrder</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/order.json">order</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  order: {
+    direction: ("buy"|"sell"),
+    quantity: amount,
+    totalPrice: amount,
+    immediateOrCancel?: bool,
+    fillOrKill?: bool,
+    passive?: bool
+  }
+
+  amount = {currency: string, counterparty: address, value: floatstr}
+
+  instructions: {
+    sequence: int,
+    fee: floatstr,
+    maxFee: floatstr,
+    maxLedgerVersion: int,
+    maxLedgerVersionOffset: int
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareOrderCancellation</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/sequence.json">sequence</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  sequence: int
+
+  instructions: {
+    sequence: int,
+    fee: floatstr,
+    maxFee: floatstr,
+    maxLedgerVersion: int,
+    maxLedgerVersionOffset: int
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">prepareSettings</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/address.json">account</a>,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/settings.json">settings</a>[,
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/instructions.json">instructions</a>]
+)
+<a href="#" onclick="javascript:toggle(this)">+</a>
+<div class="details">
+  settings: {
+    passwordSpent: bool,
+    requireDestinationTag: bool,
+    requireAuthorization: bool,
+    disallowIncomingXRP: bool,
+    disableMasterKey: bool,
+    enableTransactionIDTracking: bool,
+    noFreeze: bool,
+    globalFreeze: bool,
+    defaultRipple: bool,
+    emailHash: hash128,
+    walletLocator: hash256,
+    walletSize: int,
+    messageKey: string,
+    domain: string,
+    transferRate: float,
+    signers: string,
+    regularKey: address
+  }
+
+  instructions: {
+    sequence: int,
+    fee: floatstr,
+    maxFee: floatstr,
+    maxLedgerVersion: int,
+    maxLedgerVersionOffset: int
+  }
+</div>
+</div>
+
+<div class="method">
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/sign.json">sign</a>(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/tx.json">txJSON</a>,
+secret)
+</div>
+
+<div class="method">
+submit(
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/schemas/blob.json">txBlob</a>
+)
+</div>
+
+<div class="method">
+generateWallet()
+</div>
+
+<a href="https://github.com/ripple/ripple-lib/blob/develop/src/api/common/errors.js">errors</a>
+</body>
+</html>

docs/samples/README

@@ -0,0 +1,3 @@
+Usage:
+babel-node balances.js
+babel-node payment.js (requires setting address and secret in source file first)

docs/samples/balances.js

@@ -0,0 +1,12 @@
+'use strict';
+const RippleAPI = require('../../src').RippleAPI; // require('ripple-lib')
+
+const api = new RippleAPI({servers: ['wss://s1.ripple.com:443']});
+const address = 'r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV';
+
+api.connect().then(() => {
+  api.getBalances(address).then(balances => {
+    console.log(JSON.stringify(balances, null, 2));
+    process.exit();
+  });
+});

docs/samples/payment.js

@@ -0,0 +1,41 @@
+'use strict';
+const RippleAPI = require('../../src').RippleAPI; // require('ripple-lib')
+
+const address = 'INSERT ADDRESS HERE';
+const secret = 'INSERT SECRET HERE';
+
+const api = new RippleAPI({servers: ['wss://s1.ripple.com:443']});
+const instructions = {maxLedgerVersionOffset: 5};
+
+const payment = {
+  source: {
+    address: address,
+    amount: {
+      value: '0.01',
+      currency: 'XRP'
+    }
+  },
+  destination: {
+    address: 'rKmBGxocj9Abgy25J51Mk1iqFzW9aVF9Tc',
+    amount: {
+      value: '0.01',
+      currency: 'XRP'
+    }
+  }
+};
+
+api.connect().then(() => {
+  console.log('Connected...');
+  api.preparePayment(address, payment, instructions).then(txJSON => {
+    console.log('Payment transaction prepared...');
+    const signedTransaction = api.sign(txJSON, secret).signedTransaction;
+    console.log('Payment transaction signed...');
+    api.submit(signedTransaction).then(response => {
+      console.log(response);
+      process.exit(0);
+    }).catch(error => {
+      console.log(error);
+      process.exit(1);
+    });
+  });
+});

npm-shrinkwrap.json

@@ -0,0 +1,212 @@
+{
+  "name": "ripple-lib",
+  "version": "0.13.0-rc6",
+  "npm-shrinkwrap-version": "5.4.0",
+  "node-version": "v0.12.7",
+  "dependencies": {
+    "async": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz"
+    },
+    "babel-runtime": {
+      "version": "5.8.20",
+      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-5.8.20.tgz",
+      "dependencies": {
+        "core-js": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/core-js/-/core-js-1.0.1.tgz"
+        }
+      }
+    },
+    "bignumber.js": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-2.0.7.tgz"
+    },
+    "bn.js": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-3.1.1.tgz"
+    },
+    "es6-promisify": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-2.0.0.tgz",
+      "dependencies": {
+        "es6-promise": {
+          "version": "2.3.0",
+          "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-2.3.0.tgz"
+        }
+      }
+    },
+    "extend": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-1.2.1.tgz"
+    },
+    "hash.js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.0.3.tgz",
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+        }
+      }
+    },
+    "https-proxy-agent": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz",
+      "dependencies": {
+        "agent-base": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-2.0.0.tgz",
+          "dependencies": {
+            "semver": {
+              "version": "4.3.6",
+              "resolved": "https://registry.npmjs.org/semver/-/semver-4.3.6.tgz"
+            }
+          }
+        },
+        "debug": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-2.2.0.tgz",
+          "dependencies": {
+            "ms": {
+              "version": "0.7.1",
+              "resolved": "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz"
+            }
+          }
+        },
+        "extend": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.0.tgz"
+        }
+      }
+    },
+    "is-my-json-valid": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmjs.org/is-my-json-valid/-/is-my-json-valid-2.12.1.tgz",
+      "dependencies": {
+        "generate-function": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.0.0.tgz"
+        },
+        "generate-object-property": {
+          "version": "1.2.0",
+          "resolved": "https://registry.npmjs.org/generate-object-property/-/generate-object-property-1.2.0.tgz",
+          "dependencies": {
+            "is-property": {
+              "version": "1.0.2",
+              "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz"
+            }
+          }
+        },
+        "jsonpointer": {
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-1.1.0.tgz"
+        },
+        "xtend": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.0.tgz"
+        }
+      }
+    },
+    "lodash": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz"
+    },
+    "lru-cache": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.5.2.tgz"
+    },
+    "ripple-address-codec": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/ripple-address-codec/-/ripple-address-codec-1.6.0.tgz",
+      "dependencies": {
+        "x-address-codec": {
+          "version": "0.6.0",
+          "resolved": "https://registry.npmjs.org/x-address-codec/-/x-address-codec-0.6.0.tgz",
+          "dependencies": {
+            "base-x": {
+              "version": "1.0.1",
+              "resolved": "https://registry.npmjs.org/base-x/-/base-x-1.0.1.tgz"
+            }
+          }
+        }
+      }
+    },
+    "ripple-keypairs": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/ripple-keypairs/-/ripple-keypairs-0.8.0.tgz",
+      "dependencies": {
+        "brorand": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.0.5.tgz"
+        },
+        "elliptic": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-5.1.0.tgz",
+          "dependencies": {
+            "inherits": {
+              "version": "2.0.1",
+              "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+            }
+          }
+        }
+      }
+    },
+    "ripple-lib-transactionparser": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/ripple-lib-transactionparser/-/ripple-lib-transactionparser-0.5.0.tgz",
+      "dependencies": {
+        "bignumber.js": {
+          "version": "1.4.1",
+          "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-1.4.1.tgz"
+        }
+      }
+    },
+    "sjcl-codec": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/sjcl-codec/-/sjcl-codec-0.1.0.tgz"
+    },
+    "ws": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-0.7.2.tgz",
+      "dependencies": {
+        "bufferutil": {
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-1.1.0.tgz",
+          "dependencies": {
+            "bindings": {
+              "version": "1.2.1",
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
+            },
+            "nan": {
+              "version": "1.8.4",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.8.4.tgz"
+            }
+          }
+        },
+        "options": {
+          "version": "0.0.6",
+          "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz"
+        },
+        "ultron": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.2.tgz"
+        },
+        "utf-8-validate": {
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-1.1.0.tgz",
+          "dependencies": {
+            "bindings": {
+              "version": "1.2.1",
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
+            },
+            "nan": {
+              "version": "1.8.4",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.8.4.tgz"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package.json

@@ -1,42 +1,76 @@
 {
   "name": "ripple-lib",
-  "version": "0.7.19",
-  "description": "Ripple JavaScript client library",
+  "version": "0.13.0-rc6",
+  "license": "ISC",
+  "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
   "files": [
-    "src/js/ripple/*.js",
-    "build/sjcl.js",
-    "bin/rsign.js"
+    "dist/npm/*",
+    "bin/*",
+    "build/*",
+    "test/*",
+    "Gulpfile.js"
   ],
-  "main": "src/js/ripple",
+  "main": "dist/npm/",
   "directories": {
     "test": "test"
   },
   "dependencies": {
-    "async": "~0.2.9",
-    "ws": "~0.4.27",
-    "extend": "~1.1.3",
-    "simple-jsonrpc": "~0.0.2",
-    "jshint-loader": "~0.5.0"
+    "async": "~0.9.0",
+    "babel-runtime": "^5.5.4",
+    "bignumber.js": "^2.0.3",
+    "bn.js": "^3.1.1",
+    "es6-promisify": "^2.0.0",
+    "extend": "~1.2.1",
+    "hash.js": "^1.0.3",
+    "https-proxy-agent": "^1.0.0",
+    "is-my-json-valid": "^2.12.0",
+    "lodash": "^3.1.0",
+    "lru-cache": "~2.5.0",
+    "ripple-address-codec": "^1.6.0",
+    "ripple-keypairs": "^0.8.0",
+    "ripple-lib-transactionparser": "^0.5.0",
+    "sjcl-codec": "0.1.0",
+    "ws": "~0.7.1"
   },
   "devDependencies": {
-    "grunt": "~0.4.1",
-    "grunt-cli": "~0.1.9",
-    "grunt-contrib-concat": "~0.3.0",
-    "grunt-contrib-watch": "~0.4.4",
-    "grunt-webpack": "~0.10.5",
-    "grunt-dox": "~0.5.0",
-    "buster": "~0.6.12"
+    "assert-diff": "^1.0.1",
+    "babel": "^5.8.21",
+    "babel-core": "^5.8.22",
+    "babel-eslint": "^4.0.5",
+    "babel-loader": "^5.3.2",
+    "coveralls": "~2.10.0",
+    "eslint": "^1.2.0",
+    "eslint-plugin-flowtype": "^1.0.0",
+    "eventemitter2": "^0.4.14",
+    "flow-bin": "^0.14",
+    "gulp": "~3.8.10",
+    "gulp-bump": "~0.1.13",
+    "gulp-rename": "~1.2.0",
+    "gulp-uglify": "~1.1.0",
+    "istanbul": "~0.3.5",
+    "mocha": "~2.1.0",
+    "webpack": "~1.5.3",
+    "yargs": "~1.3.1"
   },
   "scripts": {
-    "test": "node_modules/buster/bin/buster-test",
-    "build": "node_modules/.bin/grunt"
+    "build": "gulp",
+    "clean": "rm -rf dist/npm && rm -rf build/flow",
+    "typecheck": "babel --optional runtime --blacklist flow -d build/flow/ src/ && flow check",
+    "compile": "babel -D --optional runtime -d dist/npm/ src/",
+    "watch": "babel -w -D --optional runtime -d dist/npm/ src/",
+    "compile-with-source-maps": "babel -D --optional runtime -s -t -d dist/npm/ src/",
+    "prepublish": "npm run clean && npm run compile",
+    "test": "istanbul test _mocha",
+    "coveralls": "cat ./coverage/lcov.info | coveralls",
+    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc'; echo 'parser: babel-eslint' >> eslintrc; fi; eslint -c eslintrc src/",
+    "perf": "./scripts/perf_test.sh"
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/rippleFoundation/ripple-lib.git"
+    "url": "git://github.com/ripple/ripple-lib.git"
   },
   "readmeFilename": "README.md",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=0.12.0"
   }
 }

scripts/modpow.js

@@ -0,0 +1,44 @@
+var Benchmark;
+try {
+  Benchmark = require('benchmark');
+} catch (e) {
+  console.error("Please install Benchmark.js: npm install benchmark");
+  process.exit(1);
+}
+
+var sjcl = require('../build/sjcl');
+var jsbn = require('../src/js/jsbn/jsbn');
+
+var base = "3f70f29d3f3ae354a6d2536ceafba83cfc787cd91e7acd2b6bde05e62beb8295ae18e3f786726f8d034bbc15bf8331df959f59d431736d5f306aaba63dacec279484e39d76db9b527738072af15730e8b9956a64e8e4dbe868f77d1414a8a8b8bf65380a1f008d39c5fabe1a9f8343929342ab7b4f635bdc52532d764701ff3d8072c475c012ff0c59373e8bc423928d99f58c3a6d9f6ab21ee20bc8e8818fc147db09f60c81906f2c6f73dc69725f075853a89f0cd02a30a8dd86b660ccdeffc292f398efb54088c822774445a6afde471f7dd327ef9996296898a5747726ccaeeceeb2e459df98b4128cb5ab8c7cd20c563f960a1aa770f3c81f13f967b6cc";
+var exponent = "322e393f76a1c22b147e7d193c00c023afb7c1500b006ff1bc1cc8d391fc38bd";
+var modulus = "c7f1bc1dfb1be82d244aef01228c1409c198894eca9e21430f1669b4aa3864c9f37f3d51b2b4ba1ab9e80f59d267fda1521e88b05117993175e004543c6e3611242f24432ce8efa3b81f0ff660b4f91c5d52f2511a6f38181a7bf9abeef72db056508bbb4eeb5f65f161dd2d5b439655d2ae7081fcc62fdcb281520911d96700c85cdaf12e7d1f15b55ade867240722425198d4ce39019550c4c8a921fc231d3e94297688c2d77cd68ee8fdeda38b7f9a274701fef23b4eaa6c1a9c15b2d77f37634930386fc20ec291be95aed9956801e1c76601b09c413ad915ff03bfdc0b6b233686ae59e8caf11750b509ab4e57ee09202239baee3d6e392d1640185e1cd";
+var expected = "5b3823974b3eda87286d3f38499de290bd575d8b02f06720acacf3d50950f9ca0ff6b749f3be03913ddca0b291e0b263bdab6c9cb97e4ab47ee9c235ff20931a8ca358726fab93614e2c549594f5c50b1c979b34f840b6d4fc51d6feb2dd072995421d17862cb405e040fc1ed662a3245a1f97bbafa6d1f7f76c7db6a802e3037acdf01ab5053f5da518d6753477193b9c25e1720519dcb9e2f6e70d5786656d356151845a49861dfc40187eff0e85cd18b1f3f3b97c476472edfa090b868b2388edfffecc521c20df8cebb8aacfb3669b020330dd6ea64b2a3067a972b8f249bccc19347eff43893e916f0949bd5789a5cce0f8b7cd87cece909d679345c0d4";
+
+var BigInteger = jsbn.BigInteger;
+var jsbnBase = new BigInteger(base, 16);
+var jsbnExponent = new BigInteger(exponent, 16);
+var jsbnModulus = new BigInteger(modulus, 16);
+
+var bn = sjcl.bn;
+var sjclBase = new bn(base);
+var sjclExponent = new bn(exponent);
+var sjclModulus = new bn(modulus);
+
+var suite = new Benchmark.Suite;
+
+// add tests
+suite.add('jsbn#modPow', function() {
+  jsbnBase.modPow(jsbnExponent, jsbnModulus);
+});
+suite.add('sjcl#powermodMontgomery', function() {
+  sjclBase.powermodMontgomery(sjclExponent, sjclModulus);
+});
+suite.on('cycle', function(event) {
+  console.log(String(event.target));
+});
+suite.on('complete', function() {
+  console.log('Fastest is ' + this.filter('fastest').pluck('name'));
+});
+// run async
+console.log("Running benchmark...");
+suite.run({ 'async': false });

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
+npm run compile && time node "$DIR/verify_ledger_json.js" "$DEST"

scripts/publish

@@ -0,0 +1,43 @@
+echo "PUBLISH"
+
+function exit_on_error {
+  res=$?
+  [[ ${res:-99} -eq 0 ]] || exit $res
+}
+
+rm -rf build
+
+npm install
+gulp
+npm test
+exit_on_error
+
+echo ""
+echo "publish to npm"
+npm publish
+exit_on_error
+
+rm -rf dist/bower
+echo ""
+echo "publish to bower"
+
+git clone git@github.com:ripple/bower-ripple.git dist/bower
+gulp bower
+exit_on_error
+
+cd dist/bower
+version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
+echo "version: $version"
+git add ripple.js ripple-debug.js ripple-min.js bower.json
+exit_on_error
+
+git commit -m "[TASK] add v$version"
+exit_on_error
+
+git tag "v$version"
+exit_on_error
+
+git push origin master
+git push --tags origin master
+
+cd ..

scripts/publish_rc

@@ -0,0 +1,43 @@
+echo "PUBLISH RELEASE CANDIDATE"
+
+function exit_on_error {
+  res=$?
+  [[ ${res:-99} -eq 0 ]] || exit $res
+}
+
+rm -rf build
+
+npm install
+gulp
+npm test
+exit_on_error
+
+echo ""
+echo "publish rc to npm"
+npm publish --tag beta
+exit_on_error
+
+rm -rf dist/bower
+echo ""
+echo "publish to bower"
+
+git clone git@github.com:ripple/bower-ripple.git dist/bower
+gulp bower
+exit_on_error
+
+cd dist/bower
+version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
+echo "version: $version"
+git add ripple.js ripple-debug.js ripple-min.js bower.json
+exit_on_error
+
+git commit -m "[TASK] add v$version"
+exit_on_error
+
+git tag "v$version"
+exit_on_error
+
+git push origin master
+git push --tags origin master
+
+cd ..

scripts/publish_to_bower

@@ -0,0 +1,12 @@
+rm -rf dist/bower
+git clone git@github.com:ripple/bower-ripple.git dist/bower
+gulp bower
+cd dist/bower
+version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
+echo "version: $version"
+git add ripple.js ripple-debug.js ripple-min.js bower.json
+git commit -m "[TASK] add v$version"
+git tag "v$version"
+git push origin master
+git push --tags origin master
+cd ..

scripts/verify_ledger_json.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-var */
+'use strict';
+
+var fs = require('fs');
+var ripple = require('../dist/npm')._DEPRECATED;
+var Amount = ripple.Amount;
+var Ledger = ripple.Ledger;
+
+function parse_options(from, flags) {
+  var argv = from.slice();
+  var opts_ = {argv: argv};
+
+  flags.forEach(function(f) {
+    // Do we have the flag?
+    var flag_index = argv.indexOf('--' + f);
+    // normalize the name of the flag
+    var flag = f.replace('-', '_');
+    // opts_ has Boolean value for normalized flag key
+    opts_[flag] = flag_index !== -1;
+    if (opts_[flag]) {
+      // remove the flag from the argv
+      argv.splice(flag_index, 1);
+    }
+  });
+  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)');
+  process.exit(1);
+}
+
+var json = fs.readFileSync(opts.argv[0], 'utf-8');
+var ledger = Ledger.from_json(JSON.parse(json));
+
+// This will serialize each accountState object to binary and then back to 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.');
+}
+
+// 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/api/common/constants.js

@@ -0,0 +1,44 @@
+'use strict';
+const core = require('./utils').core;
+const flagIndices = core.Transaction.set_clear_flags.AccountSet;
+const flags = core.Remote.flags.account_root;
+
+const AccountFlags = {
+  passwordSpent: flags.PasswordSpent,
+  requireDestinationTag: flags.RequireDestTag,
+  requireAuthorization: flags.RequireAuth,
+  disallowIncomingXRP: flags.DisallowXRP,
+  disableMasterKey: flags.DisableMaster,
+  noFreeze: flags.NoFreeze,
+  globalFreeze: flags.GlobalFreeze,
+  defaultRipple: flags.DefaultRipple
+};
+
+const AccountFlagIndices = {
+  requireDestinationTag: flagIndices.asfRequireDest,
+  requireAuthorization: flagIndices.asfRequireAuth,
+  disallowIncomingXRP: flagIndices.asfDisallowXRP,
+  disableMasterKey: flagIndices.asfDisableMaster,
+  enableTransactionIDTracking: flagIndices.asfAccountTxnID,
+  noFreeze: flagIndices.asfNoFreeze,
+  globalFreeze: flagIndices.asfGlobalFreeze,
+  defaultRipple: flagIndices.asfDefaultRipple
+};
+
+const AccountFields = {
+  EmailHash: {name: 'emailHash', encoding: 'hex',
+              length: 32, defaults: '0'},
+  WalletLocator: {name: 'walletLocator', encoding: 'hex',
+                  length: 64, defaults: '0'},
+  WalletSize: {name: 'walletSize', defaults: 0},
+  MessageKey: {name: 'messageKey'},
+  Domain: {name: 'domain', encoding: 'hex'},
+  TransferRate: {name: 'transferRate', defaults: 0, shift: 9},
+  Signers: {name: 'signers'}
+};
+
+module.exports = {
+  AccountFields,
+  AccountFlagIndices,
+  AccountFlags
+};

src/api/common/errors.js

@@ -0,0 +1,89 @@
+/* eslint-disable valid-jsdoc */
+'use strict';
+
+/**
+ * Base class for all errors
+ */
+function RippleError(message) {
+  this.message = message;
+}
+RippleError.prototype = new Error();
+RippleError.prototype.name = 'RippleError';
+
+function ValidationError(message) {
+  this.message = message;
+}
+ValidationError.prototype = new RippleError();
+ValidationError.prototype.name = 'ValidationError';
+
+/**
+ * Timeout, disconnects and too busy
+ */
+function NetworkError(message) {
+  this.message = message;
+}
+NetworkError.prototype = new RippleError();
+NetworkError.prototype.name = 'NetworkError';
+
+/**
+ * Failed transactions, no paths found, not enough balance, etc.
+ */
+function RippledNetworkError(message) {
+  this.message = message !== undefined ? message : 'Cannot connect to rippled';
+}
+RippledNetworkError.prototype = new NetworkError();
+
+/**
+ * Failed transactions, no paths found, not enough balance, etc.
+ */
+function TransactionError(message) {
+  this.message = message;
+}
+TransactionError.prototype = new RippleError();
+TransactionError.prototype.name = 'TransactionError';
+
+/**
+ * Asset could not be found
+ */
+function NotFoundError(message) {
+  this.message = message;
+}
+NotFoundError.prototype = new RippleError();
+NotFoundError.prototype.name = 'NotFoundError';
+
+function MissingLedgerHistoryError(message) {
+  this.message = message ||
+    'Server is missing ledger history in the specified range';
+}
+MissingLedgerHistoryError.prototype = new RippleError();
+MissingLedgerHistoryError.prototype.name = 'MissingLedgerHistoryError';
+
+/**
+ * Request timed out
+ */
+function TimeOutError(message) {
+  this.message = message;
+}
+TimeOutError.prototype = new RippleError();
+TimeOutError.prototype.name = 'TimeOutError';
+
+/**
+ * API logic failed to do what it intended
+ */
+function ApiError(message) {
+  this.message = message;
+}
+ApiError.prototype = new RippleError();
+ApiError.prototype.name = 'ApiError';
+
+module.exports = {
+  ValidationError,
+  NetworkError,
+  TransactionError,
+  RippledNetworkError,
+  NotFoundError,
+  MissingLedgerHistoryError,
+  TimeOutError,
+  ApiError,
+  RippleError
+};

src/api/common/index.js

@@ -0,0 +1,21 @@
+'use strict';
+const utils = require('./utils');
+
+module.exports = {
+  core: utils.core,
+  constants: require('./constants'),
+  errors: require('./errors'),
+  validate: require('./validate'),
+  dropsToXrp: utils.dropsToXrp,
+  xrpToDrops: utils.xrpToDrops,
+  toRippledAmount: utils.toRippledAmount,
+  generateAddress: utils.generateAddress,
+  composeAsync: utils.composeAsync,
+  wrapCatch: utils.wrapCatch,
+  convertErrors: utils.convertErrors,
+  convertExceptions: utils.convertExceptions,
+  convertKeysFromSnakeCaseToCamelCase:
+    utils.convertKeysFromSnakeCaseToCamelCase,
+  promisify: utils.promisify,
+  isValidAddress: require('./schema-validator').isValidAddress
+};

src/api/common/schema-validator.js

@@ -0,0 +1,76 @@
+/* @flow */
+'use strict';
+
+const _ = require('lodash');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const validator = require('is-my-json-valid');
+const core = require('./utils').core;
+const ValidationError = require('./errors').ValidationError;
+
+let SCHEMAS = {};
+
+function isValidAddress(address: string): boolean {
+  return typeof address === 'string' && address.length > 0 &&
+    address[0] === 'r' &&
+    core.UInt160.is_valid(address);
+}
+
+function isValidLedgerHash(ledgerHash) {
+  return core.UInt256.is_valid(ledgerHash);
+}
+
+function loadSchema(filepath: string): {} {
+  try {
+    return JSON.parse(fs.readFileSync(filepath, 'utf8'));
+  } catch (e) {
+    throw new Error('Failed to parse schema: ' + filepath);
+  }
+}
+
+function endsWith(str, suffix) {
+  return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+
+function loadSchemas(dir) {
+  const filenames = fs.readdirSync(dir).filter(name => endsWith(name, '.json'));
+  const schemas = filenames.map(name => loadSchema(path.join(dir, name)));
+  const titles = _.map(schemas, schema => schema.title);
+  const duplicates = _.keys(_.pick(_.countBy(titles), count => count > 1));
+  assert(duplicates.length === 0, 'Duplicate schemas for: ' + duplicates);
+  return _.indexBy(schemas, 'title');
+}
+
+function formatSchemaError(error) {
+  return error.field + ' ' + error.message
+    + (error.value ? ' (' + JSON.stringify(error.value) + ')' : '');
+}
+
+function formatSchemaErrors(errors) {
+  return errors.map(formatSchemaError).join(', ');
+}
+
+function schemaValidate(schemaName: string, object: any): void {
+  const formats = {address: isValidAddress,
+                   ledgerHash: isValidLedgerHash};
+  const options = {schemas: SCHEMAS, formats: formats,
+                   verbose: true, greedy: true};
+  const schema = SCHEMAS[schemaName];
+  if (schema === undefined) {
+    throw new Error('schema not found for: ' + schemaName);
+  }
+  const validate = validator(schema, options);
+  const isValid = validate(object);
+  if (!isValid) {
+    throw new ValidationError(formatSchemaErrors(validate.errors));
+  }
+}
+
+SCHEMAS = loadSchemas(path.join(__dirname, './schemas'));
+module.exports = {
+  schemaValidate: schemaValidate,
+  isValidAddress: isValidAddress,
+  loadSchema: loadSchema,
+  SCHEMAS: SCHEMAS
+};

src/api/common/schemas/address.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "address",
+  "description": "A Ripple account address",
+  "type": "string",
+  "format": "address",
+  "pattern": "^r[1-9A-HJ-NP-Za-km-z]{25,34}$"
+}

src/api/common/schemas/adjustment.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "adjustment",
+  "type": "object",
+  "properties": {
+    "address": {"$ref": "address"},
+    "amount": {
+      "type": "object",
+      "properties": {
+        "currency": {"$ref": "currency"},
+        "counterparty": {"$ref": "address"},
+        "value": {"$ref": "value"}
+      },
+      "required": ["currency", "value"],
+      "additionalProperties": false
+    },
+    "tag": {
+      "description": "A string representing an unsigned 32-bit integer most commonly used to refer to a sender's hosted account at a Ripple gateway",
+      "$ref": "uint32"
+    }
+  },
+  "required": ["address", "amount"],
+  "additionalProperties": false
+}

src/api/common/schemas/amount.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "amount",
+  "description": "An Amount on the Ripple Protocol, used also for XRP in the ripple-rest API",
+  "allOf": [
+    {"$ref": "amountbase"},
+    {"required": ["value"]}
+  ]
+}

src/api/common/schemas/amountbase.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "amountbase",
+  "description": "Base class for amount and issue",
+  "type": "object",
+  "properties": {
+    "value": {
+      "description": "The quantity of the currency, denoted as a string to retain floating point precision",
+      "$ref": "value"
+    },
+    "currency": {
+      "description": "The three-character code or hex string used to denote currencies",
+      "$ref": "currency"
+    },
+    "counterparty": {
+      "description": "The Ripple account address of the currency's issuer or gateway",
+      "$ref": "address"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["currency"],
+  "oneOf": [
+    {
+      "properties": {
+        "currency": {
+          "not": {
+            "enum": ["XRP"]
+          }
+        }
+      },
+      "required": ["counterparty"]
+    },
+    {
+      "properties": {
+        "currency": {
+          "enum": ["XRP"]
+        }
+      },
+      "not": {
+        "required": ["counterparty"]
+      }
+    }
+  ]
+}

src/api/common/schemas/balance.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "balance",
+  "description": "Balance amount",
+  "type": "object",
+  "properties": {
+    "value": {
+      "description": "The balance on the trustline",
+      "$ref": "signedValue"
+    },
+    "currency": {
+      "description": "The three-character code or hex string used to denote currencies",
+      "$ref": "currency"
+    },
+    "counterparty": {
+      "description": "The Ripple account address of the currency's issuer or gateway",
+      "$ref": "address"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["currency", "value"],
+  "oneOf": [
+    {
+      "properties": {
+        "currency": {
+          "not": {
+            "enum": ["XRP"]
+          }
+        }
+      },
+      "required": ["counterparty"]
+    },
+    {
+      "properties": {
+        "currency": {
+          "enum": ["XRP"]
+        }
+      },
+      "not": {
+        "required": ["counterparty"]
+      }
+    }
+  ]
+}

src/api/common/schemas/blob.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "blob",
+  "description": "An uppercase hex string representation of a transaction",
+  "type": "string",
+  "minLength": "1",
+  "pattern": "^[0-9A-F]*$"
+}

src/api/common/schemas/currency.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "currency",
+  "description": "The three-character code or hex string used to denote currencies",
+  "type": "string",
+  "pattern": "^([a-zA-Z0-9<>(){}[\\]|?!@#$%^&*]{3}|[A-F0-9]{40})$"
+}

src/api/common/schemas/get-account-info.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getAccountInfo",
+  "type": "object",
+  "properties": {
+    "sequence": {"$ref": "sequence"},
+    "xrpBalance": {"$ref": "value"},
+    "ownerCount": {"type": "integer", "minimum": 0},
+    "previousInitiatedTransactionID": {"$ref": "hash256"},
+    "previousAffectingTransactionID": {"$ref": "hash256"},
+    "previousAffectingTransactionLedgerVersion": {"$ref": "ledgerVersion"}
+  },
+  "required": [
+    "sequence",
+    "xrpBalance",
+    "ownerCount",
+    "previousAffectingTransactionID",
+    "previousAffectingTransactionLedgerVersion"
+  ],
+  "additionalProperties": false
+}

src/api/common/schemas/get-balances.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getBalances",
+  "type": "array",
+  "items": {"$ref": "balance"}
+}

src/api/common/schemas/get-ledger.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getLedger",
+  "type": "object",
+  "properties": {
+    "accepted": {"type": "boolean"},
+    "closed": {"type": "boolean"},
+    "stateHash": {"$ref": "hash256"},
+    "closeTime": {"type": "integer", "minimum": 0},
+    "closeTimeResolution": {"type": "integer", "minimum": 1},
+    "closeFlags": {"type": "integer", "minimum": 0},
+    "ledgerHash": {"$ref": "hash256"},
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "parentLedgerHash": {"$ref": "hash256"},
+    "parentCloseTime": {"type": "integer", "minimum": 0},
+    "totalDrops": {"$ref": "value"},
+    "transactionHash": {"$ref": "hash256"},
+    "transactions": {"type": "array", "items": {"type": "object"}},
+    "rawTransactions": {"type": "string"},
+    "transactionHashes": {"type": "array", "items": {"$ref": "hash256"}},
+    "rawState": {"type": "string"},
+    "stateHashes": {"type": "array", "items": {"$ref": "hash256"}}
+  },
+  "required": [
+    "accepted",
+    "closed",
+    "stateHash",
+    "closeTime",
+    "closeTimeResolution",
+    "closeFlags",
+    "ledgerHash",
+    "ledgerVersion",
+    "parentLedgerHash",
+    "parentCloseTime",
+    "totalDrops",
+    "transactionHash"
+  ],
+  "additionalProperties": false
+}

src/api/common/schemas/get-orderbook.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getOrderbook",
+  "type": "object",
+  "properties": {
+    "bids": {"$ref": "orderbookOrders"},
+    "asks": {"$ref": "orderbookOrders"}
+  },
+  "required": ["bids", "asks"],
+  "additionalProperties": false
+}

src/api/common/schemas/get-orders.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getOrders",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "specification": {"$ref": "order"},
+      "properties": {
+        "type": "object",
+        "properties": {
+          "maker": {"$ref": "address"},
+          "sequence": {"$ref": "sequence"},
+          "makerExchangeRate": {"$ref": "value"}
+        },
+        "required": ["maker", "sequence", "makerExchangeRate"],
+        "addtionalProperties": false
+      }
+    },
+    "required": ["specification", "properties"],
+    "additionalProperties": false
+  }
+}

src/api/common/schemas/get-paths.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getPaths",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "source": {"$ref": "adjustment"},
+      "destination": {"$ref": "adjustment"},
+      "paths": {"type": "string"}
+    },
+    "required": ["source", "destination", "paths"],
+    "additionalProperties": false
+  }
+}

src/api/common/schemas/get-server-info.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getServerInfo",
+  "type": "object",
+  "properties": {
+    "buildVersion": {"type": "string"},
+    "completeLedgers": {"type": "string", "pattern": "[0-9,-]+"},
+    "hostid": {"type": "string"},
+    "ioLatencyMs": {"type": "number"},
+    "load": {
+      "type": "object",
+      "properties": {
+        "jobTypes": {
+          "type": "array",
+          "items": {"type": "object"}
+        },
+        "threads": {"type": "number"}
+      }
+    },
+    "lastClose": {
+      "type": "object",
+      "properties": {
+        "convergeTimeS": {"type": "number"},
+        "proposers": {"type": "integer", "minimum": 0}
+      }
+    },
+    "loadFactor": {"type": "number"},
+    "peers": {"type": "integer", "minimum": 0},
+    "pubkeyNode": {"type": "string"},
+    "pubkeyValidator": {"type": "string"},
+    "serverState": {
+      "type": "string",
+      "enum": ["disconnected", "connected", "syncing", "tracking", "full", "validating", "proposing"]
+    },
+    "validatedLedger": {
+      "type": "object",
+      "properties": {
+        "age": {"type": "integer", "minimum": 0},
+        "baseFeeXrp": {"type": "number"},
+        "hash": {"$ref": "hash256"},
+        "reserveBaseXrp": {"type": "integer", "minimum": 0},
+        "reserveIncXrp": {"type": "integer", "minimum": 0},
+        "seq": {"type": "integer", "minimum": 0}
+      }
+    },
+    "validationQuorum": {"type": "number"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/get-settings.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getSettings",
+  "type": "object",
+  "properties": {
+    "passwordSpent": {"type": "boolean"},
+    "requireDestinationTag": {"type": "boolean"},
+    "requireAuthorization": {"type": "boolean"},
+    "disallowIncomingXRP": {"type": "boolean"},
+    "disableMasterKey": {"type": "boolean"},
+    "enableTransactionIDTracking": {"type": "boolean"},
+    "noFreeze": {"type": "boolean"},
+    "globalFreeze": {"type": "boolean"},
+    "defaultRipple": {"type": "boolean"},
+    "emailHash": {
+      "oneOf": [
+        {"type": "null"},
+        {"$ref": "hash128"}
+      ]
+    },
+    "walletLocator": {
+      "oneOf": [
+        {"type": "null"},
+        {"$ref": "hash256"}
+      ]
+    },
+    "walletSize": {"type": ["integer", "null"]},
+    "messageKey": {"type": "string"},
+    "domain": {"type": "string"},
+    "transferRate": {
+      "oneOf": [
+        {"type": "null"},
+        {"type": "number", "minimum": 1, "maximum": 4.294967295}
+      ]
+    },
+    "signers": {"type": "string"},
+    "regularKey": {"$ref": "address"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/get-transaction.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getTransaction",
+  "oneOf": [
+    {"$ref": "paymentTransaction"},
+    {"$ref": "orderTransaction"},
+    {"$ref": "orderCancellationTransaction"},
+    {"$ref": "trustlineTransaction"},
+    {"$ref": "settingsTransaction"}
+  ]
+}

src/api/common/schemas/get-transactions.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getTransactions",
+  "type": "array",
+  "items": {"$ref": "getTransaction"}
+}

src/api/common/schemas/get-trustlines.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "getTrustlines",
+  "type": "array",
+  "items": {
+    "properties": {
+      "specification": {"$ref": "trustline"},
+      "counterparty": {
+        "properties": {
+          "limit": {"$ref": "value"},
+          "ripplingDisabled": {"type": "boolean"},
+          "frozen": {"type": "boolean"},
+          "authorized": {"type": "boolean"}
+        },
+        "required": ["limit"],
+        "additionalProperties": false
+      },
+      "state": {
+        "properties": {
+          "balance": {"$ref": "value"}
+        },
+        "required": ["balance"],
+        "additionalProperties": false
+      }
+    },
+    "required": ["specification", "counterparty", "state"],
+    "additionalProperties": false
+  }
+}

src/api/common/schemas/hash128.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "hash128",
+  "description": "The hex representation of a 128-bit hash",
+  "type": "string",
+  "pattern": "^[A-F0-9]{32}$"
+}

src/api/common/schemas/hash256.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "hash256",
+  "description": "The hex representation of a 256-bit hash",
+  "type": "string",
+  "pattern": "^[A-F0-9]{64}$"
+}

src/api/common/schemas/instructions.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "instructions",
+  "description": "Instructions for executing a transaction",
+  "type": "object",
+  "properties": {
+    "sequence": {
+      "description": "The sequence number, relative to the initiating account, of this transaction.",
+      "$ref": "sequence"
+    },
+    "fee": {
+      "description": "Fixed Fee",
+      "$ref": "value"
+    },
+    "maxFee": {
+      "description": "Max Fee",
+      "$ref": "value"
+    },
+    "maxLedgerVersion": {
+      "description": "Highest ledger version number that a transaction can appear in.",
+      "$ref": "ledgerVersion"
+    },
+    "maxLedgerVersionOffset": {
+      "description": "Offset from current legder version to highest ledger version that a transaction can appear in.",
+      "type": "integer",
+      "minimum": 0
+    }
+  },
+  "additionalProperties": false,
+  "not": {
+    "anyOf": [
+      {
+        "description": "fee and maxFee are mutually exclusive",
+        "required": ["fee", "maxFee"]
+      },
+      {
+        "description": "maxLedgerVersion and maxLedgerVersionOffset are mutually exclusive",
+        "required": ["maxLedgerVersion", "maxLedgerVersionOffset"]
+      }
+    ]
+  }
+}

src/api/common/schemas/issue.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "issue",
+  "description": "A currency-counterparty pair, or just currency if it's XRP",
+  "allOf": [
+    {"$ref": "amountbase"},
+    {"not": {"required": ["value"]}}
+  ]
+}

src/api/common/schemas/ledger-options.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "ledger-options",
+  "description": "Options for getLedger",
+  "type": "object",
+  "properties": {
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "includeAllData": {"type": "boolean"},
+    "includeTransactions": {"type": "boolean"},
+    "includeState": {"type": "boolean"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/ledgerversion.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "ledgerVersion",
+  "description": "A ledger version number",
+  "type": "integer",
+  "minimum": 1
+}

src/api/common/schemas/max-adjustment.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "maxAdjustment",
+  "type": "object",
+  "properties": {
+    "address": {"$ref": "address"},
+    "maxAmount": {
+      "type": "object",
+      "properties": {
+        "currency": {"$ref": "currency"},
+        "counterparty": {"$ref": "address"},
+        "value": {"$ref": "value"}
+      },
+      "required": ["currency", "value"],
+      "additionalProperties": false
+    },
+    "tag": {
+      "description": "A string representing an unsigned 32-bit integer most commonly used to refer to a sender's hosted account at a Ripple gateway",
+      "$ref": "uint32"
+    }
+  },
+  "required": ["address", "maxAmount"],
+  "additionalProperties": false
+}

src/api/common/schemas/memo.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "memo",
+  "description": "Memo objects represent arbitrary data that can be included in a transaction",
+  "type": "object",
+  "properties": {
+    "type": {
+      "pattern": "^[A-Za-z0-9\\-._~:/?#[\\]@!$&'()*+,;=%]*$"
+    },
+    "format": {
+      "pattern": "^[A-Za-z0-9\\-._~:/?#[\\]@!$&'()*+,;=%]*$"
+    },
+    "data": {
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "anyOf": [
+    {"required": ["data"]},
+    {"required": ["type"]}
+  ]
+}

src/api/common/schemas/order-cancellation-transaction.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderCancellationTransaction",
+  "type": "object",
+  "properties": {
+    "type": {"enum": ["orderCancellation"]},
+    "specification": {"$ref": "orderCancellation"},
+    "outcome": {"$ref": "outcome"},
+    "id": {"$ref": "hash256"},
+    "address": {"$ref": "address"},
+    "sequence": {"$ref": "sequence"}
+  },
+  "required": ["type", "id", "address", "sequence", "specification", "outcome"],
+  "additionalProperties": false
+}

src/api/common/schemas/order-cancellation.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderCancellation",
+  "type": "object",
+  "properties": {
+    "orderSequence": {"$ref": "sequence"}
+  },
+  "required": ["orderSequence"],
+  "additionalProperties": false
+}

src/api/common/schemas/order-change.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderChange",
+  "type": "object",
+  "properties": {
+    "direction": {
+      "type": "string",
+      "enum": ["buy", "sell"]
+    },
+    "quantity": {"$ref": "balance"},
+    "totalPrice": {"$ref": "balance"},
+    "sequence": {"$ref": "sequence"},
+    "status": {"enum": ["created", "open", "closed", "canceled"]}
+  },
+  "required": ["direction", "quantity", "totalPrice", "sequence", "status"],
+  "additionalProperties": false
+}

src/api/common/schemas/order-transaction.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderTransaction",
+  "type": "object",
+  "properties": {
+    "type": {"enum": ["order"]},
+    "specification": {"$ref": "order"},
+    "outcome": {"$ref": "outcome"},
+    "id": {"$ref": "hash256"},
+    "address": {"$ref": "address"},
+    "sequence": {"$ref": "sequence"}
+  },
+  "required": ["type", "id", "address", "sequence", "specification", "outcome"],
+  "additionalProperties": false
+}

src/api/common/schemas/order.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "order",
+  "type": "object",
+  "properties": {
+    "direction": {
+      "type": "string",
+      "enum": ["buy", "sell"]
+    },
+    "quantity": {"$ref": "amount"},
+    "totalPrice": {"$ref": "amount"},
+    "immediateOrCancel": {"type": "boolean"},
+    "fillOrKill": {"type": "boolean"},
+    "passive": {
+      "description": "If enabled, the offer will not consume offers that exactly match it, and instead becomes an Offer node in the ledger. It will still consume offers that cross it.",
+      "type": "boolean"
+    }
+  },
+  "required": ["direction", "quantity", "totalPrice"],
+  "additionalProperties": false,
+  "not": {
+    "description": "immediateOrCancel and fillOrKill are mutually exclusive",
+    "required": ["immediateOrCancel", "fillOrKill"]
+  }
+}

src/api/common/schemas/orderbook-orders.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderbookOrders",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "specification": {"$ref": "order"},
+      "properties": {
+        "type": "object",
+        "properties": {
+          "maker": {"$ref": "address"},
+          "sequence": {"$ref": "sequence"},
+          "makerExchangeRate": {"$ref": "value"}
+        },
+        "required": ["maker", "sequence", "makerExchangeRate"],
+        "addtionalProperties": false
+      },
+      "state": {
+        "type": "object",
+        "properties": {
+          "fundedAmount": {"$ref": "amount"},
+          "priceOfFundedAmount": {"$ref": "amount"}
+        },
+        "required": ["fundedAmount", "priceOfFundedAmount"],
+        "additionalProperties": false
+      }
+    },
+    "required": ["specification", "properties"],
+    "additionalProperties": false
+  }
+}

src/api/common/schemas/orderbook.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orderbook",
+  "type": "object",
+  "properties": {
+    "base": {"$ref": "issue"},
+    "counter": {"$ref": "issue"}
+  },
+  "required": ["base", "counter"],
+  "additionalProperties": false
+}

src/api/common/schemas/orders-options.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "orders-options",
+  "description": "Options for getOrders and getOrderbook",
+  "type": "object",
+  "properties": {
+    "limit": {
+      "type": "integer",
+      "minimum": 1
+    },
+    "ledgerVersion": {"$ref": "ledgerVersion"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/outcome.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "outcome",
+  "type": "object",
+  "properties": {
+    "result": {"type": "string"},
+    "timestamp": {"type": "string"},
+    "fee": {"$ref": "value"},
+    "balanceChanges": {
+      "type": "object",
+      "description": "Key is the ripple address; value is an array of changes",
+      "additionalProperties": {
+        "type": "array",
+        "items": {"$ref": "balance"}
+      }
+    },
+    "orderbookChanges": {
+      "type": "object",
+      "description": "Key is the maker's ripple address; value is an array of changes",
+      "additionalProperties": {
+        "type": "array",
+        "items": {"$ref": "orderChange"}
+      }
+    },
+    "ledgerVersion": {"$ref": "ledgerVersion"},
+    "indexInLedger": {"type": "integer", "minimum": 0}
+  },
+  "required": ["result", "fee", "balanceChanges",
+    "orderbookChanges", "ledgerVersion", "indexInLedger"],
+  "additionalProperties": false
+}

src/api/common/schemas/pathfind.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "pathfind",
+  "type": "object",
+  "properties": {
+    "source": {
+      "type": "object",
+      "properties": {
+        "address": {"$ref": "address"},
+        "currencies": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "currency": {"$ref": "currency"},
+              "counterparty": {"$ref": "address"}
+            },
+            "required": ["currency"],
+            "additionalProperties": false
+          },
+          "uniqueItems": true
+        }
+      },
+      "additionalProperties": false,
+      "required": ["address"]
+    },
+    "destination": {"$ref": "adjustment"}
+  },
+  "required": ["source", "destination"],
+  "additionalProperties": false
+}

src/api/common/schemas/payment-transaction.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "paymentTransaction",
+  "type": "object",
+  "properties": {
+    "type": {"enum": ["payment"]},
+    "specification": {"$ref": "payment"},
+    "outcome": {"$ref": "outcome"},
+    "id": {"$ref": "hash256"},
+    "address": {"$ref": "address"},
+    "sequence": {"$ref": "sequence"}
+  },
+  "required": ["type", "id", "address", "sequence", "specification", "outcome"],
+  "additionalProperties": false
+}

src/api/common/schemas/payment.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "payment",
+  "type": "object",
+  "properties": {
+    "source": {"$ref": "maxAdjustment"},
+    "destination": {"$ref": "adjustment"},
+    "paths": {"type": "string"},
+    "memos": {
+      "type": "array",
+      "items": {
+        "$ref": "memo"
+      }
+    },
+    "invoiceID": {
+      "description": "A 256-bit hash that can be used to identify a particular payment",
+      "$ref": "hash256"
+    },
+    "allowPartialPayment": {
+      "description": "A boolean that, if set to true, indicates that this payment should go through even if the whole amount cannot be delivered because of a lack of liquidity or funds in the source_account account",
+      "type": "boolean"
+    },
+    "noDirectRipple": {
+      "description": "A boolean that can be set to true if paths are specified and the sender would like the Ripple Network to disregard any direct paths from the source_account to the destination_account. This may be used to take advantage of an arbitrage opportunity or by gateways wishing to issue balances from a hot wallet to a user who has mistakenly set a trustline directly to the hot wallet",
+      "type": "boolean"
+    },
+    "limitQuality": {"type": "boolean"}
+  },
+  "required": ["source", "destination"],
+  "additionalProperties": false
+}

src/api/common/schemas/quality.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "quality",
+  "description": "Ratio for incoming/outgoing transit fees.",
+  "type": "number",
+  "minimum": 0.000000001,
+  "maximum": 4.294967295
+}

src/api/common/schemas/remote-options.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "remote-options",
+  "type": "object",
+  "properties": {
+    "trace": {"type": "boolean"},
+    "servers": {"type": "array", "items": {"type": "string", "format": "uri"}}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/sequence.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "sequence",
+  "description": "An account transaction sequence number",
+  "type": "integer",
+  "minimum": 1
+}

src/api/common/schemas/settings-options.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "settings-options",
+  "description": "Options for getSettings and getAccountInfo",
+  "type": "object",
+  "properties": {
+    "ledgerVersion": {"$ref": "ledgerVersion"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/settings-transaction.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "settingsTransaction",
+  "type": "object",
+  "properties": {
+    "type": {"enum": ["settings"]},
+    "specification": {"$ref": "getSettings"},
+    "outcome": {"$ref": "outcome"},
+    "id": {"$ref": "hash256"},
+    "address": {"$ref": "address"},
+    "sequence": {"$ref": "sequence"}
+  },
+  "required": ["type", "id", "address", "sequence", "specification"],
+  "additionalProperties": false
+}

src/api/common/schemas/settings.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "settings",
+  "allOf": [
+    {
+      "$ref": "getSettings"
+    },
+    {
+      "minProperties": 1,
+      "maxProperties": 1
+    }
+  ]
+}

src/api/common/schemas/sign.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "sign",
+  "type": "object",
+  "properties": {
+    "signedTransaction": {
+      "type": "string",
+      "pattern": "^[A-F0-9]+$"
+    },
+    "id": {"$ref": "hash256"}
+  },
+  "required": ["signedTransaction", "id"],
+  "additionalProperties": false
+}

src/api/common/schemas/signed-value.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "signedValue",
+  "description": "A string representation of a floating point number",
+  "type": "string",
+  "pattern": "^[-]?[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?$"
+}

src/api/common/schemas/submit.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "submit",
+  "type": "object",
+  "properties": {
+    "success": {"type": "boolean"},
+    "engineResult": {"type": "string"},
+    "engineResultCode": {"type": "integer"},
+    "engineResultMessage": {"type": "string"},
+    "txBlob": {"type": "string"},
+    "txJson": {"type": "object"}
+  },
+  "required": ["success", "engineResult", "engineResultCode"],
+  "additionalProperties": false
+}

src/api/common/schemas/timestamp.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "timestamp",
+  "description": "An ISO 8601 combined date and time timestamp",
+  "type": "string",
+  "pattern": "^$|^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T(2[0-3]|[01][0-9]):[0-5][0-9]:[0-5][0-9](Z|[+](2[0-3]|[01][0-9]):[0-5][0-9])$"
+}

src/api/common/schemas/transaction-options.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "transaction-options",
+  "description": "Options for getTransaction",
+  "type": "object",
+  "properties": {
+    "minLedgerVersion": {"$ref": "ledgerVersion"},
+    "maxLedgerVersion": {"$ref": "ledgerVersion"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/transactions-options.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "transactions-options",
+  "description": "Options for getTransactions",
+  "type": "object",
+  "properties": {
+    "start": {"$ref": "hash256"},
+    "limit": {
+      "type": "integer",
+      "minimum": 1
+    },
+    "minLedgerVersion": {"$ref": "ledgerVersion"},
+    "maxLedgerVersion": {"$ref": "ledgerVersion"},
+    "earliestFirst": {"type": "boolean"},
+    "excludeFailures": {"type": "boolean"},
+    "initiated": {"type": "boolean"},
+    "counterparty": {"$ref": "address"},
+    "types": {
+      "type": "array",
+      "items": {
+        "enum": [
+          "payment",
+          "trustline",
+          "order",
+          "orderCancellation",
+          "settings"
+        ]
+      }
+    },
+    "binary": {"type": "boolean"}
+  },
+  "additionalProperties": false,
+  "not": {
+    "anyOf": [
+      {"required": ["incoming", "outgoing"]},
+      {"required": ["start", "minLedgerVersion"]},
+      {"required": ["start", "maxLedgerVersion"]}
+    ]
+  }
+}

src/api/common/schemas/trustline-transaction.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "trustlineTransaction",
+  "type": "object",
+  "properties": {
+    "type": {"enum": ["trustline"]},
+    "specification": {"$ref": "trustline"},
+    "outcome": {"$ref": "outcome"},
+    "id": {"$ref": "hash256"},
+    "address": {"$ref": "address"},
+    "sequence": {"$ref": "sequence"}
+  },
+  "required": ["type", "id", "address", "sequence", "specification", "outcome"],
+  "additionalProperties": false
+}

src/api/common/schemas/trustline.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "trustline",
+  "type": "object",
+  "properties": {
+    "currency": {"$ref": "currency"},
+    "counterparty": {"$ref": "address"},
+    "limit": {"$ref": "value"},
+    "qualityIn": {"$ref": "quality"},
+    "qualityOut": {"$ref": "quality"},
+    "ripplingDisabled": {"type": "boolean"},
+    "authorized": {"type": "boolean"},
+    "frozen": {"type": "boolean"}
+  },
+  "required": ["currency", "counterparty", "limit"],
+  "additionalProperties": false
+}

src/api/common/schemas/trustlines-options.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "trustlines-options",
+  "description": "Options for getTrustlines and getBalances",
+  "type": "object",
+  "properties": {
+    "counterparty": {"$ref": "address"},
+    "currency": {"$ref": "currency"},
+    "limit": {
+      "type": "integer",
+      "minimum": 1
+    },
+    "ledgerVersion": {"$ref": "ledgerVersion"}
+  },
+  "additionalProperties": false
+}

src/api/common/schemas/tx.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "tx",
+  "description": "An object in rippled txJSON format",
+  "type": "object",
+  "properties": {
+    "Account": {"$ref": "address"}
+  },
+  "required": ["Account"]
+}

src/api/common/schemas/uint32.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "uint32",
+  "description": "A 32-bit unsigned integer",
+  "type": "integer",
+  "minimum": 0,
+  "maximum": 4294967295
+}

src/api/common/schemas/value.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "value",
+  "description": "A string representation of a non-negative floating point number",
+  "type": "string",
+  "pattern": "^[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?$"
+}

src/api/common/utils.js

@@ -0,0 +1,121 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const BigNumber = require('bignumber.js');
+const core = require('../../core');
+const errors = require('./errors');
+const es6promisify = require('es6-promisify');
+const keypairs = require('ripple-keypairs');
+
+type Amount = {currency: string, issuer: string, value: string}
+
+function dropsToXrp(drops: string): string {
+  return (new BigNumber(drops)).dividedBy(1000000.0).toString();
+}
+
+function xrpToDrops(xrp: string): string {
+  return (new BigNumber(xrp)).times(1000000.0).floor().toString();
+}
+
+function toRippledAmount(amount: Amount): string|Amount {
+  if (amount.currency === 'XRP') {
+    return xrpToDrops(amount.value);
+  }
+  return {
+    currency: amount.currency,
+    issuer: amount.counterparty ? amount.counterparty : amount.issuer,
+    value: amount.value
+  };
+}
+
+function generateAddress(options?: Object): Object {
+  const {accountID, seed} = keypairs.generateWallet(options);
+  return {secret: seed, address: accountID};
+}
+
+type AsyncFunction = (...x: any) => void
+
+function wrapCatch(asyncFunction: AsyncFunction): AsyncFunction {
+  return function() {
+    try {
+      asyncFunction.apply(this, arguments);
+    } catch (error) {
+      const callback = arguments[arguments.length - 1];
+      callback(error);
+    }
+  };
+}
+
+type Callback = (err: any, data: any) => void
+type Wrapper = (data: any) => any
+
+function composeAsync(wrapper: Wrapper, callback: Callback): Callback {
+  return function(error, data) {
+    if (error) {
+      callback(error);
+      return;
+    }
+    let result;
+    try {
+      result = wrapper(data);
+    } catch (exception) {
+      callback(exception);
+      return;
+    }
+    callback(null, result);
+  };
+}
+
+function convertErrors(callback: () => void): () => void {
+  return function(error, data) {
+    if (error && !(error instanceof errors.RippleError)) {
+      callback(new errors.RippleError(error));
+    } else {
+      callback(error, data);
+    }
+  };
+}
+
+function convertExceptions<T>(f: () => T): () => T {
+  return function() {
+    try {
+      return f.apply(this, arguments);
+    } catch (error) {
+      throw new errors.ApiError(error.message);
+    }
+  };
+}
+
+const FINDSNAKE = /([a-zA-Z]_[a-zA-Z])/g;
+function convertKeysFromSnakeCaseToCamelCase(obj: any): any {
+  if (typeof obj === 'object') {
+    let newKey;
+    return _.reduce(obj, (result, value, key) => {
+      newKey = key;
+      if (FINDSNAKE.test(key)) {
+        newKey = key.replace(FINDSNAKE, r => r[0] + r[2].toUpperCase());
+      }
+      result[newKey] = convertKeysFromSnakeCaseToCamelCase(value);
+      return result;
+    }, {});
+  }
+  return obj;
+}
+
+function promisify(asyncFunction: AsyncFunction): Function {
+  return es6promisify(wrapCatch(asyncFunction));
+}
+
+module.exports = {
+  core,
+  dropsToXrp,
+  xrpToDrops,
+  toRippledAmount,
+  generateAddress,
+  composeAsync,
+  wrapCatch,
+  convertExceptions,
+  convertErrors,
+  convertKeysFromSnakeCaseToCamelCase,
+  promisify
+};

src/api/common/validate.js

@@ -0,0 +1,81 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const core = require('./utils').core;
+const ValidationError = require('./errors').ValidationError;
+const schemaValidate = require('./schema-validator').schemaValidate;
+
+function error(text) {
+  return new ValidationError(text);
+}
+
+function validateAddressAndSecret(obj: {address: string, secret: string}
+): void {
+  const address = obj.address;
+  const secret = obj.secret;
+  schemaValidate('address', address);
+  if (!secret) {
+    throw error('Parameter missing: secret');
+  }
+  if (!core.Seed.from_json(secret).is_valid()) {
+    throw error('secret is invalid');
+  }
+}
+
+function validateSecret(secret: string): void {
+  if (!secret) {
+    throw error('Parameter missing: secret');
+  }
+  if (typeof secret !== 'string' || secret[0] !== 's') {
+    throw error('Invalid parameter');
+  }
+
+  const seed = new core.Seed().parse_base58(secret);
+  if (!seed.is_valid()) {
+    throw error('invalid seed');
+  }
+}
+
+function validateLedgerRange(options) {
+  if (!_.isUndefined(options.minLedgerVersion)
+      && !_.isUndefined(options.maxLedgerVersion)) {
+    if (Number(options.minLedgerVersion) > Number(options.maxLedgerVersion)) {
+      throw error('minLedgerVersion must not be greater than maxLedgerVersion');
+    }
+  }
+}
+
+function validateOptions(schema, options) {
+  schemaValidate(schema, options);
+  validateLedgerRange(options);
+}
+
+module.exports = {
+  address: _.partial(schemaValidate, 'address'),
+  addressAndSecret: validateAddressAndSecret,
+  secret: validateSecret,
+  currency: _.partial(schemaValidate, 'currency'),
+  identifier: _.partial(schemaValidate, 'hash256'),
+  ledgerVersion: _.partial(schemaValidate, 'ledgerVersion'),
+  sequence: _.partial(schemaValidate, 'sequence'),
+  order: _.partial(schemaValidate, 'order'),
+  orderbook: _.partial(schemaValidate, 'orderbook'),
+  payment: _.partial(schemaValidate, 'payment'),
+  pathfind: _.partial(schemaValidate, 'pathfind'),
+  settings: _.partial(schemaValidate, 'settings'),
+  trustline: _.partial(schemaValidate, 'trustline'),
+  txJSON: _.partial(schemaValidate, 'tx'),
+  blob: _.partial(schemaValidate, 'blob'),
+  getTransactionsOptions: _.partial(validateOptions, 'transactions-options'),
+  getSettingsOptions: _.partial(validateOptions, 'settings-options'),
+  getAccountInfoOptions: _.partial(validateOptions, 'settings-options'),
+  getTrustlinesOptions: _.partial(validateOptions, 'trustlines-options'),
+  getBalancesOptions: _.partial(validateOptions, 'trustlines-options'),
+  getOrdersOptions: _.partial(validateOptions, 'orders-options'),
+  getOrderbookOptions: _.partial(validateOptions, 'orders-options'),
+  getTransactionOptions: _.partial(validateOptions, 'transaction-options'),
+  getLedgerOptions: _.partial(validateOptions, 'ledger-options'),
+  options: _.partial(validateOptions, 'options'),
+  remoteOptions: _.partial(schemaValidate, 'remote-options'),
+  instructions: _.partial(schemaValidate, 'instructions')
+};

src/api/index.js

@@ -0,0 +1,82 @@
+/* @flow */
+
+'use strict';
+const _ = require('lodash');
+const common = require('./common');
+const server = require('./server/server');
+const connect = server.connect;
+const disconnect = server.disconnect;
+const getServerInfo = server.getServerInfo;
+const getFee = server.getFee;
+const isConnected = server.isConnected;
+const getLedgerVersion = server.getLedgerVersion;
+const getTransaction = require('./ledger/transaction');
+const getTransactions = require('./ledger/transactions');
+const getTrustlines = require('./ledger/trustlines');
+const getBalances = require('./ledger/balances');
+const getPaths = require('./ledger/pathfind');
+const getOrders = require('./ledger/orders');
+const getOrderbook = require('./ledger/orderbook');
+const getSettings = require('./ledger/settings');
+const getAccountInfo = require('./ledger/accountinfo');
+const preparePayment = require('./transaction/payment');
+const prepareTrustline = require('./transaction/trustline');
+const prepareOrder = require('./transaction/order');
+const prepareOrderCancellation = require('./transaction/ordercancellation');
+const prepareSettings = require('./transaction/settings');
+const sign = require('./transaction/sign');
+const submit = require('./transaction/submit');
+const errors = require('./common').errors;
+const convertExceptions = require('./common').convertExceptions;
+const generateAddress = convertExceptions(common.generateAddress);
+const computeLedgerHash = require('./offline/ledgerhash');
+const getLedger = require('./ledger/ledger');
+const isValidAddress = common.isValidAddress;
+
+function RippleAPI(options: {}) {
+  common.validate.remoteOptions(options);
+  const _options = _.assign({}, options, {automatic_resubmission: false});
+  this.remote = new common.core.Remote(_options);
+}
+
+RippleAPI.prototype = {
+  connect,
+  disconnect,
+  isConnected,
+  getServerInfo,
+  getFee,
+  getLedgerVersion,
+
+  getTransaction,
+  getTransactions,
+  getTrustlines,
+  getBalances,
+  getPaths,
+  getOrders,
+  getOrderbook,
+  getSettings,
+  getAccountInfo,
+  getLedger,
+
+  preparePayment,
+  prepareTrustline,
+  prepareOrder,
+  prepareOrderCancellation,
+  prepareSettings,
+  sign,
+  submit,
+
+  computeLedgerHash,
+  isValidAddress,
+  generateAddress,
+  errors
+};
+
+// these are exposed only for use by unit tests; they are not part of the API
+RippleAPI._PRIVATE = {
+  common: common,
+  ledgerUtils: require('./ledger/utils'),
+  schemaValidator: require('./common/schema-validator')
+};
+
+module.exports = RippleAPI;

src/api/ledger/accountinfo.js

@@ -0,0 +1,78 @@
+/* @flow */
+
+'use strict';
+const utils = require('./utils');
+const removeUndefined = require('./parse/utils').removeUndefined;
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+
+type AccountData = {
+  Sequence: number,
+  Account: string,
+  Balance: string,
+  Flags: number,
+  LedgerEntryType: string,
+  OwnerCount: number,
+  PreviousTxnID: string,
+  AccountTxnID?: string,
+  PreviousTxnLgrSeq: number,
+  index: string
+}
+
+type AccountDataResponse = {
+  account_data: AccountData,
+  ledger_current_index?: number,
+  ledger_hash?: string,
+  ledger_index: number,
+  validated: boolean
+}
+
+type AccountInfoOptions = {
+  ledgerVersion?: number
+}
+
+type AccountInfoCallback = (err: any, data: AccountInfoResponse) => void
+
+type AccountInfoResponse = {
+  sequence: number,
+  xrpBalance: string,
+  ownerCount: number,
+  previousInitiatedTransactionID: string,
+  previousAffectingTransactionID: string,
+  previousAffectingTransactionLedgerVersion: number
+}
+
+function formatAccountInfo(response: AccountDataResponse) {
+  const data = response.account_data;
+  return removeUndefined({
+    sequence: data.Sequence,
+    xrpBalance: utils.common.dropsToXrp(data.Balance),
+    ownerCount: data.OwnerCount,
+    previousInitiatedTransactionID: data.AccountTxnID,
+    previousAffectingTransactionID: data.PreviousTxnID,
+    previousAffectingTransactionLedgerVersion: data.PreviousTxnLgrSeq
+  });
+}
+
+function getAccountInfoAsync(account: string, options: AccountInfoOptions,
+                             callback: AccountInfoCallback
+) {
+  validate.address(account);
+  validate.getAccountInfoOptions(options);
+
+  const request = {
+    account: account,
+    ledger: options.ledgerVersion || 'validated'
+  };
+
+  this.remote.requestAccountInfo(request,
+    composeAsync(formatAccountInfo, convertErrors(callback)));
+}
+
+function getAccountInfo(account: string, options: AccountInfoOptions = {}
+): Promise<AccountInfoResponse> {
+  return utils.promisify(getAccountInfoAsync).call(this, account, options);
+}
+
+module.exports = getAccountInfo;

src/api/ledger/balances.js

@@ -0,0 +1,50 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const async = require('async');
+const utils = require('./utils');
+const getTrustlines = require('./trustlines');
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+
+function getTrustlineBalanceAmount(trustline) {
+  return {
+    currency: trustline.specification.currency,
+    counterparty: trustline.specification.counterparty,
+    value: trustline.state.balance
+  };
+}
+
+function formatBalances(balances) {
+  const xrpBalance = {
+    currency: 'XRP',
+    value: balances.xrp
+  };
+  return [xrpBalance].concat(
+    balances.trustlines.map(getTrustlineBalanceAmount));
+}
+
+function getTrustlinesAsync(account, options, callback) {
+  getTrustlines.call(this, account, options)
+    .then(data => callback(null, data))
+    .catch(callback);
+}
+
+function getBalancesAsync(account, options, callback) {
+  validate.address(account);
+  validate.getBalancesOptions(options);
+
+  const ledgerVersion = options.ledgerVersion
+                      || this.remote.getLedgerSequence();
+  async.parallel({
+    xrp: _.partial(utils.getXRPBalance, this.remote, account, ledgerVersion),
+    trustlines: _.partial(getTrustlinesAsync.bind(this), account, options)
+  }, composeAsync(formatBalances, convertErrors(callback)));
+}
+
+function getBalances(account: string, options = {}) {
+  return utils.promisify(getBalancesAsync).call(this, account, options);
+}
+
+module.exports = getBalances;

src/api/ledger/ledger.js

@@ -0,0 +1,28 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+const parseLedger = require('./parse/ledger');
+
+function getLedgerAsync(options, callback) {
+  validate.getLedgerOptions(options);
+
+  const request = {
+    ledger: options.ledgerVersion || 'validated',
+    expand: options.includeAllData,
+    transactions: options.includeTransactions,
+    accounts: options.includeState
+  };
+
+  this.remote.requestLedger(request,
+    composeAsync(response => parseLedger(response.ledger),
+    convertErrors(callback)));
+}
+
+function getLedger(options = {}) {
+  return utils.promisify(getLedgerAsync).call(this, options);
+}
+
+module.exports = getLedger;

src/api/ledger/orderbook.js

@@ -0,0 +1,86 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const async = require('async');
+const utils = require('./utils');
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+const parseOrderbookOrder = require('./parse/orderbook-order');
+
+// account is to specify a "perspective", which affects which unfunded offers
+// are returned
+function getBookOffers(remote, account, ledgerVersion, limit,
+    takerGets, takerPays, callback
+) {
+  remote.requestBookOffers(utils.renameCounterpartyToIssuerInOrder({
+    taker_gets: takerGets,
+    taker_pays: takerPays,
+    ledger: ledgerVersion || 'validated',
+    limit: limit,
+    taker: account
+  }), composeAsync(data => data.offers, convertErrors(callback)));
+}
+
+function isSameIssue(a, b) {
+  return a.currency === b.currency && a.counterparty === b.counterparty;
+}
+
+function directionFilter(direction, order) {
+  return order.specification.direction === direction;
+}
+
+function flipOrder(order) {
+  const specification = order.specification;
+  const flippedSpecification = {
+    quantity: specification.totalPrice,
+    totalPrice: specification.quantity,
+    direction: specification.direction === 'buy' ? 'sell' : 'buy'
+  };
+  const newSpecification = _.merge({}, specification, flippedSpecification);
+  return _.merge({}, order, {specification: newSpecification});
+}
+
+function alignOrder(base, order) {
+  const quantity = order.specification.quantity;
+  return isSameIssue(quantity, base) ? order : flipOrder(order);
+}
+
+function formatBidsAndAsks(orderbook, offers) {
+  // the "base" currency is the currency that you are buying or selling
+  // the "counter" is the currency that the "base" is priced in
+  // a "bid"/"ask" is an order to buy/sell the base, respectively
+  // for bids: takerGets = totalPrice = counter, takerPays = quantity = base
+  // for asks: takerGets = quantity = base, takerPays = totalPrice = counter
+  // quality = takerPays / takerGets; price = totalPrice / quantity
+  // for bids: lowest quality => lowest quantity/totalPrice => highest price
+  // for asks: lowest quality => lowest totalPrice/quantity => lowest price
+  // for both bids and asks, lowest quality is closest to mid-market
+  // we sort the orders so that earlier orders are closer to mid-market
+  const orders = _.sortBy(offers, 'quality').map(parseOrderbookOrder);
+  const alignedOrders = orders.map(_.partial(alignOrder, orderbook.base));
+  const bids = alignedOrders.filter(_.partial(directionFilter, 'buy'));
+  const asks = alignedOrders.filter(_.partial(directionFilter, 'sell'));
+  return {bids, asks};
+}
+
+function getOrderbookAsync(account, orderbook, options, callback) {
+  validate.address(account);
+  validate.orderbook(orderbook);
+  validate.getOrderbookOptions(options);
+
+  const getter = _.partial(getBookOffers, this.remote, account,
+    options.ledgerVersion, options.limit);
+  const getOffers = _.partial(getter, orderbook.base, orderbook.counter);
+  const getReverseOffers = _.partial(getter, orderbook.counter, orderbook.base);
+  async.parallel([getOffers, getReverseOffers],
+    composeAsync((data) => formatBidsAndAsks(orderbook, _.flatten(data)),
+                 callback));
+}
+
+function getOrderbook(account: string, orderbook: Object, options = {}) {
+  return utils.promisify(getOrderbookAsync).call(this,
+    account, orderbook, options);
+}
+
+module.exports = getOrderbook;

src/api/ledger/orders.js

@@ -0,0 +1,42 @@
+/* @flow */
+'use strict';
+const _ = require('lodash');
+const utils = require('./utils');
+const validate = utils.common.validate;
+const composeAsync = utils.common.composeAsync;
+const convertErrors = utils.common.convertErrors;
+const parseAccountOrder = require('./parse/account-order');
+
+function requestAccountOffers(remote, address, ledgerVersion, marker, limit,
+  callback
+) {
+  remote.requestAccountOffers({
+    account: address,
+    marker: marker,
+    limit: utils.clamp(limit, 10, 400),
+    ledger: ledgerVersion
+  },
+  composeAsync((data) => ({
+    marker: data.marker,
+    results: data.offers.map(_.partial(parseAccountOrder, address))
+  }), convertErrors(callback)));
+}
+
+function getOrdersAsync(account, options, callback) {
+  validate.address(account);
+  validate.getOrdersOptions(options);
+
+  const ledgerVersion = options.ledgerVersion
+                      || this.remote.getLedgerSequence();
+  const getter = _.partial(requestAccountOffers, this.remote, account,
+                           ledgerVersion);
+  utils.getRecursive(getter, options.limit,
+    composeAsync((orders) => _.sortBy(orders,
+      (order) => order.properties.sequence), callback));
+}
+
+function getOrders(account: string, options = {}) {
+  return utils.promisify(getOrdersAsync).call(this, account, options);
+}
+
+module.exports = getOrders;

src/api/ledger/parse/account-order.js

@@ -0,0 +1,41 @@
+/* @flow */
+'use strict';
+const utils = require('./utils');
+const flags = utils.core.Remote.flags.offer;
+const parseAmount = require('./amount');
+const BigNumber = require('bignumber.js');
+
+// TODO: remove this function once rippled provides quality directly
+function computeQuality(takerGets, takerPays) {
+  const quotient = new BigNumber(takerPays.value).dividedBy(takerGets.value);
+  return quotient.toDigits(16, BigNumber.ROUND_HALF_UP).toString();
+}
+
+// rippled 'account_offers' returns a different format for orders than 'tx'
+// the flags are also different
+function parseAccountOrder(address: string, order: Object): Object {
+  const direction = (order.flags & flags.Sell) === 0 ? 'buy' : 'sell';
+  const takerGetsAmount = parseAmount(order.taker_gets);
+  const takerPaysAmount = parseAmount(order.taker_pays);
+  const quantity = (direction === 'buy') ? takerPaysAmount : takerGetsAmount;
+  const totalPrice = (direction === 'buy') ? takerGetsAmount : takerPaysAmount;
+
+  // note: immediateOrCancel and fillOrKill orders cannot enter the order book
+  // so we can omit those flags here
+  const specification = utils.removeUndefined({
+    direction: direction,
+    quantity: quantity,
+    totalPrice: totalPrice,
+    passive: ((order.flags & flags.Passive) !== 0) || undefined
+  });
+
+  const properties = {
+    maker: address,
+    sequence: order.seq,
+    makerExchangeRate: computeQuality(takerGetsAmount, takerPaysAmount)
+  };
+
+  return {specification, properties};
+}
+
+module.exports = parseAccountOrder;