Release 1.0.0-beta.5

This reverts commit 9e9a0a7d9b.

We should move methods like deriveKeypair and deriveAddress
off of the schemaValidator object.

.gitignore

@@ -17,7 +17,7 @@
 
 # Ignore object files.
 *.o
-build/*.js
+build/
 tags
 bin/rippled
 Debug/*.*
@@ -25,6 +25,7 @@ Release/*.*
 
 # Ignore locally installed node_modules
 node_modules
+!test/node_modules
 
 # Ignore tmp directory.
 tmp
@@ -50,5 +51,13 @@ test/config.js
 # Ignore npm-debug
 npm-debug.log
 
-# Ignore dist folder, build for bower
+# Ignore dist folder, built from tsc
 dist/
+
+# Ignore perf test cache
+scripts/cache
+
+.eslintrc
+
+# nyc (istanbul)
+.nyc_output

.npmignore

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

.nvmrc

@@ -0,0 +1 @@
+v8

.nycrc

@@ -0,0 +1,10 @@
+{
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.d.ts"],
+  "extension": [".ts"],
+  "require": ["ts-node/register"],
+  "reporter": ["text-summary", "html"],
+  "sourceMap": true,
+  "instrument": true,
+  "cache": true
+}

.travis.yml

@@ -1,13 +1,10 @@
 language: node_js
 node_js:
-  - "0.10"
-script: npm test --coverage
-after_success:
-- npm run coveralls
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/d1ec4245f90231619d30
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false
+  - 6
+  - 8
+  - 9
+script:
+  - yarn compile
+  - yarn test
+  - yarn build
+  - yarn lint

Gulpfile.js

@@ -1,163 +1,216 @@
-var gulp = require('gulp');
-var concat = require('gulp-concat');
-var uglify = require('gulp-uglify');
-var rename = require('gulp-rename');
-var webpack = require('webpack');
-var jshint = require('gulp-jshint');
-var map = require('map-stream');
-var bump = require('gulp-bump');
-var argv = require('yargs').argv;
-//var header = require('gulp-header');
+/* eslint-disable no-var, no-param-reassign */
+/* these eslint rules are disabled because gulp does not support babel yet */
+'use strict';
+const _ = require('lodash');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const gulp = require('gulp');
+const rename = require('gulp-rename');
+const webpack = require('webpack');
+const bump = require('gulp-bump');
+const argv = require('yargs').argv;
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
 
 var pkg = require('./package.json');
 
-var banner = '/*! <%= pkg.name %> - v<%= pkg.version %> - '
-+ '<%= new Date().toISOString() %>\n'
-+ '<%= pkg.homepage ? "* " + pkg.homepage + "\n" : "" %>'
-+ '* Copyright (c) <%= new Date().getFullYear() %> <%= pkg.author.name %>;'
-+ ' Licensed <%= pkg.license %> */'
+var uglifyOptions = {
+  mangle: {
+    reserved: ['_', 'RippleError', 'RippledError', 'UnexpectedError',
+    'LedgerVersionError', 'ConnectionError', 'NotConnectedError',
+    'DisconnectedError', 'TimeoutError', 'ResponseFormatError',
+    'ValidationError', 'NotFoundError', 'MissingLedgerHistoryError',
+    'PendingLedgerVersionError'
+    ]
+  }
+};
 
-var sjclSrc = [
-  '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-ecc-pointextras.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-montgomery.js',
-  'src/js/sjcl-custom/sjcl-validecc.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-canonical.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-der.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-recoverablepublickey.js',
-  'src/js/sjcl-custom/sjcl-jacobi.js'
-];
-
-gulp.task('concat-sjcl', function() {
-  return gulp.src(sjclSrc)
-  .pipe(concat('sjcl.js'))
-  .pipe(gulp.dest('./build/'));
-});
-
-gulp.task('build', [ 'concat-sjcl' ], function(callback) {
-  webpack({
+function getWebpackConfig(extension, overrides) {
+  overrides = overrides || {};
+  let defaults = {
     cache: true,
-    entry: './src/js/ripple/index.js',
+    externals: [{
+      'lodash': '_'
+    }],
+    entry: './src/index.ts',
     output: {
       library: 'ripple',
-      path: './build/',
-      filename: [ 'ripple-', '.js' ].join(pkg.version)
+      path: path.join(__dirname, 'build/'),
+      filename: ['ripple-', extension].join(pkg.version)
     },
-  }, callback);
+    plugins: [
+      new webpack.NormalModuleReplacementPlugin(/^ws$/, './wswrapper'),
+      new webpack.NormalModuleReplacementPlugin(/^\.\/wallet$/, './wallet-web'),
+      new webpack.NormalModuleReplacementPlugin(/^.*setup-api$/,
+        './setup-api-web')
+    ],
+    module: {
+      rules: [{
+        test: /jayson/,
+        use: 'null',
+      }, {
+        test: /\.ts$/,
+        use: [{
+          loader: 'ts-loader',
+          options: {
+            compilerOptions: {declaration: false}
+          },
+        }],
+      }, {
+        test: /\.json/,
+        use: 'json-loader',
+      }]
+    },
+    resolve: {
+      extensions: [ '.ts', '.js' ]
+    },
+  };
+  return _.assign({}, defaults, overrides);
+}
+
+function webpackConfigForWebTest(testFileName, path) {
+  var match = testFileName.match(/\/?([^\/]*)-test.js$/);
+  if (!match) {
+    assert(false, 'wrong filename:' + testFileName);
+  }
+  var configOverrides = {
+    externals: [{
+      'lodash': '_',
+      'ripple-api': 'ripple',
+      'net': 'null'
+    }],
+    entry: testFileName,
+    output: {
+      library: match[1].replace(/-/g, '_'),
+      path: './test-compiled-for-web/' + (path ? path : ''),
+      filename: match[1] + '-test.js'
+    }
+  };
+  return getWebpackConfig('.js', configOverrides);
+}
+
+gulp.task('build-tests', function(callback) {
+  var times = 0;
+  function done() {
+    if (++times >= 5) {
+      callback();
+    }
+  }
+  webpack(webpackConfigForWebTest('./test/rangeset-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/connection-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/api-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/broadcast-api-test.js'), done);
+  webpack(webpackConfigForWebTest('./test/integration/integration-test.js',
+    'integration/'), done);
 });
 
-gulp.task('bower-build', [ 'build' ], function(callback) {
-  return gulp.src([ './build/ripple-', '.js' ].join(pkg.version))
+function createLink(from, to) {
+  if (fs.existsSync(to)) {
+    fs.unlinkSync(to);
+  }
+  fs.linkSync(from, to);
+}
+
+function createBuildLink(callback) {
+  return function(err, res) {
+    createLink('./build/ripple-' + pkg.version + '.js',
+      './build/ripple-latest.js');
+    callback(err, res);
+  };
+}
+
+gulp.task('build', function(callback) {
+  webpack(getWebpackConfig('.js'), createBuildLink(callback));
+});
+
+gulp.task('build-min', function(callback) {
+  const webpackConfig = getWebpackConfig('-min.js');
+  webpackConfig.plugins.push(new UglifyJsPlugin({uglifyOptions}));
+  webpack(webpackConfig, function() {
+    createLink('./build/ripple-' + pkg.version + '-min.js',
+      './build/ripple-latest-min.js');
+    callback();
+  });
+});
+
+gulp.task('build-debug', function(callback) {
+  const webpackConfig = getWebpackConfig('-debug.js', {devtool: 'eval'});
+  webpackConfig.plugins.unshift(new webpack.LoaderOptionsPlugin({debug: true}));
+  webpack(webpackConfig, 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.ts',
+    externals: [{
+      './transaction': buildUseError('Transaction'),
+      './orderbook': buildUseError('OrderBook'),
+      './account': buildUseError('Account'),
+      './serializedobject': buildUseError('SerializedObject')
+    }],
+    plugins: [
+      new UglifyJsPlugin()
+    ]
+  };
+  webpack(getWebpackConfig('-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/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
-gulp.task('bower-build-min', [ 'build-min' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-min.js' ].join(pkg.version))
+gulp.task('bower-build-min', ['build-min'], function() {
+  return gulp.src(['./build/ripple-', '-min.js'].join(pkg.version))
   .pipe(rename('ripple-min.js'))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
-gulp.task('bower-build-debug', [ 'build-debug' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-debug.js' ].join(pkg.version))
+gulp.task('bower-build-debug', ['build-debug'], function() {
+  return gulp.src(['./build/ripple-', '-debug.js'].join(pkg.version))
   .pipe(rename('ripple-debug.js'))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
 gulp.task('bower-version', function() {
-  gulp.src('./dist/bower.json')
+  gulp.src('./dist/bower/bower.json')
   .pipe(bump({version: pkg.version}))
-  .pipe(gulp.dest('./dist/'));
+  .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");
+    throw new Error('No type found, pass it in using the --type argument');
   }
+
   gulp.src('./package.json')
-  .pipe(bump({type:argv.type}))
+  .pipe(bump({type: argv.type}))
   .pipe(gulp.dest('./'));
 });
 
 gulp.task('version-beta', function() {
   gulp.src('./package.json')
-  .pipe(bump({version: pkg.version+'-beta'}))
+  .pipe(bump({version: pkg.version + '-beta'}))
   .pipe(gulp.dest('./'));
 });
 
-gulp.task('build-min', [ 'build' ], function(callback) {
-  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', [ 'concat-sjcl' ], function(callback) {
-  webpack({
-    cache: true,
-    entry: './src/js/ripple/index.js',
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: [ 'ripple-', '-debug.js' ].join(pkg.version)
-    },
-    debug: true,
-    devtool: 'eval'
-  }, callback);
-});
-
-gulp.task('lint', function() {
-  gulp.src('src/js/ripple/*.js')
-  .pipe(jshint())
-  .pipe(map(function(file, callback) {
-    if (!file.jshint.success) {
-      console.log('\nIn', file.path);
-
-      file.jshint.results.forEach(function(err) {
-        if (err && err.error) {
-          var col1 = err.error.line + ':' + err.error.character;
-          var col2 = '[' + err.error.reason + ']';
-          var col3 = '(' + err.error.code + ')';
-
-          while (col1.length < 8) {
-            col1 += ' ';
-          }
-
-          console.log('  ' + [ col1, col2, col3 ].join(' '));
-        }
-      });
-    }
-
-    callback(null, file);
-  }));
-});
-
-gulp.task('watch', function() {
-  gulp.watch('src/js/ripple/*', [ 'build-debug' ]);
-});
-
-gulp.task('default', [ 'concat-sjcl', 'build', 'build-debug', 'build-min' ]);
-
-gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug', 'bower-version']);
+gulp.task('default', ['build', 'build-debug', 'build-min']);

HISTORY.md

@@ -1,82 +1,599 @@
-##0.9.0
+# ripple-lib Release History
 
+## 1.0.0-beta.5 (2018-08-11)
+
++ [Fix a TypeScript error by importing the `Prepare` type](https://github.com/ripple/ripple-lib/commit/7cd517268bda5fe74b91dad02fedf8b51b7eae9b)
+
+## 1.0.0-beta.4 (2018-08-10)
+
++ [Add `prepareTransaction()`](https://github.com/ripple/ripple-lib/pull/898)
++ Internal improvements and cleanup
+
+## 1.0.0-beta.3 (2018-07-17)
+
++ For payment channel transactions, `getTransaction` includes a new
+  `channelChanges` property that describes the details of the payment channel.
+  (#920)
+
+### Bug Fixes
+
++ A bug caused calculated fees to use too many decimal places. This was fixed by
+  rounding fees to 6 decimal places. (#912)
++ When using the Settings transaction to set up a multi-signing list, the
+  threshold and weights fields are required. (#909)
++ Docs: Fix the MIMETYPE in examples with memos. (#914)
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+460dbb521e24c44cb53dabc1a74feeca33d031b44d889dd5b51103ca92d51de6  ripple-1.0.0-beta.3-debug.js
+cccfd24973c6b7990d9e933a589175dae26249825737fff4f2f73d8558a3f186  ripple-1.0.0-beta.3-min.js
+0dc456a58fb078347d9920310621595905085595d73c2b8fe96bea73bcf35450  ripple-1.0.0-beta.3.js
+```
+
+## 1.0.0-beta.2 (2018-06-08)
+
+### Breaking Changes
+
++ During transaction preparation, there is now a maximum fee. Also, when a transaction is signed, its fee is checked and an error is thrown if the fee exceeds the maximum. The default `maxFeeXRP` is `'2'` (2 XRP). Override this value in the RippleAPI constructor.
++ Attempting to prepare a transaction with an exact `fee` higher than `maxFeeXRP` causes a `ValidationError` to be thrown.
++ Attempting to sign a transaction with a fee higher than `maxFeeXRP` causes a `ValidationError` to be thrown.
++ The value returned by `getFee()` is capped at `maxFeeXRP`.
+
+### Other Changes
+
++ In Transaction Instructions, the `maxFee` parameter is deprecated. Use the `maxFeeXRP` parameter in the RippleAPI constructor.
+
+#### Overview of new fee limit
+
+Most users of ripple-lib do not need to make any code changes to accommodate the new soft limit on fees. The limit is designed to protect against the most severe cases where an unintentionally high fee may be used.
+
++ When having ripple-lib provide the fee with a `prepare*` method, a maximum fee of `maxFeeXRP` (default 2 XRP) applies. You can prepare more economical transactions by setting a lower `maxFeeXRP`, or support high-priority transactions by setting a higher `maxFeeXRP` in the RippleAPI constructor.
++ When using `sign` with a Fee higher than `maxFeeXRP`, a `ValidationError` is thrown.
+
+If you have any questions or concerns, please open an issue on GitHub.
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+ef348a2805098e61395b689b410cbf4bfd35e4d72e38c89f4ab74ec5e19793f5  ripple-1.0.0-beta.2-debug.js
+ea33fd53df8c7176d5fbf52dae0b64aade7180860f26449062cdbefaf8bd4d9b  ripple-1.0.0-beta.2-min.js
+fe5cc6e97c9b8a1470dacb34f16a64255cd639a25381abe9db1ba79e102456f2  ripple-1.0.0-beta.2.js
+```
+
+## 1.0.0-beta.1 (2018-05-24)
+
+### Breaking Changes
+
++ Amounts in drops and XRP are checked for validity. Some
+  methods may now throw a `BigNumber Error` or `ValidationError` if the amount
+  is invalid. This may include methods that previously did not throw.
++ Note that 1 drop is equivalent to 0.000001 XRP and 1 XRP is equivalent to 1,000,000 drops.
++ Using drops is recommended. All rippled APIs require XRP amounts to be
+  expressed in drops.
+
+### Other Changes
+
++ Allow specifying amounts in drops for consistency with the `rippled`
+  APIs.
++ Export `xrpToDrops()` and `dropsToXrp()` functions.
++ Potentially breaking change: Improve errors. For example, `RippledError` now includes the full response from
+  the `rippled` server ([#687](https://github.com/ripple/ripple-lib/issues/687)). `NotConnectedError`
+  may be thrown with a different message than before.
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+a80ebb39e186640246306eadb2879147458c8271fd3c6cb32e6ef78d0b4b01a5  ripple-1.0.0-beta.1-debug.js
+81bcc4b5fd6fd52220ed151242eaddd63eb29c4078845edc68f65b769557d126  ripple-1.0.0-beta.1-min.js
+738b4d65b58cf4e3542fa396f8d319a24cd7d0b7aff5ff629a900e244f735ff4  ripple-1.0.0-beta.1.js
+```
+
+## 1.0.0-beta.0 (2018-05-10)
+
++ [Add `request`, `hasNextPage`, and
+  `requestNextPage`](https://github.com/ripple/ripple-lib/pull/887).
+  + This provides support for all rippled APIs, including subscriptions.
+
+When using rippled APIs, you must:
++ For all XRP amounts, use drops (1 drop = 0.000001 XRP).
++ Instead of `counterparty`, use `issuer`.
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+ab2094979a3d6b320c7bc22bc5946c50fa5e29af0976d352e7689b0a4d840c55  ripple-1.0.0-beta.0-debug.js
+0e7f7d740606c2866ebf63776b13b41a555848e1a1419e2c8058d2e6c562d7fd  ripple-1.0.0-beta.0-min.js
+bd05e8806832ca4192aea7ba2d0362baa9f44605f8e8e6676acd25eb0b94b778  ripple-1.0.0-beta.0.js
+```
+
+## 0.22.0 (2018-05-10)
+
++ [`getOrderbook` - return raw order data](https://github.com/ripple/ripple-lib/pull/886). The full `BookOffer` data is now provided under `data`.
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+33f71b55c4adec4452826e44fe7809377364df04222b60f0fce01e7de2daff33  ripple-0.22.0-debug.js
+63232888a4ea77065e8e8eb8fdaa8ebfe3a785428fe935e2667c1ea54c837f29  ripple-0.22.0-min.js
+ab98026fabe296bd938297c48cb58e01dfdbe90f3c66c9617d6a3e1efd4c6b93  ripple-0.22.0.js
+```
+
+## 0.21.0 (2018-04-11)
+
++ [Upgrade https-proxy-agent](https://github.com/ripple/ripple-lib/pull/883)
++ [Add getAccountObjects](https://github.com/ripple/ripple-lib/pull/881)
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+3ab52209ad4a80393c8c08ef3f4aa9cfb47bc76c0ede2ee9fa7f5ca180ba4d67  ripple-0.21.0-debug.js
+3b1efccded347bed5f64757098a1ea6a513bb8932d922d00af47cd24e001dc14  ripple-0.21.0-min.js
+db08e5a3eab1f659b4c803543374398004d950ba720adc4b9a7658817cb5c94b  ripple-0.21.0.js
+```
+
+## 0.20.0 (2018-04-09)
+
++ [Add support for using a keypair with sign()](https://github.com/ripple/ripple-lib/pull/769)
++ [Fix a bug caused by jsonschema v1.2.3 by pinning to v1.2.2](https://github.com/ripple/ripple-lib/pull/882)
++ [Improve Payment Channel documentation](https://github.com/ripple/ripple-lib/pull/877)
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+389811a9baa72f77e2a43d0b48045762d29a6f616ed5fd2660ba76fc12a3ecc5  ripple-0.20.0-debug.js
+c1746ea0dd55318cb4e1ef3955ef14759d9d70861437c69abafc10169916f068  ripple-0.20.0-min.js
+17958b0e46395d2b2a35a003693c0babdfb5382513d3cc58a62f8648ad710b0e  ripple-0.20.0.js
+```
+
+## 0.19.1 (2018-03-22)
+
++ [Fix: Include TypeScript declarations in npm package](https://github.com/ripple/ripple-lib/pull/863)
++ [Fix: Documentation link to checkCash](https://github.com/ripple/ripple-lib/pull/871)
++ [Internal: Clean up types and migrate more APIs to new request method](https://github.com/ripple/ripple-lib/pull/857)
++ [Internal: Fix Payment source and destination types](https://github.com/ripple/ripple-lib/pull/870)
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+3ed5332aa035c07bae6c1abfdfc8ca77cdbb05cc4b88878f544f1ea4cb793f4d  ripple-0.19.1-debug.js
+2f5507aa00a40ab6a94de1822af87db5e927edef3885aef5d9b39ccb623ccb54  ripple-0.19.1-min.js
+1e439aee1b220242d56ea687a9b55a67b8614212c1ddbd70a4fcf34503fc487a  ripple-0.19.1.js
+```
+
+## 0.19.0 (2018-03-02)
+
++ [Add support for Checks](https://github.com/ripple/ripple-lib/pull/853)
++ [Add support for the Deposit Authorization account root flag](https://github.com/ripple/ripple-lib/pull/852)
++ [Generate .ts.d TypeScript declaration files](https://github.com/ripple/ripple-lib/pull/851)
++ [Improve documentation of getTransactions params](https://github.com/ripple/ripple-lib/pull/856)
++ [Add new request interface](https://github.com/ripple/ripple-lib/pull/843) (private for now)
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+0e7ce4594b7e455fbc57ad81f6fddc391d1e1f349a49c96ad783be50f80fdc14  ripple-0.19.0-debug.js
+6d716a0357929e51e476f22136880f7a0e5458fd396ac145ce9308f278ff7cc1  ripple-0.19.0-min.js
+6715db1af638f99226ab7f8f244103306aa6e04d1b8c1da47a63431053bacb84  ripple-0.19.0.js
+```
+
+## 0.18.2 (2018-02-13)
+
++ [Fix: Publish updated browser builds to npm so that users can easily use
+  CDNs](https://github.com/ripple/ripple-lib/pull/849)
++ [Fix: Browserify fails due to dependency on `ws`](https://github.com/ripple/ripple-lib/pull/847)
++ [Fix: `build` script fails when `node_modules` is in path](https://github.com/ripple/ripple-lib/pull/846)
++ [Reduce size of published npm package](https://github.com/ripple/ripple-lib/commit/0c318816ccf25c4c3932934a35ef903cc552edc1)
++ Clean up files from Flow (we migrated to TypeScript)
++ Typos and code cleanup
+
+The SHA-256 checksums for the browser version of this release can be found
+below.
+```
+% shasum -a 256 *
+f08ab61137255be3639e9d210ded2a182b6e0388f257a70d9b372ce7e7e518a6  ripple-0.18.2-debug.js
+0604835b8421391167b4314ce93a76b5994780a08bd7edf36d91eb5e8f2643a2  ripple-0.18.2-min.js
+fda56ab5c8256e04355e20064877ef4053f26c87f37cfcf861340f22bf89ee40  ripple-0.18.2.js
+```
+
+## 0.18.1 (2018-01-27)
+
+Note: The package published to npm for this version did not include updated
+browser builds. If you are using a CDN that pulls from npm, please use 0.18.2 or
+later.
+
++ [Fix: isSameIssue() should check counterparty](https://github.com/ripple/ripple-lib/pull/836). This bug caused `getOrderbook()` to return incorrect values.
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 *
+6871855a2af1dc591ef557d442c11e8c60e01c5932054e13e8cbb84a182f45e0  ripple-0.18.1-debug.js
+331f0baff46af44933a8fa31f128132945ff82a147acfff0a7315adb446e3de0  ripple-0.18.1-min.js
+26324bb0725d2d484fe3b6086335d49734f45dc647b07c60746e0d8619f1ed3e  ripple-0.18.1.js
+```
+
+## 0.18.0 (2018-01-25)
+
++ [Convert from Flow to TypeScript](https://github.com/ripple/ripple-lib/pull/816)
++ [Use ES Module syntax](https://github.com/ripple/ripple-lib/pull/815) (Babel still compiles these to common.js modules for
+  distribution)
++ Docs: [Improve escrow creation example/test](https://github.com/ripple/ripple-lib/pull/820)
++ [Fix type errors](https://github.com/ripple/ripple-lib/pull/811)
++ [Fix lint errors](https://github.com/ripple/ripple-lib/pull/813)
+
+## 0.17.9 (2017-11-14)
+
++ [Update ws dependency to 3.3.1](https://github.com/ripple/ripple-lib/pull/804)
++ [Remove unnecessary polyfills](https://github.com/ripple/ripple-lib/pull/807)
++ Fix lint errors ([#786](https://github.com/ripple/ripple-lib/pull/786), [#808](https://github.com/ripple/ripple-lib/pull/808))
++ [Update ripple-keypairs dependency to 0.10.1](https://github.com/ripple/ripple-lib/pull/805)
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 *
+b52f251eedac2509d72093eab1e8dba0d0f4a9fe6a28ec1cc90853cfb0fd7110  ripple-0.17.9-debug.js
+d577a2bbdbdf7535c5365a1c52a2a31989d1b966e30abcba65c87133a536b9dc  ripple-0.17.9-min.js
+ff4c3002842fac72ec2ebbd081e9594b0de6050d4d051a8fd6c06adb9a351488  ripple-0.17.9.js
+```
+
+The SHA-1 checksums for the browser version of this release can be found below.
+```
+% shasum *
+e1995afc34aef6accd269cfccc55a45619618a41  ripple-0.17.9-debug.js
+e6ad9a9c111ab696f5637bfa372d80999e5ae362  ripple-0.17.9-min.js
+4866494ec5f9095cc34bea142f1e2b8ac5f7fbf8  ripple-0.17.9.js
+```
+
+## 0.17.8 (2017-11-06)
+
++ Fix: Freezing in Safari 10.1 (updated bignumber.js) (closes #762)
++ [Fix: `getSettings` should include signers](https://github.com/ripple/ripple-lib/commit/2a90f9b134e168937dceb7da283d63734eac9e7c)
++ Update for Node 6
++ Update lodash dependency
++ Migrate to yarn
+
+## 0.17.7 (2017-05-08)
+
++ Replace AJV with jsonschema
+
+## 0.16.5 (2016-01-21)
+
++ [Filter insufficient source funds paths from pathfind results](https://github.com/ripple/ripple-lib/pull/688)
+
+## 0.16.4
+
++ [Update `ws` to 1.0.1](https://github.com/ripple/ripple-lib/pull/682)
+
+## 0.16.2
+
++ Bump `ripple-binary-codec` dependency version to 0.1.1 to fix issue with `computeLedgerHash` for transactions with `DeliverMin`
+
+## 0.16.1
+
++ [FIX: Use assert not assert-diff](https://github.com/ripple/ripple-lib/commit/f6ebe325193e7208c5ee8d8e84a7504714f0009e)
+
+## 0.16.0
+
+__BREAKING CHANGES__
++ [Fix types of XRP values in `getServerInfo` response](https://github.com/ripple/ripple-lib/commit/99d08065e4bda3dda6ae1f183adbd11abc70a9b7)
++ [Change error event format and fix crash due to error event on websocket](https://github.com/ripple/ripple-lib/commit/9cd72595f0efc062d77b9d625695d6030c524cc6)
+
+__OTHER CHANGES__
++ [Fix `generateAddress` docs and add error event listener to boilerplate](https://github.com/ripple/ripple-lib/commit/809d981987a2890fac3a73a40a05c598b9040334)
++ [Allow setting `maxLedgerVersion` to `null` to specify no maximum](https://github.com/ripple/ripple-lib/commit/82613e7e8b360d1ae1552eab4559ab4763c06d7e)
++ [Add support for client certificates](https://github.com/ripple/ripple-lib/commit/5f5e48e4140345d166b8c1a3ee0847b0d9e2d893)
++ [`getFee` returns a string not a float](https://github.com/ripple/ripple-lib/commit/7bf2da6014c87e164542e69356efeaabb575a157)
++ [Fix parsing of quality for `getTrustlines`](https://github.com/ripple/ripple-lib/commit/86ff315ef2a39dfdc2ce97e0e1c4aa73f04e363b)
++ Fix `DeliverMin` value when specifying `minAmount`
++ [http server example](https://github.com/ripple/ripple-lib/commit/76866ab901ea46a2dd73181605e0f7f4220043d4)
+
+## 0.15.2
+
++ [Fix support for proxy credentials in proxy URL and fix error when there are more than 10 outstanding requests](https://github.com/ripple/ripple-lib/commit/0990ad4a6f1d59ca9d2cb859b4e2d71693f3fc4b)
+
+## 0.15.1
+
++ [Fix `babel-polyfill` require](https://github.com/ripple/ripple-lib/commit/062148674c3b1293ab82c28e25615ddd530339fa)
++ [Fix samples](https://github.com/ripple/ripple-lib/commit/5d5cf868a2ddb1b1cd40e4a4f0a782d0066c2055)
++ [Add unit tests for `RippleAPIBroadcast`](https://github.com/ripple/ripple-lib/commit/ddf8fe5b1a9c750490dca98fb9ffaaf8017f87e0)
+
+## 0.15.0
+
+__BREAKING CHANGES__
++ ["servers" parameter changed to single "server"](https://github.com/ripple/ripple-lib/commit/7061e9afe46f0682254d098adeff3dd7157521a1)
+
+__OTHER CHANGES__
++ [Fix handling memos in `prepareSettings`](https://github.com/ripple/ripple-lib/commit/c9704137b7b538e8dbf31c483bcdcf2dcfd7cd75)
++ [Docs: SusPay warnings, offline mode, and other tweaks](https://github.com/ripple/ripple-lib/commit/4b4fc36ebd93f1360781a65f2869bd2c4f0a5093)
++ [Fix prepareOrderCancellation documentation](https://github.com/ripple/ripple-lib/commit/5e720891f579fd73d43c64e5ec519d9121023c10)
+
+## 0.14.0
+
+__BREAKING CHANGES__
++ [`prepareOrderCancellation` now takes orderCancellation specification](https://github.com/ripple/ripple-lib/commit/7f33d8a71e56289e5a5e0ead1c74f75ebcde72bc)
++ [Rename "ledgerClosed" event to "ledger" and change format](https://github.com/ripple/ripple-lib/commit/8a3d4a64db5fbf560ebf87dc62e0212513c5e18a)
+
+__OTHER CHANGES__
++ [Fix proxy support and add support for proxy authorization](https://github.com/ripple/ripple-lib/commit/14b840f3feca758e0384b746c94e36d8bf59b8c2)
++ [Fix trace option](https://github.com/ripple/ripple-lib/commit/af620755c53556c55eed12de4b0013ef5a349ce2)
++ [Allow memos on all transaction types](https://github.com/ripple/ripple-lib/commit/b5081344da8e66fbd3a5113cc3313325ef72a494)
++ [Add documentation for RippleAPI options](https://github.com/ripple/ripple-lib/commit/a76b554cadb9f9f918b06f8386bc29355682a1a4)
++ [Docs: more on basic types, tx types](https://github.com/ripple/ripple-lib/commit/fdbac63f466b4fd3be701d4878800d856692e26e)
++ [Docs: revised introductory material](https://github.com/ripple/ripple-lib/commit/ef2515507dbd3c6a426ab5b31332a1bdf72d5b2d)
++ [boost coverage to almost 100%](https://github.com/ripple/ripple-lib/commit/995606b1e6f3643af34d9fd442ccd31f320b03eb)
+
+## 0.13.2
+
++ [Fix: Specify send_max when pathfinding with a source amount](https://github.com/ripple/ripple-lib/commit/75142139184625c8b9fcc480b1825d9985337813)
+
+## 0.13.1
+
++ [Add documentation for API events](https://github.com/ripple/ripple-lib/commit/25d1ac0c5f95cad32ea4ceebb)
++ [Fix: Add babel-polyfill](https://github.com/ripple/ripple-lib/commit/8a53abc32f6ec6c7d50cd182492d6fb511b86704)
++ [Fix: Bump version on ripple-hashes](https://github.com/ripple/ripple-lib/commit/12e5765c64aea31b3c2fb65ff989cf01e6368f58)
+
+## 0.13.0
+
+__BREAKING CHANGES__
++ Add new RippleAPI interface and delete old API
+    - [RippleAPI README and samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples)
+
+__OTHER CHANGES__
++ [Removed timeout method of Request and added default timeout](https://github.com/ripple/ripple-lib/commit/634fe5683a9082e57682ff7d5c4fb9483b4af818)
++ [Add Remote.closeCurrentPathFind function, so current pathfind can be properly closed](https://github.com/ripple/ripple-lib/commit/e99010f363fc7cbe7fd547d3ca5b32ea083c44e6)
++ [Implement Balance Sheet API](https://github.com/ripple/ripple-lib/pull/579)
++ [Fix bugs in orderbook subscription](https://github.com/ripple/ripple-lib/commit/7404795dc64a85216148de7bc3ca7da7b33f4490)
++ [Fix crash due to rippled slowDown error](https://github.com/ripple/ripple-lib/commit/84838b2e9f6969b593b8462a62a6b8f516ada937)
++ [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)
++ [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.9
+
++ [OrderBook performance optimizations](https://github.com/ripple/ripple-lib/commit/3e17d91edf36745f6b6c09b0ad88971b7775f6ab)
+
+## 0.12.7 and 0.12.8
+
++ [Improve performance of orderbook](https://github.com/ripple/ripple-lib/commit/c745faaaf0956ca98448a754b4fe97fb50574fc7)
++ [Remove Firefox warning about prototype overwrite](https://github.com/ripple/ripple-lib/commit/0c62fa21123b220b066871e1c41a3b4fe6f51885)
++ [Fix compare bug in `Amount` class](https://github.com/ripple/ripple-lib/commit/806547dd154e1b0bf252e8a74ad3ac6aa8a97660)
+
+## 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)
+
+__OTHER 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)
+
+__OTHER 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 sjcl 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 CHANGES__
++ [Change accountRequest method signature](https://github.com/ripple/ripple-lib/commit/6f5d1104aa3eb440c518ec4f39e264fdce15fa15)
+
+__OTHER CHANGES__
++ [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`:
+```js
+// 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 without 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
+
+__BREAKING CHANGES__
++ 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))
+
+__OTHER CHANGES__
 + 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))
++ 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))
 
-+ **Breaking change:** make maxLoops in seed.get_key optional. [Example use in tests](https://github.com/ripple/ripple-lib/blob/develop/test/seed-test.js) ([23e473b](https://github.com/ripple/ripple-lib/commit/23e473b6886c457781949c825b3ff48b3984e51f)) 
-
-##0.8.2
+## 0.8.2
 
 + Currency: Allow mixed letters and numbers in currencies
-
-+ Deprecate account_tx map/reduce/filter
-
++ 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
+## 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
+## 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 separate export
 
-+ Amount: Make Constants static fields on the class, instead of a seperate export
-
-
-##0.7.39
+## 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
+## 0.7.37
 
 + **Deprecations**
 
@@ -87,11 +604,8 @@
     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
       {
@@ -100,28 +614,19 @@
       }
     ```
 + 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
+## 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.
-
++ Transactions that err with `telINSUF_FEE_P` will be automatically resubmitted. This error indicates that the `Fee` supplied in the transaction submission request was inadequate. 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
@@ -149,6 +654,4 @@
 ```
 
 + Added persistence hooks.
-
 + General performance improvements, especially for long-running processes.
-

LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2012,2013,2014 Ripple Labs Inc.
+ISC License
+
+Copyright (c) 2012-2015 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
@@ -11,42 +13,3 @@ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 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.
-
-Address all questions regarding this license to:
-
-  Tom Wu
-  tjw@cs.Stanford.EDU

README.md

@@ -1,94 +1,73 @@
-#ripple-lib
+# ripple-lib
 
-JavaScript client for [rippled](https://github.com/ripple/rippled)
+A JavaScript API for interacting with the XRP Ledger
 
-[![Build Status](https://travis-ci.org/ripple/ripple-lib.svg?branch=develop)](https://travis-ci.org/ripple/ripple-lib) [![Coverage Status](https://coveralls.io/repos/ripple/ripple-lib/badge.png?branch=develop)](https://coveralls.io/r/ripple/ripple-lib?branch=develop)
+[![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)
 
 [![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)
 
-###Features
+### Features
 
-+ Connect to a rippled server in JavaScript (Node.js or browser)
-+ Issue [rippled API](https://ripple.com/wiki/JSON_Messages) requests
-+ Listen to events on the Ripple network (transaction, ledger, etc.)
-+ Sign and submit transactions to the Ripple network
++ Connect to a `rippled` server from Node.js or a web browser
++ Issue [rippled API](https://ripple.com/build/rippled-apis/) requests
++ Listen to events on the XRP Ledger (transaction, ledger, etc.)
++ Sign and submit transactions to the XRP Ledger
 
-###In this file
+## Getting Started
 
-1. [Installation](README.md#installation)
-2. [Quickstart](README.md#quickstart)
-3. [Running tests](https://github.com/ripple/ripple-lib#running-tests)
+See also: [RippleAPI Beginners Guide](https://ripple.com/build/rippleapi-beginners-guide/)
 
-###Additional documentation
+You can use `npm`, but we recommend using `yarn` for the added assurance provided by `yarn.lock`.
 
-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**
++ [Yarn Installation Instructions](https://yarnpkg.com/en/docs/install)
 
+Install `ripple-lib`:
 ```
-  $ npm install ripple-lib
+$ yarn add ripple-lib
 ```
 
-**Via bower (for browser use)**
+Then see the [documentation](https://github.com/ripple/ripple-lib/blob/develop/docs/index.md) and [code samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples).
 
+### Mailing lists
+
+We have a low-traffic mailing list for announcements of new ripple-lib releases. (About 1 email per week)
+
++ [Subscribe to ripple-lib-announce](https://groups.google.com/forum/#!forum/ripple-lib-announce)
+
+If you're using the XRP Ledger in production, you should run a [rippled server](https://github.com/ripple/rippled) and subscribe to the ripple-server mailing list as well.
+
++ [Subscribe to ripple-server](https://groups.google.com/forum/#!forum/ripple-server)
+
+## Development
+
+To build the library for Node.js:
 ```
-  $ bower install ripple
+$ yarn compile
 ```
 
-See the [bower-ripple repo](https://github.com/ripple/bower-ripple) for additional bower instructions
-
-
-**Building ripple-lib from github**
+The TypeScript compiler will [output](./tsconfig.json#L7) the resulting JS files in `./dist/npm/`.
 
+To build the library for the browser:
 ```
-  $ git clone https://github.com/ripple/ripple-lib
-  $ npm install
-  $ npm run build
+$ yarn build
 ```
 
-Then use the minified `build/ripple-*-min.js`
+Gulp will [output](./Gulpfile.js) the resulting JS files in `./build/`.
 
-##Quickstart
+For more details, see the `scripts` in `package.json`.
 
-`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({
-  // see the API Reference for available options
-  servers: [ 'wss://s1.ripple.com:443' ]
-});
-
-remote.connect(function() {
-  /* remote connected */
-  remote.request('server_info', function(err, info) {
-
-  });
-});
-```
-
-##Running tests
+## Running tests
 
 1. Clone the repository
+2. `cd` into the repository and install dependencies with `yarn install`
+3. `yarn test` or `yarn test --coverage` (`istanbul` will create coverage reports in `coverage/lcov-report/`)
 
-2. `cd` into the repository and install dependencies with `npm install`
+## Generating Documentation
 
-3. `npm test` or `node_modules/.bin/mocha test/*-test.js`
+The continuous integration tests require that the documentation stays up-to-date. If you make changes to the JSON schemas, fixtures, or documentation sources, you must update the documentation by running `yarn run docgen`.
 
-**Generating code coverage**
+`npm` may be used instead of `yarn` in the commands above.
 
-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/`.
+## More Information
+
++ [Ripple Developer Center](https://ripple.com/build/)

bench/modpow.js

@@ -1,44 +0,0 @@
-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 });

bin/decode_binary.js

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

bin/rsign.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-var Transaction = require('../src/js/ripple/transaction').Transaction;
-
-var argv = process.argv.slice(2);
-
-var verbose;
-var secret;
-var tx_json;
-
-if (~argv.indexOf('-v')){
-  argv.splice(argv.indexOf('-v'), 1);
-  verbose = true;
-}
-
-secret  = argv.shift();
-tx_json = argv.shift();
-
-if (tx_json === '-') {
-  read_input(ready);
-} else {
-  ready();
-}
-
-function read_input(callback) {
-  tx_json = '';
-  process.stdin.on('data', function(data) { tx_json += data; });
-  process.stdin.on('end', callback);
-  process.stdin.resume();
-}
-
-function ready() {
-  var valid_arguments = secret && tx_json;
-
-  if (!valid_arguments) {
-    console.error('Invalid arguments\n');
-    print_usage();
-  } else {
-    var valid_json = true;
-
-    try {
-      tx_json = JSON.parse(tx_json);
-    } catch(exception) {
-      valid_json = false;
-    }
-
-    if (!valid_json) {
-      console.error('Invalid JSON\n');
-      print_usage();
-    } else {
-      sign_transaction();
-    }
-  }
-}
-
-function print_usage() {
-  console.log(
-    '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
-    })
-    );
-};
-
-function sign_transaction() {
-  var tx = new Transaction();
-
-  tx.tx_json = tx_json;
-  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());
-  }
-};
-
-// vim:sw=2:sts=2:ts=8:et

bin/validate_address.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-
-var UInt160 = require('../').UInt160;
-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');
-};

circle.yml

@@ -0,0 +1,18 @@
+machine:
+  node:
+    version: 6.11.3
+  hosts:
+    testripple.circleci.com: 127.0.0.1
+dependencies:
+  pre:
+    - wget https://s3-us-west-2.amazonaws.com/ripple-debs/rippled_0.30.1-b11-1.deb
+    - sudo dpkg -i rippled_0.30.1-b11-1.deb
+test:
+  pre:
+    - rippled -a --start --conf "$HOME/$CIRCLE_PROJECT_REPONAME/test/integration/rippled.cfg":
+        background: true
+  override:
+    - scripts/ci.sh "$CIRCLE_NODE_INDEX" "$CIRCLE_NODE_TOTAL":
+        parallel: true
+  post:
+    - killall /usr/bin/rippled

custom_typings/node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This is an extension of Node's `process` object to include the browser
+ * property, which is added by webpack.
+ */
+interface AmbiguousProcess extends NodeJS.Process {
+  browser?: true
+}
+
+declare var process: AmbiguousProcess;

deploy/start rippled.bat

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

docs/GUIDES.md

@@ -1,206 +0,0 @@
-#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)
-
-##Generating a new Ripple Wallet
-
-  ```js
-    var Wallet = require('ripple-lib').Wallet;
-
-    var wallet = Wallet.generate();
-    console.log(wallet);
-    // { address: 'rEf4sbVobiiDGExrNj2PkNHGMA8eS6jWh3',
-    //   secret: 'shFh4a38EZpEdZxrLifEnVPAoBRce' }
-  ```
-
-##Connecting to the Ripple network
-
-1. [Get ripple-lib](README.md#getting-ripple-lib)
-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 remote = new Remote({options});
-
-  remote.connect(function() {
-    /* 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.
-
-
-##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 [request_server_info](https://ripple.com/wiki/JSON_Messages#server_info).
-
-+ Constructing a `Request` with event listeners
-```js
-var request = remote.request('server_info');
-
-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 request = remote.request('subscribe');
-
-    request.addStream('ledger'); //remote will emit `ledger_closed`
-    request.addStream('transactions'); //remote will emit `transaction`
-
-    request.on('ledger_closed', function onLedgerClosed(ledgerData) {
-	//handle ledger
-    });
-
-    request.on('transaction', function onTransacstion(transaction) {
-	//handle transaction
-    });
-
-    request.request(function(err) {
-      	if (err) {
-        } else {
-        }
-    });
-  });
-```
-* 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 '1XRP' or '10.50USD' 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('1XRP');
-
-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.
-
-
-##4. Submitting a trade offer to the network
-
-Submitting a trade offer to the network is similar to submitting a payment transaction. Here is an example for a trade that expires in 24 hours where you are offering to sell 1 USD in exchange for 100 XRP:
-
-```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: '1',
-    taker_gets: '1/USD/' + GATEWAY
-  });
-
-  transaction.submit(function(err, res) {
-    /* handle submission errors / success */
-  });
-});
-```

docs/REFERENCE.md

@@ -1,302 +0,0 @@
-#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)
-
-#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
-
-##Server requests
-
-**[server_info([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.request('server_info');
-
-request.setServer('wss://s1.ripple.com');
-
-request.request(function(err, res) {
-
-});
-```
-
-**[unl_list([callback])](https://ripple.com/wiki/JSON_Messages#unl_list)**
-
-**[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)**
-
-**[requestPeers([callback])](https://ripple.com/wiki/JSON_Messages#peers)**
-
-
-**[connect(ip, port, [callback])](https://ripple.com/wiki/JSON_Messages#connect)**
-
-##Ledger requests
-
-**[ledger(ledger, [opts], [callback])](https://ripple.com/wiki/JSON_Messages#ledger)**
-
-**ledger_header([callback])**
-
-**[ledger_current([callback])](https://ripple.com/wiki/JSON_Messages#ledger_current)**
-
-**[ledger_entry(type, [callback])](https://ripple.com/wiki/JSON_Messages#ledger_entry)**
-
-**[subscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#subscribe)**
-
-Start receiving selected streams from the server.
-
-**[unsubscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#unsubscribe)**
-
-Stop receiving selected streams from the server.
-
-##Account requests
-
-**[account_info(account, [callback])](https://ripple.com/wiki/JSON_Messages#account_info)**
-
-Return information about the specified account.
-
-```
-{
-  ledger_current_index: <number>,
-  account_data: {
-    Account:            <string>,
-    Balance:            <number>,
-    Flags:              <number>,
-    LedgerEntryType:    <string>,
-    OwnerCount:         <number>,
-    PreviousTxnID:      <string>,
-    PreviousTxnLgrSeq:  <number>,
-    Sequence:           <number> ,
-    index:              <string>
-  }
-}
-```
-
-**[account_lines(accountID, [account_index], [ledger], [callback])](https://ripple.com/wiki/JSON_Messages#account_lines)**
-
-**[account_offers(accountID, [account_index], [ledger], [callback])](https://ripple.com/wiki/JSON_Messages#account_offers)**
-
-Return the specified account's outstanding offers.
-
-**[account_tx(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`
-
-**[wallet_accounts(seed, [callback])](https://ripple.com/wiki/JSON_Messages#wallet_accounts)**
-
-Return a list of accounts for a wallet. *Requires trusted remote*
-
-**account_balance(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.
-
-**account_flags(account, [ledger], [callback])**
-
-Return the flags for an account.
-
-**owner_count(account, [ledger], [callback])**
-
-Return the owner count for an account.
-
-**ripple_balance(account, issuer, currency, [ledger], [callback])**
-
-Return a request to get a ripple balance
-
-##Orderbook requests
-
-**[book_offers(options, [callback])](https://ripple.com/wiki/JSON_Messages#book_offers)**
-
-Return the offers for an order book, also called a *snapshot*
-
-```js
-var request = remote.request('book_offers', {
-  taker_gets: {
-    'currency':'XRP'
-  },
-  taker_pays: {
-    'currency':'USD',
-    'issuer': 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B'
-  }
-});
-
-request.request(function(err, offers) {
-  //handle offers
-});
-```
-
-##Transaction requests
-
-**[transaction_entry(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.
-
-**[tx(hash, [callback])](https://ripple.com/wiki/JSON_Messages#tx)**
-
-Searches ledger history for validated transaction hashes.
-
-**[sign(secret, tx_json, [callback])](https://ripple.com/wiki/JSON_Messages#sign)**
-
-Sign a transaction. *Requires trusted remote*
-
-**[submit([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.
-
-**[ripple_path_find(src_account, dst_account, dst_amount, src_currencies, [callback])](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

@@ -1,168 +0,0 @@
-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/samples/README.md

@@ -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({server: '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/cancelall.js

@@ -0,0 +1,38 @@
+'use strict';
+const RippleAPI = require('../../dist/npm').RippleAPI; // require('ripple-lib')
+
+const address = 'rLDYrujdKUfVx28T9vRDAbyJ7G2WVXKo4K';
+const secret = '';
+
+const api = new RippleAPI({server: 'wss://s1.ripple.com:443'});
+const instructions = {maxLedgerVersionOffset: 5};
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function cancelOrder(orderSequence) {
+  console.log('Cancelling order: ' + orderSequence.toString());
+  return api.prepareOrderCancellation(address, {orderSequence}, instructions)
+  .then(prepared => {
+    const signing = api.sign(prepared.txJSON, secret);
+    return api.submit(signing.signedTransaction);
+  });
+}
+
+function cancelAllOrders(orderSequences) {
+  if (orderSequences.length === 0) {
+    return Promise.resolve();
+  }
+  const orderSequence = orderSequences.pop();
+  return cancelOrder(orderSequence).then(() => cancelAllOrders(orderSequences));
+}
+
+api.connect().then(() => {
+  console.log('Connected...');
+  return api.getOrders(address).then(orders => {
+    const orderSequences = orders.map(order => order.properties.sequence);
+    return cancelAllOrders(orderSequences);
+  }).then(() => process.exit(0));
+}).catch(fail);

docs/samples/payment.js

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

docs/src/basictypes.md.ejs

@@ -0,0 +1,55 @@
+# Basic Types
+
+## Address
+
+```json
+"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59"
+```
+
+Every XRP Ledger account has an *address*, which is a base58-encoding of a hash of the account's public key. XRP Ledger addresses always start with the lowercase letter `r`.
+
+## Account Sequence Number
+
+Every XRP Ledger account has a *sequence number* that is used to keep transactions in order. Every transaction must have a sequence number. A transaction can only be executed if it has the next sequence number in order, of the account sending it. This prevents one transaction from executing twice and transactions executing out of order. The sequence number starts at `1` and increments for each transaction that the account makes.
+
+## Currency
+
+Currencies are represented as either 3-character currency codes or 40-character uppercase hexadecimal strings. We recommend using uppercase [ISO 4217 Currency Codes](http://www.xe.com/iso4217.php) only. The string "XRP" is disallowed on trustlines because it is reserved for the XRP Ledger's native currency. The following characters are permitted: all uppercase and lowercase letters, digits, as well as the symbols `?`, `!`, `@`, `#`, `$`, `%`, `^`, `&`, `*`, `<`, `>`, `(`, `)`, `{`, `}`, `[`, `]`, and `|`.
+
+## Value
+A *value* is a quantity of a currency represented as a decimal string. Be careful: JavaScript's native number format does not have sufficient precision to represent all values. XRP has different precision from other currencies.
+
+**XRP** has 6 significant digits past the decimal point. In other words, XRP cannot be divided into positive values smaller than `0.000001` (1e-6). This smallest unit is called a "drop". XRP has a maximum value of `100000000000` (1e11). Some RippleAPI methods accept XRP in order to maintain compatibility with older versions of the API. For consistency with the `rippled` APIs, we recommend formally specifying XRP values in *drops* in all API requests, and converting them to XRP for display. This is similar to Bitcoin's *satoshis* and Ethereum's *wei*. 1 XRP = 1,000,000 drops.
+
+**Non-XRP values** have 16 decimal digits of precision, with a maximum value of `9999999999999999e80`. The smallest positive non-XRP value is `1e-81`.
+
+## Amount
+
+Example 100.00 USD amount:
+
+```json
+{
+  "currency": "USD",
+  "counterparty": "rMH4UxPrbuMa1spCBR98hLLyNJp4d8p4tM",
+  "value": "100"
+}
+```
+
+Example 3.0 XRP amount, in drops:
+```json
+{
+  "currency": "drops",
+  "value": "3000000"
+}
+```
+(Requires `ripple-lib` version 1.0.0 or higher.)
+
+An *amount* is an object specifying a currency, a quantity of that currency, and the counterparty (issuer) on the trustline that holds the value. For XRP, there is no counterparty.
+
+A *lax amount* allows the counterparty to be omitted for all currencies. If the counterparty is not specified in an amount within a transaction specification, then any counterparty may be used for that amount.
+
+A *lax lax amount* allows either or both the counterparty and value to be omitted.
+
+A *balance* is an amount than can have a negative value.
+
+<%- renderSchema('objects/amount-base.json') %>

docs/src/boilerplate.md.ejs

@@ -0,0 +1,62 @@
+## Boilerplate
+
+Use the following [boilerplate code](https://en.wikipedia.org/wiki/Boilerplate_code) to wrap your custom code using RippleAPI.
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI;
+
+const api = new RippleAPI({
+  server: 'wss://s1.ripple.com' // Public rippled server hosted by Ripple, Inc.
+});
+api.on('error', (errorCode, errorMessage) => {
+  console.log(errorCode + ': ' + errorMessage);
+});
+api.on('connected', () => {
+  console.log('connected');
+});
+api.on('disconnected', (code) => {
+  // code - [close code](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent) sent by the server
+  // will be 1000 if this was normal closure
+  console.log('disconnected, code:', code);
+});
+api.connect().then(() => {
+  /* insert code here */
+}).then(() => {
+  return api.disconnect();
+}).catch(console.error);
+```
+
+RippleAPI is designed to work in [Node.js](https://nodejs.org) version **6.11.3**. RippleAPI may work on older Node.js versions if you use [Babel](https://babeljs.io/) for [ECMAScript 6](https://babeljs.io/docs/learn-es2015/) support.
+
+The code samples in this documentation are written with ECMAScript 6 (ES6) features, but `RippleAPI` also works with ECMAScript 5 (ES5). Regardless of whether you use ES5 or ES6, the methods that return Promises return [ES6-style promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
+
+<aside class="notice">
+All the code snippets in this documentation assume that you have surrounded them with this boilerplate.
+</aside>
+
+<aside class="notice">
+If you omit the "catch" section, errors may not be visible.
+</aside>
+
+<aside class="notice">
+The "error" event is emitted whenever an error occurs that cannot be associated with a specific request. If the listener is not registered, an exception will be thrown whenever the event is emitted.
+</aside>
+
+### Parameters
+
+The RippleAPI constructor optionally takes one argument, an object with the following options:
+
+<%- renderSchema('input/api-options.json') %>
+
+If you omit the `server` parameter, RippleAPI operates [offline](#offline-functionality).
+
+
+### Installation ###
+
+1. Install [Node.js](https://nodejs.org) and [Yarn](https://yarnpkg.com/en/docs/install). Most Linux distros have a package for Node.js; check that it's the version you want.
+2. Use yarn to install RippleAPI:
+      `yarn add ripple-lib`
+
+After you have installed ripple-lib, you can create scripts using the [boilerplate](#boilerplate) and run them using the Node.js executable, typically named `node`:
+
+      `node script.js`

docs/src/combine.md.ejs

@@ -0,0 +1,24 @@
+## combine
+
+`combine(signedTransactions: Array<string>): {signedTransaction: string, id: string}`
+
+Combines signed transactions from multiple accounts for a multisignature transaction. The signed transaction must subsequently be [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema("input/combine.json") %>
+
+### Return Value
+
+This method returns an object with the following structure:
+
+<%- renderSchema("output/sign.json") %>
+
+### Example
+
+```javascript
+const signedTransactions = <%- importFile('test/fixtures/requests/combine.json') %>;
+return api.combine(signedTransactions);
+```
+
+<%- renderFixture("responses/combine.json") %>

docs/src/computeLedgerHash.md.ejs

@@ -0,0 +1,28 @@
+## computeLedgerHash
+
+`computeLedgerHash(ledger: Object): string`
+
+Compute the hash of a ledger.
+
+### Parameters
+
+<aside class="notice">
+The parameter to this method has the same structure as the return value of getLedger.
+</aside>
+
+<%- renderSchema('input/compute-ledger-hash.json') %>
+
+### Return Value
+
+This method returns an uppercase hexadecimal string representing the hash of the ledger.
+
+### Example
+
+```javascript
+const ledger = <%- importFile('test/fixtures/requests/compute-ledger-hash.json') %>;
+return api.computeLedgerHash(ledger);
+```
+
+```json
+"F4D865D83EB88C1A1911B9E90641919A1314F36E1B099F8E95FE3B7C77BE3349"
+```

docs/src/connect.md.ejs

@@ -0,0 +1,17 @@
+## connect
+
+`connect(): Promise<void>`
+
+Tells the RippleAPI instance to connect to its rippled server.
+
+### Parameters
+
+This method has no parameters.
+
+### Return Value
+
+This method returns a promise that resolves with a void value when a connection is established.
+
+### Example
+
+See [Boilerplate](#boilerplate) for code sample.

docs/src/disconnect.md.ejs

@@ -0,0 +1,17 @@
+## disconnect
+
+`disconnect(): Promise<void>`
+
+Tells the RippleAPI instance to disconnect from its rippled server.
+
+### Parameters
+
+This method has no parameters.
+
+### Return Value
+
+This method returns a promise that resolves with a void value when a connection is destroyed.
+
+### Example
+
+See [Boilerplate](#boilerplate) for code sample

docs/src/events.md.ejs

@@ -0,0 +1,81 @@
+# API Events
+
+## ledger
+
+This event is emitted whenever a new ledger version is validated on the connected server.
+
+### Return Value
+
+<%- renderSchema('output/ledger-event.json') %>
+
+### Example
+
+```javascript
+api.on('ledger', ledger => {
+  console.log(JSON.stringify(ledger, null, 2));
+});
+```
+
+<%- renderFixture('responses/ledger-event.json') %>
+
+## error
+
+This event is emitted when there is an error on the connection to the server that cannot be associated to a specific request.
+
+### Return Value
+
+The first parameter is a string indicating the error type:
+* `badMessage` - rippled returned a malformed message
+* `websocket` - the websocket library emitted an error
+* one of the error codes found in the [rippled Universal Errors](https://ripple.com/build/rippled-apis/#universal-errors).
+
+The second parameter is a message explaining the error.
+
+The third parameter is:
+* the message that caused the error for `badMessage`
+* the error object emitted for `websocket`
+* the parsed response for rippled errors
+
+### Example
+
+```javascript
+api.on('error', (errorCode, errorMessage, data) => {
+  console.log(errorCode + ': ' + errorMessage);
+});
+```
+
+```
+tooBusy: The server is too busy to help you now.
+```
+
+## connected
+
+This event is emitted after connection successfully opened.
+
+### Example
+
+```javascript
+api.on('connected', () => {
+  console.log('Connection is open now.');
+});
+```
+
+## disconnected
+
+This event is emitted when connection is closed.
+
+### Return Value
+
+The only parameter is a number containing the [close code](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent) send by the server.
+
+### Example
+
+```javascript
+api.on('disconnected', (code) => {
+  if (code !== 1000) {
+    console.log('Connection is closed due to error.');
+  } else {
+    console.log('Connection is closed normally.');
+  }
+});
+```

docs/src/generateAddress.md.ejs

@@ -0,0 +1,23 @@
+## generateAddress
+
+`generateAddress(): {address: string, secret: string}`
+
+Generate a new XRP Ledger address and corresponding secret.
+
+### Parameters
+
+<%- renderSchema('input/generate-address.json') %>
+
+### Return Value
+
+This method returns an object with the following structure:
+
+<%- renderSchema('output/generate-address.json') %>
+
+### Example
+
+```javascript
+return api.generateAddress();
+```
+
+<%- renderFixture('responses/generate-address.json') %>

docs/src/getAccountInfo.md.ejs

@@ -0,0 +1,25 @@
+## getAccountInfo
+
+`getAccountInfo(address: string, options: Object): Promise<Object>`
+
+Returns information for the specified account. Note: For account data that is modifiable by the user, see [getSettings](#getsettings).
+
+### Parameters
+
+<%- renderSchema('input/get-account-info.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-account-info.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getAccountInfo(address).then(info =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-account-info.json') %>

docs/src/getAccountObjects.md.ejs

@@ -0,0 +1,33 @@
+## getAccountObjects
+
+`getAccountObjects(address: string, options: object): Promise<AccountObjectsResponse>`
+
+Returns objects owned by an account. For an account's trust lines and balances, see `getTrustlines` and `getBalances`.
+
+### Parameters
+
+<%- renderSchema('input/get-account-objects.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-account-objects.json') %>
+
+The types of objects that may be returned include:
+* Offer objects for orders that are currently live, unfunded, or expired but not yet removed.
+* RippleState objects for trust lines where this account's side is not in the default state.
+* A SignerList object if the account has multi-signing enabled.
+* Escrow objects for held payments that have not yet been executed or canceled.
+* PayChannel objects for open payment channels.
+* Check objects for pending checks.
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getAccountObjects(address: address).then(objects =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-account-objects.json') %>

docs/src/getBalanceSheet.md.ejs

@@ -0,0 +1,25 @@
+## getBalanceSheet
+
+`getBalanceSheet(address: string, options: Object): Promise<Object>`
+
+Returns aggregate balances by currency plus a breakdown of assets and obligations for a specified account.
+
+### Parameters
+
+<%- renderSchema('input/get-balance-sheet.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-balance-sheet.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getBalanceSheet(address).then(balanceSheet =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-balance-sheet.json') %>

docs/src/getBalances.md.ejs

@@ -0,0 +1,25 @@
+## getBalances
+
+`getBalances(address: string, options: Object): Promise<Array<Object>>`
+
+Returns balances for a specified account.
+
+### Parameters
+
+<%- renderSchema('input/get-balances.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of objects with the following structure:
+
+<%- renderSchema('output/get-balances.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getBalances(address).then(balances =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-balances.json') %>

docs/src/getFee.md.ejs

@@ -0,0 +1,25 @@
+## getFee
+
+`getFee(): Promise<string>`
+
+Returns the estimated transaction fee for the rippled server the RippleAPI instance is connected to.
+
+This will use the [feeCushion parameter](#parameters) provided to the RippleAPI constructor, or the default value of `1.2`.
+
+### Parameters
+
+<%- renderSchema('input/get-fee.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with a string-encoded floating point value representing the estimated fee to submit a transaction, expressed in XRP.
+
+### Example
+
+```javascript
+return api.getFee().then(fee => {/* ... */});
+```
+
+```json
+"0.000012"
+```

docs/src/getLedger.md.ejs

@@ -0,0 +1,24 @@
+## getLedger
+
+`getLedger(options: Object): Promise<Object>`
+
+Returns header information for the specified ledger (or the most recent validated ledger if no ledger is specified). Optionally, all the transactions that were validated in the ledger or the account state information can be returned with the ledger header.
+
+### Parameters
+
+<%- renderSchema('input/get-ledger.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-ledger.json') %>
+
+### Example
+
+```javascript
+return api.getLedger()
+  .then(ledger => {/* ... */});
+```
+
+<%- renderFixture('responses/get-ledger.json') %>

docs/src/getLedgerVersion.md.ejs

@@ -0,0 +1,26 @@
+## getLedgerVersion
+
+`getLedgerVersion(): Promise<number>`
+
+Returns the most recent validated ledger version number known to the connected server.
+
+### Parameters
+
+This method has no parameters.
+
+### Return Value
+
+This method returns a promise that resolves with a positive integer representing the most recent validated ledger version number known to the connected server.
+
+### Example
+
+```javascript
+return api.getLedgerVersion().then(ledgerVersion => {
+  /* ... */
+});
+```
+
+```json
+16869039
+```
+

docs/src/getOrderbook.md.ejs

@@ -0,0 +1,32 @@
+## getOrderbook
+
+`getOrderbook(address: string, orderbook: Object, options: Object): Promise<Object>`
+
+Returns open orders for the specified account. Open orders are orders that have not yet been fully executed and are still in the order book.
+
+### Parameters
+
+<%- renderSchema('input/get-orderbook.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure (Note: the structures of `bids` and `asks` are identical):
+
+<%- renderSchema('output/get-orderbook.json') %>
+
+### Raw order data
+
+(Requires ripple-lib 0.22.0 or higher.) The response includes a `data` property containing the raw order data. This may include `owner_funds`, `Flags`, and other fields.
+
+For details, see the rippled method [book_offers](https://ripple.com/build/rippled-apis/#book-offers).
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const orderbook = <%- importFile('test/fixtures/requests/get-orderbook.json') %>;
+return api.getOrderbook(address, orderbook)
+  .then(orderbook => {/* ... */});
+```
+
+<%- renderFixture('responses/get-orderbook.json') %>

docs/src/getOrders.md.ejs

@@ -0,0 +1,25 @@
+## getOrders
+
+`getOrders(address: string, options: Object): Promise<Array<Object>>`
+
+Returns open orders for the specified account. Open orders are orders that have not yet been fully executed and are still in the order book.
+
+### Parameters
+
+<%- renderSchema('input/get-orders.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of objects with the following structure:
+
+<%- renderSchema('output/get-orders.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getOrders(address).then(orders =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-orders.json') %>

docs/src/getPaths.md.ejs

@@ -0,0 +1,25 @@
+## getPaths
+
+`getPaths(pathfind: Object): Promise<Array<Object>>`
+
+Finds paths to send a payment. Paths are options for how to route a payment.
+
+### Parameters
+
+<%- renderSchema("input/get-paths.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of objects with the following structure:
+
+<%- renderSchema("output/get-paths.json") %>
+
+### Example
+
+```javascript
+const pathfind = <%- importFile('test/fixtures/requests/getpaths/normal.json') %>;
+return api.getPaths(pathfind)
+  .then(paths => {/* ... */});
+```
+
+<%- renderFixture("responses/get-paths.json") %>

docs/src/getPaymentChannel.md.ejs

@@ -0,0 +1,26 @@
+## getPaymentChannel
+
+`getPaymentChannel(id: string): Promise<Object>`
+
+Returns specified payment channel.
+
+### Parameters
+
+<%- renderSchema('input/get-payment-channel.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-payment-channel.json') %>
+
+### Example
+
+```javascript
+const channelId =
+  'E30E709CF009A1F26E0E5C48F7AA1BFB79393764F15FB108BDC6E06D3CBD8415';
+return api.getPaymentChannel(channelId).then(channel =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-payment-channel.json') %>

docs/src/getServerInfo.md.ejs

@@ -0,0 +1,23 @@
+## getServerInfo
+
+`getServerInfo(): Promise<object>`
+
+Get status information about the server that the RippleAPI instance is connected to.
+
+### Parameters
+
+This method has no parameters.
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<%- renderSchema('output/get-server-info.json') %>
+
+### Example
+
+```javascript
+return api.getServerInfo().then(info => {/* ... */});
+```
+
+<%- renderFixture('responses/get-server-info.json') %>

docs/src/getSettings.md.ejs

@@ -0,0 +1,25 @@
+## getSettings
+
+`getSettings(address: string, options: Object): Promise<Object>`
+
+Returns settings for the specified account. Note: For account data that is not modifiable by the user, see [getAccountInfo](#getaccountinfo).
+
+### Parameters
+
+<%- renderSchema('input/get-settings.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of objects with the following structure (Note: all fields are optional as they will not be shown if they are set to their default value):
+
+<%- renderSchema('output/get-settings.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getSettings(address).then(settings =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/get-settings.json') %>

docs/src/getTransaction.md.ejs

@@ -0,0 +1,26 @@
+## getTransaction
+
+`getTransaction(id: string, options: Object): Promise<Object>`
+
+Retrieves a transaction by its [Transaction ID](#transaction-id).
+
+### Parameters
+
+<%- renderSchema('input/get-transaction.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with a transaction object containing the following fields.
+
+<%- renderSchema('output/get-transaction.json') %>
+
+### Example
+
+```javascript
+const id = '01CDEAA89BF99D97DFD47F79A0477E1DCC0989D39F70E8AACBFE68CC83BD1E94';
+return api.getTransaction(id).then(transaction => {
+  /* ... */
+});
+```
+
+<%- renderFixture('responses/get-transaction-payment.json') %>

docs/src/getTransactions.md.ejs

@@ -0,0 +1,24 @@
+## getTransactions
+
+`getTransactions(address: string, options: Object): Promise<Array<Object>>`
+
+Retrieves historical transactions of an account.
+
+### Parameters
+
+<%- renderSchema('input/get-transactions.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of transaction object in the same format as [getTransaction](#gettransaction).
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getTransactions(address).then(transaction => {
+  /* ... */
+});
+```
+
+<%- renderFixture('responses/get-transactions.json') %>

docs/src/getTrustlines.md.ejs

@@ -0,0 +1,25 @@
+## getTrustlines
+
+`getTrustlines(address: string, options: Object): Promise<Array<Object>>`
+
+Returns trustlines for a specified account.
+
+### Parameters
+
+<%- renderSchema("input/get-trustlines.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an array of objects with the following structure.
+
+<%- renderSchema("output/get-trustlines.json") %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.getTrustlines(address).then(trustlines =>
+  {/* ... */});
+```
+
+<%- renderFixture("responses/get-trustlines.json") %>

docs/src/hasNextPage.md.ejs

@@ -0,0 +1,27 @@
+## hasNextPage
+
+`hasNextPage(currentResponse): boolean`
+
+Returns `true` when there are more pages available.
+
+When there are more results than contained in the response, the response includes a `marker` field. You can use this convenience method, or check for `marker` yourself.
+
+See [Markers and Pagination](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+
+### Return Value
+
+This method returns `true` if `currentResponse` includes a `marker`.
+
+### Example
+
+```javascript
+return api.request('ledger_data', {
+  ledger_index: 'validated'
+}).then(response => {
+  /* Do something useful with response */
+
+  if (api.hasNextPage(response)) {
+    /* There are more pages available */
+  }
+}).catch(console.error);
+```

docs/src/index.md.ejs

@@ -0,0 +1,52 @@
+<% include introduction.md.ejs %>
+<% include boilerplate.md.ejs %>
+<% include offline.md.ejs %>
+<% include basictypes.md.ejs %>
+<% include transactions.md.ejs %>
+<% include specifications.md.ejs %>
+<% include rippledAPIs.md.ejs %>
+<% include request.md.ejs %>
+<% include hasNextPage.md.ejs %>
+<% include requestNextPage.md.ejs %>
+<% include methods.md.ejs %>
+<% include connect.md.ejs %>
+<% include disconnect.md.ejs %>
+<% include isConnected.md.ejs %>
+<% include getServerInfo.md.ejs %>
+<% include getFee.md.ejs %>
+<% include getLedgerVersion.md.ejs %>
+<% include getTransaction.md.ejs %>
+<% include getTransactions.md.ejs %>
+<% include getTrustlines.md.ejs %>
+<% include getBalances.md.ejs %>
+<% include getBalanceSheet.md.ejs %>
+<% include getPaths.md.ejs %>
+<% include getOrders.md.ejs %>
+<% include getOrderbook.md.ejs %>
+<% include getSettings.md.ejs %>
+<% include getAccountInfo.md.ejs %>
+<% include getAccountObjects.md.ejs %>
+<% include getPaymentChannel.md.ejs %>
+<% include getLedger.md.ejs %>
+<% include preparePayment.md.ejs %>
+<% include prepareTrustline.md.ejs %>
+<% include prepareOrder.md.ejs %>
+<% include prepareOrderCancellation.md.ejs %>
+<% include prepareSettings.md.ejs %>
+<% include prepareEscrowCreation.md.ejs %>
+<% include prepareEscrowCancellation.md.ejs %>
+<% include prepareEscrowExecution.md.ejs %>
+<% include preparePaymentChannelCreate.md.ejs %>
+<% include preparePaymentChannelClaim.md.ejs %>
+<% include preparePaymentChannelFund.md.ejs %>
+<% include prepareCheckCreate.md.ejs %>
+<% include prepareCheckCancel.md.ejs %>
+<% include prepareCheckCash.md.ejs %>
+<% include sign.md.ejs %>
+<% include combine.md.ejs %>
+<% include submit.md.ejs %>
+<% include generateAddress.md.ejs %>
+<% include signPaymentChannelClaim.md.ejs %>
+<% include verifyPaymentChannelClaim.md.ejs %>
+<% include computeLedgerHash.md.ejs %>
+<% include events.md.ejs %>

docs/src/introduction.md.ejs

@@ -0,0 +1,10 @@
+# Introduction
+
+RippleAPI (ripple-lib) is the official client library to the XRP Ledger. Currently, RippleAPI is only available in JavaScript.
+Using RippleAPI, you can:
+
+* [Query transactions from the XRP Ledger history](#gettransaction)
+* [Sign](#sign) transactions securely without connecting to any server
+* [Submit](#submit) transactions to the XRP Ledger, including [Payments](#payment), [Orders](#order), [Settings changes](#settings), and [other types](#transaction-types)
+* [Generate a new XRP Ledger Address](#generateaddress)
+* ... and [much more](#api-methods).

docs/src/isConnected.md.ejs

@@ -0,0 +1,23 @@
+## isConnected
+
+`isConnected(): boolean`
+
+Checks if the RippleAPI instance is connected to its rippled server.
+
+### Parameters
+
+This method has no parameters.
+
+### Return Value
+
+This method returns `true` if connected and `false` if not connected.
+
+### Example
+
+```javascript
+return api.isConnected();
+```
+
+```json
+true
+```

docs/src/methods.md.ejs

@@ -0,0 +1 @@
+# API Methods

docs/src/offline.md.ejs

@@ -0,0 +1,26 @@
+## Offline functionality
+
+RippleAPI can also function without internet connectivity. This can be useful in order to generate secrets and sign transactions from a secure, isolated machine.
+
+To instantiate RippleAPI in offline mode, use the following boilerplate code:
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI;
+
+const api = new RippleAPI();
+/* insert code here */
+```
+
+Methods that depend on the state of the XRP Ledger are unavailable in offline mode. To prepare transactions offline, you **must** specify  the `fee`, `sequence`, and `maxLedgerVersion` parameters in the [transaction instructions](#transaction-instructions). You can use the following methods while offline:
+
+* [preparePayment](#preparepayment)
+* [prepareTrustline](#preparetrustline)
+* [prepareOrder](#prepareorder)
+* [prepareOrderCancellation](#prepareordercancellation)
+* [prepareSettings](#preparesettings)
+* [prepareEscrowCreation](#prepareescrowcreation)
+* [prepareEscrowCancellation](#prepareescrowcancellation)
+* [prepareEscrowExecution](#prepareescrowexecution)
+* [sign](#sign)
+* [generateAddress](#generateaddress)
+* [computeLedgerHash](#computeledgerhash)

docs/src/prepareCheckCancel.md.ejs

@@ -0,0 +1,30 @@
+## prepareCheckCancel
+
+`prepareCheckCancel(address: string, checkCancel: Object, instructions: Object): Promise<Object>`
+
+Prepare a Check cancellation transaction. This cancels an unredeemed Check, removing it from the ledger without sending any money. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-check-cancel.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const checkCancel = <%- importFile('test/fixtures/requests/prepare-check-cancel.json') %>;
+return api.prepareCheckCancel(address, checkCancel).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-check-cancel.json') %>

docs/src/prepareCheckCash.md.ejs

@@ -0,0 +1,30 @@
+## prepareCheckCash
+
+`prepareCheckCash(address: string, checkCash: Object, instructions: Object): Promise<Object>`
+
+Prepare a Check cashing transaction. This redeems a Check to receive up to the amount authorized by the corresponding CheckCreate transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-check-cash.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const checkCash = <%- importFile('test/fixtures/requests/prepare-check-cash-amount.json') %>;
+return api.prepareCheckCash(address, checkCash).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-check-cash-amount.json') %>

docs/src/prepareCheckCreate.md.ejs

@@ -0,0 +1,30 @@
+## prepareCheckCreate
+
+`prepareCheckCreate(address: string, checkCreate: Object, instructions: Object): Promise<Object>`
+
+Prepare a Check creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-check-create.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const checkCreate = <%- importFile('test/fixtures/requests/prepare-check-create.json') %>;
+return api.prepareCheckCreate(address, checkCreate).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-check-create.json') %>

docs/src/prepareEscrowCancellation.md.ejs

@@ -0,0 +1,30 @@
+## prepareEscrowCancellation
+
+`prepareEscrowCancellation(address: string, escrowCancellation: Object, instructions: Object): Promise<Object>`
+
+Prepare an escrow cancellation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-escrow-cancellation.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const escrowCancellation = <%- importFile('test/fixtures/requests/prepare-escrow-cancellation.json') %>;
+return api.prepareEscrowCancellation(address, escrowCancellation).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-escrow-cancellation.json') %>

docs/src/prepareEscrowCreation.md.ejs

@@ -0,0 +1,30 @@
+## prepareEscrowCreation
+
+`prepareEscrowCreation(address: string, escrowCreation: Object, instructions: Object): Promise<Object>`
+
+Prepare an escrow creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-escrow-creation.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const escrowCreation = <%- importFile('test/fixtures/requests/prepare-escrow-creation.json') %>;
+return api.prepareEscrowCreation(address, escrowCreation).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-escrow-creation.json') %>

docs/src/prepareEscrowExecution.md.ejs

@@ -0,0 +1,30 @@
+## prepareEscrowExecution
+
+`prepareEscrowExecution(address: string, escrowExecution: Object, instructions: Object): Promise<Object>`
+
+Prepare an escrow execution transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-escrow-execution.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const escrowExecution = <%- importFile('test/fixtures/requests/prepare-escrow-execution.json') %>;
+return api.prepareEscrowExecution(address, escrowExecution).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-escrow-execution.json') %>

docs/src/prepareOrder.md.ejs

@@ -0,0 +1,32 @@
+## prepareOrder
+
+`prepareOrder(address: string, order: Object, instructions: Object): Promise<Object>`
+
+Prepare an order transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-order.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+
+// Buy 10.10 USD (of the specified issuer) for 2.0 XRP (2000000 drops), fill or kill.
+const order = <%- importFile('test/fixtures/requests/prepare-order.json') %>;
+return api.prepareOrder(address, order)
+  .then(prepared => {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-order.json') %>

docs/src/prepareOrderCancellation.md.ejs

@@ -0,0 +1,30 @@
+## prepareOrderCancellation
+
+`prepareOrderCancellation(address: string, orderCancellation: Object, instructions: Object): Promise<Object>`
+
+Prepare an order cancellation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema("input/prepare-order-cancellation.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema("output/prepare.json") %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const orderCancellation = {orderSequence: 123};
+return api.prepareOrderCancellation(address, orderCancellation)
+  .then(prepared => {/* ... */});
+```
+
+<%- renderFixture("responses/prepare-order-cancellation.json") %>

docs/src/preparePayment.md.ejs

@@ -0,0 +1,30 @@
+## preparePayment
+
+`preparePayment(address: string, payment: Object, instructions: Object): Promise<Object>`
+
+Prepare a payment transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema("input/prepare-payment.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema("output/prepare.json") %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const payment = <%- importFile('test/fixtures/requests/prepare-payment.json') %>;
+return api.preparePayment(address, payment).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture("responses/prepare-payment.json") %>

docs/src/preparePaymentChannelClaim.md.ejs

@@ -0,0 +1,30 @@
+## preparePaymentChannelClaim
+
+`preparePaymentChannelClaim(address: string, paymentChannelClaim: Object, instructions: Object): Promise<Object>`
+
+Prepare a payment channel claim transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-payment-channel-claim.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const paymentChannelClaim = <%- importFile('test/fixtures/requests/prepare-payment-channel-claim.json') %>;
+return api.preparePaymentChannelClaim(address, paymentChannelClaim).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-payment-channel-claim.json') %>

docs/src/preparePaymentChannelCreate.md.ejs

@@ -0,0 +1,30 @@
+## preparePaymentChannelCreate
+
+`preparePaymentChannelCreate(address: string, paymentChannelCreate: Object, instructions: Object): Promise<Object>`
+
+Prepare a payment channel creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-payment-channel-create.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const paymentChannelCreate = <%- importFile('test/fixtures/requests/prepare-payment-channel-create.json') %>;
+return api.preparePaymentChannelCreate(address, paymentChannelCreate).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-payment-channel-create.json') %>

docs/src/preparePaymentChannelFund.md.ejs

@@ -0,0 +1,30 @@
+## preparePaymentChannelFund
+
+`preparePaymentChannelFund(address: string, paymentChannelFund: Object, instructions: Object): Promise<Object>`
+
+Prepare a payment channel fund transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-payment-channel-fund.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const paymentChannelFund = <%- importFile('test/fixtures/requests/prepare-payment-channel-fund.json') %>;
+return api.preparePaymentChannelFund(address, paymentChannelFund).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture('responses/prepare-payment-channel-fund.json') %>

docs/src/prepareSettings.md.ejs

@@ -0,0 +1,30 @@
+## prepareSettings
+
+`prepareSettings(address: string, settings: Object, instructions: Object): Promise<Object>`
+
+Prepare a settings transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema('input/prepare-settings.json') %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema('output/prepare.json') %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const settings = <%- importFile('test/fixtures/requests/prepare-settings.json') %>;
+return api.prepareSettings(address, settings)
+  .then(prepared => {/* ... */});
+```
+
+<%- renderFixture('requests/prepare-settings.json') %>

docs/src/prepareTrustline.md.ejs

@@ -0,0 +1,30 @@
+## prepareTrustline
+
+`prepareTrustline(address: string, trustline: Object, instructions: Object): Promise<Object>`
+
+Prepare a trustline transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema("input/prepare-trustline.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema("output/prepare.json") %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+const trustline = <%- importFile('test/fixtures/requests/prepare-trustline.json') %>;
+return api.prepareTrustline(address, trustline).then(prepared =>
+  {/* ... */});
+```
+
+<%- renderFixture("responses/prepare-trustline.json") %>

docs/src/request.md.ejs

@@ -0,0 +1,27 @@
+## request
+
+`request(command: string, options: object): Promise<object>`
+
+Returns the response from invoking the specified command, with the specified options, on the connected rippled server.
+
+Refer to [rippled APIs](https://ripple.com/build/rippled-apis/) for commands and options. All XRP amounts must be specified in drops. One drop is equal to 0.000001 XRP. See [Specifying Currency Amounts](https://ripple.com/build/rippled-apis/#specifying-currency-amounts).
+
+Most commands return data for the `current` (in-progress, open) ledger by default. Do not rely on this. Always specify a ledger version in your request. In the example below, the 'validated' ledger is requested, which is the most recent ledger that has been validated by the whole network. See [Specifying Ledgers](https://ripple.com/build/rippled-apis/#specifying-ledgers).
+
+### Return Value
+
+This method returns a promise that resolves with the response from rippled.
+
+### Example
+
+```javascript
+// Replace 'ledger' with your desired rippled command
+return api.request('ledger', {
+  ledger_index: 'validated'
+}).then(response => {
+  /* Do something useful with response */
+  console.log(JSON.stringify(response, null, 2))
+}).catch(console.error);
+```
+
+<%- renderFixture('responses/ledger.json') %>

docs/src/requestNextPage.md.ejs

@@ -0,0 +1,29 @@
+## requestNextPage
+
+`requestNextPage(command: string, params: object = {}, currentResponse: object): Promise<object>`
+
+Requests the next page of data.
+
+You can use this convenience method, or include `currentResponse.marker` in `params` yourself, when using `request`.
+
+See [Markers and Pagination](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+
+### Return Value
+
+This method returns a promise that resolves with the next page of data from rippled.
+
+If the response does not have a next page, the promise will reject with `new errors.NotFoundError('response does not have a next page')`.
+
+### Example
+
+```javascript
+const command = 'ledger_data'
+const params = {
+  ledger_index: 'validated'
+}
+return api.request(command, params).then(response => {
+  return api.requestNextPage(command, params, response)
+}).then(response_page_2 => {
+  /* Do something useful with second page of response */
+}).catch(console.error);
+```

docs/src/rippledAPIs.md.ejs

@@ -0,0 +1,66 @@
+# rippled APIs
+
+ripple-lib relies on [rippled APIs](https://ripple.com/build/rippled-apis/) for all online functionality. With ripple-lib version 1.0.0 and higher, you can easily access rippled APIs through ripple-lib. Use the `request()`, `hasNextPage()`, and `requestNextPage()` methods:
+* Use `request()` to issue any `rippled` command, including `account_currencies`, `subscribe`, and `unsubscribe`. [Full list of API Methods](https://ripple.com/build/rippled-apis/#api-methods). 
+* Use `hasNextPage()` to determine whether a response has more pages. This is true when the response includes a [`marker` field](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+* Use `requestNextPage()` to request the next page of data.
+
+When using rippled APIs, [specify XRP amounts in drops](https://ripple.com/build/rippled-apis/#specifying-currency-amounts). 1 XRP = 1000000 drops.
+
+## Listening to streams
+
+The `rippled` server can push updates to your client when various events happen. Refer to [Subscriptions in the `rippled` API docs](https://ripple.com/build/rippled-apis/#subscriptions) for details.
+
+Note that the `streams` parameter for generic streams takes an array. For example, to subscribe to the `validations` stream, use `{ streams: [ 'validations' ] }`.
+
+The string names of some generic streams to subscribe to are in the table below. (Refer to `rippled` for an up-to-date list of streams.)
+
+Type | Description
+---- | -----------
+`server` | Sends a message whenever the status of the `rippled` server (for example, network connectivity) changes.
+`ledger` | Sends a message whenever the consensus process declares a new validated ledger.
+`transactions` | Sends a message whenever a transaction is included in a closed ledger.
+`transactions_proposed` | Sends a message whenever a transaction is included in a closed ledger, as well as some transactions that have not yet been included in a validated ledger and may never be. Not all proposed transactions appear before validation. Even some transactions that don't succeed are included in validated ledgers because they take the anti-spam transaction fee.
+`validations` | Sends a message whenever the server receives a validation message, also called a validation vote, regardless of whether the server trusts the validator.
+`manifests` | Sends a message whenever the server receives a manifest.
+`peer_status` | (Admin-only) Information about connected peer `rippled` servers, especially with regards to the consensus process.
+
+When you subscribe to a stream, you must also listen to the relevant message type(s). Some of the available message types are in the table below. (Refer to `rippled` for an up-to-date list of message types.)
+
+Type | Description
+---- | -----------
+`ledgerClosed` | Sent by the `ledger` stream when the consensus process declares a new fully validated ledger. The message identifies the ledger and provides some information about its contents.
+`validationReceived` | Sent by the `validations` stream when the server receives a validation message, also called a validation vote, regardless of whether the server trusts the validator.
+`manifestReceived` | Sent by the `manifests` stream when the server receives a manifest.
+`transaction` | Sent by many subscriptions including `transactions`, `transactions_proposed`, `accounts`, `accounts_proposed`, and `book` (Order Book). See [Transaction Streams](https://ripple.com/build/rippled-apis/#transaction-streams) for details.
+`peerStatusChange` | (Admin-only) Reports a large amount of information on the activities of other `rippled` servers to which the server is connected.
+
+To register your listener function, use `connection.on(type, handler)`.
+
+Here is an example of listening for transactions on given account(s):
+```
+const account = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn' // Replace with the account you want notifications for
+api.connect().then(() => { // Omit this if you are already connected
+
+  // 'transaction' can be replaced with the relevant `type` from the table above
+  api.connection.on('transaction', (event) => {
+
+      // Do something useful with `event`
+      console.log(JSON.stringify(event, null, 2))
+  })
+
+  api.request('subscribe', {
+      accounts: [ account ]
+  }).then(response => {
+      if (response.status === 'success') {
+          console.log('Successfully subscribed')
+      }
+  }).catch(error => {
+      // Handle `error`
+  })
+})
+```
+
+The subscription ends when you unsubscribe or the WebSocket connection is closed.
+
+For full details, see [rippled Subscriptions](https://ripple.com/build/rippled-apis/#subscriptions).

docs/src/sign.md.ejs

@@ -0,0 +1,29 @@
+## sign
+
+```
+sign(txJSON: string, secret: string, options: Object): {signedTransaction: string, id: string}
+sign(txJSON: string, keypair: Object, options: Object): {signedTransaction: string, id: string}
+```
+
+Sign a prepared transaction. The signed transaction must subsequently be [submitted](#submit).
+
+### Parameters
+
+<%- renderSchema("input/sign.json") %>
+
+### Return Value
+
+This method returns an object with the following structure:
+
+<%- renderSchema("output/sign.json") %>
+
+### Example
+
+```javascript
+const txJSON = '{"Flags":2147483648,"TransactionType":"AccountSet","Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Domain":"726970706C652E636F6D","LastLedgerSequence":8820051,"Fee":"12","Sequence":23}';
+const secret = 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV';
+const keypair = { privateKey: '00ACCD3309DB14D1A4FC9B1DAE608031F4408C85C73EE05E035B7DC8B25840107A', publicKey: '02F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8' };
+return api.sign(txJSON, secret); // or: api.sign(txJSON, keypair);
+```
+
+<%- renderFixture("responses/sign.json") %>

docs/src/signPaymentChannelClaim.md.ejs

@@ -0,0 +1,28 @@
+## signPaymentChannelClaim
+
+`signPaymentChannelClaim(channel: string, amount: string, privateKey: string): string`
+
+Sign a payment channel claim. The signature can be submitted in a subsequent [PaymentChannelClaim](#preparepaymentchannelclaim) transaction.
+
+### Parameters
+
+<%- renderSchema("input/sign-payment-channel-claim.json") %>
+
+### Return Value
+
+This method returns a signature string:
+
+<%- renderSchema("output/sign-payment-channel-claim.json") %>
+
+### Example
+
+```javascript
+const channel =
+  '3E18C05AD40319B809520F1A136370C4075321B285217323396D6FD9EE1E9037';
+const amount = '.00001';
+const privateKey =
+  'ACCD3309DB14D1A4FC9B1DAE608031F4408C85C73EE05E035B7DC8B25840107A';
+return api.signPaymentChannelClaim(channel, amount, privateKey);
+```
+
+<%- renderFixture("responses/sign-payment-channel-claim.json") %>

docs/src/specifications.md.ejs

@@ -0,0 +1,143 @@
+# Transaction Specifications
+
+A *transaction specification* specifies what a transaction should do. Each [Transaction Type](#transaction-types) has its own type of specification.
+
+## Payment
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/payment.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-payment.json') %>
+
+## Trustline
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/trustline.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-trustline.json') %>
+
+## Order
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/order.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-order.json') %>
+
+## Order Cancellation
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/order-cancellation.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-order-cancellation.json') %>
+
+## Settings
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('output/get-settings.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-settings.json') %>
+
+## Escrow Creation
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/escrow-creation.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-escrow-creation.json') %>
+
+## Escrow Cancellation
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/escrow-cancellation.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-escrow-cancellation.json') %>
+
+## Escrow Execution
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/escrow-execution.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-escrow-execution.json') %>
+
+## Check Create
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/check-create.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-check-create.json') %>
+
+## Check Cancel
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/check-cancel.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-check-cancel.json') %>
+
+## Check Cash
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/check-cash.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-check-cash-amount.json') %>
+
+## Payment Channel Create
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/payment-channel-create.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-payment-channel-create.json') %>
+
+## Payment Channel Fund
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/payment-channel-fund.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-payment-channel-fund.json') %>
+
+## Payment Channel Claim
+
+See [Transaction Types](#transaction-types) for a description.
+
+<%- renderSchema('specifications/payment-channel-claim.json') %>
+
+### Example
+
+<%- renderFixture('requests/prepare-payment-channel-claim.json') %>

docs/src/submit.md.ejs

@@ -0,0 +1,25 @@
+## submit
+
+`submit(signedTransaction: string): Promise<Object>`
+
+Submits a signed transaction. The transaction is not guaranteed to succeed; it must be verified with [getTransaction](#gettransaction).
+
+### Parameters
+
+<%- renderSchema('input/submit.json') %>
+
+### Return Value
+
+This method returns an object with the following structure:
+
+<%- renderSchema('output/submit.json') %>
+
+### Example
+
+```javascript
+const signedTransaction = '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100BDE09A1F6670403F341C21A77CF35BA47E45CDE974096E1AA5FC39811D8269E702203D60291B9A27F1DCABA9CF5DED307B4F23223E0B6F156991DB601DFB9C41CE1C770A726970706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304';
+return api.submit(signedTransaction)
+  .then(result => {/* ... */});
+```
+
+<%- renderFixture('responses/submit.json') %>

docs/src/transactions.md.ejs

@@ -0,0 +1,72 @@
+# Transaction Overview
+
+## Transaction Types
+
+A transaction type is specified by the strings in the first column in the table below.
+
+Type | Description
+---- | -----------
+[payment](#payment) | A `payment` transaction represents a transfer of value from one account to another. Depending on the [path](https://ripple.com/build/paths/) taken, additional exchanges of value may occur atomically to facilitate the payment.
+[order](#order) | An `order` transaction creates a limit order. It defines an intent to exchange currencies, and creates an order in the XRP Ledger's order book if not completely fulfilled when placed. Orders can be partially fulfilled.
+[orderCancellation](#order-cancellation) | An `orderCancellation` transaction cancels an order in the XRP Ledger's order book.
+[trustline](#trustline) | A `trustline` transactions creates or modifies a trust line between two accounts.
+[settings](#settings) | A `settings` transaction modifies the settings of an account in the XRP Ledger.
+[escrowCreation](#escrow-creation) | An `escrowCreation` transaction creates an escrow on the ledger, which locks XRP until a cryptographic condition is met or it expires. It is like an escrow service where the XRP Ledger acts as the escrow agent.
+[escrowCancellation](#escrow-cancellation) | An `escrowCancellation` transaction unlocks the funds in an escrow and sends them back to the creator of the escrow, but it will only work after the escrow expires.
+[escrowExecution](#escrow-execution) | An `escrowExecution` transaction unlocks the funds in an escrow and sends them to the destination of the escrow, but it will only work if the cryptographic condition is provided.
+[checkCreate](#check-create) | A `checkCreate` transaction creates a check on the ledger, which is a deferred payment that can be cashed by its intended destination.
+[checkCancel](#check-cancel) | A `checkCancel` transaction cancels an unreedemed Check, removing it from the ledger without sending any money.
+[checkCash](#check-cash) | A `checkCash` transaction redeems a Check to receive up to the amount authorized by the corresponding `checkCreate` transaction. Only the `destination` address of a Check can cash it.
+[paymentChannelCreate](#payment-channel-create) | A `paymentChannelCreate` transaction opens a payment channel between two addresses with XRP set aside for asynchronous payments.
+[paymentChannelFund](#payment-channel-fund) | A `paymentChannelFund` transaction adds XRP to a payment channel and optionally sets a new expiration for the channel.
+[paymentChannelClaim](#payment-channel-claim) | A `paymentChannelClaim` transaction withdraws XRP from a channel and optionally requests to close it.
+
+## Transaction Flow
+
+Executing a transaction with `RippleAPI` requires the following four steps:
+
+1. Prepare - Create an unsigned transaction based on a [specification](#transaction-specifications) and [instructions](#transaction-instructions). There is a method to prepare each type of transaction:
+    * [preparePayment](#preparepayment)
+    * [prepareTrustline](#preparetrustline)
+    * [prepareOrder](#prepareorder)
+    * [prepareOrderCancellation](#prepareordercancellation)
+    * [prepareSettings](#preparesettings)
+    * [prepareEscrowCreation](#prepareescrowcreation)
+    * [prepareEscrowCancellation](#prepareescrowcancellation)
+    * [prepareEscrowExecution](#prepareescrowexecution)
+    * [prepareCheckCreate](#preparecheckcreate)
+    * [prepareCheckCancel](#preparecheckcancel)
+    * [prepareCheckCash](#preparecheckcash)
+2. [Sign](#sign) - Cryptographically sign the transaction locally and save the [transaction ID](#transaction-id). Signing is how the owner of an account authorizes a transaction to take place. For multisignature transactions, the `signedTransaction` fields returned by `sign` must be collected and passed to the [combine](#combine) method.
+3. [Submit](#submit) - Submit the transaction to the connected server.
+4. Verify - Verify that the transaction got validated by querying with [getTransaction](#gettransaction). This is necessary because transactions may fail even if they were successfully submitted.
+
+## Transaction Fees
+
+Every transaction must destroy a small amount of XRP as a cost to send the transaction. This is also called a *transaction fee*. The transaction cost is designed to increase along with the load on the XRP Ledger, making it very expensive to deliberately or inadvertently overload the peer-to-peer network that powers the XRP Ledger.
+
+You can choose the size of the fee you want to pay or let a default be used. You can get an estimate of the fee required to be included in the next ledger closing with the [getFee](#getfee) method.
+
+## Transaction Instructions
+
+Transaction instructions indicate how to execute a transaction, complementary with the [transaction specification](#transaction-specifications).
+
+<%- renderSchema("objects/instructions.json") %>
+
+We recommend that you specify a `maxLedgerVersion` so that you can quickly determine that a failed transaction will never succeeed in the future. It is impossible for a transaction to succeed after the XRP Ledger's consensus-validated ledger version exceeds the transaction's `maxLedgerVersion`. If you omit `maxLedgerVersion`, the "prepare\*" method automatically supplies a `maxLedgerVersion` equal to the current ledger plus 3, which it includes in the return value from the "prepare\*" method.
+
+## Transaction ID
+
+```json
+"F4AB442A6D4CBB935D66E1DA7309A5FC71C7143ED4049053EC14E3875B0CF9BF"
+```
+
+A transaction ID is a 64-bit hexadecimal string that uniquely identifies the transaction. The transaction ID is derived from the transaction instruction and specifications, using a strong hash function.
+
+You can look up a transaction by ID using the [getTransaction](#gettransaction) method.
+
+## Transaction Memos
+
+Every transaction can optionally have an array of memos for user applications. The `memos` field in each [transaction specification](#transaction-specifications) is an array of objects with the following structure:
+
+<%- renderSchema('objects/memos.json') %>

docs/src/verifyPaymentChannelClaim.md.ejs

@@ -0,0 +1,31 @@
+## verifyPaymentChannelClaim
+
+`verifyPaymentChannelClaim(channel: string, amount: string, signature: string, publicKey: string): boolean`
+
+Verify a payment channel claim signature.
+
+### Parameters
+
+<%- renderSchema("input/verify-payment-channel-claim.json") %>
+
+### Return Value
+
+This method returns `true` if the claim signature is valid.
+
+<%- renderSchema("output/verify-payment-channel-claim.json") %>
+
+### Example
+
+```javascript
+const channel =
+  '3E18C05AD40319B809520F1A136370C4075321B285217323396D6FD9EE1E9037';
+const amount = '.00001';
+const signature = <%- importFile("test/fixtures/responses/sign-payment-channel-claim.json") %>;
+const publicKey =
+  '02F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8';
+return api.verifyPaymentChannelClaim(channel, amount, signature, publicKey);
+```
+
+```json
+true
+```

package.json

@@ -1,47 +1,77 @@
 {
   "name": "ripple-lib",
-  "version": "0.9.0-rc1",
-  "description": "Ripple JavaScript client library",
+  "version": "1.0.0-beta.5",
+  "license": "ISC",
+  "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
   "files": [
-    "src/js/*",
-    "bin/*",
-    "build/*",
-    "test/*",
-    "Makefile",
-    "Gulpfile.js"
+    "dist/npm/*",
+    "build/*"
   ],
-  "main": "src/js/ripple",
+  "main": "dist/npm/",
+  "types": "dist/npm/index.d.ts",
+  "browser": {
+    "ws": "./dist/npm/common/wswrapper.js"
+  },
   "directories": {
     "test": "test"
   },
   "dependencies": {
-    "async": "~0.8.0",
-    "ws": "~0.4.31",
-    "extend": "~1.2.1",
-    "lru-cache": "~2.5.0",
-    "superagent": "^0.18.0",
-    "gulp-bump": "~0.1.10",
-    "ripple-wallet-generator": "1.0.1"
+    "@types/lodash": "^4.14.85",
+    "@types/ws": "^3.2.0",
+    "bignumber.js": "^4.1.0",
+    "https-proxy-agent": "2.2.1",
+    "jsonschema": "1.2.2",
+    "lodash": "^4.17.4",
+    "ripple-address-codec": "^2.0.1",
+    "ripple-binary-codec": "^0.1.13",
+    "ripple-hashes": "^0.3.1",
+    "ripple-keypairs": "^0.10.1",
+    "ripple-lib-transactionparser": "0.7.1",
+    "ws": "^3.3.1"
   },
   "devDependencies": {
-    "mocha": "~1.14.0",
-    "gulp": "~3.6.2",
-    "gulp-concat": "~2.2.0",
-    "gulp-jshint": "~1.5.5",
-    "gulp-uglify": "~0.3.0",
-    "gulp-rename": "~1.2.0",
-    "webpack": "~1.1.11",
-    "map-stream": "~0.1.0",
-    "istanbul": "~0.2.10",
-    "coveralls": "~2.10.0",
-    "nock": "^0.34.1",
-    "yargs": "~1.3.1"
+    "@types/node": "^8.0.53",
+    "assert-diff": "^1.0.1",
+    "coveralls": "^2.13.1",
+    "doctoc": "^0.15.0",
+    "ejs": "^2.3.4",
+    "eventemitter2": "^0.4.14",
+    "gulp": "^3.8.10",
+    "gulp-bump": "^0.1.13",
+    "gulp-rename": "^1.2.0",
+    "http-server": "^0.8.5",
+    "jayson": "^1.2.2",
+    "json-loader": "^0.5.2",
+    "json-schema-to-markdown-table": "^0.4.0",
+    "mocha": "^2.1.0",
+    "mocha-in-sauce": "^0.0.1",
+    "mocha-junit-reporter": "^1.9.1",
+    "null-loader": "^0.1.1",
+    "nyc": "^11.3.0",
+    "source-map-support": "^0.5.0",
+    "ts-loader": "^3.2.0",
+    "ts-node": "^3.3.0",
+    "tslint": "^5.8.0",
+    "tslint-eslint-rules": "^4.1.1",
+    "typescript": "2.9.2",
+    "uglifyjs-webpack-plugin": "^1.1.4",
+    "webpack": "^3.10.0",
+    "yargs": "^8.0.2"
   },
   "scripts": {
-    "build": "node_modules/.bin/gulp",
-    "pretest": "node_modules/.bin/gulp concat-sjcl",
-    "test": "./node_modules/.bin/istanbul test -x build/sjcl.js -x src/js/jsbn/* ./node_modules/mocha/bin/mocha -- --reporter spec test/*-test.js",
-    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
+    "build": "gulp",
+    "doctoc": "doctoc docs/index.md --title '# RippleAPI Reference' --github --maxlevel 2",
+    "docgen": "node --harmony scripts/build_docs.js",
+    "clean": "rm -rf dist/npm",
+    "compile": "mkdir -p dist/npm/common && cp -r src/common/schemas dist/npm/common/ && tsc",
+    "watch": "tsc -w",
+    "prepublish": "npm run clean && npm run compile && npm run build",
+    "test": "nyc mocha",
+    "coveralls": "cat ./coverage/lcov.info | coveralls",
+    "lint": "tslint -p ./",
+    "perf": "./scripts/perf_test.sh",
+    "start": "node scripts/http.js",
+    "sauce": "node scripts/sauce-runner.js"
   },
   "repository": {
     "type": "git",
@@ -49,6 +79,6 @@
   },
   "readmeFilename": "README.md",
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=6.12.3"
   }
 }

scripts/build_docs.js

@@ -0,0 +1,51 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const execSync = require('child_process').execSync;
+const ejs = require('ejs');
+const renderFromPaths =
+  require('json-schema-to-markdown-table').renderFromPaths;
+const ROOT = path.dirname(path.normalize(__dirname));
+
+function strip(string) {
+  return string.replace(/^\s+|\s+$/g, '');
+}
+
+function importFile(relativePath) {
+  const absolutePath = path.join(ROOT, relativePath);
+  return strip(fs.readFileSync(absolutePath).toString('utf-8'));
+}
+
+function renderFixture(fixtureRelativePath) {
+  const json = importFile(path.join('test', 'fixtures', fixtureRelativePath));
+  return '\n```json\n' + json + '\n```\n';
+}
+
+function renderSchema(schemaRelativePath) {
+  const schemasPath = path.join(ROOT, 'src', 'common', 'schemas');
+  const schemaPath = path.join(schemasPath, schemaRelativePath);
+  return renderFromPaths(schemaPath, schemasPath);
+}
+
+function main() {
+  const locals = {
+    importFile: importFile,
+    renderFixture: renderFixture,
+    renderSchema: renderSchema
+  };
+
+  const indexPath = path.join(ROOT, 'docs', 'src', 'index.md.ejs');
+  ejs.renderFile(indexPath, locals, function(error, output) {
+    if (error) {
+      console.error(error);
+      process.exit(1);
+    } else {
+      const outputPath = path.join(ROOT, 'docs', 'index.md');
+      fs.writeFileSync(outputPath, output);
+      execSync('npm run doctoc', {cwd: ROOT});
+      process.exit(0);
+    }
+  });
+}
+
+main();

scripts/checkeol.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+function checkEOL {
+  local changedFiles=$(git --no-pager diff --name-only -M100% --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD)
+  local result=0
+  for name in $changedFiles; do
+    grep  -c -U -q $'\r' $name
+      if [ $? -eq 0 ]; then
+        echo "windows eol found in $name" >&2
+        result=1
+      fi
+  done
+  if [ $result -eq 1 ]; then
+    false
+  fi
+}
+
+checkEOL

scripts/ci.sh

@@ -0,0 +1,96 @@
+#!/bin/bash -ex
+
+NODE_INDEX="$1"
+TOTAL_NODES="$2"
+
+function checkEOL {
+  ./scripts/checkeol.sh
+}
+
+lint() {
+  echo "tslint $(node_modules/.bin/tslint --version)"
+  yarn lint
+}
+
+unittest() {
+  # test "src"
+  mocha test --reporter mocha-junit-reporter --reporter-options mochaFile=$CIRCLE_TEST_REPORTS/test-results.xml
+  yarn test --coverage
+  yarn run coveralls
+
+  # test compiled version in "dist/npm"
+  $(npm bin)/babel -D --optional runtime --ignore "**/node_modules/**" -d test-compiled/ test/
+  echo "--reporter spec --timeout 5000 --slow 500" > test-compiled/mocha.opts
+  mkdir -p test-compiled/node_modules
+  ln -nfs ../../dist/npm test-compiled/node_modules/ripple-api
+  mocha --opts test-compiled/mocha.opts test-compiled
+
+  #compile tests for browser testing
+  #gulp build-min build-tests
+  #node --harmony test-compiled/mocked-server.js > /dev/null &
+
+  #echo "Running tests in PhantomJS"
+  #mocha-phantomjs test/localrunner.html
+  #echo "Running tests using minified version in PhantomJS"
+  #mocha-phantomjs test/localrunnermin.html
+
+  #echo "Running tests in SauceLabs"
+  #http-server &
+  #yarn run sauce
+
+  #pkill -f mocked-server.js
+  #pkill -f http-server
+  rm -rf test-compiled
+}
+
+integrationtest() {
+  mocha test/integration/integration-test.js
+  mocha test/integration/http-integration-test.js
+
+  # run integration tests in PhantomJS
+  #gulp build-tests build-min
+  #echo "Running integragtion tests in PhantomJS"
+  #mocha-phantomjs test/localintegrationrunner.html
+}
+
+doctest() {
+  mv docs/index.md docs/index.md.save
+  yarn run docgen
+  mv docs/index.md docs/index.md.test
+  mv docs/index.md.save docs/index.md
+  cmp docs/index.md docs/index.md.test
+  rm docs/index.md.test
+}
+
+oneNode() {
+  checkEOL
+  doctest
+  lint
+  unittest
+  integrationtest
+}
+
+twoNodes() {
+  case "$NODE_INDEX" in
+    0) doctest; lint; integrationtest;;
+    1) checkEOL; unittest;;
+    *) echo "ERROR: invalid usage"; exit 2;;
+  esac
+}
+
+threeNodes() {
+  case "$NODE_INDEX" in
+    0) doctest; lint; integrationtest;;
+    1) checkEOL;;
+    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

scripts/http.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const createHTTPServer = require('../dist/npm/http').createHTTPServer;
+const port = 5990;
+const serverUrl = 'wss://s1.ripple.com';
+
+
+function main() {
+  const server = createHTTPServer({server: serverUrl}, port);
+  server.start().then(() => {
+    console.log('Server started on port ' + String(port));
+  });
+}
+
+
+main();

scripts/publish

@@ -7,37 +7,12 @@ function exit_on_error {
 
 rm -rf build
 
-npm install
+yarn install
 gulp
-npm test
+yarn test
 exit_on_error
 
 echo ""
 echo "publish to npm"
-npm publish
+yarn publish
 exit_on_error
-
-rm -rf dist
-echo ""
-echo "publish to bower"
-
-git clone git@github.com:ripple/bower-ripple.git dist
-gulp bower
-exit_on_error
-
-cd dist
-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

@@ -7,37 +7,12 @@ function exit_on_error {
 
 rm -rf build
 
-npm install
+yarn install
 gulp
-npm test
+yarn test
 exit_on_error
 
 echo ""
 echo "publish rc to npm"
-npm publish --tag beta
+yarn publish --tag beta
 exit_on_error
-
-rm -rf dist
-echo ""
-echo "publish to bower"
-
-git clone git@github.com:ripple/bower-ripple.git dist
-gulp bower
-exit_on_error
-
-cd dist
-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

@@ -1,12 +0,0 @@
-rm -rf dist
-git clone git@github.com:ripple/bower-ripple.git dist
-gulp bower
-cd dist
-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/sauce-runner.js

@@ -0,0 +1,100 @@
+
+const _ = require('lodash');
+const MochaSauce = require('mocha-in-sauce');
+
+const testUrl = 'http://testripple.circleci.com:8080/test/saucerunner.html';
+
+
+function main() {
+  // uncomment for more debug info
+  // process.env.DEBUG = '*';
+
+  // configure
+  const config = {
+    name: 'RippleAPI',
+    host: 'localhost',
+    port: 4445,
+    maxDuration: 180000,
+    // the current build name (optional)
+    build: Date.now(),
+    url: testUrl,
+    runSauceConnect: true
+  };
+
+  if (process.env.CIRCLE_BUILD_NUM) {
+    config.build = process.env.CIRCLE_BUILD_NUM;
+    config.tags = [process.env.CIRCLE_BRANCH, process.env.CIRCLE_SHA1];
+    config.tunnelIdentifier = process.env.CIRCLE_BUILD_NUM;
+  }
+
+  const sauce = new MochaSauce(config);
+
+  sauce.concurrency(5);
+
+  // setup what browsers to test with
+  sauce.browser({browserName: 'firefox', platform: 'Linux',
+   version: '43'});
+  sauce.browser({browserName: 'firefox', platform: 'Windows 8.1',
+    version: '43'});
+  sauce.browser({browserName: 'firefox', platform: 'OS X 10.11',
+   version: '43'});
+  sauce.browser({browserName: 'safari', platform: 'OS X 10.11',
+    version: '9'});
+  sauce.browser({browserName: 'safari', platform: 'OS X 10.10',
+    version: '8'});
+  sauce.browser({browserName: 'safari', platform: 'OS X 10.9',
+    version: '7'});
+  sauce.browser({browserName: 'chrome', platform: 'OS X 10.11',
+    version: '47'});
+  sauce.browser({browserName: 'chrome', platform: 'Linux',
+    version: '47'});
+  sauce.browser({browserName: 'chrome', platform: 'Windows 8.1',
+    version: '47'});
+  sauce.browser({browserName: 'internet explorer', platform: 'Windows 10',
+    version: '11'});
+  sauce.browser({browserName: 'MicrosoftEdge', platform: 'Windows 10',
+    version: '20'});
+
+  sauce.on('init', function(browser) {
+    console.log('  init : %s %s', browser.browserName, browser.platform);
+  });
+
+  sauce.on('start', function(browser) {
+    console.log('  start : %s %s', browser.browserName, browser.platform);
+  });
+
+  sauce.on('end', function(browser, res) {
+    console.log('  end : %s %s : %d failures', browser.browserName,
+      browser.platform, res && res.failures);
+  });
+
+  sauce.on('connected', sauceConnectProcess => {
+    sauceConnectProcess.on('exit', function(code, /* signal */) {
+      if (code > 0) {
+        console.log('something wrong - exiting');
+        process.exit();
+      } else {
+        console.log('normal tunnel exit');
+      }
+    });
+  });
+
+
+  sauce.start(function(err, res) {
+    let failure = false;
+    if (err) {
+      console.log('Error starting Sauce');
+      console.error(err);
+      process.exitCode = 2;
+    } else {
+      console.log('-------------- done --------------');
+      failure = _.some(res, 'failures');
+      console.log('Tests are failed:', failure);
+      if (failure) {
+        process.exitCode = 1;
+      }
+    }
+  });
+}
+
+main();

scripts/verify_ledger_json.js

@@ -1,49 +0,0 @@
-var fs = require('fs');
-var Ledger = require('../src/js/ripple/ledger').Ledger;
-
-function parse_options(from, flags) {
-  var argv = from.slice(),
-      opts = {argv:argv};
-
-  flags.forEach(function(f) {
-    // Do we have the flag?
-    var flag_index = argv.indexOf('--' + f);
-    // normalize the name of the flag
-    f = f.replace('-', '_');
-    // opts has Boolean value for normalized flag key
-    opts[f] = !!~flag_index;
-    if (opts[f]) {
-      // 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.");
-}
-
-console.log("Transaction hash in header:    " + ledger.ledger_json.transaction_hash);
-console.log("Calculated transaction hash:   " + ledger.calc_tx_hash().to_hex());
-console.log("Account state hash in header:  " + ledger.ledger_json.account_hash);
-console.log("Calculated account state hash: " + ledger.calc_account_hash(
-                                                 {sanity_test:opts.sanity_test})
-                                                   .to_hex());

src/api.ts

@@ -0,0 +1,337 @@
+import {EventEmitter} from 'events'
+import {
+  Connection,
+  errors,
+  validate,
+  xrpToDrops,
+  dropsToXrp,
+  iso8601ToRippleTime,
+  txFlags
+} from './common'
+import {
+  connect,
+  disconnect,
+  isConnected,
+  getLedgerVersion,
+  formatLedgerClose
+} from './server/server'
+import getTransaction from './ledger/transaction'
+import getTransactions from './ledger/transactions'
+import getTrustlines from './ledger/trustlines'
+import getBalances from './ledger/balances'
+import getBalanceSheet from './ledger/balance-sheet'
+import getPaths from './ledger/pathfind'
+import getOrders from './ledger/orders'
+import getOrderbook from './ledger/orderbook'
+import getSettings from './ledger/settings'
+import getAccountInfo from './ledger/accountinfo'
+import getAccountObjects from './ledger/accountobjects'
+import getPaymentChannel from './ledger/payment-channel'
+import preparePayment from './transaction/payment'
+import prepareTrustline from './transaction/trustline'
+import prepareOrder from './transaction/order'
+import prepareOrderCancellation from './transaction/ordercancellation'
+import prepareEscrowCreation from './transaction/escrow-creation'
+import prepareEscrowExecution from './transaction/escrow-execution'
+import prepareEscrowCancellation from './transaction/escrow-cancellation'
+import preparePaymentChannelCreate from './transaction/payment-channel-create'
+import preparePaymentChannelFund from './transaction/payment-channel-fund'
+import preparePaymentChannelClaim from './transaction/payment-channel-claim'
+import prepareCheckCreate from './transaction/check-create'
+import prepareCheckCancel from './transaction/check-cancel'
+import prepareCheckCash from './transaction/check-cash'
+import prepareSettings from './transaction/settings'
+import sign from './transaction/sign'
+import combine from './transaction/combine'
+import submit from './transaction/submit'
+import {generateAddressAPI} from './offline/generate-address'
+import computeLedgerHash from './offline/ledgerhash'
+import signPaymentChannelClaim from './offline/sign-payment-channel-claim'
+import verifyPaymentChannelClaim from './offline/verify-payment-channel-claim'
+import getLedger from './ledger/ledger'
+
+import {
+  AccountObjectsRequest, AccountObjectsResponse,
+  AccountOffersRequest, AccountOffersResponse,
+  AccountInfoRequest, AccountInfoResponse,
+  AccountLinesRequest, AccountLinesResponse,
+  BookOffersRequest, BookOffersResponse,
+  GatewayBalancesRequest, GatewayBalancesResponse,
+  LedgerRequest, LedgerResponse,
+  LedgerEntryRequest, LedgerEntryResponse,
+  ServerInfoRequest, ServerInfoResponse
+} from './common/types/commands'
+
+
+import RangeSet from './common/rangeset'
+import * as ledgerUtils from './ledger/utils'
+import * as transactionUtils from './transaction/utils'
+import * as schemaValidator from './common/schema-validator'
+import {getServerInfo, getFee} from './common/serverinfo'
+import {clamp} from './ledger/utils'
+import {Instructions, Prepare} from './transaction/types'
+
+export type APIOptions = {
+  server?: string,
+  feeCushion?: number,
+  maxFeeXRP?: string,
+  trace?: boolean,
+  proxy?: string,
+  timeout?: number
+}
+
+/**
+ * Get the response key / property name that contains the listed data for a
+ * command. This varies from command to command, but we need to know it to
+ * properly count across many requests.
+ */
+function getCollectKeyFromCommand(command: string): string|undefined {
+  switch (command) {
+    case 'account_offers':
+    case 'book_offers':
+      return 'offers'
+    case 'account_lines':
+      return 'lines'
+    default:
+      return undefined
+  }
+}
+
+class RippleAPI extends EventEmitter {
+  _feeCushion: number
+  _maxFeeXRP: string
+
+  // New in > 0.21.0
+  // non-validated ledger versions are allowed, and passed to rippled as-is.
+  connection: Connection
+
+  // these are exposed only for use by unit tests; they are not part of the API.
+  static _PRIVATE = {
+    validate,
+    RangeSet,
+    ledgerUtils,
+    schemaValidator
+  }
+
+  constructor(options: APIOptions = {}) {
+    super()
+    validate.apiOptions(options)
+    this._feeCushion = options.feeCushion || 1.2
+    this._maxFeeXRP = options.maxFeeXRP || '2'
+    const serverURL = options.server
+    if (serverURL !== undefined) {
+      this.connection = new Connection(serverURL, options)
+      this.connection.on('ledgerClosed', message => {
+        this.emit('ledger', formatLedgerClose(message))
+      })
+      this.connection.on('error', (errorCode, errorMessage, data) => {
+        this.emit('error', errorCode, errorMessage, data)
+      })
+      this.connection.on('connected', () => {
+        this.emit('connected')
+      })
+      this.connection.on('disconnected', code => {
+        this.emit('disconnected', code)
+      })
+    } else {
+      // use null object pattern to provide better error message if user
+      // tries to call a method that requires a connection
+      this.connection = new Connection(null, options)
+    }
+  }
+
+
+  /**
+   * Makes a request to the API with the given command and
+   * additional request body parameters.
+   */
+  async request(command: 'account_info', params: AccountInfoRequest):
+    Promise<AccountInfoResponse>
+  async request(command: 'account_lines', params: AccountLinesRequest):
+    Promise<AccountLinesResponse>
+  async request(command: 'account_objects', params: AccountObjectsRequest):
+    Promise<AccountObjectsResponse>
+  async request(command: 'account_offers', params: AccountOffersRequest):
+  Promise<AccountOffersResponse>
+  async request(command: 'book_offers', params: BookOffersRequest):
+    Promise<BookOffersResponse>
+  async request(command: 'gateway_balances', params: GatewayBalancesRequest):
+    Promise<GatewayBalancesResponse>
+  async request(command: 'ledger', params: LedgerRequest):
+    Promise<LedgerResponse>
+  async request(command: 'ledger_entry', params: LedgerEntryRequest):
+    Promise<LedgerEntryResponse>
+  async request(command: 'server_info', params?: ServerInfoRequest):
+    Promise<ServerInfoResponse>
+  async request(command: string, params: any):
+    Promise<any>
+  async request(command: string, params: any = {}): Promise<any> {
+    return this.connection.request({
+      ...params,
+      command
+    })
+  }
+
+  /**
+   * Returns true if there are more pages of data.
+   *
+   * When there are more results than contained in the response, the response
+   * includes a `marker` field.
+   *
+   * See https://ripple.com/build/rippled-apis/#markers-and-pagination
+   */
+  hasNextPage<T extends {marker?: string}>(currentResponse: T): boolean {
+    return !!currentResponse.marker
+  }
+
+  async requestNextPage<T extends {marker?: string}>(
+    command: string,
+    params: object = {},
+    currentResponse: T
+  ): Promise<object> {
+    if (!currentResponse.marker) {
+      return Promise.reject(
+        new errors.NotFoundError('response does not have a next page')
+      )
+    }
+    const nextPageParams = Object.assign({}, params, {
+      marker: currentResponse.marker
+    })
+    return this.request(command, nextPageParams)
+  }
+
+  /**
+   * Prepare a transaction.
+   *
+   * You can later submit the transaction with `submit()`.
+   */
+  async prepareTransaction(txJSON: object, instructions: Instructions = {}):
+    Promise<Prepare> {
+    return transactionUtils.prepareTransaction(txJSON, this, instructions)
+  }
+
+  /**
+   * Convert a string to hex.
+   *
+   * This can be used to generate `MemoData`, `MemoType`, and `MemoFormat`.
+   *
+   * @param string string to convert to hex
+   */
+  convertStringToHex(string: string): string {
+    return transactionUtils.convertStringToHex(string)
+  }
+
+  /**
+   * Makes multiple paged requests to the API to return a given number of
+   * resources. _requestAll() will make multiple requests until the `limit`
+   * number of resources is reached (if no `limit` is provided, a single request
+   * will be made).
+   *
+   * If the command is unknown, an additional `collect` property is required to
+   * know which response key contains the array of resources.
+   *
+   * NOTE: This command is used by existing methods and is not recommended for
+   * general use. Instead, use rippled's built-in pagination and make multiple
+   * requests as needed.
+   */
+  async _requestAll(command: 'account_offers', params: AccountOffersRequest):
+    Promise<AccountOffersResponse[]>
+  async _requestAll(command: 'book_offers', params: BookOffersRequest):
+    Promise<BookOffersResponse[]>
+  async _requestAll(command: 'account_lines', params: AccountLinesRequest):
+    Promise<AccountLinesResponse[]>
+  async _requestAll(
+    command: string,
+    params: any = {},
+    options: {collect?: string} = {}): Promise<any[]> {
+    // The data under collection is keyed based on the command. Fail if command
+    // not recognized and collection key not provided.
+    const collectKey = options.collect || getCollectKeyFromCommand(command)
+    if (!collectKey) {
+      throw new errors.ValidationError(`no collect key for command ${command}`)
+    }
+    // If limit is not provided, fetches all data over multiple requests.
+    // NOTE: This may return much more than needed. Set limit when possible.
+    const countTo: number =
+        (params.limit !== undefined) ? params.limit : Infinity
+    let count: number = 0
+    let marker: string = params.marker
+    let lastBatchLength: number
+    const results = []
+    do {
+      const countRemaining = clamp(countTo - count, 10, 400)
+      const repeatProps = {
+        ...params,
+        limit: countRemaining,
+        marker
+      }
+      const singleResult = await this.request(command, repeatProps)
+      const collectedData = singleResult[collectKey]
+      marker = singleResult['marker']
+      results.push(singleResult)
+      // Make sure we handle when no data (not even an empty array) is returned.
+      const isExpectedFormat = Array.isArray(collectedData)
+      if (isExpectedFormat) {
+        count += collectedData.length
+        lastBatchLength = collectedData.length
+      } else {
+        lastBatchLength = 0
+      }
+    } while(!!marker && count < countTo && lastBatchLength !== 0)
+    return results
+  }
+
+  connect = connect
+  disconnect = disconnect
+  isConnected = isConnected
+  getServerInfo = getServerInfo
+  getFee = getFee
+  getLedgerVersion = getLedgerVersion
+
+  getTransaction = getTransaction
+  getTransactions = getTransactions
+  getTrustlines = getTrustlines
+  getBalances = getBalances
+  getBalanceSheet = getBalanceSheet
+  getPaths = getPaths
+  getOrders = getOrders
+  getOrderbook = getOrderbook
+  getSettings = getSettings
+  getAccountInfo = getAccountInfo
+  getAccountObjects = getAccountObjects
+  getPaymentChannel = getPaymentChannel
+  getLedger = getLedger
+
+  preparePayment = preparePayment
+  prepareTrustline = prepareTrustline
+  prepareOrder = prepareOrder
+  prepareOrderCancellation = prepareOrderCancellation
+  prepareEscrowCreation = prepareEscrowCreation
+  prepareEscrowExecution = prepareEscrowExecution
+  prepareEscrowCancellation = prepareEscrowCancellation
+  preparePaymentChannelCreate = preparePaymentChannelCreate
+  preparePaymentChannelFund = preparePaymentChannelFund
+  preparePaymentChannelClaim = preparePaymentChannelClaim
+  prepareCheckCreate = prepareCheckCreate
+  prepareCheckCash = prepareCheckCash
+  prepareCheckCancel = prepareCheckCancel
+  prepareSettings = prepareSettings
+  sign = sign
+  combine = combine
+  submit = submit
+
+  generateAddress = generateAddressAPI
+  computeLedgerHash = computeLedgerHash
+  signPaymentChannelClaim = signPaymentChannelClaim
+  verifyPaymentChannelClaim = verifyPaymentChannelClaim
+  errors = errors
+
+  xrpToDrops = xrpToDrops
+  dropsToXrp = dropsToXrp
+  iso8601ToRippleTime = iso8601ToRippleTime
+  txFlags = txFlags
+}
+
+export {
+  RippleAPI
+}

src/broadcast.ts

@@ -0,0 +1,73 @@
+
+import * as _ from 'lodash'
+import {RippleAPI} from './api'
+
+class RippleAPIBroadcast extends RippleAPI {
+
+  ledgerVersion: number | undefined = undefined
+  private _apis: RippleAPI[]
+
+  constructor(servers, options) {
+    super(options)
+
+    const apis: RippleAPI[] = servers.map(server => new RippleAPI(
+      _.assign({}, options, {server})
+    ))
+
+    // exposed for testing
+    this._apis = apis
+
+    this.getMethodNames().forEach(name => {
+      this[name] = function() { // eslint-disable-line no-loop-func
+        return Promise.race(apis.map(api => api[name](...arguments)))
+      }
+    })
+
+    // connection methods must be overridden to apply to all api instances
+    this.connect = async function() {
+      await Promise.all(apis.map(api => api.connect()))
+    }
+    this.disconnect = async function() {
+      await Promise.all(apis.map(api => api.disconnect()))
+    }
+    this.isConnected = function() {
+      return apis.map(api => api.isConnected()).every(Boolean)
+    }
+
+    // synchronous methods are all passed directly to the first api instance
+    const defaultAPI = apis[0]
+    const syncMethods = ['sign', 'generateAddress', 'computeLedgerHash']
+    syncMethods.forEach(name => {
+      this[name] = defaultAPI[name].bind(defaultAPI)
+    })
+
+    apis.forEach(api => {
+      api.on('ledger', this.onLedgerEvent.bind(this))
+      api.on('error', (errorCode, errorMessage, data) =>
+        this.emit('error', errorCode, errorMessage, data))
+    })
+  }
+
+  onLedgerEvent(ledger) {
+    if (ledger.ledgerVersion > this.ledgerVersion ||
+        this.ledgerVersion === undefined) {
+      this.ledgerVersion = ledger.ledgerVersion
+      this.emit('ledger', ledger)
+    }
+  }
+
+  getMethodNames() {
+    const methodNames: string[] = []
+    const rippleAPI = this._apis[0]
+    for (const name of Object.getOwnPropertyNames(rippleAPI)) {
+      if (typeof rippleAPI[name] === 'function') {
+        methodNames.push(name)
+      }
+    }
+    return methodNames
+  }
+}
+
+export {
+  RippleAPIBroadcast
+}

src/common/browser-hacks.ts

@@ -0,0 +1,20 @@
+
+function setPrototypeOf(object, prototype) {
+  // Object.setPrototypeOf not supported on Internet Explorer 9
+  Object.setPrototypeOf ? Object.setPrototypeOf(object, prototype) :
+    // @ts-ignore: Specifically a fallback for IE9
+    object.__proto__ = prototype
+}
+
+function getConstructorName(object: Object): string {
+  // hack for internet explorer
+  if (!object.constructor.name) {
+    return object.constructor.toString().match(/^function\s+([^(]*)/)![1]
+  }
+  return object.constructor.name
+}
+
+export {
+  getConstructorName,
+  setPrototypeOf
+}

src/common/connection.ts

@@ -0,0 +1,470 @@
+import * as _ from 'lodash'
+import {EventEmitter} from 'events'
+import {parse as parseUrl} from 'url'
+import * as WebSocket from 'ws'
+import RangeSet from './rangeset'
+import {RippledError, DisconnectedError, NotConnectedError,
+  TimeoutError, ResponseFormatError, ConnectionError,
+  RippledNotInitializedError} from './errors'
+
+export interface ConnectionOptions {
+  trace?: boolean,
+  proxy?: string
+  proxyAuthorization?: string
+  authorization?: string
+  trustedCertificates?: string[]
+  key?: string
+  passphrase?: string
+  certificate?: string
+  timeout?: number
+}
+
+class Connection extends EventEmitter {
+
+  private _url: string
+  private _trace: boolean
+  private _console?: Console
+  private _proxyURL?: string
+  private _proxyAuthorization?: string
+  private _authorization?: string
+  private _trustedCertificates?: string[]
+  private _key?: string
+  private _passphrase?: string
+  private _certificate?: string
+  private _timeout: number
+  private _isReady: boolean = false
+  private _ws: null|WebSocket = null
+  protected _ledgerVersion: null|number = null
+  private _availableLedgerVersions = new RangeSet()
+  private _nextRequestID: number = 1
+  private _retry: number = 0
+  private _retryTimer: null|NodeJS.Timer = null
+  private _onOpenErrorBound: null| null|((...args: any[]) => void) = null
+  private _onUnexpectedCloseBound: null|((...args: any[]) => void) = null
+  private _fee_base: null|number = null
+  private _fee_ref: null|number = null
+
+  constructor(url, options: ConnectionOptions = {}) {
+    super()
+    this.setMaxListeners(Infinity)
+    this._url = url
+    this._trace = options.trace || false
+    if (this._trace) {
+      // for easier unit testing
+      this._console = console
+    }
+    this._proxyURL = options.proxy
+    this._proxyAuthorization = options.proxyAuthorization
+    this._authorization = options.authorization
+    this._trustedCertificates = options.trustedCertificates
+    this._key = options.key
+    this._passphrase = options.passphrase
+    this._certificate = options.certificate
+    this._timeout = options.timeout || (20 * 1000)
+  }
+
+  _updateLedgerVersions(data) {
+    this._ledgerVersion = Number(data.ledger_index)
+    if (data.validated_ledgers) {
+      this._availableLedgerVersions.reset()
+      this._availableLedgerVersions.parseAndAddRanges(
+        data.validated_ledgers)
+    } else {
+      this._availableLedgerVersions.addValue(this._ledgerVersion)
+    }
+  }
+
+  _updateFees(data) {
+    this._fee_base = Number(data.fee_base)
+    this._fee_ref = Number(data.fee_ref)
+  }
+
+  // return value is array of arguments to Connection.emit
+  _parseMessage(message): [string, Object] | ['error', string, string, Object] {
+    const data = JSON.parse(message)
+    if (data.type === 'response') {
+      if (!(Number.isInteger(data.id) && data.id >= 0)) {
+        throw new ResponseFormatError('valid id not found in response', data)
+      }
+      return [data.id.toString(), data]
+    } else if (data.type === undefined && data.error) {
+      return ['error', data.error, data.error_message, data] // e.g. slowDown
+    }
+
+    // Possible `data.type` values include 'ledgerClosed',
+    // 'transaction', 'path_find', and many others.
+    if (data.type === 'ledgerClosed') {
+      this._updateLedgerVersions(data)
+      this._updateFees(data)
+    }
+    return [data.type, data]
+  }
+
+  _onMessage(message) {
+    if (this._trace) {
+      this._console!.log(message)
+    }
+    let parameters
+    try {
+      parameters = this._parseMessage(message)
+    } catch (error) {
+      this.emit('error', 'badMessage', error.message, message)
+      return
+    }
+    // we don't want this inside the try/catch or exceptions in listener
+    // will be caught
+    this.emit.apply(this, parameters)
+  }
+
+  get _state() {
+    return this._ws ? this._ws.readyState : WebSocket.CLOSED
+  }
+
+  get _shouldBeConnected() {
+    return this._ws !== null
+  }
+
+  isConnected() {
+    return this._state === WebSocket.OPEN && this._isReady
+  }
+
+  _onUnexpectedClose(beforeOpen, resolve, reject, code) {
+    if (this._onOpenErrorBound) {
+      this._ws!.removeListener('error', this._onOpenErrorBound)
+      this._onOpenErrorBound = null
+    }
+    // just in case
+    this._ws!.removeAllListeners('open')
+    this._ws = null
+    this._isReady = false
+    if (beforeOpen) {
+      // connection was closed before it was properly opened, so we must return
+      // error to connect's caller
+      this.connect().then(resolve, reject)
+    } else {
+      // if first parameter ws lib sends close code,
+      // but sometimes it forgots about it, so default to 1006 - CLOSE_ABNORMAL
+      this.emit('disconnected', code || 1006)
+      this._retryConnect()
+    }
+  }
+
+  _calculateTimeout(retriesCount) {
+    return (retriesCount < 40)
+      // First, for 2 seconds: 20 times per second
+      ? (1000 / 20)
+      : (retriesCount < 40 + 60)
+        // Then, for 1 minute: once per second
+        ? (1000)
+        : (retriesCount < 40 + 60 + 60)
+          // Then, for 10 minutes: once every 10 seconds
+          ? (10 * 1000)
+          // Then: once every 30 seconds
+          : (30 * 1000)
+  }
+
+  _retryConnect() {
+    this._retry += 1
+    const retryTimeout = this._calculateTimeout(this._retry)
+    this._retryTimer = setTimeout(() => {
+      this.emit('reconnecting', this._retry)
+      this.connect().catch(this._retryConnect.bind(this))
+    }, retryTimeout)
+  }
+
+  _clearReconnectTimer() {
+    if (this._retryTimer !== null) {
+      clearTimeout(this._retryTimer)
+      this._retryTimer = null
+    }
+  }
+
+  _onOpen() {
+    if (!this._ws) {
+      return Promise.reject(new DisconnectedError())
+    }
+    if (this._onOpenErrorBound) {
+      this._ws.removeListener('error', this._onOpenErrorBound)
+      this._onOpenErrorBound = null
+    }
+
+    const request = {
+      command: 'subscribe',
+      streams: ['ledger']
+    }
+    return this.request(request).then((data: any) => {
+      if (_.isEmpty(data) || !data.ledger_index) {
+        // rippled instance doesn't have validated ledgers
+        return this._disconnect(false).then(() => {
+          throw new RippledNotInitializedError('Rippled not initialized')
+        })
+      }
+
+      this._updateLedgerVersions(data)
+      this._updateFees(data)
+      this._rebindOnUnxpectedClose()
+
+      this._retry = 0
+      this._ws.on('error', error => {
+        // TODO: "type" does not exist on official error type, safe to remove?
+        if (process.browser && error && (<any>error).type === 'error') {
+          // we are in browser, ignore error - `close` event will be fired
+          // after error
+          return
+        }
+        this.emit('error', 'websocket', error.message, error)
+      })
+
+      this._isReady = true
+      this.emit('connected')
+
+      return undefined
+    })
+  }
+
+  _rebindOnUnxpectedClose() {
+    if (this._onUnexpectedCloseBound) {
+      this._ws.removeListener('close', this._onUnexpectedCloseBound)
+    }
+    this._onUnexpectedCloseBound =
+      this._onUnexpectedClose.bind(this, false, null, null)
+    this._ws.once('close', this._onUnexpectedCloseBound)
+  }
+
+  _unbindOnUnxpectedClose() {
+    if (this._onUnexpectedCloseBound) {
+      this._ws.removeListener('close', this._onUnexpectedCloseBound)
+    }
+    this._onUnexpectedCloseBound = null
+  }
+
+  _onOpenError(reject, error) {
+    this._onOpenErrorBound = null
+    this._unbindOnUnxpectedClose()
+    reject(new NotConnectedError(error.message, error))
+  }
+
+  _createWebSocket(): WebSocket {
+    const options: WebSocket.ClientOptions = {}
+    if (this._proxyURL !== undefined) {
+      const parsedURL = parseUrl(this._url)
+      const parsedProxyURL = parseUrl(this._proxyURL)
+      const proxyOverrides = _.omitBy({
+        secureEndpoint: (parsedURL.protocol === 'wss:'),
+        secureProxy: (parsedProxyURL.protocol === 'https:'),
+        auth: this._proxyAuthorization,
+        ca: this._trustedCertificates,
+        key: this._key,
+        passphrase: this._passphrase,
+        cert: this._certificate
+      }, _.isUndefined)
+      const proxyOptions = _.assign({}, parsedProxyURL, proxyOverrides)
+      let HttpsProxyAgent
+      try {
+        HttpsProxyAgent = require('https-proxy-agent')
+      } catch (error) {
+        throw new Error('"proxy" option is not supported in the browser')
+      }
+      options.agent = new HttpsProxyAgent(proxyOptions)
+    }
+    if (this._authorization !== undefined) {
+      const base64 = new Buffer(this._authorization).toString('base64')
+      options.headers = {Authorization: `Basic ${base64}`}
+    }
+    const optionsOverrides = _.omitBy({
+      ca: this._trustedCertificates,
+      key: this._key,
+      passphrase: this._passphrase,
+      cert: this._certificate
+    }, _.isUndefined)
+    const websocketOptions = _.assign({}, options, optionsOverrides)
+    const websocket = new WebSocket(this._url, null, websocketOptions)
+    // we will have a listener for each outstanding request,
+    // so we have to raise the limit (the default is 10)
+    if (typeof websocket.setMaxListeners === 'function') {
+      websocket.setMaxListeners(Infinity)
+    }
+    return websocket
+  }
+
+  connect() {
+    this._clearReconnectTimer()
+    return new Promise((resolve, reject) => {
+      if (!this._url) {
+        reject(new ConnectionError(
+          'Cannot connect because no server was specified'))
+      }
+      if (this._state === WebSocket.OPEN) {
+        resolve()
+      } else if (this._state === WebSocket.CONNECTING) {
+        this._ws.once('open', resolve)
+      } else {
+        this._ws = this._createWebSocket()
+        // when an error causes the connection to close, the close event
+        // should still be emitted; the "ws" documentation says: "The close
+        // event is also emitted when then underlying net.Socket closes the
+        // connection (end or close)."
+        // In case if there is connection error (say, server is not responding)
+        // we must return this error to connection's caller. After successful
+        // opening, we will forward all errors to main api object.
+        this._onOpenErrorBound = this._onOpenError.bind(this, reject)
+        this._ws.once('error', this._onOpenErrorBound)
+        this._ws.on('message', this._onMessage.bind(this))
+        // in browser close event can came before open event, so we must
+        // resolve connect's promise after reconnect in that case.
+        // after open event we will rebound _onUnexpectedCloseBound
+        // without resolve and reject functions
+        this._onUnexpectedCloseBound = this._onUnexpectedClose.bind(this, true,
+          resolve, reject)
+        this._ws.once('close', this._onUnexpectedCloseBound)
+        this._ws.once('open', () => this._onOpen().then(resolve, reject))
+      }
+    })
+  }
+
+  disconnect() {
+    return this._disconnect(true)
+  }
+
+  _disconnect(calledByUser) {
+    if (calledByUser) {
+      this._clearReconnectTimer()
+      this._retry = 0
+    }
+    return new Promise(resolve => {
+      if (this._state === WebSocket.CLOSED) {
+        resolve()
+      } else if (this._state === WebSocket.CLOSING) {
+        this._ws.once('close', resolve)
+      } else {
+        if (this._onUnexpectedCloseBound) {
+          this._ws.removeListener('close', this._onUnexpectedCloseBound)
+          this._onUnexpectedCloseBound = null
+        }
+        this._ws.once('close', code => {
+          this._ws = null
+          this._isReady = false
+          if (calledByUser) {
+            this.emit('disconnected', code || 1000) // 1000 - CLOSE_NORMAL
+          }
+          resolve()
+        })
+        this._ws.close()
+      }
+    })
+  }
+
+  reconnect() {
+    return this.disconnect().then(() => this.connect())
+  }
+
+  _whenReady<T>(promise: Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      if (!this._shouldBeConnected) {
+        reject(new NotConnectedError())
+      } else if (this._state === WebSocket.OPEN && this._isReady) {
+        promise.then(resolve, reject)
+      } else {
+        this.once('connected', () => promise.then(resolve, reject))
+      }
+    })
+  }
+
+  getLedgerVersion(): Promise<number> {
+    return this._whenReady(Promise.resolve(this._ledgerVersion!))
+  }
+
+  hasLedgerVersions(lowLedgerVersion, highLedgerVersion): Promise<boolean> {
+    return this._whenReady(Promise.resolve(
+      this._availableLedgerVersions.containsRange(
+        lowLedgerVersion, highLedgerVersion || this._ledgerVersion)))
+  }
+
+  hasLedgerVersion(ledgerVersion): Promise<boolean> {
+    return this.hasLedgerVersions(ledgerVersion, ledgerVersion)
+  }
+
+  getFeeBase(): Promise<number> {
+    return this._whenReady(Promise.resolve(Number(this._fee_base)))
+  }
+
+  getFeeRef(): Promise<number> {
+    return this._whenReady(Promise.resolve(Number(this._fee_ref)))
+  }
+
+  _send(message: string): Promise<void> {
+    if (this._trace) {
+      this._console.log(message)
+    }
+    return new Promise((resolve, reject) => {
+      this._ws.send(message, undefined, error => {
+        if (error) {
+          reject(new DisconnectedError(error.message, error))
+        } else {
+          resolve()
+        }
+      })
+    })
+  }
+
+  request(request, timeout?: number): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (!this._shouldBeConnected) {
+        reject(new NotConnectedError())
+      }
+
+      let timer = null
+      const self = this
+      const id = this._nextRequestID
+      this._nextRequestID += 1
+      const eventName = id.toString()
+
+      function onDisconnect() {
+        clearTimeout(timer)
+        self.removeAllListeners(eventName)
+        reject(new DisconnectedError('websocket was closed'))
+      }
+
+      function cleanup() {
+        clearTimeout(timer)
+        self.removeAllListeners(eventName)
+        if (self._ws !== null) {
+          self._ws.removeListener('close', onDisconnect)
+        }
+      }
+
+      function _resolve(response) {
+        cleanup()
+        resolve(response)
+      }
+
+      function _reject(error) {
+        cleanup()
+        reject(error)
+      }
+
+      this.once(eventName, response => {
+        if (response.status === 'error') {
+          _reject(new RippledError(response.error, response))
+        } else if (response.status === 'success') {
+          _resolve(response.result)
+        } else {
+          _reject(new ResponseFormatError(
+            'unrecognized status: ' + response.status, response))
+        }
+      })
+
+      this._ws.once('close', onDisconnect)
+
+      // JSON.stringify automatically removes keys with value of 'undefined'
+      const message = JSON.stringify(Object.assign({}, request, {id}))
+
+      this._whenReady(this._send(message)).then(() => {
+        const delay = timeout || this._timeout
+        timer = setTimeout(() => _reject(new TimeoutError()), delay)
+      }).catch(_reject)
+    })
+  }
+}
+
+export default Connection

src/common/constants.ts

@@ -0,0 +1,52 @@
+
+import {txFlagIndices} from './txflags'
+
+const accountRootFlags = {
+  PasswordSpent: 0x00010000, // password set fee is spent
+  RequireDestTag: 0x00020000, // require a DestinationTag for payments
+  RequireAuth: 0x00040000, // require authorization to hold IOUs
+  DepositAuth: 0x01000000, // require account to auth deposits
+  DisallowXRP: 0x00080000, // disallow sending XRP
+  DisableMaster: 0x00100000, // force regular key
+  NoFreeze: 0x00200000, // permanently disallowed freezing trustlines
+  GlobalFreeze: 0x00400000, // trustlines globally frozen
+  DefaultRipple: 0x00800000
+}
+
+const AccountFlags = {
+  passwordSpent: accountRootFlags.PasswordSpent,
+  requireDestinationTag: accountRootFlags.RequireDestTag,
+  requireAuthorization: accountRootFlags.RequireAuth,
+  depositAuth: accountRootFlags.DepositAuth,
+  disallowIncomingXRP: accountRootFlags.DisallowXRP,
+  disableMasterKey: accountRootFlags.DisableMaster,
+  noFreeze: accountRootFlags.NoFreeze,
+  globalFreeze: accountRootFlags.GlobalFreeze,
+  defaultRipple: accountRootFlags.DefaultRipple
+}
+
+const AccountFlagIndices = {
+  requireDestinationTag: txFlagIndices.AccountSet.asfRequireDest,
+  requireAuthorization: txFlagIndices.AccountSet.asfRequireAuth,
+  depositAuth: txFlagIndices.AccountSet.asfDepositAuth,
+  disallowIncomingXRP: txFlagIndices.AccountSet.asfDisallowXRP,
+  disableMasterKey: txFlagIndices.AccountSet.asfDisableMaster,
+  enableTransactionIDTracking: txFlagIndices.AccountSet.asfAccountTxnID,
+  noFreeze: txFlagIndices.AccountSet.asfNoFreeze,
+  globalFreeze: txFlagIndices.AccountSet.asfGlobalFreeze,
+  defaultRipple: txFlagIndices.AccountSet.asfDefaultRipple
+}
+
+const AccountFields = {
+  EmailHash: {name: 'emailHash', encoding: 'hex',
+    length: 32, defaults: '0'},
+  MessageKey: {name: 'messageKey'},
+  Domain: {name: 'domain', encoding: 'hex'},
+  TransferRate: {name: 'transferRate', defaults: 0, shift: 9}
+}
+
+export {
+  AccountFields,
+  AccountFlagIndices,
+  AccountFlags
+}

src/common/errors.ts

@@ -0,0 +1,93 @@
+
+import {inspect} from 'util'
+import * as browserHacks from './browser-hacks'
+
+class RippleError extends Error {
+
+  name: string
+  message: string
+  data?: any
+
+  constructor(message = '', data?: any) {
+    super(message)
+
+    this.name = browserHacks.getConstructorName(this)
+    this.message = message
+    this.data = data
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor)
+    }
+  }
+
+  toString() {
+    let result = '[' + this.name + '(' + this.message
+    if (this.data) {
+      result += ', ' + inspect(this.data)
+    }
+    result += ')]'
+    return result
+  }
+
+  /* console.log in node uses util.inspect on object, and util.inspect allows
+  us to customize its output:
+  https://nodejs.org/api/util.html#util_custom_inspect_function_on_objects */
+  inspect() {
+    return this.toString()
+  }
+}
+
+class RippledError extends RippleError {}
+
+class UnexpectedError extends RippleError {}
+
+class LedgerVersionError extends RippleError {}
+
+class ConnectionError extends RippleError {}
+
+class NotConnectedError extends ConnectionError {}
+
+class DisconnectedError extends ConnectionError {}
+
+class RippledNotInitializedError extends ConnectionError {}
+
+class TimeoutError extends ConnectionError {}
+
+class ResponseFormatError extends ConnectionError {}
+
+class ValidationError extends RippleError {}
+
+class NotFoundError extends RippleError {
+  constructor(message = 'Not found') {
+    super(message)
+  }
+}
+
+class MissingLedgerHistoryError extends RippleError {
+  constructor(message?: string) {
+    super(message || 'Server is missing ledger history in the specified range')
+  }
+}
+
+class PendingLedgerVersionError extends RippleError {
+  constructor(message?: string) {
+    super(message || 'maxLedgerVersion is greater than server\'s most recent ' +
+      ' validated ledger')
+  }
+}
+
+export {
+  RippleError,
+  UnexpectedError,
+  ConnectionError,
+  RippledError,
+  NotConnectedError,
+  DisconnectedError,
+  RippledNotInitializedError,
+  TimeoutError,
+  ResponseFormatError,
+  ValidationError,
+  NotFoundError,
+  PendingLedgerVersionError,
+  MissingLedgerHistoryError,
+  LedgerVersionError
+}

src/common/index.ts

@@ -0,0 +1,23 @@
+import * as constants from './constants'
+import * as errors from './errors'
+import * as validate from './validate'
+import * as serverInfo from './serverinfo'
+export {
+  constants,
+  errors,
+  validate,
+  serverInfo
+}
+
+export {
+  dropsToXrp,
+  xrpToDrops,
+  toRippledAmount,
+  removeUndefined,
+  convertKeysFromSnakeCaseToCamelCase,
+  iso8601ToRippleTime,
+  rippleTimeToISO8601
+} from './utils'
+export {default as Connection} from './connection'
+export {txFlags} from './txflags'
+

src/common/rangeset.ts

@@ -0,0 +1,63 @@
+import * as _ from 'lodash'
+import * as assert from 'assert'
+
+type Interval = [number, number]
+
+function mergeIntervals(intervals: Interval[]): Interval[] {
+  const stack: Interval[] = [[-Infinity, -Infinity]]
+  _.sortBy(intervals, x => x[0]).forEach(interval => {
+    const lastInterval: Interval = stack.pop()!
+    if (interval[0] <= lastInterval[1] + 1) {
+      stack.push([lastInterval[0], Math.max(interval[1], lastInterval[1])])
+    } else {
+      stack.push(lastInterval)
+      stack.push(interval)
+    }
+  })
+  return stack.slice(1)
+}
+
+class RangeSet {
+
+  ranges: Array<[number, number]>
+
+  constructor() {
+    this.reset()
+  }
+
+  reset() {
+    this.ranges = []
+  }
+
+  serialize() {
+    return this.ranges.map(range =>
+      range[0].toString() + '-' + range[1].toString()).join(',')
+  }
+
+  addRange(start: number, end: number) {
+    assert(start <= end, 'invalid range')
+    this.ranges = mergeIntervals(this.ranges.concat([[start, end]]))
+  }
+
+  addValue(value: number) {
+    this.addRange(value, value)
+  }
+
+  parseAndAddRanges(rangesString: string) {
+    const rangeStrings = rangesString.split(',')
+    _.forEach(rangeStrings, rangeString => {
+      const range = rangeString.split('-').map(Number)
+      this.addRange(range[0], range.length === 1 ? range[0] : range[1])
+    })
+  }
+
+  containsRange(start: number, end: number) {
+    return _.some(this.ranges, range => range[0] <= start && range[1] >= end)
+  }
+
+  containsValue(value: number) {
+    return this.containsRange(value, value)
+  }
+}
+
+export default RangeSet

src/common/schema-validator.ts

@@ -0,0 +1,162 @@
+import * as _ from 'lodash'
+import * as assert from 'assert'
+const {Validator} = require('jsonschema')
+import {ValidationError} from './errors'
+import {isValidAddress} from 'ripple-address-codec'
+import {isValidSecret} from './utils'
+
+function loadSchemas() {
+  // listed explicitly for webpack (instead of scanning schemas directory)
+  const schemas = [
+    require('./schemas/objects/tx-json.json'),
+    require('./schemas/objects/tx-type.json'),
+    require('./schemas/objects/hash128.json'),
+    require('./schemas/objects/hash256.json'),
+    require('./schemas/objects/sequence.json'),
+    require('./schemas/objects/signature.json'),
+    require('./schemas/objects/issue.json'),
+    require('./schemas/objects/ledgerversion.json'),
+    require('./schemas/objects/max-adjustment.json'),
+    require('./schemas/objects/memo.json'),
+    require('./schemas/objects/memos.json'),
+    require('./schemas/objects/public-key.json'),
+    require('./schemas/objects/private-key.json'),
+    require('./schemas/objects/uint32.json'),
+    require('./schemas/objects/value.json'),
+    require('./schemas/objects/source-adjustment.json'),
+    require('./schemas/objects/destination-adjustment.json'),
+    require('./schemas/objects/tag.json'),
+    require('./schemas/objects/lax-amount.json'),
+    require('./schemas/objects/lax-lax-amount.json'),
+    require('./schemas/objects/min-adjustment.json'),
+    require('./schemas/objects/source-exact-adjustment.json'),
+    require('./schemas/objects/destination-exact-adjustment.json'),
+    require('./schemas/objects/tx-hash.json'),
+    require('./schemas/objects/address.json'),
+    require('./schemas/objects/adjustment.json'),
+    require('./schemas/objects/quality.json'),
+    require('./schemas/objects/amount.json'),
+    require('./schemas/objects/amount-base.json'),
+    require('./schemas/objects/balance.json'),
+    require('./schemas/objects/blob.json'),
+    require('./schemas/objects/currency.json'),
+    require('./schemas/objects/signed-value.json'),
+    require('./schemas/objects/orderbook.json'),
+    require('./schemas/objects/instructions.json'),
+    require('./schemas/objects/settings.json'),
+    require('./schemas/specifications/settings.json'),
+    require('./schemas/specifications/payment.json'),
+    require('./schemas/specifications/escrow-cancellation.json'),
+    require('./schemas/specifications/order-cancellation.json'),
+    require('./schemas/specifications/order.json'),
+    require('./schemas/specifications/escrow-execution.json'),
+    require('./schemas/specifications/escrow-creation.json'),
+    require('./schemas/specifications/payment-channel-create.json'),
+    require('./schemas/specifications/payment-channel-fund.json'),
+    require('./schemas/specifications/payment-channel-claim.json'),
+    require('./schemas/specifications/check-create.json'),
+    require('./schemas/specifications/check-cash.json'),
+    require('./schemas/specifications/check-cancel.json'),
+    require('./schemas/specifications/trustline.json'),
+    require('./schemas/output/sign.json'),
+    require('./schemas/output/submit.json'),
+    require('./schemas/output/get-account-info.json'),
+    require('./schemas/output/get-account-objects.json'),
+    require('./schemas/output/get-balances.json'),
+    require('./schemas/output/get-balance-sheet.json'),
+    require('./schemas/output/get-ledger.json'),
+    require('./schemas/output/get-orderbook.json'),
+    require('./schemas/output/get-orders.json'),
+    require('./schemas/output/order-change.json'),
+    require('./schemas/output/get-payment-channel.json'),
+    require('./schemas/output/prepare.json'),
+    require('./schemas/output/ledger-event.json'),
+    require('./schemas/output/get-paths.json'),
+    require('./schemas/output/get-server-info.json'),
+    require('./schemas/output/get-settings.json'),
+    require('./schemas/output/orderbook-orders.json'),
+    require('./schemas/output/outcome.json'),
+    require('./schemas/output/get-transaction.json'),
+    require('./schemas/output/get-transactions.json'),
+    require('./schemas/output/get-trustlines.json'),
+    require('./schemas/output/sign-payment-channel-claim.json'),
+    require('./schemas/output/verify-payment-channel-claim.json'),
+    require('./schemas/input/get-balances.json'),
+    require('./schemas/input/get-balance-sheet.json'),
+    require('./schemas/input/get-ledger.json'),
+    require('./schemas/input/get-orders.json'),
+    require('./schemas/input/get-orderbook.json'),
+    require('./schemas/input/get-paths.json'),
+    require('./schemas/input/get-payment-channel.json'),
+    require('./schemas/input/api-options.json'),
+    require('./schemas/input/get-settings.json'),
+    require('./schemas/input/get-account-info.json'),
+    require('./schemas/input/get-account-objects.json'),
+    require('./schemas/input/get-transaction.json'),
+    require('./schemas/input/get-transactions.json'),
+    require('./schemas/input/get-trustlines.json'),
+    require('./schemas/input/prepare-payment.json'),
+    require('./schemas/input/prepare-order.json'),
+    require('./schemas/input/prepare-trustline.json'),
+    require('./schemas/input/prepare-order-cancellation.json'),
+    require('./schemas/input/prepare-settings.json'),
+    require('./schemas/input/prepare-escrow-creation.json'),
+    require('./schemas/input/prepare-escrow-cancellation.json'),
+    require('./schemas/input/prepare-escrow-execution.json'),
+    require('./schemas/input/prepare-payment-channel-create.json'),
+    require('./schemas/input/prepare-payment-channel-fund.json'),
+    require('./schemas/input/prepare-payment-channel-claim.json'),
+    require('./schemas/input/prepare-check-create.json'),
+    require('./schemas/input/prepare-check-cash.json'),
+    require('./schemas/input/prepare-check-cancel.json'),
+    require('./schemas/input/compute-ledger-hash.json'),
+    require('./schemas/input/sign.json'),
+    require('./schemas/input/submit.json'),
+    require('./schemas/input/generate-address.json'),
+    require('./schemas/input/sign-payment-channel-claim.json'),
+    require('./schemas/input/verify-payment-channel-claim.json'),
+    require('./schemas/input/combine.json')
+  ]
+  const titles = schemas.map(schema => schema.title)
+  const duplicates = _.keys(_.pickBy(_.countBy(titles), count => count > 1))
+  assert(duplicates.length === 0, 'Duplicate schemas for: ' + duplicates)
+  const validator = new Validator()
+  // Register custom format validators that ignore undefined instances
+  // since jsonschema will still call the format validator on a missing
+  // (optional)  property
+  validator.customFormats.address = function(instance) {
+    if (instance === undefined) {
+      return true
+    }
+    return isValidAddress(instance)
+  }
+  validator.customFormats.secret = function(instance) {
+    if (instance === undefined) {
+      return true
+    }
+    return isValidSecret(instance)
+  }
+
+  // Register under the root URI '/'
+  _.forEach(schemas, schema => validator.addSchema(schema, '/' + schema.title))
+  return validator
+}
+
+const schemaValidator = loadSchemas()
+
+function schemaValidate(schemaName: string, object: any): void {
+  // Lookup under the root URI '/'
+  const schema = schemaValidator.getSchema('/' + schemaName)
+  if (schema === undefined) {
+    throw new ValidationError('no schema for ' + schemaName)
+  }
+  const result = schemaValidator.validate(object, schema)
+  if (!result.valid) {
+    throw new ValidationError(result.errors.join())
+  }
+}
+
+export {
+  schemaValidate,
+  isValidSecret
+}

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

@@ -0,0 +1,64 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "api-options",
+  "type": "object",
+  "properties": {
+    "trace": {
+      "type": "boolean",
+      "description": "If true, log rippled requests and responses to stdout."
+    },
+    "feeCushion": {
+      "type": "number",
+      "minimum": 1,
+      "description": "Factor to multiply estimated fee by to provide a cushion in case the required fee rises during submission of a transaction. Defaults to `1.2`."
+    },
+    "maxFeeXRP": {
+      "type": "string",
+      "description": "Maximum fee to use with transactions, in XRP. Must be a string-encoded number. Defaults to `'2'`."
+    },
+    "server": {
+      "type": "string",
+      "description": "URI for rippled websocket port to connect to. Must start with `wss://` or `ws://`.",
+      "format": "uri",
+      "pattern": "^wss?://"
+    },
+    "proxy": {
+      "format": "uri",
+      "description": "URI for HTTP/HTTPS proxy to use to connect to the rippled server."
+    },
+    "timeout": {
+      "type": "integer",
+      "description": "Timeout in milliseconds before considering a request to have failed.",
+      "minimum": 1
+    },
+    "proxyAuthorization": {
+      "type": "string",
+      "description": "Username and password for HTTP basic authentication to the proxy in the format **username:password**."
+    },
+    "authorization": {
+      "type": "string",
+      "description": "Username and password for HTTP basic authentication to the rippled server in the format **username:password**."
+    },
+    "trustedCertificates": {
+      "type": "array",
+      "description": "Array of PEM-formatted SSL certificates to trust when connecting to a proxy. This is useful if you want to use a self-signed certificate on the proxy server. Note: Each element must contain a single certificate; concatenated certificates are not valid.",
+      "items": {
+        "type": "string",
+        "description": "A PEM-formatted SSL certificate to trust when connecting to a proxy."
+      }
+    },
+    "key": {
+      "type": "string",
+      "description": "A string containing the private key of the client in PEM format. (Can be an array of keys)."
+    },
+    "passphrase": {
+      "type": "string",
+      "description": "The passphrase for the private key of the client."
+    },
+    "certificate": {
+      "type": "string",
+      "description": "A string containing the certificate key of the client in PEM format. (Can be an array of certificates)."
+    }
+  },
+  "additionalProperties": false
+}

src/common/schemas/input/combine.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "combineParameters",
+  "type": "object",
+  "properties": {
+    "signedTransactions": {
+      "type": "array",
+      "description": "An array of signed transactions (from the output of [sign](#sign)) to combine.",
+      "items": {
+        "type": "string",
+        "pattern": "^[A-F0-9]+$",
+        "description": "A single-signed transaction represented as an uppercase hexadecimal string (from the output of [sign](#sign))"
+      },
+      "minLength": 1
+    }
+  },
+  "additionalProperties": false,
+  "required": ["signedTransactions"]
+}

src/common/schemas/input/compute-ledger-hash.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "computeLedgerHashParameters",
+  "type": "object",
+  "properties": {
+    "ledger": {
+      "$ref": "getLedger",
+      "description": "The ledger header to hash."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["ledger"]
+}

src/common/schemas/input/generate-address.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "generateAddressParameters",
+  "type": "object",
+  "properties": {
+    "options": {
+      "type": "object",
+      "description": "Options to control how the address and secret are generated.",
+      "properties": {
+        "entropy": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 255
+          },
+          "description": "The entropy to use to generate the seed."
+        },
+        "algorithm": {
+          "type": "string",
+          "enum": ["ecdsa-secp256k1", "ed25519"],
+          "description": "The digital signature algorithm to generate an address for. Can be `ecdsa-secp256k1` (default) or `ed25519`."
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}