Release 1.5.0

Update webpack (#1112 )
Update README (#1111 )
2025-11-05 05:15:48 +00:00 · 2019-12-14 22:45:12 -08:00 · 2019-12-14 10:24:32 -08:00 · 2019-12-14 10:24:05 -08:00 · 2019-12-14 10:23:09 -08:00 · 2019-12-11 23:47:41 -08:00
189 changed files with 9580 additions and 9146 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -0,0 +1,25 @@
+{
+  "env": {
+    "browser": true,
+    "es6": true,
+    "node": true,
+    "mocha": true
+  },
+  "extends": [
+    "eslint:recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "module"
+  },
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  "rules": {
+    "no-useless-constructor": 0,
+    "no-unused-vars": 0,
+    "no-prototype-builtins": 0,
+    "require-atomic-updates": 0
+  }
+}
--- a/.npmignore
+++ b/.npmignore
@@ -1,4 +0,0 @@
-lib-cov
-coverage.html
-src
-dist/bower
--- a/.prettierrc
+++ b/.prettierrc
@@ -0,0 +1,9 @@
+{
+  "parser": "typescript",
+  "printWidth": 80,
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "quoteProps": "consistent"
+  }
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,10 @@
 language: node_js
 node_js:
-  - 6
  - 8
  - 10
-  - 11
+  - 12
+  - 13
 script:
-  - yarn compile
  - yarn test
  - yarn build
  - yarn lint
--- a/APPLICATIONS.md
+++ b/APPLICATIONS.md
@@ -12,7 +12,7 @@ Warning: Use at your own risk.

 ## Data and visualizations

- **[Wipple - XRP Intelligence](https://wipple.devnull.network/)**
+- **[xrp1ntel - XRP Intelligence](https://xrp1ntel.com/)**

  Monitor the XRP Network in real time and explore historical statistics.

@@ -36,7 +36,7 @@ Warning: Use at your own risk.

  List of XRPL validators, nodes, and testnet validators.

- **[XRP Scan - XRP Ledger explorer](https://http://xrpscan.com)**
+- **[XRP Scan - XRP Ledger explorer](https://xrpscan.com)**

  XRP Ledger explorer, metrics and analytics.

@@ -60,6 +60,10 @@ Warning: Use at your own risk.

 ## Wallets and wallet tools

+- **[XRP Toolkit](https://www.xrptoolkit.com)**
+
+  A web interface to the XRP Ledger, supporting both hardware and software wallets.
+
 - **[Toast Wallet](https://toastwallet.com/)**

  A free, open source XRP Wallet for iOS, Android, Windows, Mac and Linux.
--- a/Gulpfile.js
+++ b/Gulpfile.js
@@ -1,151 +0,0 @@
-/* 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 webpack = require('webpack');
-const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
-
-const pkg = require('./package.json');
-
-const uglifyOptions = {
-  mangle: {
-    reserved: ['_', 'RippleError', 'RippledError', 'UnexpectedError',
-    'LedgerVersionError', 'ConnectionError', 'NotConnectedError',
-    'DisconnectedError', 'TimeoutError', 'ResponseFormatError',
-    'ValidationError', 'NotFoundError', 'MissingLedgerHistoryError',
-    'PendingLedgerVersionError'
-    ]
-  }
-};
-
-function getWebpackConfig(extension, overrides) {
-  overrides = overrides || {};
-  let defaults = {
-    cache: true,
-    externals: [{
-      'lodash': '_'
-    }],
-    entry: './src/index.ts',
-    output: {
-      library: 'ripple',
-      path: path.join(__dirname, 'build/'),
-      filename: `ripple-${pkg.version}${extension}`
-    },
-    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: {
-              composite: false,
-              declaration: false,
-              declarationMap: false
-            }
-          },
-        }],
-      }]
-    },
-    resolve: {
-      extensions: [ '.ts', '.js' ]
-    },
-  };
-  return _.assign({}, defaults, overrides);
-}
-
-function webpackConfigForWebTest(testFileName) {
-  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: path.join(__dirname, 'test-compiled-for-web/'),
-      filename: match[1] + '-test.js'
-    }
-  };
-  return getWebpackConfig('.js', configOverrides);
-}
-
-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);
-  };
-}
-
-function watch(callback) {
-  gulp.watch('src/*', gulp.series(buildDebug));
-  callback();
-}
-
-function build(callback) {
-  webpack(getWebpackConfig('.js'), createBuildLink(callback));
-}
-
-function buildDebug(callback) {
-  const webpackConfig = getWebpackConfig('-debug.js', {devtool: 'eval'});
-  webpackConfig.plugins.unshift(new webpack.LoaderOptionsPlugin({debug: true}));
-  webpack(webpackConfig, callback);
-}
-
-function buildMin(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();
-  });
-}
-
-function buildTests(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);
-}
-
-exports.watch = watch;
-exports.build = build;
-exports.buildDebug = buildDebug;
-exports.buildMin = buildMin;
-exports.buildTests = buildTests;
-
-exports.default = gulp.parallel(build, buildDebug, buildMin);
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,5 +1,98 @@
 # ripple-lib Release History

+## 1.5.0 (2019-12-14)
+
+* Add support for `WalletLocator` (#1083)
+* Types: Move and de-dupe `TransactionJSON` type (#1096)
+  * This resolves an error surfaced by [TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#local-and-imported-type-declarations-now-conflict)
+* Add a heartbeat to detect hung connections (#1101)
+* Dependencies
+  * Update TypeScript version (#1096)
+  * Update ripple-lib-transactionparser to 0.8.1 (#1097)
+  * Update ripple-binary-codec to 0.2.5
+  * Update webpack (#1112)
+  * Require node 8 and yarn (#1107)
+* Testing: Refactor and add unit tests
+  * Fix some errors caught by the improved tests
+
+## 1.4.2 (2019-11-14)
+
+* Add support for tick size (#1090) (thanks @RareData)
+* Update email hash default to allow proper clearing (#1089) (thanks @RareData)
+* Fix Unhandled Promise Rejection Warning on message `_send`
+  * Add an immediate catch to the `_send` promise passed to `_whenReady` in case there is rejection before async handlers are added (#1092) (thanks @nickewansmith)
+* Docs improvements
+  * Add XRP Toolkit reference (#1088)
+* Internal improvements
+  * Add a prettier config
+  * Update Node.js Testing Versions (#1085)
+    * Testing matrix based on: https://nodejs.org/en/about/releases/
+      - Node 11 is no longer supported (not LTS)
+      - Node 12 added (active LTS)
+      - Node 13 added ("current" release)
+
+## 1.4.1 (2019-11-06)
+
+* Compatibility: Change TypeScript compile target back to `es6` (#1071)
+  * WARNING: This allows for the use of Node v6, which is no longer supported by Node.js, as it was end-of-life'd in April 2019
+  * We recommend updating to Node v8/v10 ASAP in order to get security updates and fixes from the Node.js team
+  * We are not actively running tests against Node v6 (ref #1076)
+* Docs: `getAccountObjects` doc fix
+* Dependencies:
+  * Update `bignumber.js`
+  * Update `ripple-keypairs`
+  * Update `ws`
+* Build process: Update `webpack` flow
+
+## 1.4.0 (2019-10-28)
+
+* Unref timer so it does not hang the Node.js process
+* Add a 2-second timeout for connect()
+* Improve getTransaction() error when tx has not been validated yet
+* Add support for the new X-address format
+* Fix error in Safari, Chrome 78, Firefox 70
+* Some error messages have changed slightly. For example:
+  * `-instance.Account is not of a type(s) string,instance.Account does not conform to the "address" format`
+  * `+instance.Account is not of a type(s) string,instance.Account is not exactly one from <xAddress>,<classicAddress>`
+
+### Internal improvements
+
+* Reduce dependency size
+* Move tests to TypeScript
+* Replace tslint with eslint
+* Update https-proxy-agent
+* Add tests
+
+## 1.3.4 (2019-10-18)
+
+* Update ripple-lib-transactionparser
+* Improve error message when signing fails (e.g. due to trailing zeros)
+* Integrate ripple-hashes (in TypeScript with improved naming and docs)
+* Add multi-signing example to sign() method docs
+* Update TypeScript
+
+## 1.3.3 (2019-09-10)
+
+* Expand node version compatibility to support Node.js 12 ([ripple-binary-codec#32](https://github.com/ripple/ripple-binary-codec/issues/32))
+
+## 1.3.2 (2019-09-03)
+
+* Export and document `rippleTimeToISO8601()` method
+* Add type for isValidAddress (fixes error TS7016, #1032)
+* Docs: update recommended Node.js version (#1031)
+
+When using this release with [rippled](https://github.com/ripple/rippled), we recommend using [rippled version 1.3.1](https://github.com/ripple/rippled/releases/tag/1.3.1) or later.
+
+## 1.3.1 (2019-08-26)
+
+* Upgrade to gulp 4 (#1030)
+* Remove http server (unused)
+* Update dependencies
+
+There are no changes in the browser version with this release. The npm package for Node.js should be slightly smaller.
+
+When using this release with [rippled](https://github.com/ripple/rippled), we recommend using [rippled version 1.3.1](https://github.com/ripple/rippled/releases/tag/1.3.1).
+
 ## 1.3.0 (2019-08-16)

 ### Bug fixes:
--- a/README.md
+++ b/README.md
@@ -1,9 +1,13 @@
-# ripple-lib
+# ripple-lib (RippleAPI)

-A JavaScript API for interacting with the XRP Ledger
+A JavaScript/TypeScript API for interacting with the XRP Ledger

 [![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)

+This is the recommended library for integrating a JavaScript/TypeScript app with the XRP Ledger, especially if you intend to use advanced functionality such as IOUs, payment paths, the decentralized exchange, account settings, payment channels, escrows, multi-signing, and more.
+
+**What is ripple-lib used for?** Here's a [list of applications](APPLICATIONS.md) that use `ripple-lib`. Open a PR to add your app or project to the list!
+
 ### Features

 + Connect to a `rippled` server from Node.js or a web browser
@@ -12,10 +16,6 @@ A JavaScript API for interacting with the XRP Ledger
 + Sign and submit transactions to the XRP Ledger
 + Type definitions for TypeScript

-## Getting Started
-
-See also: [RippleAPI Beginners Guide](https://xrpl.org/get-started-with-rippleapi-for-javascript.html)
-
 ### Requirements

 + **[Node v10](https://nodejs.org/)** is recommended. Other versions may work but are not frequently tested.
@@ -28,9 +28,11 @@ In an existing project (with `package.json`), install `ripple-lib`:
 $ yarn add ripple-lib
 ```

-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).
+## Documentation

-**What is ripple-lib used for?** Here's a [list of applications](APPLICATIONS.md) that use `ripple-lib`. Open a PR to add your app or project to the list!
+ [RippleAPI Beginners Guide](https://xrpl.org/get-started-with-rippleapi-for-javascript.html)
+ [RippleAPI Full Reference Documentation](https://xrpl.org/rippleapi-reference.html) ([in this repo](https://github.com/ripple/ripple-lib/blob/develop/docs/index.md))
+ [Code Samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples)

 ### Mailing Lists

@@ -44,35 +46,41 @@ If you're using the XRP Ledger in production, you should run a [rippled server](

 ## Development

-To build the library for Node.js:
-```
-$ yarn compile
-```
-
-The TypeScript compiler will [output](./tsconfig.json#L7) the resulting JS files in `./dist/npm/`.
-
-To build the library for the browser:
+To build the library for Node.js and the browser:
 ```
 $ yarn build
 ```

-Gulp will [output](./Gulpfile.js) the resulting JS files in `./build/`.
+The TypeScript compiler will [output](./tsconfig.json#L7) the resulting JS files in `./dist/npm/`.
+
+webpack will output the resulting JS files in `./build/`.

 For details, see the `scripts` in `package.json`.

 ## Running Tests

+### Unit Tests
+
 1. Clone the repository
 2. `cd` into the repository and install dependencies with `yarn install`
 3. `yarn test`

-Also, run `yarn lint` to lint the code with `tslint`.
+### Linting
+
+Run `yarn lint` to lint the code with `tslint`.

 ## Generating Documentation

-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`.
+Do not edit `./docs/index.md` directly because it is a generated file.
+
+Instead, edit the appropriate `.md.ejs` files in `./docs/src/`.
+
+If you make changes to the JSON schemas, fixtures, or documentation sources, update the documentation by running `yarn run docgen`.

 ## More Information

-+ [RippleAPI Reference](https://developers.ripple.com/rippleapi-reference.html) - XRP Ledger Dev Portal
-+ [XRP Ledger Dev Portal](https://developers.ripple.com/)
+ [ripple-lib-announce mailing list](https://groups.google.com/forum/#!forum/ripple-lib-announce) - subscribe for release announcements
+ [RippleAPI Reference](https://xrpl.org/rippleapi-reference.html) - XRP Ledger Dev Portal
+ [XRP Ledger Dev Portal](https://xrpl.org/)
+
+ [![Build Status](https://travis-ci.org/ripple/ripple-lib.svg?branch=master)](https://travis-ci.org/ripple/ripple-lib)
--- a/docs/index.md
+++ b/docs/index.md
@@ -80,6 +80,7 @@
  - [sign](#sign)
  - [combine](#combine)
  - [submit](#submit)
+  - [generateXAddress](#generatexaddress)
  - [generateAddress](#generateaddress)
  - [isValidAddress](#isvalidaddress)
  - [isValidSecret](#isvalidsecret)
@@ -91,6 +92,7 @@
  - [xrpToDrops](#xrptodrops)
  - [dropsToXrp](#dropstoxrp)
  - [iso8601ToRippleTime](#iso8601torippletime)
+  - [rippleTimeToISO8601](#rippletimetoiso8601)
  - [txFlags](#txflags)
  - [schemaValidator](#schemavalidator)
  - [schemaValidate](#schemavalidate)
@@ -104,7 +106,8 @@

 # Introduction

-RippleAPI (ripple-lib) is the official client library to the XRP Ledger. Currently, RippleAPI is only available in JavaScript.
+RippleAPI (ripple-lib) is the official client library to the XRP Ledger. Currently, RippleAPI is only available in JavaScript/TypeScript.
+
 Using RippleAPI, you can:

 * [Query transactions from the XRP Ledger history](#gettransaction)
@@ -113,6 +116,10 @@ Using RippleAPI, you can:
 * [Generate a new XRP Ledger Address](#generateaddress)
 * ... and [much more](#api-methods).

+This page contains documentation for ripple-lib. To use ripple-lib with npm/yarn, begin with the [Getting Started](https://github.com/ripple/ripple-lib#getting-started) steps.
+
+**What is ripple-lib used for?** Here's a [list of applications that use `ripple-lib`](https://github.com/ripple/ripple-lib/blob/develop/APPLICATIONS.md). Open a PR to add your app or project to the list!
+
 ## Boilerplate

 Use the following [boilerplate code](https://en.wikipedia.org/wiki/Boilerplate_code) to wrap your custom code using RippleAPI.
@@ -141,7 +148,7 @@ api.connect().then(() => {
 }).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.
+RippleAPI is designed to work in [Node.js](https://nodejs.org) version 6 or higher. Ripple recommends Node.js v10 LTS.

 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).

@@ -224,7 +231,19 @@ Methods that depend on the state of the XRP Ledger are unavailable in offline mo
 "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`.
+```json
+"X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ"
+```
+
+An *address* refers to a specific XRP Ledger account. It is a base-58 encoding of a hash of the account's public key. There are two kinds of addresses in common use:
+
+### Classic Address
+
+A *classic address* encodes a hash of the account's public key and a checksum. It has no other data. This kind of address always starts with the lowercase letter `r`.
+
+### X-address
+
+An *X-address* encodes a hash of the account's public key, a tag, and a checksum. This kind of address starts with the uppercase letter `X` if it is intended for use on the production XRP Ledger (mainnet). It starts with the uppercase letter `T` if it is intended for use on a test network such as Testnet or Devnet.

 ## Account Sequence Number

@@ -376,12 +395,12 @@ Name | Type | Description
 source | object | The source of the funds to be sent.
 *source.* address | [address](#address) | The address to send from.
 *source.* amount | [laxAmount](#amount) | An exact amount to send. If the counterparty is not specified, amounts with any counterparty may be used. (This field cannot be used with source.maxAmount)
-*source.* tag | integer | *Optional* An arbitrary unsigned 32-bit integer that identifies a reason for payment or a non-Ripple account.
+*source.* tag | integer | *Optional* An arbitrary 32-bit unsigned integer. It typically maps to an off-ledger account; for example, a hosted wallet or exchange account.
 *source.* maxAmount | [laxAmount](#amount) | The maximum amount to send. (This field cannot be used with source.amount)
 destination | object | The destination of the funds to be sent.
 *destination.* address | [address](#address) | An address representing the destination of the transaction.
 *destination.* amount | [laxAmount](#amount) | An exact amount to deliver to the recipient. If the counterparty is not specified, amounts with any counterparty may be used. (This field cannot be used with `destination.minAmount`.)
-*destination.* tag | integer | *Optional* An arbitrary unsigned 32-bit integer that identifies a reason for payment or a non-Ripple account.
+*destination.* tag | integer | *Optional* An arbitrary 32-bit unsigned integer. It typically maps to an off-ledger account; for example, a hosted wallet or exchange account.
 *destination.* minAmount | [laxAmount](#amount) | The minimum amount to be delivered. (This field cannot be used with destination.amount)
 allowPartialPayment | boolean | *Optional* If true, this payment should proceed even if the whole amount cannot be delivered due to a lack of liquidity or a lack of funds in the source account.
 invoiceID | string | *Optional* A 256-bit hash that can be used to identify a particular payment.
@@ -522,7 +541,7 @@ defaultRipple | boolean | *Optional* Enable [rippling](https://ripple.com/build/
 depositAuth | boolean | *Optional* Enable [Deposit Authorization](https://ripple.com/build/deposit-authorization/) on this account. If set, transactions cannot send value of any kind to this account unless the sender of those transactions is the account itself. (Requires the [DepositAuth amendment](https://ripple.com/build/known-amendments/#depositauth))
 disableMasterKey | boolean | *Optional* Disallows use of the master key to sign transactions for this account. To disable the master key, you must authorize the transaction by signing it with the master key pair. You cannot use a regular key pair or a multi-signature. You can re-enable the master key pair using a regular key pair or multi-signature. See [AccountSet](https://developers.ripple.com/accountset.html).
 disallowIncomingXRP | boolean | *Optional* Indicates that client applications should not send XRP to this account. Not enforced by rippled.
-domain | string | *Optional*  The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase.
+domain | string | *Optional* The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase.
 emailHash | string,null | *Optional* Hash of an email address to be used for generating an avatar image. Conventionally, clients use Gravatar to display this image. Use `null` to clear.
 enableTransactionIDTracking | boolean | *Optional* Track the ID of this account’s most recent transaction.
 globalFreeze | boolean | *Optional* Freeze all assets issued by this account.
@@ -537,9 +556,11 @@ signers | object | *Optional* Settings that determine what sets of accounts can
 *signers.* threshold | integer | A target number for the signer weights. A multi-signature from this list is valid only if the sum weights of the signatures provided is equal or greater than this value. To delete the signers setting, use the value `0`.
 *signers.* weights | array | *Optional* Weights of signatures for each signer.
 *signers.* weights[] | object | An association of an address and a weight.
-*signers.weights[].* address | [address](#address) | A Ripple account address
+*signers.weights[].* address | [address](#address) | An account address on the XRP Ledger
 *signers.weights[].* weight | integer | The weight that the signature of this account counts as towards the threshold.
-transferRate | number,null | *Optional*  The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.
+tickSize | string | *Optional* Tick size to use for offers involving a currency issued by this address. The exchange rates of those offers is rounded to this many significant digits. Valid values are 3 to 15 inclusive, or 0 to disable.
+transferRate | number,null | *Optional* The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.
+walletLocator | string,null | *Optional* Transaction hash or any other 64 character hexadecimal string, that may or may not represent the result of a hash operation. Use `null` to clear.

 ### Example

@@ -774,12 +795,14 @@ signature | string | *Optional* Signed claim authorizing withdrawal of XRP from

 # 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). 
+ripple-lib relies on [rippled APIs](https://ripple.com/build/rippled-apis/) for online functionality. In addition to ripple-lib's own methods, you can also 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://developers.ripple.com/basic-data-types.html#specifying-currency-amounts).
 * [Specify timestamps as the number of seconds since the "Ripple Epoch"](https://developers.ripple.com/basic-data-types.html#specifying-time).
 * Instead of `counterparty`, use `issuer`.
@@ -850,7 +873,7 @@ Returns the response from invoking the specified command, with the specified opt

 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).
+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://xrpl.org/basic-data-types.html#specifying-ledgers).

 ### Return Value

@@ -1685,6 +1708,7 @@ return api.getTransactions(address).then(transaction => {
    },
    "outcome": {
      "result": "tesSUCCESS",
+      "timestamp": "2019-04-01T07:39:01.000Z",
      "fee": "0.00001",
      "deliveredAmount": {
        "currency": "USD",
@@ -1778,6 +1802,7 @@ return api.getTransactions(address).then(transaction => {
    },
    "outcome": {
      "result": "tesSUCCESS",
+      "timestamp": "2019-04-01T07:39:01.000Z",
      "fee": "0.00001",
      "deliveredAmount": {
        "currency": "USD",
@@ -2288,12 +2313,12 @@ Name | Type | Description
 source | object | Properties of the source of the payment.
 *source.* address | [address](#address) | The address to send from.
 *source.* amount | [laxAmount](#amount) | An exact amount to send. If the counterparty is not specified, amounts with any counterparty may be used. (This field cannot be used with source.maxAmount)
-*source.* tag | integer | *Optional* An arbitrary unsigned 32-bit integer that identifies a reason for payment or a non-Ripple account.
+*source.* tag | integer | *Optional* An arbitrary 32-bit unsigned integer. It typically maps to an off-ledger account; for example, a hosted wallet or exchange account.
 *source.* maxAmount | [laxAmount](#amount) | The maximum amount to send. (This field cannot be used with source.amount)
 destination | object | Properties of the destination of the payment.
 *destination.* address | [address](#address) | An address representing the destination of the transaction.
 *destination.* amount | [laxAmount](#amount) | An exact amount to deliver to the recipient. If the counterparty is not specified, amounts with any counterparty may be used. (This field cannot be used with `destination.minAmount`.)
-*destination.* tag | integer | *Optional* An arbitrary unsigned 32-bit integer that identifies a reason for payment or a non-Ripple account.
+*destination.* tag | integer | *Optional* An arbitrary 32-bit unsigned integer. It typically maps to an off-ledger account; for example, a hosted wallet or exchange account.
 *destination.* minAmount | [laxAmount](#amount) | The minimum amount to be delivered. (This field cannot be used with destination.amount)
 paths | string | The paths of trustlines and orders to use in executing the payment.

@@ -3890,7 +3915,7 @@ defaultRipple | boolean | *Optional* Enable [rippling](https://ripple.com/build/
 depositAuth | boolean | *Optional* Enable [Deposit Authorization](https://ripple.com/build/deposit-authorization/) on this account. If set, transactions cannot send value of any kind to this account unless the sender of those transactions is the account itself. (Requires the [DepositAuth amendment](https://ripple.com/build/known-amendments/#depositauth))
 disableMasterKey | boolean | *Optional* Disallows use of the master key to sign transactions for this account. To disable the master key, you must authorize the transaction by signing it with the master key pair. You cannot use a regular key pair or a multi-signature. You can re-enable the master key pair using a regular key pair or multi-signature. See [AccountSet](https://developers.ripple.com/accountset.html).
 disallowIncomingXRP | boolean | *Optional* Indicates that client applications should not send XRP to this account. Not enforced by rippled.
-domain | string | *Optional*  The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase.
+domain | string | *Optional* The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase.
 emailHash | string,null | *Optional* Hash of an email address to be used for generating an avatar image. Conventionally, clients use Gravatar to display this image. Use `null` to clear.
 enableTransactionIDTracking | boolean | *Optional* Track the ID of this account’s most recent transaction.
 globalFreeze | boolean | *Optional* Freeze all assets issued by this account.
@@ -3905,9 +3930,11 @@ signers | object | *Optional* Settings that determine what sets of accounts can
 *signers.* threshold | integer | A target number for the signer weights. A multi-signature from this list is valid only if the sum weights of the signatures provided is equal or greater than this value. To delete the signers setting, use the value `0`.
 *signers.* weights | array | *Optional* Weights of signatures for each signer.
 *signers.* weights[] | object | An association of an address and a weight.
-*signers.weights[].* address | [address](#address) | A Ripple account address
+*signers.weights[].* address | [address](#address) | An account address on the XRP Ledger
 *signers.weights[].* weight | integer | The weight that the signature of this account counts as towards the threshold.
-transferRate | number,null | *Optional*  The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.
+tickSize | string | *Optional* Tick size to use for offers involving a currency issued by this address. The exchange rates of those offers is rounded to this many significant digits. Valid values are 3 to 15 inclusive, or 0 to disable.
+transferRate | number,null | *Optional* The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.
+walletLocator | string,null | *Optional* Transaction hash or any other 64 character hexadecimal string, that may or may not represent the result of a hash operation. Use `null` to clear.

 ### Example

@@ -3923,8 +3950,10 @@ return api.getSettings(address).then(settings =>
  "requireDestinationTag": true,
  "disallowIncomingXRP": true,
  "emailHash": "23463B99B62A72F26ED677CC556C44E8",
+  "walletLocator": "00000000000000000000000000000000000000000000000000000000DEADBEEF",
  "domain": "example.com",
  "transferRate": 1.002,
+  "tickSize": 5,
  "signers": {
    "threshold": 3,
    "weights": [
@@ -4028,12 +4057,13 @@ limit | integer | *Optional* (May be omitted) The limit that was used in this re
 validated | boolean | *Optional* If included and set to true, the information in this request comes from a validated ledger version. Otherwise, the information is subject to change.

 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.
+
+* `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

@@ -5402,6 +5432,8 @@ options | object | *Optional* Options that control the type of signature that wi
 *options.* signAs | [address](#address) | *Optional* The account that the signature should count for in multisigning.
 secret | secret string | *Optional* The secret of the account that is initiating the transaction. (This field cannot be used with keypair).

+When this method is used for multisigning, the `options` parameter is required. See the multisigning example in this section for more details.
+
 ### Return Value

 This method returns an object with the following structure:
@@ -5429,6 +5461,94 @@ return api.sign(txJSON, secret); // or: api.sign(txJSON, keypair);
 ```


+### Example (multisigning)
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI;
+
+// jon's address will have a multi-signing setup with a quorum of 2
+const jon = {
+    account: 'rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj',
+    secret: 'sh4Va7b1wQof8knHFV2sxwX12fSgK'
+};
+const aya = {
+    account: 'rnrPdBjs98fFFfmRpL6hM7exT788SWQPFN',
+    secret: 'snaMuMrXeVc2Vd4NYvHofeGNjgYoe'
+};
+const bran = {
+    account: 'rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH',
+    secret: 'shQtQ8Um5MS218yvEU3Ehy1eZQKqH'
+};
+
+// Setup the signers list with a quorum of 2
+const multiSignSetupTransaction = {
+    "Flags": 0,
+    "TransactionType": "SignerListSet",
+    "Account": "rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj",
+    "Fee": "120",
+    "SignerQuorum": 2,
+    "SignerEntries": [
+        {
+            "SignerEntry": {
+                "Account": "rnrPdBjs98fFFfmRpL6hM7exT788SWQPFN",
+                "SignerWeight": 2
+            }
+        },
+        {
+            "SignerEntry": {
+                "Account": "rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH",
+                "SignerWeight": 1
+            }
+        },
+    ]
+};
+
+// a transaction which requires multi signing
+const multiSignPaymentTransaction = {
+    TransactionType: 'Payment',
+    Account: 'rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj',
+    Destination: 'rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH',
+    Amount: '88000000'
+};
+
+const api = new RippleAPI({
+    server: 'wss://s.altnet.rippletest.net:51233'
+});
+
+api.connect().then(() => {
+    // adding the multi signing feature to jon's account
+    api.prepareTransaction(multiSignSetupTransaction).then((prepared) => {
+        console.log(prepared);
+        jonSign = api.sign(prepared.txJSON, jon.secret).signedTransaction;
+        api.submit(jonSign).then( response => {
+            console.log(response.resultCode, response.resultMessage);
+
+            // multi sign a transaction
+            api.prepareTransaction(multiSignPaymentTransaction).then(prepared => {
+                console.log(prepared);
+
+                // Aya and Bran sign it too but with 'signAs' set to their own account
+                let ayaSign = api.sign(prepared.txJSON, aya.secret, {'signAs': aya.account}).signedTransaction;
+                let branSign = api.sign(prepared.txJSON, bran.secret, {'signAs': bran.account}).signedTransaction;
+
+                // signatures are combined and submitted
+                let combinedTx = api.combine([ayaSign, branSign]);
+                api.submit(combinedTx.signedTransaction).then(response => {
+                    console.log(response.tx_json.hash);
+                    return api.disconnect();
+                }).catch(console.error);
+            }).catch(console.error);
+        }).catch(console.error)
+    }).catch(console.error);
+}).catch(console.error);
+```
+
+Assuming the multisigning account was setup properly, the above example will respond with `resultCode: 'tesSUCCESS'` and the hash for the transaction.
+If any of `{signAs: some_address}` options were missing the code will return a validation error as follow:
+```
+[ValidationError(txJSON is not the same for all signedTransactions)]
+```
+
 ## combine

 `combine(signedTransactions: Array<string>): {signedTransaction: string, id: string}`
@@ -5530,9 +5650,9 @@ return api.submit(signedTransaction)
 ```


-## generateAddress
+## generateXAddress

-`generateAddress(): {address: string, secret: string}`
+`generateXAddress(options?: object): {address: string, secret: string}`

 Generate a new XRP Ledger address and corresponding secret.

@@ -5543,6 +5663,7 @@ Name | Type | Description
 options | object | *Optional* Options to control how the address and secret are generated.
 *options.* algorithm | string | *Optional* The digital signature algorithm to generate an address for. Can be `ecdsa-secp256k1` (default) or `ed25519`.
 *options.* entropy | array\<integer\> | *Optional* The entropy to use to generate the seed.
+*options.* test | boolean | *Optional* Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`.

 ### Return Value

@@ -5550,8 +5671,8 @@ This method returns an object with the following structure:

 Name | Type | Description
 ---- | ---- | -----------
-address | [address](#address) | A randomly generated Ripple account address.
-secret | secret string | The secret corresponding to the `address`.
+xAddress | [xAddress](#x-address) | A randomly generated XRP Ledger address in X-address format.
+secret | secret string | The secret corresponding to the address.

 ### Example

@@ -5562,6 +5683,52 @@ return api.generateAddress();

 ```json
 {
+  "xAddress": "XVLcsWWNiFdUEqoDmSwgxh1abfddG1LtbGFk7omPgYpbyE8",
+  "secret": "sp6JS7f14BuwFY8Mw6bTtLKWauoUs"
+}
+```
+
+
+## generateAddress
+
+`generateAddress(options?: object): {address: string, secret: string}`
+
+Deprecated: This method returns a classic address. If you do not need the classic address, use `generateXAddress` instead.
+
+Generate a new XRP Ledger address and corresponding secret.
+
+### Parameters
+
+Name | Type | Description
+---- | ---- | -----------
+options | object | *Optional* Options to control how the address and secret are generated.
+*options.* algorithm | string | *Optional* The digital signature algorithm to generate an address for. Can be `ecdsa-secp256k1` (default) or `ed25519`.
+*options.* entropy | array\<integer\> | *Optional* The entropy to use to generate the seed.
+*options.* includeClassicAddress | boolean | *Optional* If `true`, return the classic address, in addition to the X-address.
+*options.* test | boolean | *Optional* Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`.
+
+### Return Value
+
+This method returns an object with the following structure:
+
+Name | Type | Description
+---- | ---- | -----------
+xAddress | [xAddress](#x-address) | A randomly generated XRP Ledger address in X-address format.
+classicAddress | [classicAddress](#classic-address) | A randomly generated XRP Ledger Account ID (classic address).
+address | [classicAddress](#classic-address) | Deprecated: Use `classicAddress` instead.
+secret | secret string | The secret corresponding to the address.
+
+### Example
+
+```javascript
+return api.generateAddress();
+```
+
+
+```json
+{
+  "xAddress": "XVLcsWWNiFdUEqoDmSwgxh1abfddG1LtbGFk7omPgYpbyE8",
+  "classicAddress": "rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f",
  "address": "rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f",
  "secret": "sp6JS7f14BuwFY8Mw6bTtLKWauoUs"
 }
@@ -5572,7 +5739,7 @@ return api.generateAddress();

 `isValidAddress(address: string): boolean`

-Checks if the specified string contains a valid address.
+Checks if the specified string contains a valid address. X-addresses are considered valid with ripple-lib v1.4.0 and higher.

 ### Parameters

@@ -5860,6 +6027,34 @@ api.iso8601ToRippleTime('2017-02-17T15:04:57Z');
 540659097
 ```

+## rippleTimeToISO8601
+
+`rippleTimeToISO8601(rippleTime: number): string`
+
+This method takes the number of seconds since the "Ripple Epoch" of January 1, 2000 (00:00 UTC) and returns a string representation of a date.
+
+The Ripple Epoch is 946684800 seconds after the Unix Epoch.
+
+This method is useful for interpreting timestamps returned by the rippled APIs. The rippled APIs represent time as an unsigned integer of the number of seconds since the Ripple Epoch.
+
+### Parameters
+
+`rippleTime`: A number of seconds since the Ripple Epoch.
+
+### Return Value
+
+A string representing a date and time, created by calling a `Date` object's `toISOString()` method.
+
+### Example
+
+```javascript
+api.rippleTimeToISO8601(540659097);
+```
+
+```json
+'2017-02-17T15:04:57.000Z'
+```
+
 ## txFlags

 `txFlags.TRANSACTION_TYPE.FLAG`
--- a/docs/src/basictypes.md.ejs
+++ b/docs/src/basictypes.md.ejs
@@ -6,7 +6,19 @@
 "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`.
+```json
+"X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ"
+```
+
+An *address* refers to a specific XRP Ledger account. It is a base-58 encoding of a hash of the account's public key. There are two kinds of addresses in common use:
+
+### Classic Address
+
+A *classic address* encodes a hash of the account's public key and a checksum. It has no other data. This kind of address always starts with the lowercase letter `r`.
+
+### X-address
+
+An *X-address* encodes a hash of the account's public key, a tag, and a checksum. This kind of address starts with the uppercase letter `X` if it is intended for use on the production XRP Ledger (mainnet). It starts with the uppercase letter `T` if it is intended for use on a test network such as Testnet or Devnet.

 ## Account Sequence Number

--- a/docs/src/boilerplate.md.ejs
+++ b/docs/src/boilerplate.md.ejs
@@ -26,7 +26,7 @@ api.connect().then(() => {
 }).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.
+RippleAPI is designed to work in [Node.js](https://nodejs.org) version 6 or higher. Ripple recommends Node.js v10 LTS.

 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).

--- a/docs/src/generateAddress.md.ejs
+++ b/docs/src/generateAddress.md.ejs
@@ -1,6 +1,8 @@
 ## generateAddress

-`generateAddress(): {address: string, secret: string}`
+`generateAddress(options?: object): {address: string, secret: string}`
+
+Deprecated: This method returns a classic address. If you do not need the classic address, use `generateXAddress` instead.

 Generate a new XRP Ledger address and corresponding secret.

--- a/docs/src/generateXAddress.md.ejs
+++ b/docs/src/generateXAddress.md.ejs
@@ -0,0 +1,23 @@
+## generateXAddress
+
+`generateXAddress(options?: object): {address: string, secret: string}`
+
+Generate a new XRP Ledger address and corresponding secret.
+
+### Parameters
+
+<%- renderSchema('input/generate-x-address.json') %>
+
+### Return Value
+
+This method returns an object with the following structure:
+
+<%- renderSchema('output/generate-x-address.json') %>
+
+### Example
+
+```javascript
+return api.generateAddress();
+```
+
+<%- renderFixture('responses/generate-x-address.json') %>
--- a/docs/src/getAccountObjects.md.ejs
+++ b/docs/src/getAccountObjects.md.ejs
@@ -15,12 +15,13 @@ This method returns a promise that resolves with an object with the following st
 <%- 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.
+
+* `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

--- a/docs/src/index.md.ejs
+++ b/docs/src/index.md.ejs
@@ -52,6 +52,7 @@
 <% include sign.md.ejs %>
 <% include combine.md.ejs %>
 <% include submit.md.ejs %>
+<% include generateXAddress.md.ejs %>
 <% include generateAddress.md.ejs %>
 <% include isValidAddress.md.ejs %>
 <% include isValidSecret.md.ejs %>
@@ -62,6 +63,7 @@
 <% include computeLedgerHash.md.ejs %>
 <% include xrpToDropsAndDropsToXrp.md.ejs %>
 <% include iso8601ToRippleTime.md.ejs %>
+<% include rippleTimeToISO8601.md.ejs %>
 <% include txFlags.md.ejs %>
 <% include schemaValidator.md.ejs %>
 <% include events.md.ejs %>
--- a/docs/src/introduction.md.ejs
+++ b/docs/src/introduction.md.ejs
@@ -1,6 +1,7 @@
 # Introduction

-RippleAPI (ripple-lib) is the official client library to the XRP Ledger. Currently, RippleAPI is only available in JavaScript.
+RippleAPI (ripple-lib) is the official client library to the XRP Ledger. Currently, RippleAPI is only available in JavaScript/TypeScript.
+
 Using RippleAPI, you can:

 * [Query transactions from the XRP Ledger history](#gettransaction)
@@ -8,3 +9,7 @@ Using RippleAPI, you can:
 * [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).
+
+This page contains documentation for ripple-lib. To use ripple-lib with npm/yarn, begin with the [Getting Started](https://github.com/ripple/ripple-lib#getting-started) steps.
+
+**What is ripple-lib used for?** Here's a [list of applications that use `ripple-lib`](https://github.com/ripple/ripple-lib/blob/develop/APPLICATIONS.md). Open a PR to add your app or project to the list!
--- a/docs/src/isValidAddress.md.ejs
+++ b/docs/src/isValidAddress.md.ejs
@@ -2,7 +2,7 @@

 `isValidAddress(address: string): boolean`

-Checks if the specified string contains a valid address.
+Checks if the specified string contains a valid address. X-addresses are considered valid with ripple-lib v1.4.0 and higher.

 ### Parameters

--- a/docs/src/request.md.ejs
+++ b/docs/src/request.md.ejs
@@ -6,7 +6,7 @@ Returns the response from invoking the specified command, with the specified opt

 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).
+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://xrpl.org/basic-data-types.html#specifying-ledgers).

 ### Return Value

--- a/docs/src/rippleTimeToISO8601.md.ejs
+++ b/docs/src/rippleTimeToISO8601.md.ejs
@@ -0,0 +1,27 @@
+## rippleTimeToISO8601
+
+`rippleTimeToISO8601(rippleTime: number): string`
+
+This method takes the number of seconds since the "Ripple Epoch" of January 1, 2000 (00:00 UTC) and returns a string representation of a date.
+
+The Ripple Epoch is 946684800 seconds after the Unix Epoch.
+
+This method is useful for interpreting timestamps returned by the rippled APIs. The rippled APIs represent time as an unsigned integer of the number of seconds since the Ripple Epoch.
+
+### Parameters
+
+`rippleTime`: A number of seconds since the Ripple Epoch.
+
+### Return Value
+
+A string representing a date and time, created by calling a `Date` object's `toISOString()` method.
+
+### Example
+
+```javascript
+api.rippleTimeToISO8601(540659097);
+```
+
+```json
+'2017-02-17T15:04:57.000Z'
+```
--- a/docs/src/rippledAPIs.md.ejs
+++ b/docs/src/rippledAPIs.md.ejs
@@ -1,11 +1,13 @@
 # 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). 
+ripple-lib relies on [rippled APIs](https://ripple.com/build/rippled-apis/) for online functionality. In addition to ripple-lib's own methods, you can also 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://developers.ripple.com/basic-data-types.html#specifying-currency-amounts).
 * [Specify timestamps as the number of seconds since the "Ripple Epoch"](https://developers.ripple.com/basic-data-types.html#specifying-time).
 * Instead of `counterparty`, use `issuer`.
--- a/docs/src/sign.md.ejs
+++ b/docs/src/sign.md.ejs
@@ -15,6 +15,8 @@ This method can sign any of [the transaction types supported by ripple-binary-co

 <%- renderSchema("input/sign.json") %>

+When this method is used for multisigning, the `options` parameter is required. See the multisigning example in this section for more details.
+
 ### Return Value

 This method returns an object with the following structure:
@@ -31,3 +33,91 @@ return api.sign(txJSON, secret); // or: api.sign(txJSON, keypair);
 ```

 <%- renderFixture("responses/sign.json") %>
+
+### Example (multisigning)
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI;
+
+// jon's address will have a multi-signing setup with a quorum of 2
+const jon = {
+    account: 'rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj',
+    secret: 'sh4Va7b1wQof8knHFV2sxwX12fSgK'
+};
+const aya = {
+    account: 'rnrPdBjs98fFFfmRpL6hM7exT788SWQPFN',
+    secret: 'snaMuMrXeVc2Vd4NYvHofeGNjgYoe'
+};
+const bran = {
+    account: 'rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH',
+    secret: 'shQtQ8Um5MS218yvEU3Ehy1eZQKqH'
+};
+
+// Setup the signers list with a quorum of 2
+const multiSignSetupTransaction = {
+    "Flags": 0,
+    "TransactionType": "SignerListSet",
+    "Account": "rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj",
+    "Fee": "120",
+    "SignerQuorum": 2,
+    "SignerEntries": [
+        {
+            "SignerEntry": {
+                "Account": "rnrPdBjs98fFFfmRpL6hM7exT788SWQPFN",
+                "SignerWeight": 2
+            }
+        },
+        {
+            "SignerEntry": {
+                "Account": "rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH",
+                "SignerWeight": 1
+            }
+        },
+    ]
+};
+
+// a transaction which requires multi signing
+const multiSignPaymentTransaction = {
+    TransactionType: 'Payment',
+    Account: 'rJKpme4m2zBQceBuU89d7vLMzgoUw2Ptj',
+    Destination: 'rJ93RLnT1t5A8fCr7HTScw7WtfKJMRXodH',
+    Amount: '88000000'
+};
+
+const api = new RippleAPI({
+    server: 'wss://s.altnet.rippletest.net:51233'
+});
+
+api.connect().then(() => {
+    // adding the multi signing feature to jon's account
+    api.prepareTransaction(multiSignSetupTransaction).then((prepared) => {
+        console.log(prepared);
+        jonSign = api.sign(prepared.txJSON, jon.secret).signedTransaction;
+        api.submit(jonSign).then( response => {
+            console.log(response.resultCode, response.resultMessage);
+
+            // multi sign a transaction
+            api.prepareTransaction(multiSignPaymentTransaction).then(prepared => {
+                console.log(prepared);
+
+                // Aya and Bran sign it too but with 'signAs' set to their own account
+                let ayaSign = api.sign(prepared.txJSON, aya.secret, {'signAs': aya.account}).signedTransaction;
+                let branSign = api.sign(prepared.txJSON, bran.secret, {'signAs': bran.account}).signedTransaction;
+
+                // signatures are combined and submitted
+                let combinedTx = api.combine([ayaSign, branSign]);
+                api.submit(combinedTx.signedTransaction).then(response => {
+                    console.log(response.tx_json.hash);
+                    return api.disconnect();
+                }).catch(console.error);
+            }).catch(console.error);
+        }).catch(console.error)
+    }).catch(console.error);
+}).catch(console.error);
+```
+
+Assuming the multisigning account was setup properly, the above example will respond with `resultCode: 'tesSUCCESS'` and the hash for the transaction.
+If any of `{signAs: some_address}` options were missing the code will return a validation error as follow:
+```
+[ValidationError(txJSON is not the same for all signedTransactions)]
+```
--- a/package.json
+++ b/package.json
@@ -1,11 +1,11 @@
 {
  "name": "ripple-lib",
-  "version": "1.3.0",
+  "version": "1.5.0",
  "license": "ISC",
-  "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
+  "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
  "files": [
    "dist/npm/*",
-    "build/*"
+    "build/ripple-latest-min.js"
  ],
  "main": "dist/npm/",
  "types": "dist/npm/index.d.ts",
@@ -18,50 +18,52 @@
  },
  "dependencies": {
    "@types/lodash": "^4.14.136",
-    "@types/ws": "^3.2.0",
-    "bignumber.js": "^4.1.0",
-    "https-proxy-agent": "2.2.1",
+    "@types/ws": "^6.0.3",
+    "bignumber.js": "^9.0.0",
+    "https-proxy-agent": "^3.0.0",
    "jsonschema": "1.2.2",
    "lodash": "^4.17.4",
-    "ripple-address-codec": "^2.0.1",
-    "ripple-binary-codec": "0.2.2",
-    "ripple-hashes": "0.3.2",
-    "ripple-keypairs": "^0.10.1",
-    "ripple-lib-transactionparser": "0.7.1",
-    "ws": "^3.3.1"
+    "lodash.isequal": "^4.5.0",
+    "ripple-address-codec": "^4.0.0",
+    "ripple-binary-codec": "^0.2.5",
+    "ripple-keypairs": "^0.11.0",
+    "ripple-lib-transactionparser": "0.8.1",
+    "ws": "^7.2.0"
  },
  "devDependencies": {
-    "@types/node": "11.13.0",
-    "assert-diff": "^1.0.1",
+    "@types/mocha": "^5.2.7",
+    "@types/node": "^12.12.5",
+    "@typescript-eslint/eslint-plugin": "^2.3.3",
+    "@typescript-eslint/parser": "^2.3.3",
+    "assert-diff": "^2.0.3",
    "doctoc": "^0.15.0",
    "ejs": "^2.3.4",
-    "eventemitter2": "^0.4.14",
-    "gulp": "^4.0.2",
-    "json-loader": "^0.5.2",
+    "eslint": "^6.5.1",
+    "eventemitter2": "^5.0.1",
    "json-schema-to-markdown-table": "^0.4.0",
-    "mocha": "6.1.3",
+    "mocha": "6.2.0",
    "mocha-junit-reporter": "^1.9.1",
-    "null-loader": "^0.1.1",
    "nyc": "^14.1.1",
-    "source-map-support": "0.5.12",
-    "ts-loader": "^3.2.0",
-    "ts-node": "8.0.3",
-    "tslint": "^5.8.0",
-    "tslint-eslint-rules": "^4.1.1",
-    "typescript": "3.4.2",
-    "uglifyjs-webpack-plugin": "^1.1.4",
-    "webpack": "3.12.0"
+    "ts-node": "^8.4.1",
+    "typescript": "^3.6.4",
+    "webpack": "^4.41.2",
+    "webpack-bundle-analyzer": "^3.6.0",
+    "webpack-cli": "^3.3.9"
  },
  "scripts": {
-    "build": "gulp",
+    "build:schemas": "mkdir -p dist/npm/common && cp -r src/common/schemas dist/npm/common/",
+    "build:lib": "tsc --build",
+    "build:web": "webpack",
+    "build": "yarn build:schemas && yarn build:lib && yarn build:web",
+    "analyze": "yarn build:web --analyze",
+    "watch": "yarn build:lib --watch",
+    "clean": "rm -rf dist/npm",
    "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/js && cp -r src/common/js/ dist/npm/common/js/ && mkdir -p dist/npm/common && cp -r src/common/schemas dist/npm/common/ && tsc --build",
-    "watch": "tsc -w",
-    "prepublish": "npm run clean && npm run compile && npm run build",
+    "prepublish": "yarn clean && yarn build",
    "test": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha --exit",
-    "lint": "tslint -p ./",
+    "test:watch": "TS_NODE_PROJECT=src/tsconfig.json mocha --watch --reporter dot",
+    "lint": "eslint src/**/*.ts 'test/*-test.{ts,js}'",
    "perf": "./scripts/perf_test.sh",
    "start": "node scripts/http.js"
  },
@@ -71,6 +73,7 @@
  },
  "readmeFilename": "README.md",
  "engines": {
-    "node": ">=6.12.3"
+    "node": ">=8",
+    "yarn": "^1.15.2"
  }
 }
--- a/src/api.ts
+++ b/src/api.ts
@@ -5,8 +5,10 @@ import {
  validate,
  xrpToDrops,
  dropsToXrp,
+  rippleTimeToISO8601,
  iso8601ToRippleTime,
-  txFlags
+  txFlags,
+  ensureClassicAddress
 } from './common'
 import {
  connect,
@@ -45,8 +47,8 @@ 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 {deriveKeypair, deriveAddress} from './offline/derive'
+import {generateAddressAPI, GenerateAddressOptions, GeneratedAddress} from './offline/generate-address'
+import {deriveKeypair, deriveAddress, deriveXAddress} from './offline/derive'
 import computeLedgerHash from './offline/ledgerhash'
 import signPaymentChannelClaim from './offline/sign-payment-channel-claim'
 import verifyPaymentChannelClaim from './offline/verify-payment-channel-claim'
@@ -60,8 +62,9 @@ import {
  BookOffersRequest, BookOffersResponse,
  GatewayBalancesRequest, GatewayBalancesResponse,
  LedgerRequest, LedgerResponse,
+  LedgerDataRequest, LedgerDataResponse,
  LedgerEntryRequest, LedgerEntryResponse,
-  ServerInfoRequest, ServerInfoResponse
+  ServerInfoRequest, ServerInfoResponse,
 } from './common/types/commands'


@@ -73,6 +76,7 @@ import {getServerInfo, getFee} from './common/serverinfo'
 import {clamp, renameCounterpartyToIssuer} from './ledger/utils'
 import {TransactionJSON, Instructions, Prepare} from './transaction/types'
 import {ConnectionOptions} from './common/connection'
+import {isValidXAddress, isValidClassicAddress} from 'ripple-address-codec'

 export interface APIOptions extends ConnectionOptions {
  server?: string,
@@ -137,7 +141,14 @@ class RippleAPI extends EventEmitter {
        this.emit('connected')
      })
      this.connection.on('disconnected', code => {
-        this.emit('disconnected', code)
+        let finalCode = code;
+        // This is a backwards-compatible fix for this change in the ws library: 
+        //   https://github.com/websockets/ws/issues/1257
+        // TODO: Remove in next major, breaking version
+        if (finalCode === 1005) {
+          finalCode = 1000;
+        }
+        this.emit('disconnected', finalCode)
      })
    } else {
      // use null object pattern to provide better error message if user
@@ -165,6 +176,8 @@ class RippleAPI extends EventEmitter {
    Promise<GatewayBalancesResponse>
  async request(command: 'ledger', params: LedgerRequest):
    Promise<LedgerResponse>
+    async request(command: 'ledger_data', params?: LedgerDataRequest):
+      Promise<LedgerDataResponse>
  async request(command: 'ledger_entry', params: LedgerEntryRequest):
    Promise<LedgerEntryResponse>
  async request(command: 'server_info', params?: ServerInfoRequest):
@@ -174,7 +187,8 @@ class RippleAPI extends EventEmitter {
  async request(command: string, params: any = {}): Promise<any> {
    return this.connection.request({
      ...params,
-      command
+      command,
+      account: params.account ? ensureClassicAddress(params.account) : undefined
    })
  }

@@ -194,7 +208,7 @@ class RippleAPI extends EventEmitter {
    command: string,
    params: object = {},
    currentResponse: T
-  ): Promise<object> {
+  ): Promise<T> {
    if (!currentResponse.marker) {
      return Promise.reject(
        new errors.NotFoundError('response does not have a next page')
@@ -287,6 +301,15 @@ class RippleAPI extends EventEmitter {
    return results
  }

+  // @deprecated Use X-addresses instead
+  generateAddress(options: GenerateAddressOptions = {}): GeneratedAddress {
+    return generateAddressAPI({...options, includeClassicAddress: true})
+  }
+
+  generateXAddress(options: GenerateAddressOptions = {}): GeneratedAddress {
+    return generateAddressAPI(options)
+  }
+
  connect = connect
  disconnect = disconnect
  isConnected = isConnected
@@ -327,7 +350,6 @@ class RippleAPI extends EventEmitter {
  combine = combine
  submit = submit

-  generateAddress = generateAddressAPI
  deriveKeypair = deriveKeypair
  deriveAddress = deriveAddress
  computeLedgerHash = computeLedgerHash
@@ -335,8 +357,17 @@ class RippleAPI extends EventEmitter {
  verifyPaymentChannelClaim = verifyPaymentChannelClaim
  errors = errors

+  static deriveXAddress = deriveXAddress
+
+  // RippleAPI.deriveClassicAddress (static) is a new name for api.deriveAddress
+  static deriveClassicAddress = deriveAddress
+
+  static isValidXAddress = isValidXAddress
+  static isValidClassicAddress = isValidClassicAddress
+
  xrpToDrops = xrpToDrops
  dropsToXrp = dropsToXrp
+  rippleTimeToISO8601 = rippleTimeToISO8601
  iso8601ToRippleTime = iso8601ToRippleTime
  txFlags = txFlags

--- a/src/broadcast.ts
+++ b/src/broadcast.ts
@@ -1,13 +1,13 @@

 import * as _ from 'lodash'
-import {RippleAPI} from './api'
+import {RippleAPI, APIOptions} from './api'

 class RippleAPIBroadcast extends RippleAPI {

  ledgerVersion: number | undefined = undefined
  private _apis: RippleAPI[]

-  constructor(servers, options) {
+  constructor(servers, options: APIOptions = {}) {
    super(options)

    const apis: RippleAPI[] = servers.map(server => new RippleAPI(
--- a/src/common/browser-hacks.ts
+++ b/src/common/browser-hacks.ts
@@ -7,11 +7,14 @@ function setPrototypeOf(object, prototype) {
 }

 function getConstructorName(object: object): string {
-  // hack for internet explorer
-  if (!object.constructor.name) {
-    return object.constructor.toString().match(/^function\s+([^(]*)/)![1]
+  if (object.constructor.name) {
+    return object.constructor.name
  }
-  return object.constructor.name
+  // try to guess it on legacy browsers (ie)
+  const constructorString = object.constructor.toString()
+  const functionConstructor = constructorString.match(/^function\s+([^(]*)/)
+  const classConstructor = constructorString.match(/^class\s([^\s]*)/)
+  return functionConstructor ? functionConstructor[1] : classConstructor[1]
 }

 export {
--- a/src/common/connection.ts
+++ b/src/common/connection.ts
@@ -1,14 +1,14 @@
 import * as _ from 'lodash'
 import {EventEmitter} from 'events'
 import {parse as parseUrl} from 'url'
-import * as WebSocket from 'ws'
+import WebSocket from 'ws'
 import RangeSet from './rangeset'
 import {RippledError, DisconnectedError, NotConnectedError,
  TimeoutError, ResponseFormatError, ConnectionError,
  RippledNotInitializedError} from './errors'

 export interface ConnectionOptions {
-  trace?: boolean,
+  trace?: boolean
  proxy?: string
  proxyAuthorization?: string
  authorization?: string
@@ -16,7 +16,8 @@ export interface ConnectionOptions {
  key?: string
  passphrase?: string
  certificate?: string
-  timeout?: number
+  timeout?: number,
+  connectionTimeout?: number
 }

 class Connection extends EventEmitter {
@@ -38,11 +39,14 @@ class Connection extends EventEmitter {
  private _availableLedgerVersions = new RangeSet()
  private _nextRequestID: number = 1
  private _retry: number = 0
-  private _retryTimer: null|NodeJS.Timer = null
+  private _connectTimer: null|NodeJS.Timeout = null
+  private _retryTimer: null|NodeJS.Timeout = null
+  private _heartbeatInterval: null|NodeJS.Timeout = 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
+  private _connectionTimeout: number

  constructor(url, options: ConnectionOptions = {}) {
    super()
@@ -61,6 +65,7 @@ class Connection extends EventEmitter {
    this._passphrase = options.passphrase
    this._certificate = options.certificate
    this._timeout = options.timeout || (20 * 1000)
+    this._connectionTimeout = options.connectionTimeout || 2000
  }

  _updateLedgerVersions(data) {
@@ -179,6 +184,13 @@ class Connection extends EventEmitter {
    }
  }

+  _clearConnectTimer() {
+    if (this._connectTimer !== null) {
+      clearTimeout(this._connectTimer)
+      this._connectTimer = null
+    }
+  }
+
  _onOpen() {
    if (!this._ws) {
      return Promise.reject(new DisconnectedError())
@@ -282,16 +294,26 @@ class Connection extends EventEmitter {
  }

  connect(): Promise<void> {
+    this._clearConnectTimer()
    this._clearReconnectTimer()
-    return new Promise((resolve, reject) => {
+    this._clearHeartbeatInterval()
+    return new Promise<void>((_resolve, reject) => {
+      this._connectTimer = setTimeout(() => {
+          reject(new ConnectionError(`Error: connect() timed out after ${this._connectionTimeout} ms. ` +
+          `If your internet connection is working, the rippled server may be blocked or inaccessible.`))
+      }, this._connectionTimeout)
      if (!this._url) {
        reject(new ConnectionError(
          'Cannot connect because no server was specified'))
      }
+      const resolve = () => {
+        this._startHeartbeatInterval();
+        _resolve();
+      }
      if (this._state === WebSocket.OPEN) {
        resolve()
      } else if (this._state === WebSocket.CONNECTING) {
-        this._ws.once('open', resolve)
+        this._ws.once('open', () => resolve)
      } else {
        this._ws = this._createWebSocket()
        // when an error causes the connection to close, the close event
@@ -311,9 +333,20 @@ class Connection extends EventEmitter {
        this._onUnexpectedCloseBound = this._onUnexpectedClose.bind(this, true,
          resolve, reject)
        this._ws.once('close', this._onUnexpectedCloseBound)
-        this._ws.once('open', () => this._onOpen().then(resolve, reject))
+        this._ws.once('open', () => {
+          return this._onOpen().then(resolve, reject)
+        })
      }
    })
+    // Once we have a resolution or rejection, clear the timeout timer as no 
+    // longer needed.
+    .then(() => {
+      this._clearConnectTimer()
+    })
+    .catch((err) => {
+      this._clearConnectTimer()
+      throw err;
+    })
  }

  disconnect(): Promise<void> {
@@ -321,7 +354,9 @@ class Connection extends EventEmitter {
  }

  _disconnect(calledByUser): Promise<void> {
+    this._clearHeartbeatInterval()
    if (calledByUser) {
+      this._clearConnectTimer()
      this._clearReconnectTimer()
      this._retry = 0
    }
@@ -349,11 +384,34 @@ class Connection extends EventEmitter {
  }

  reconnect() {
+    // NOTE: We currently have a "reconnecting" event, but that only triggers through
+    // _retryConnect, which was written in a way that is required to run as an internal 
+    // part of the post-disconnect connect() flow.
+    // See: https://github.com/ripple/ripple-lib/pull/1101#issuecomment-565360423
+    this.emit('reconnect');
    return this.disconnect().then(() => this.connect())
  }

+  private _clearHeartbeatInterval = () => {
+    clearInterval(this._heartbeatInterval);
+  }
+
+  private _startHeartbeatInterval = () => {
+    this._clearHeartbeatInterval()
+    this._heartbeatInterval = setInterval(() => this._heartbeat(), 1000 * 60);
+  }
+
+  /**
+   * A heartbeat is just a "ping" command, sent on an interval.
+   * If this succeeds, we're good. If it fails, disconnect so that the consumer can reconnect, if desired.
+   */
+  private _heartbeat = () => {
+    return this.request({command: "ping"}).catch(() => this.reconnect());
+  }
+
  _whenReady<T>(promise: Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
+      promise.catch(reject);
      if (!this._shouldBeConnected) {
        reject(new NotConnectedError())
      } else if (this._state === WebSocket.OPEN && this._isReady) {
@@ -456,6 +514,10 @@ class Connection extends EventEmitter {
      this._whenReady(this._send(message)).then(() => {
        const delay = timeout || this._timeout
        timer = setTimeout(() => _reject(new TimeoutError()), delay)
+        // Node.js won't exit if a timer is still running, so we tell Node to ignore (Node will still wait for the request to complete)
+        if (timer.unref) {
+          timer.unref()
+        }
      }).catch(_reject)
    })
  }
--- a/src/common/constants.ts
+++ b/src/common/constants.ts
@@ -74,10 +74,12 @@ const AccountFlagIndices = {

 const AccountFields = {
  EmailHash: {name: 'emailHash', encoding: 'hex',
-    length: 32, defaults: '0'},
+    length: 32, defaults: '00000000000000000000000000000000'},
+  WalletLocator: {name: 'walletLocator'},
  MessageKey: {name: 'messageKey'},
  Domain: {name: 'domain', encoding: 'hex'},
-  TransferRate: {name: 'transferRate', defaults: 0, shift: 9}
+  TransferRate: {name: 'transferRate', defaults: 0, shift: 9},
+  TickSize: {name: 'tickSize', defaults: 0}
 }

 export {
--- a/src/common/hashes/README.md
+++ b/src/common/hashes/README.md
@@ -0,0 +1,49 @@
+# XRP Ledger Hashes
+
+Methods to hash XRP Ledger objects
+
+## Methods
+
+### computeBinaryTransactionHash = (txBlobHex: string): string
+
+Compute the hash of a binary transaction blob.
+
+### computeTransactionHash = (txJSON: any): string
+
+Compute the hash of a transaction in txJSON format.
+
+### computeBinaryTransactionSigningHash = (txBlobHex: string): string
+
+### computeTransactionSigningHash = (txJSON: any): string
+
+### computeAccountHash = (address: string): string
+
+Compute the hash of an account, given the account's classic address (starting with `r`).
+
+### computeSignerListHash = (address: string): string
+
+Compute the hash of an account's SignerList.
+
+### computeOrderHash = (address: string, sequence: number): string
+
+Compute the hash of an order, given the owner's classic address (starting with `r`) and the account sequence number of the `OfferCreate` order transaction.
+
+### computeTrustlineHash = (address1: string, address2: string, currency: string): string
+
+Compute the hash of a trustline, given the two parties' classic addresses (starting with `r`) and the currency code.
+
+### computeTransactionTreeHash = (transactions: any[]): string
+
+### computeStateTreeHash = (entries: any[]): string
+
+### computeLedgerHash = (ledgerHeader): string
+
+Compute the hash of a ledger.
+
+### computeEscrowHash = (address, sequence): string
+
+Compute the hash of an escrow, given the owner's classic address (starting with `r`) and the account sequence number of the `EscrowCreate` escrow transaction.
+
+### computePaymentChannelHash = (address, dstAddress, sequence): string
+
+Compute the hash of a payment channel, given the owner's classic address (starting with `r`), the classic address of the destination, and the account sequence number of the `PaymentChannelCreate` payment channel transaction.
--- a/src/common/hashes/hash-prefix.ts
+++ b/src/common/hashes/hash-prefix.ts
@@ -0,0 +1,40 @@
+/**
+ * Prefix for hashing functions.
+ *
+ * These prefixes are inserted before the source material used to
+ * generate various hashes. This is done to put each hash in its own
+ * "space." This way, two different types of objects with the
+ * same binary data will produce different hashes.
+ *
+ * Each prefix is a 4-byte value with the last byte set to zero
+ * and the first three bytes formed from the ASCII equivalent of
+ * some arbitrary string. For example "TXN".
+ */
+
+ enum HashPrefix {
+  // transaction plus signature to give transaction ID
+  TRANSACTION_ID = 0x54584E00, // 'TXN'
+
+  // transaction plus metadata
+  TRANSACTION_NODE = 0x534E4400, // 'TND'
+
+  // inner node in tree
+  INNER_NODE = 0x4D494E00, // 'MIN'
+
+  // leaf node in tree
+  LEAF_NODE = 0x4D4C4E00, // 'MLN'
+
+  // inner transaction to sign
+  TRANSACTION_SIGN = 0x53545800, // 'STX'
+
+  // inner transaction to sign (TESTNET)
+  TRANSACTION_SIGN_TESTNET = 0x73747800, // 'stx'
+
+  // inner transaction to multisign
+  TRANSACTION_MULTISIGN = 0x534D5400, // 'SMT'
+
+  // ledger
+  LEDGER = 0x4C575200 // 'LWR'
+}
+
+export default HashPrefix
--- a/src/common/hashes/index.ts
+++ b/src/common/hashes/index.ts
@@ -0,0 +1,155 @@
+import BigNumber from 'bignumber.js'
+import {decodeAccountID} from 'ripple-address-codec'
+import sha512Half from './sha512Half'
+import HashPrefix from './hash-prefix'
+import {SHAMap, NodeType} from './shamap'
+import {encode} from 'ripple-binary-codec'
+import ledgerspaces from './ledgerspaces'
+
+const padLeftZero = (string: string, length: number): string => {
+  return Array(length - string.length + 1).join('0') + string
+}
+
+const intToHex = (integer: number, byteLength: number): string => {
+  return padLeftZero(Number(integer).toString(16), byteLength * 2)
+}
+
+const bytesToHex = (bytes: number[]): string => {
+  return Buffer.from(bytes).toString('hex')
+}
+
+const bigintToHex = (integerString: string | number | BigNumber, byteLength: number): string => {
+  const hex = (new BigNumber(integerString)).toString(16)
+  return padLeftZero(hex, byteLength * 2)
+}
+
+const ledgerSpaceHex = (name: string): string => {
+  return intToHex(ledgerspaces[name].charCodeAt(0), 2)
+}
+
+const addressToHex = (address: string): string => {
+  return (Buffer.from(decodeAccountID(address))).toString('hex')
+}
+
+const currencyToHex = (currency: string): string => {
+  if (currency.length === 3) {
+    const bytes = new Array(20 + 1).join('0').split('').map(parseFloat)
+    bytes[12] = currency.charCodeAt(0) & 0xff
+    bytes[13] = currency.charCodeAt(1) & 0xff
+    bytes[14] = currency.charCodeAt(2) & 0xff
+    return bytesToHex(bytes)
+  }
+  return currency
+}
+
+const addLengthPrefix = (hex: string): string => {
+  const length = hex.length / 2
+  if (length <= 192) {
+    return bytesToHex([length]) + hex
+  } else if (length <= 12480) {
+    const x = length - 193
+    return bytesToHex([193 + (x >>> 8), x & 0xff]) + hex
+  } else if (length <= 918744) {
+    const x = length - 12481
+    return bytesToHex([241 + (x >>> 16), x >>> 8 & 0xff, x & 0xff]) + hex
+  }
+  throw new Error('Variable integer overflow.')
+}
+
+export const computeBinaryTransactionHash = (txBlobHex: string): string => {
+  const prefix = HashPrefix.TRANSACTION_ID.toString(16).toUpperCase()
+  return sha512Half(prefix + txBlobHex)
+}
+
+export const computeTransactionHash = (txJSON: any): string => {
+  return computeBinaryTransactionHash(encode(txJSON))
+}
+
+export const computeBinaryTransactionSigningHash = (txBlobHex: string): string => {
+  const prefix = HashPrefix.TRANSACTION_SIGN.toString(16).toUpperCase()
+  return sha512Half(prefix + txBlobHex)
+}
+
+export const computeTransactionSigningHash = (txJSON: any): string => {
+  return computeBinaryTransactionSigningHash(encode(txJSON))
+}
+
+export const computeAccountHash = (address: string): string => {
+  return sha512Half(ledgerSpaceHex('account') + addressToHex(address))
+}
+
+export const computeSignerListHash = (address: string): string => {
+  return sha512Half(ledgerSpaceHex('signerList') +
+              addressToHex(address) +
+              '00000000') // uint32(0) signer list index
+}
+
+export const computeOrderHash = (address: string, sequence: number): string => {
+  const prefix = '00' + intToHex(ledgerspaces.offer.charCodeAt(0), 1)
+  return sha512Half(prefix + addressToHex(address) + intToHex(sequence, 4))
+}
+
+export const computeTrustlineHash = (address1: string, address2: string, currency: string): string => {
+  const address1Hex = addressToHex(address1)
+  const address2Hex = addressToHex(address2)
+
+  const swap = (new BigNumber(address1Hex, 16)).isGreaterThan(
+    new BigNumber(address2Hex, 16))
+  const lowAddressHex = swap ? address2Hex : address1Hex
+  const highAddressHex = swap ? address1Hex : address2Hex
+
+  const prefix = ledgerSpaceHex('rippleState')
+  return sha512Half(prefix + lowAddressHex + highAddressHex +
+              currencyToHex(currency))
+}
+
+export const computeTransactionTreeHash = (transactions: any[]): string => {
+  const shamap = new SHAMap()
+
+  transactions.forEach(txJSON => {
+    const txBlobHex = encode(txJSON)
+    const metaHex = encode(txJSON.metaData)
+    const txHash = computeBinaryTransactionHash(txBlobHex)
+    const data = addLengthPrefix(txBlobHex) + addLengthPrefix(metaHex)
+    shamap.addItem(txHash, data, NodeType.TRANSACTION_METADATA)
+  })
+
+  return shamap.hash
+}
+
+export const computeStateTreeHash = (entries: any[]): string => {
+  const shamap = new SHAMap()
+
+  entries.forEach(ledgerEntry => {
+    const data = encode(ledgerEntry)
+    shamap.addItem(ledgerEntry.index, data, NodeType.ACCOUNT_STATE)
+  })
+
+  return shamap.hash
+}
+
+// see rippled Ledger::updateHash()
+export const computeLedgerHash = (ledgerHeader): string => {
+  const prefix = HashPrefix.LEDGER.toString(16).toUpperCase()
+  return sha512Half(prefix +
+    intToHex(ledgerHeader.ledger_index, 4) +
+    bigintToHex(ledgerHeader.total_coins, 8) +
+    ledgerHeader.parent_hash +
+    ledgerHeader.transaction_hash +
+    ledgerHeader.account_hash +
+    intToHex(ledgerHeader.parent_close_time, 4) +
+    intToHex(ledgerHeader.close_time, 4) +
+    intToHex(ledgerHeader.close_time_resolution, 1) +
+    intToHex(ledgerHeader.close_flags, 1)
+  )
+}
+
+export const computeEscrowHash = (address, sequence): string => {
+  return sha512Half(ledgerSpaceHex('escrow') + addressToHex(address) +
+    intToHex(sequence, 4))
+}
+
+export const computePaymentChannelHash = (address, dstAddress, sequence): string => {
+  return sha512Half(ledgerSpaceHex('paychan') + addressToHex(address) +
+    addressToHex(dstAddress) + intToHex(sequence, 4))
+}
--- a/src/common/hashes/ledgerspaces.ts
+++ b/src/common/hashes/ledgerspaces.ts
@@ -0,0 +1,25 @@
+
+/**
+ * Ripple ledger namespace prefixes.
+ *
+ * The Ripple ledger is a key-value store. In order to avoid name collisions,
+ * names are partitioned into namespaces.
+ *
+ * Each namespace is just a single character prefix.
+ */
+export default {
+  account        : 'a',
+  dirNode        : 'd',
+  generatorMap   : 'g',
+  rippleState    : 'r',
+  offer          : 'o',  // Entry for an offer.
+  ownerDir       : 'O',  // Directory of things owned by an account.
+  bookDir        : 'B',  // Directory of order books.
+  contract       : 'c',
+  skipList       : 's',
+  amendment      : 'f',
+  feeSettings    : 'e',
+  signerList     : 'S',
+  escrow         : 'u',
+  paychan        : 'x'
+}
--- a/src/common/hashes/sha512Half.ts
+++ b/src/common/hashes/sha512Half.ts
@@ -0,0 +1,7 @@
+import {createHash} from 'crypto'
+
+const sha512Half = (hex: string): string => {
+  return createHash('sha512').update(Buffer.from(hex, 'hex')).digest('hex').toUpperCase().slice(0, 64)
+}
+
+export default sha512Half
--- a/src/common/hashes/shamap.ts
+++ b/src/common/hashes/shamap.ts
@@ -0,0 +1,173 @@
+import hashPrefix from './hash-prefix'
+import sha512Half from './sha512Half'
+const HEX_ZERO = '0000000000000000000000000000000000000000000000000000000000000000'
+
+export enum NodeType {
+  INNER = 1,
+  TRANSACTION_NO_METADATA = 2,
+  TRANSACTION_METADATA = 3,
+  ACCOUNT_STATE = 4
+}
+
+export abstract class Node {
+  /**
+   * Abstract constructor representing a node in a SHAMap tree.
+   * Can be either InnerNode or Leaf.
+   * @constructor
+   */
+  public constructor() {}
+
+  public addItem(_tag: string, _node: Node): void {
+    throw new Error('Called unimplemented virtual method SHAMapTreeNode#addItem.')
+  }
+  public get hash(): string|void {
+    throw new Error('Called unimplemented virtual method SHAMapTreeNode#hash.');
+  }
+}
+
+export class InnerNode extends Node {
+  public leaves: { [slot: number]: Node }
+  public type: NodeType
+  public depth: number
+  public empty: boolean
+
+  /**
+   * Define an Inner (non-leaf) node in a SHAMap tree.
+   * @param {number} depth i.e. how many parent inner nodes
+   * @constructor
+   */
+  public constructor(depth: number = 0) {
+    super()
+    this.leaves = {}
+    this.type = NodeType.INNER
+    this.depth = depth
+    this.empty = true
+  }
+
+  /**
+   * @param {string} tag equates to a ledger entry `index`
+   * @param {Node} node to add
+   * @return {void}
+   */  
+  public addItem(tag: string, node: Node): void {
+    const existingNode = this.getNode(parseInt(tag[this.depth],16))
+    if (existingNode) {
+      // A node already exists in this slot
+      if (existingNode instanceof InnerNode) {
+        // There is an inner node, so we need to go deeper
+        existingNode.addItem(tag, node)
+      } else if (existingNode instanceof Leaf) {
+        if (existingNode.tag === tag) {
+          // Collision
+          throw new Error(
+              'Tried to add a node to a SHAMap that was already in there.')
+        } else {
+          // Turn it into an inner node
+          const newInnerNode = new InnerNode(this.depth + 1)
+    
+          // Parent new and existing node
+          newInnerNode.addItem(existingNode.tag, existingNode)
+          newInnerNode.addItem(tag, node)
+    
+          // And place the newly created inner node in the slot
+          this.setNode(parseInt(tag[this.depth], 16), newInnerNode)
+        }
+      }
+    } else {
+      // Neat, we have a nice open spot for the new node
+      this.setNode(parseInt(tag[this.depth], 16), node)
+    }
+  }
+
+  /**
+   * Overwrite the node that is currently in a given slot.
+   * @param {number} slot a number 0-15
+   * @param {Node} node to place
+   * @return {void}
+   */
+  public setNode(slot: number, node: Node): void {
+    if (slot < 0 || slot > 15) {
+      throw new Error ('Invalid slot: slot must be between 0-15.')
+    }
+    this.leaves[slot] = node
+    this.empty = false
+  }
+
+  /**
+   * Get the node that is currently in a given slot.
+   * @param {number} slot a number 0-15
+   * @return {Node}
+   */
+  public getNode(slot: number): Node {
+    if (slot < 0 || slot > 15) {
+      throw new Error ('Invalid slot: slot must be between 0-15.')
+    }    
+    return this.leaves[slot]
+  }
+
+  public get hash(): string {
+    if (this.empty) return HEX_ZERO
+    let hex = ''
+    for (let i = 0; i < 16; i++) {
+      hex += this.leaves[i] ? this.leaves[i].hash : HEX_ZERO
+    }
+    const prefix = hashPrefix.INNER_NODE.toString(16)
+    return sha512Half(prefix + hex)
+  } 
+}
+
+export class Leaf extends Node {
+  public tag: string
+  public type: NodeType
+  public data: string
+
+  /**
+   * Leaf node in a SHAMap tree.
+   * @param {string} tag equates to a ledger entry `index`
+   * @param {string} data hex of account state, transaction etc
+   * @param {number} type one of TYPE_ACCOUNT_STATE, TYPE_TRANSACTION_MD etc
+   * @constructor
+   */
+  public constructor(tag: string, data: string, type: NodeType) {
+    super()
+    this.tag = tag
+    this.type = type
+    this.data = data
+  }
+
+  public get hash(): string|void {
+    switch (this.type) {
+      case NodeType.ACCOUNT_STATE:
+        const leafPrefix = hashPrefix.LEAF_NODE.toString(16)
+        return sha512Half(leafPrefix + this.data + this.tag)
+      case NodeType.TRANSACTION_NO_METADATA:
+        const txIDPrefix = hashPrefix.TRANSACTION_ID.toString(16)
+        return sha512Half(txIDPrefix + this.data)
+      case NodeType.TRANSACTION_METADATA:
+        const txNodePrefix = hashPrefix.TRANSACTION_NODE.toString(16)
+        return sha512Half(txNodePrefix + this.data + this.tag)
+      default:
+        throw new Error('Tried to hash a SHAMap node of unknown type.')
+    }
+  }  
+}
+
+export class SHAMap {
+  public root: InnerNode
+
+  /**
+   * SHAMap tree.
+   * @constructor
+   */
+  public constructor() {
+    this.root = new InnerNode(0)
+  }
+
+  public addItem(tag: string, data: string, type: NodeType): void {
+    this.root.addItem(tag, new Leaf(tag, data, type))
+  }
+
+  public get hash(): string {
+    return this.root.hash
+  }
+}
--- a/src/common/index.ts
+++ b/src/common/index.ts
@@ -2,13 +2,35 @@ import * as constants from './constants'
 import * as errors from './errors'
 import * as validate from './validate'
 import * as serverInfo from './serverinfo'
+import {xAddressToClassicAddress, isValidXAddress} from 'ripple-address-codec'
+
+export function ensureClassicAddress(account: string): string {
+  if (isValidXAddress(account)) {
+    const {
+      classicAddress,
+      tag
+    } = xAddressToClassicAddress(account)
+
+    // Except for special cases, X-addresses used for requests
+    // must not have an embedded tag. In other words,
+    // `tag` should be `false`.
+    if (tag !== false) {
+      throw new Error('This command does not support the use of a tag. Use an address without a tag.')
+    }
+
+    // For rippled requests that use an account, always use a classic address.
+    return classicAddress
+  } else {
+    return account
+  }
+}
+
 export {
  constants,
  errors,
  validate,
  serverInfo
 }
-
 export {
  dropsToXrp,
  xrpToDrops,
@@ -20,4 +42,3 @@ export {
 } from './utils'
 export {default as Connection} from './connection'
 export {txFlags} from './txflags'
-
--- a/src/common/js/lodash.isequal.js
+++ b/src/common/js/lodash.isequal.js
--- a/src/common/rangeset.ts
+++ b/src/common/rangeset.ts
@@ -35,7 +35,7 @@ class RangeSet {
  }

  addRange(start: number, end: number) {
-    assert(start <= end, `invalid range ${start} <= ${end}`)
+    assert.ok(start <= end, `invalid range ${start} <= ${end}`)
    this.ranges = mergeIntervals(this.ranges.concat([[start, end]]))
  }

--- a/src/common/schema-validator.ts
+++ b/src/common/schema-validator.ts
@@ -2,7 +2,7 @@ import * as _ from 'lodash'
 import * as assert from 'assert'
 const {Validator} = require('jsonschema')
 import {ValidationError} from './errors'
-import {isValidAddress} from 'ripple-address-codec'
+import {isValidClassicAddress, isValidXAddress} from 'ripple-address-codec'
 import {isValidSecret} from './utils'

 function loadSchemas() {
@@ -34,6 +34,8 @@ function loadSchemas() {
    require('./schemas/objects/destination-address-tag.json'),
    require('./schemas/objects/transaction-hash.json'),
    require('./schemas/objects/address.json'),
+    require('./schemas/objects/x-address.json'),
+    require('./schemas/objects/classic-address.json'),
    require('./schemas/objects/adjustment.json'),
    require('./schemas/objects/quality.json'),
    require('./schemas/objects/amount.json'),
@@ -121,17 +123,28 @@ function loadSchemas() {
  ]
  const titles = schemas.map(schema => schema.title)
  const duplicates = _.keys(_.pickBy(_.countBy(titles), count => count > 1))
-  assert(duplicates.length === 0, 'Duplicate schemas for: ' + duplicates)
+  assert.ok(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) {
+
+  // This relies on "format": "xAddress" in `x-address.json`!
+  validator.customFormats.xAddress = function(instance) {
+    if (instance === undefined) {
+      return true
+    }
+    return isValidXAddress(instance)
+  }
+
+  // This relies on "format": "classicAddress" in `classic-address.json`!
+  validator.customFormats.classicAddress = function(instance) {
    if (instance === undefined) {
      return true
    }
    return isValidAddress(instance)
  }
+
  validator.customFormats.secret = function(instance) {
    if (instance === undefined) {
      return true
@@ -158,6 +171,10 @@ function schemaValidate(schemaName: string, object: any): void {
  }
 }

+function isValidAddress(address: string): boolean {
+  return isValidXAddress(address) || isValidClassicAddress(address)
+}
+
 export {
  schemaValidate,
  isValidSecret,
--- a/src/common/schemas/input/generate-address.json
+++ b/src/common/schemas/input/generate-address.json
@@ -20,6 +20,14 @@
          "type": "string",
          "enum": ["ecdsa-secp256k1", "ed25519"],
          "description": "The digital signature algorithm to generate an address for. Can be `ecdsa-secp256k1` (default) or `ed25519`."
+        },
+        "test": {
+          "type": "boolean",
+          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`."
+        },
+        "includeClassicAddress": {
+          "type": "boolean",
+          "description": "If `true`, return the classic address, in addition to the X-address."
        }
      },
      "additionalProperties": false
--- a/src/common/schemas/input/generate-x-address.json
+++ b/src/common/schemas/input/generate-x-address.json
@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "generateXAddressParameters",
+  "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`."
+        },
+        "test": {
+          "type": "boolean",
+          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`."
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}
--- a/src/common/schemas/objects/address.json
+++ b/src/common/schemas/objects/address.json
@@ -1,9 +1,12 @@
 {
  "$schema": "http://json-schema.org/draft-04/schema#",
  "title": "address",
-  "description": "A Ripple account address",
+  "description": "An account address on the XRP Ledger",
  "type": "string",
  "format": "address",
  "link": "address",
-  "pattern": "^r[1-9A-HJ-NP-Za-km-z]{25,34}$"
+  "oneOf": [
+    {"$ref": "xAddress"},
+    {"$ref": "classicAddress"}
+  ]
 }
--- a/src/common/schemas/objects/classic-address.json
+++ b/src/common/schemas/objects/classic-address.json
@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "classicAddress",
+  "description": "A classic address (Account ID) for the XRP Ledger",
+  "type": "string",
+  "format": "classicAddress",
+  "link": "classic-address",
+  "pattern": "^r[1-9A-HJ-NP-Za-km-z]{24,34}$"
+}
--- a/src/common/schemas/objects/settings-plus-memos.json
+++ b/src/common/schemas/objects/settings-plus-memos.json
@@ -21,7 +21,7 @@
    },
    "domain": {
      "type": "string",
-      "description": " The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase."
+      "description": "The domain that owns this account, as a hexadecimal string representing the ASCII for the domain in lowercase."
    },
    "emailHash": {
      "description": "Hash of an email address to be used for generating an avatar image. Conventionally, clients use Gravatar to display this image. Use `null` to clear.",
@@ -30,6 +30,13 @@
        {"$ref": "hash128"}
      ]
    },
+    "walletLocator": {
+      "description": "Transaction hash or any other 64 character hexadecimal string, that may or may not represent the result of a hash operation. Use `null` to clear.",
+      "oneOf": [
+        {"type": "null"},
+        {"$ref": "hash256"}
+      ]
+    },
    "enableTransactionIDTracking": {
      "type": "boolean",
      "description": "Track the ID of this account’s most recent transaction."
@@ -98,11 +105,15 @@
      "additionalProperties": false
    },
    "transferRate": {
-      "description": " The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.",
+      "description": "The fee to charge when users transfer this account’s issuances, as the decimal amount that must be sent to deliver 1 unit. Has precision up to 9 digits beyond the decimal point. Use `null` to set no fee.",
      "oneOf": [
        {"type": "null"},
        {"type": "number", "minimum": 1, "maximum": 4.294967295}
      ]
+    },
+    "tickSize": {
+      "description": "Tick size to use for offers involving a currency issued by this address. The exchange rates of those offers is rounded to this many significant digits. Valid values are 3 to 15 inclusive, or 0 to disable.",
+      "enum": [0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
    }
  },
  "additionalProperties": false
--- a/src/common/schemas/objects/tag.json
+++ b/src/common/schemas/objects/tag.json
@@ -1,7 +1,7 @@
 {
  "$schema": "http://json-schema.org/draft-04/schema#",
  "title": "tag",
-  "description": "An arbitrary unsigned 32-bit integer that identifies a reason for payment or a non-Ripple account.",
+  "description": "An arbitrary 32-bit unsigned integer. It typically maps to an off-ledger account; for example, a hosted wallet or exchange account.",
  "type": "integer",
  "$ref": "uint32"
 }
--- a/src/common/schemas/objects/x-address.json
+++ b/src/common/schemas/objects/x-address.json
@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "xAddress",
+  "description": "An XRP Ledger address in X-address format",
+  "type": "string",
+  "format": "xAddress",
+  "link": "x-address",
+  "pattern": "^[XT][1-9A-HJ-NP-Za-km-z]{46}$"
+}
--- a/src/common/schemas/output/generate-address.json
+++ b/src/common/schemas/output/generate-address.json
@@ -3,16 +3,24 @@
  "title": "generateAddress",
  "type": "object",
  "properties": {
+    "xAddress": {
+      "$ref": "xAddress",
+      "description": "A randomly generated XRP Ledger address in X-address format."
+    },
+    "classicAddress": {
+      "$ref": "classicAddress",
+      "description": "A randomly generated XRP Ledger Account ID (classic address)."
+    },
    "address": {
-      "$ref": "address",
-      "description": "A randomly generated Ripple account address."
+      "$ref": "classicAddress",
+      "description": "Deprecated: Use `classicAddress` instead."
    },
    "secret": {
      "type": "string",
      "format": "secret",
-      "description": "The secret corresponding to the `address`."
+      "description": "The secret corresponding to the address."
    }
  },
-  "required": ["address", "secret"],
+  "required": ["xAddress", "classicAddress", "address", "secret"],
  "additionalProperties": false
 }
--- a/src/common/schemas/output/generate-x-address.json
+++ b/src/common/schemas/output/generate-x-address.json
@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "generateXAddress",
+  "type": "object",
+  "properties": {
+    "xAddress": {
+      "$ref": "xAddress",
+      "description": "A randomly generated XRP Ledger address in X-address format."
+    },
+    "secret": {
+      "type": "string",
+      "format": "secret",
+      "description": "The secret corresponding to the address."
+    }
+  },
+  "required": ["xAddress", "secret"],
+  "additionalProperties": false
+}
--- a/src/common/serverinfo.ts
+++ b/src/common/serverinfo.ts
@@ -29,7 +29,8 @@ export type GetServerInfoResponse = {
    reserveIncrementXRP: string,
    ledgerVersion: number
  },
-  validationQuorum: number
+  validationQuorum: number,
+  networkLedger?: string
 }

 function renameKeys(object, mapping) {
--- a/src/common/types/commands/index.ts
+++ b/src/common/types/commands/index.ts
@@ -5,5 +5,6 @@ export * from './account_offers'
 export * from './book_offers'
 export * from './gateway_balances'
 export * from './ledger'
+export * from './ledger_data'
 export * from './ledger_entry'
 export * from './server_info'
--- a/src/common/types/commands/ledger_data.ts
+++ b/src/common/types/commands/ledger_data.ts
@@ -0,0 +1,12 @@
+import { LedgerData } from '../objects'
+
+export interface LedgerDataRequest {
+  id?: any
+  ledger_hash?: string
+  ledger_index?: string
+  binary?: boolean
+  limit?: number
+  marker?: string
+}
+
+export type LedgerDataResponse = LedgerData;
--- a/src/common/types/objects/index.ts
+++ b/src/common/types/objects/index.ts
@@ -1,6 +1,7 @@
 export * from './adjustments'
 export * from './amounts'
 export * from './ledger'
+export * from './ledger_data'
 export * from './ledger_entries'
 export * from './memos'
 export * from './orders'
--- a/src/common/types/objects/ledger_data.ts
+++ b/src/common/types/objects/ledger_data.ts
@@ -0,0 +1,6 @@
+export interface LedgerData {
+  ledger_index: string
+  ledger_hash: string
+  marker: string
+  state: ({ data?: string; LedgerEntryType?: string; index: string } & any)[]
+}
--- a/src/common/types/objects/ledger_entries.ts
+++ b/src/common/types/objects/ledger_entries.ts
@@ -17,7 +17,7 @@ export interface AccountRootLedgerEntry {
  RegularKey?: string,
  TickSize?: number,
  TransferRate?: number,
-  WalletLocator?: string, // DEPRECATED
+  WalletLocator?: string,
  WalletSize?: number // DEPRECATED
 }

--- a/src/common/types/objects/settings.ts
+++ b/src/common/types/objects/settings.ts
@@ -17,6 +17,7 @@ export type FormattedSettings = {
  disallowIncomingXRP?: boolean,
  domain?: string,
  emailHash?: string|null,
+  walletLocator?: string|null,
  enableTransactionIDTracking?: boolean,
  globalFreeze?: boolean,
  memos?: Memo[],
@@ -27,5 +28,6 @@ export type FormattedSettings = {
  requireAuthorization?: boolean,
  requireDestinationTag?: boolean,
  signers?: Signers,
-  transferRate?: number|null
+  transferRate?: number|null,
+  tickSize?: number
 }
--- a/src/common/utils.ts
+++ b/src/common/utils.ts
@@ -13,11 +13,11 @@ function isValidSecret(secret: string): boolean {
  }
 }

-function dropsToXrp(drops: string | BigNumber): string {
+function dropsToXrp(drops: BigNumber.Value): string {
  if (typeof drops === 'string') {
    if (!drops.match(/^-?[0-9]*\.?[0-9]*$/)) {
      throw new ValidationError(`dropsToXrp: invalid value '${drops}',` +
-        ` should be a number matching (^-?[0-9]*\.?[0-9]*$).`)
+        ` should be a number matching (^-?[0-9]*\\.?[0-9]*$).`)
    } else if (drops === '.') {
      throw new ValidationError(`dropsToXrp: invalid value '${drops}',` +
        ` should be a BigNumber or string-encoded number.`)
@@ -47,11 +47,11 @@ function dropsToXrp(drops: string | BigNumber): string {
  return (new BigNumber(drops)).dividedBy(1000000.0).toString(10)
 }

-function xrpToDrops(xrp: string | BigNumber): string {
+function xrpToDrops(xrp: BigNumber.Value): string {
  if (typeof xrp === 'string') {
    if (!xrp.match(/^-?[0-9]*\.?[0-9]*$/)) {
      throw new ValidationError(`xrpToDrops: invalid value '${xrp}',` +
-        ` should be a number matching (^-?[0-9]*\.?[0-9]*$).`)
+        ` should be a number matching (^-?[0-9]*\\.?[0-9]*$).`)
    } else if (xrp === '.') {
      throw new ValidationError(`xrpToDrops: invalid value '${xrp}',` +
        ` should be a BigNumber or string-encoded number.`)
@@ -83,7 +83,7 @@ function xrpToDrops(xrp: string | BigNumber): string {
      ` too many decimal places.`)
  }

-  return (new BigNumber(xrp)).times(1000000.0).floor().toString(10)
+  return (new BigNumber(xrp)).times(1000000.0).integerValue(BigNumber.ROUND_FLOOR).toString(10)
 }

 function toRippledAmount(amount: Amount): RippledAmount {
--- a/src/ledger/accountinfo.ts
+++ b/src/ledger/accountinfo.ts
@@ -1,4 +1,4 @@
-import {validate, removeUndefined, dropsToXrp} from '../common'
+import {validate, removeUndefined, dropsToXrp, ensureClassicAddress} from '../common'
 import {RippleAPI} from '..'
 import {AccountInfoResponse} from '../common/types/commands/account_info'

@@ -34,6 +34,11 @@ export default async function getAccountInfo(
 ): Promise<FormattedGetAccountInfoResponse> {
  // 1. Validate
  validate.getAccountInfo({address, options})
+
+  // Only support retrieving account info without a tag,
+  // since account info is not distinguished by tag.
+  address = ensureClassicAddress(address)
+
  // 2. Make Request
  const response = await this.request('account_info', {
    account: address,
--- a/src/ledger/balances.ts
+++ b/src/ledger/balances.ts
@@ -1,11 +1,10 @@
 import * as utils from './utils'
-import {validate} from '../common'
+import {validate, ensureClassicAddress} from '../common'
 import {Connection} from '../common'
 import {GetTrustlinesOptions} from './trustlines'
 import {FormattedTrustline} from '../common/types/objects/trustlines'
 import {RippleAPI} from '..'

-
 export type Balance = {
  value: string,
  currency: string,
@@ -52,6 +51,13 @@ function getBalances(this: RippleAPI, address: string, options: GetTrustlinesOpt
 ): Promise<GetBalances> {
  validate.getTrustlines({address, options})

+  // Only support retrieving balances without a tag,
+  // since we currently do not calculate balances
+  // on a per-tag basis. Apps must interpret and
+  // use tags independent of the XRP Ledger, comparing
+  // with the XRP Ledger's balance as an accounting check.
+  address = ensureClassicAddress(address)
+
  return Promise.all([
    getLedgerVersionHelper(this.connection, options.ledgerVersion).then(
      ledgerVersion =>
--- a/src/ledger/orders.ts
+++ b/src/ledger/orders.ts
@@ -33,6 +33,6 @@ export default async function getOrders(
    ledger_index: options.ledgerVersion || await this.getLedgerVersion(),
    limit: options.limit
  })
-  // 3. Return Formatted Response
+  // 3. Return Formatted Response, from the perspective of `address`
  return formatResponse(address, responses)
 }
--- a/src/ledger/parse/account-order.ts
+++ b/src/ledger/parse/account-order.ts
@@ -17,7 +17,7 @@ export type FormattedAccountOrder = {
 // TODO: remove this function once rippled provides quality directly
 function computeQuality(takerGets, takerPays) {
  const quotient = new BigNumber(takerPays.value).dividedBy(takerGets.value)
-  return quotient.toDigits(16, BigNumber.ROUND_HALF_UP).toString()
+  return quotient.precision(16, BigNumber.ROUND_HALF_UP).toString()
 }

 // rippled 'account_offers' returns a different format for orders than 'tx'
--- a/src/ledger/parse/cancellation.ts
+++ b/src/ledger/parse/cancellation.ts
@@ -1,7 +1,7 @@
 import * as assert from 'assert'

 function parseOrderCancellation(tx: any): object {
-  assert(tx.TransactionType === 'OfferCancel')
+  assert.ok(tx.TransactionType === 'OfferCancel')
  return {
    orderSequence: tx.OfferSequence
  }
--- a/src/ledger/parse/check-cancel.ts
+++ b/src/ledger/parse/check-cancel.ts
@@ -8,7 +8,7 @@ export type FormattedCheckCancel = {
 }

 function parseCheckCancel(tx: any): FormattedCheckCancel {
-  assert(tx.TransactionType === 'CheckCancel')
+  assert.ok(tx.TransactionType === 'CheckCancel')

  return removeUndefined({
    checkID: tx.CheckID
--- a/src/ledger/parse/check-cash.ts
+++ b/src/ledger/parse/check-cash.ts
@@ -23,7 +23,7 @@ export type FormattedCheckCash = {
 }

 function parseCheckCash(tx: any): FormattedCheckCash {
-  assert(tx.TransactionType === 'CheckCash')
+  assert.ok(tx.TransactionType === 'CheckCash')

  return removeUndefined({
    checkID: tx.CheckID,
--- a/src/ledger/parse/check-create.ts
+++ b/src/ledger/parse/check-create.ts
@@ -24,7 +24,7 @@ export type FormattedCheckCreate = {
 }

 function parseCheckCreate(tx: any): FormattedCheckCreate {
-  assert(tx.TransactionType === 'CheckCreate')
+  assert.ok(tx.TransactionType === 'CheckCreate')

  return removeUndefined({
    destination: tx.Destination,
--- a/src/ledger/parse/deposit-preauth.ts
+++ b/src/ledger/parse/deposit-preauth.ts
@@ -10,7 +10,7 @@ export type FormattedDepositPreauth = {
 }

 function parseDepositPreauth(tx: any): FormattedDepositPreauth {
-  assert(tx.TransactionType === 'DepositPreauth')
+  assert.ok(tx.TransactionType === 'DepositPreauth')

  return removeUndefined({
    authorize: tx.Authorize,
--- a/src/ledger/parse/escrow-cancellation.ts
+++ b/src/ledger/parse/escrow-cancellation.ts
@@ -3,7 +3,7 @@ import {parseMemos} from './utils'
 import {removeUndefined} from '../../common'

 function parseEscrowCancellation(tx: any): object {
-  assert(tx.TransactionType === 'EscrowCancel')
+  assert.ok(tx.TransactionType === 'EscrowCancel')

  return removeUndefined({
    memos: parseMemos(tx),
--- a/src/ledger/parse/escrow-creation.ts
+++ b/src/ledger/parse/escrow-creation.ts
@@ -4,7 +4,7 @@ import {parseTimestamp, parseMemos} from './utils'
 import {removeUndefined} from '../../common'

 function parseEscrowCreation(tx: any): object {
-  assert(tx.TransactionType === 'EscrowCreate')
+  assert.ok(tx.TransactionType === 'EscrowCreate')

  return removeUndefined({
    amount: parseAmount(tx.Amount).value,
--- a/src/ledger/parse/escrow-execution.ts
+++ b/src/ledger/parse/escrow-execution.ts
@@ -3,7 +3,7 @@ import {parseMemos} from './utils'
 import {removeUndefined} from '../../common'

 function parseEscrowExecution(tx: any): object {
-  assert(tx.TransactionType === 'EscrowFinish')
+  assert.ok(tx.TransactionType === 'EscrowFinish')

  return removeUndefined({
    memos: parseMemos(tx),
--- a/src/ledger/parse/fields.ts
+++ b/src/ledger/parse/fields.ts
@@ -8,7 +8,7 @@ function parseField(info, value) {
    return Buffer.from(value, 'hex').toString('ascii')
  }
  if (info.shift) {
-    return (new BigNumber(value)).shift(-info.shift).toNumber()
+    return (new BigNumber(value)).shiftedBy(-info.shift).toNumber()
  }
  return value
 }
--- a/src/ledger/parse/order.ts
+++ b/src/ledger/parse/order.ts
@@ -10,7 +10,7 @@ import {
 const flags = txFlags.OfferCreate

 function parseOrder(tx: OfferCreateTransaction): FormattedOrderSpecification {
-  assert(tx.TransactionType === 'OfferCreate')
+  assert.ok(tx.TransactionType === 'OfferCreate')

  const direction = (tx.Flags & flags.Sell) === 0 ? 'buy' : 'sell'
  const takerGetsAmount = parseAmount(tx.TakerGets)
--- a/src/ledger/parse/payment-channel-claim.ts
+++ b/src/ledger/parse/payment-channel-claim.ts
@@ -4,7 +4,7 @@ import parseAmount from './amount'
 const claimFlags = txFlags.PaymentChannelClaim

 function parsePaymentChannelClaim(tx: any): object {
-  assert(tx.TransactionType === 'PaymentChannelClaim')
+  assert.ok(tx.TransactionType === 'PaymentChannelClaim')

  return removeUndefined({
    channel: tx.Channel,
--- a/src/ledger/parse/payment-channel-create.ts
+++ b/src/ledger/parse/payment-channel-create.ts
@@ -4,7 +4,7 @@ import {removeUndefined} from '../../common'
 import parseAmount from './amount'

 function parsePaymentChannelCreate(tx: any): object {
-  assert(tx.TransactionType === 'PaymentChannelCreate')
+  assert.ok(tx.TransactionType === 'PaymentChannelCreate')

  return removeUndefined({
    amount: parseAmount(tx.Amount).value,
--- a/src/ledger/parse/payment-channel-fund.ts
+++ b/src/ledger/parse/payment-channel-fund.ts
@@ -4,7 +4,7 @@ import {removeUndefined} from '../../common'
 import parseAmount from './amount'

 function parsePaymentChannelFund(tx: any): object {
-  assert(tx.TransactionType === 'PaymentChannelFund')
+  assert.ok(tx.TransactionType === 'PaymentChannelFund')

  return removeUndefined({
    channel: tx.Channel,
--- a/src/ledger/parse/payment.ts
+++ b/src/ledger/parse/payment.ts
@@ -19,7 +19,7 @@ function removeGenericCounterparty(amount, address) {

 // Payment specification
 function parsePayment(tx: any): object {
-  assert(tx.TransactionType === 'Payment')
+  assert.ok(tx.TransactionType === 'Payment')

  const source = {
    address: tx.Account,
--- a/src/ledger/parse/settings.ts
+++ b/src/ledger/parse/settings.ts
@@ -7,7 +7,7 @@ import parseFields from './fields'
 function getAccountRootModifiedNode(tx: any) {
  const modifiedNodes = tx.meta.AffectedNodes.filter(node =>
    node.ModifiedNode.LedgerEntryType === 'AccountRoot')
-  assert(modifiedNodes.length === 1)
+  assert.ok(modifiedNodes.length === 1)
  return modifiedNodes[0].ModifiedNode
 }

@@ -51,7 +51,7 @@ function parseFlags(tx: any): any {

 function parseSettings(tx: any) {
  const txType = tx.TransactionType
-  assert(txType === 'AccountSet' || txType === 'SetRegularKey' ||
+  assert.ok(txType === 'AccountSet' || txType === 'SetRegularKey' ||
         txType === 'SignerListSet')

  return _.assign({}, parseFlags(tx), parseFields(tx))
--- a/src/ledger/parse/trustline.ts
+++ b/src/ledger/parse/trustline.ts
@@ -14,7 +14,7 @@ function parseFlag(flagsValue, trueValue, falseValue) {
 }

 function parseTrustline(tx: any): object {
-  assert(tx.TransactionType === 'TrustSet')
+  assert.ok(tx.TransactionType === 'TrustSet')

  return removeUndefined({
    limit: tx.LimitAmount.value,
--- a/src/ledger/parse/utils.ts
+++ b/src/ledger/parse/utils.ts
@@ -1,5 +1,5 @@
 import * as _ from 'lodash'
-import transactionParser = require('ripple-lib-transactionparser')
+import transactionParser from 'ripple-lib-transactionparser'
 import BigNumber from 'bignumber.js'
 import * as common from '../../common'
 import parseAmount from './amount'
@@ -15,14 +15,14 @@ function adjustQualityForXRP(
  const denominatorShift = (takerGetsCurrency === 'XRP' ? -6 : 0)
  const shift = numeratorShift - denominatorShift
  return shift === 0 ? quality :
-    (new BigNumber(quality)).shift(shift).toString()
+    (new BigNumber(quality)).shiftedBy(shift).toString()
 }

 function parseQuality(quality?: number|null): number|undefined {
  if (typeof quality !== 'number') {
    return undefined
  }
-  return (new BigNumber(quality)).shift(-9).toNumber()
+  return (new BigNumber(quality)).shiftedBy(-9).toNumber()
 }

 function parseTimestamp(rippleTime?: number|null): string|undefined {
--- a/src/ledger/pathfind.ts
+++ b/src/ledger/pathfind.ts
@@ -73,7 +73,7 @@ function addDirectXrpPath(paths: RippledPathsResponse, xrpBalance: string
  // Add XRP "path" only if the source acct has enough XRP to make the payment
  const destinationAmount = paths.destination_amount
  // @ts-ignore: destinationAmount can be a currency amount object! Fix!
-  if ((new BigNumber(xrpBalance)).greaterThanOrEqualTo(destinationAmount)) {
+  if ((new BigNumber(xrpBalance)).isGreaterThanOrEqualTo(destinationAmount)) {
    paths.alternatives.unshift({
      paths_computed: [],
      source_amount: paths.destination_amount
--- a/src/ledger/settings.ts
+++ b/src/ledger/settings.ts
@@ -1,9 +1,10 @@
 import * as _ from 'lodash'
 import parseFields from './parse/fields'
-import {validate, constants} from '../common'
+import {validate, constants, ensureClassicAddress} from '../common'
 import {FormattedSettings} from '../common/types/objects'
 import {AccountInfoResponse} from '../common/types/commands'
 import {RippleAPI} from '..'
+
 const AccountFlags = constants.AccountFlags

 export type SettingsOptions = {
@@ -38,6 +39,11 @@ export async function getSettings(
 ): Promise<FormattedSettings> {
  // 1. Validate
  validate.getSettings({address, options})
+
+  // Only support retrieving settings without a tag,
+  // since settings do not distinguish by tag.
+  address = ensureClassicAddress(address)
+
  // 2. Make Request
  const response = await this.request('account_info', {
    account: address,
--- a/src/ledger/transaction.ts
+++ b/src/ledger/transaction.ts
@@ -30,8 +30,12 @@ function attachTransactionDate(connection: Connection, tx: any

  if (!ledgerVersion) {
    return new Promise(() => {
-      throw new errors.NotFoundError(
-        'ledger_index and LedgerSequence not found in tx')
+      const error = new errors.NotFoundError(
+        'Transaction has not been validated yet; try again later')
+      error.data = {
+        details: '(ledger_index and LedgerSequence not found in tx)'
+      }
+      throw error
    })
  }

--- a/src/ledger/transactions.ts
+++ b/src/ledger/transactions.ts
@@ -1,14 +1,13 @@
 import * as _ from 'lodash'
-import binary = require('ripple-binary-codec')
-const {computeTransactionHash} = require('ripple-hashes')
+import binary from 'ripple-binary-codec';
+import {computeTransactionHash} from '../common/hashes'
 import * as utils from './utils'
 import parseTransaction from './parse/transaction'
 import getTransaction from './transaction'
-import {validate, errors, Connection} from '../common'
+import {validate, errors, Connection, ensureClassicAddress} from '../common'
 import {FormattedTransactionType} from '../transaction/types'
 import {RippleAPI} from '..'

-
 export type TransactionsOptions = {
  start?: string,
  limit?: number,
@@ -167,6 +166,12 @@ function getTransactions(this: RippleAPI, address: string, options: Transactions
 ): Promise<GetTransactionsResponse> {
  validate.getTransactions({address, options})

+  // Only support retrieving transactions without a tag,
+  // since we currently do not filter transactions based
+  // on tag. Apps must interpret and use tags
+  // independently, filtering transactions if needed.
+  address = ensureClassicAddress(address)
+
  const defaults = {maxLedgerVersion: -1}
  if (options.start) {
    return getTransaction.call(this, options.start).then(tx => {
--- a/src/ledger/trustlines.ts
+++ b/src/ledger/trustlines.ts
@@ -1,5 +1,5 @@
 import * as _ from 'lodash'
-import {validate} from '../common'
+import {validate, ensureClassicAddress} from '../common'
 import parseAccountTrustline from './parse/account-trustline'
 import {RippleAPI} from '..'
 import {FormattedTrustline} from '../common/types/objects/trustlines'
@@ -20,11 +20,16 @@ async function getTrustlines(
 ): Promise<FormattedTrustline[]> {
  // 1. Validate
  validate.getTrustlines({address, options})
-  const ledgerVersion = await this.getLedgerVersion()
+
+  // Only support retrieving trustlines without a tag,
+  // since it does not make sense to filter trustlines
+  // by tag.
+  address = ensureClassicAddress(address)
+
  // 2. Make Request
  const responses = await this._requestAll('account_lines', {
    account: address,
-    ledger_index: ledgerVersion,
+    ledger_index: await this.getLedgerVersion(),
    limit: options.limit,
    peer: options.counterparty
  })
--- a/src/ledger/utils.ts
+++ b/src/ledger/utils.ts
@@ -4,7 +4,7 @@ import * as common from '../common'
 import {Connection} from '../common'
 import {FormattedTransactionType} from '../transaction/types'
 import {Issue} from '../common/types/objects'
-import {RippleAPI} from '..'
+import {RippleAPI} from '..' 

 export type RecursiveData = {
  marker: string,
@@ -14,7 +14,7 @@ export type RecursiveData = {
 export type Getter = (marker?: string, limit?: number) => Promise<RecursiveData>

 function clamp(value: number, min: number, max: number): number {
-  assert(min <= max, 'Illegal clamp bounds')
+  assert.ok(min <= max, 'Illegal clamp bounds')
  return Math.min(Math.max(value, min), max)
 }

--- a/src/offline/derive.ts
+++ b/src/offline/derive.ts
@@ -1,6 +1,13 @@
 import {deriveKeypair, deriveAddress} from 'ripple-keypairs'
+import {classicAddressToXAddress} from 'ripple-address-codec'
+
+function deriveXAddress(options: {publicKey: string, tag: number | false, test: boolean}): string {
+  const classicAddress = deriveAddress(options.publicKey)
+  return classicAddressToXAddress(classicAddress, options.tag, options.test)
+}

 export {
  deriveKeypair,
-  deriveAddress
+  deriveAddress,
+  deriveXAddress
 }
--- a/src/offline/generate-address.ts
+++ b/src/offline/generate-address.ts
@@ -1,19 +1,45 @@
-import keypairs = require('ripple-keypairs')
-import * as common from '../common'
-const {errors, validate} = common
+import {classicAddressToXAddress} from 'ripple-address-codec'
+import keypairs from 'ripple-keypairs'
+import {errors, validate} from '../common'

 export type GeneratedAddress = {
-  secret: string,
-  address: string
+  xAddress: string,
+  classicAddress?: string,
+  address?: string, // @deprecated Use `classicAddress` instead.
+  secret: string
 }

-function generateAddressAPI(options?: any): GeneratedAddress {
+export interface GenerateAddressOptions {
+  // The entropy to use to generate the seed.
+  entropy?: Uint8Array | number[],
+
+  // The digital signature algorithm to generate an address for. Can be `ecdsa-secp256k1` (default) or `ed25519`.
+  algorithm?: 'ecdsa-secp256k1' | 'ed25519',
+
+  // Specifies whether the address is intended for use on a test network such as Testnet or Devnet.
+  // If `true`, the address should only be used for testing, and will start with `T`.
+  // If `false` (default), the address should only be used on mainnet, and will start with `X`.
+  test?: boolean,
+
+  // If `true`, return the classic address, in addition to the X-address.
+  includeClassicAddress?: boolean
+}
+
+function generateAddressAPI(options: GenerateAddressOptions): GeneratedAddress {
  validate.generateAddress({options})
  try {
    const secret = keypairs.generateSeed(options)
    const keypair = keypairs.deriveKeypair(secret)
-    const address = keypairs.deriveAddress(keypair.publicKey)
-    return {secret, address}
+    const classicAddress = keypairs.deriveAddress(keypair.publicKey)
+    const returnValue: any = {
+      xAddress: classicAddressToXAddress(classicAddress, false, options && options.test),
+      secret
+    }
+    if (options.includeClassicAddress) {
+      returnValue.classicAddress = classicAddress
+      returnValue.address = classicAddress
+    }
+    return returnValue
  } catch (error) {
    throw new errors.UnexpectedError(error.message)
  }
--- a/src/offline/ledgerhash.ts
+++ b/src/offline/ledgerhash.ts
@@ -1,5 +1,5 @@
 import * as _ from 'lodash'
-import hashes = require('ripple-hashes')
+import {computeLedgerHash, computeTransactionTreeHash, computeStateTreeHash} from '../common/hashes'
 import * as common from '../common'

 function convertLedgerHeader(header): any {
@@ -22,11 +22,11 @@ function convertLedgerHeader(header): any {

 function hashLedgerHeader(ledgerHeader) {
  const header = convertLedgerHeader(ledgerHeader)
-  return hashes.computeLedgerHash(header)
+  return computeLedgerHash(header)
 }

-function computeTransactionHash(ledger, version,
-    options: ComputeLedgerHashOptions) {
+function computeTransactionHash(ledger,
+    options: ComputeLedgerHeaderHashOptions) {
  let transactions: any[]
  if (ledger.rawTransactions) {
    transactions = JSON.parse(ledger.rawTransactions)
@@ -56,7 +56,7 @@ function computeTransactionHash(ledger, version,
      tx.meta ? {metaData: tx.meta} : {})
    return renameMeta
  })
-  const transactionHash = hashes.computeTransactionTreeHash(txs, version)
+  const transactionHash = computeTransactionTreeHash(txs)
  if (ledger.transactionHash !== undefined
      && ledger.transactionHash !== transactionHash) {
    throw new common.errors.ValidationError('transactionHash in header'
@@ -68,8 +68,8 @@ function computeTransactionHash(ledger, version,
  return transactionHash
 }

-function computeStateHash(ledger, version,
-    options: ComputeLedgerHashOptions) {
+function computeStateHash(ledger,
+    options: ComputeLedgerHeaderHashOptions) {
  if (ledger.rawState === undefined) {
    if (options.computeTreeHashes) {
      throw new common.errors.ValidationError('rawState'
@@ -78,7 +78,7 @@ function computeStateHash(ledger, version,
    return ledger.stateHash
  }
  const state = JSON.parse(ledger.rawState)
-  const stateHash = hashes.computeStateTreeHash(state, version)
+  const stateHash = computeStateTreeHash(state)
  if (ledger.stateHash !== undefined && ledger.stateHash !== stateHash) {
    throw new common.errors.ValidationError('stateHash in header'
      + ' does not match computed hash of state')
@@ -86,20 +86,17 @@ function computeStateHash(ledger, version,
  return stateHash
 }

-const sLCF_SHAMapV2 = 0x02
-
-export type ComputeLedgerHashOptions = {
+export type ComputeLedgerHeaderHashOptions = {
  computeTreeHashes?: boolean
 }

-function computeLedgerHash(ledger: any,
-    options: ComputeLedgerHashOptions = {}): string {
-  const version = ((ledger.closeFlags & sLCF_SHAMapV2) === 0) ? 1 : 2
+function computeLedgerHeaderHash(ledger: any,
+    options: ComputeLedgerHeaderHashOptions = {}): string {
  const subhashes = {
-    transactionHash: computeTransactionHash(ledger, version, options),
-    stateHash: computeStateHash(ledger, version, options)
+    transactionHash: computeTransactionHash(ledger, options),
+    stateHash: computeStateHash(ledger, options)
  }
  return hashLedgerHeader(_.assign({}, ledger, subhashes))
 }

-export default computeLedgerHash
+export default computeLedgerHeaderHash
--- a/src/offline/sign-payment-channel-claim.ts
+++ b/src/offline/sign-payment-channel-claim.ts
@@ -1,6 +1,6 @@
 import * as common from '../common'
-import keypairs = require('ripple-keypairs')
-import binary = require('ripple-binary-codec')
+import keypairs from 'ripple-keypairs'
+import binary from 'ripple-binary-codec'
 const {validate, xrpToDrops} = common

 function signPaymentChannelClaim(channel: string, amount: string,
--- a/src/offline/verify-payment-channel-claim.ts
+++ b/src/offline/verify-payment-channel-claim.ts
@@ -1,5 +1,5 @@
-import keypairs = require('ripple-keypairs')
-import binary = require('ripple-binary-codec')
+import keypairs from 'ripple-keypairs'
+import binary from 'ripple-binary-codec'
 import {validate, xrpToDrops} from '../common'

 function verifyPaymentChannelClaim(channel: string, amount: string,
--- a/src/transaction/check-cancel.ts
+++ b/src/transaction/check-cancel.ts
@@ -1,6 +1,6 @@
-import {TransactionJSON, prepareTransaction} from './utils'
+import {prepareTransaction} from './utils'
 import {validate} from '../common'
-import {Instructions, Prepare} from './types'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {RippleAPI} from '..'

 export type CheckCancelParameters = {
--- a/src/transaction/combine.ts
+++ b/src/transaction/combine.ts
@@ -1,13 +1,13 @@
 import * as _ from 'lodash'
-import binary = require('ripple-binary-codec')
+import binary from 'ripple-binary-codec'
 import * as utils from './utils'
 import BigNumber from 'bignumber.js'
-import {decodeAddress} from 'ripple-address-codec'
+import {decodeAccountID} from 'ripple-address-codec'
 import {validate} from '../common'
-import {computeBinaryTransactionHash} from 'ripple-hashes'
+import {computeBinaryTransactionHash} from '../common/hashes'

 function addressToBigNumber(address) {
-  const hex = (Buffer.from(decodeAddress(address))).toString('hex')
+  const hex = (Buffer.from(decodeAccountID(address))).toString('hex')
  return new BigNumber(hex, 16)
 }

--- a/src/transaction/escrow-execution.ts
+++ b/src/transaction/escrow-execution.ts
@@ -1,7 +1,7 @@
 import * as utils from './utils'
 const validate = utils.common.validate
 const ValidationError = utils.common.errors.ValidationError
-import {Instructions, Prepare} from './types'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {Memo} from '../common/types/objects'
 import {RippleAPI} from '..'

@@ -15,7 +15,7 @@ export type EscrowExecution = {

 function createEscrowExecutionTransaction(account: string,
  payment: EscrowExecution
-): utils.TransactionJSON {
+): TransactionJSON {
  const txJSON: any = {
    TransactionType: 'EscrowFinish',
    Account: account,
--- a/src/transaction/payment-channel-claim.ts
+++ b/src/transaction/payment-channel-claim.ts
@@ -2,7 +2,7 @@ import * as utils from './utils'
 const ValidationError = utils.common.errors.ValidationError
 const claimFlags = utils.common.txFlags.PaymentChannelClaim
 import {validate, xrpToDrops} from '../common'
-import {Instructions, Prepare} from './types'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {RippleAPI} from '..'

 export type PaymentChannelClaim = {
@@ -17,8 +17,8 @@ export type PaymentChannelClaim = {

 function createPaymentChannelClaimTransaction(account: string,
  claim: PaymentChannelClaim
-): utils.TransactionJSON {
-  const txJSON: utils.TransactionJSON = {
+): TransactionJSON {
+  const txJSON: TransactionJSON = {
    Account: account,
    TransactionType: 'PaymentChannelClaim',
    Channel: claim.channel,
--- a/src/transaction/payment-channel-create.ts
+++ b/src/transaction/payment-channel-create.ts
@@ -1,6 +1,6 @@
 import * as utils from './utils'
 import {validate, iso8601ToRippleTime, xrpToDrops} from '../common'
-import {Instructions, Prepare} from './types'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {RippleAPI} from '..'

 export type PaymentChannelCreate = {
@@ -15,7 +15,7 @@ export type PaymentChannelCreate = {

 function createPaymentChannelCreateTransaction(account: string,
  paymentChannel: PaymentChannelCreate
-): utils.TransactionJSON {
+): TransactionJSON {
  const txJSON: any = {
    Account: account,
    TransactionType: 'PaymentChannelCreate',
--- a/src/transaction/payment-channel-fund.ts
+++ b/src/transaction/payment-channel-fund.ts
@@ -1,6 +1,6 @@
 import * as utils from './utils'
 import {validate, iso8601ToRippleTime, xrpToDrops} from '../common'
-import {Instructions, Prepare} from './types'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {RippleAPI} from '..'

 export type PaymentChannelFund = {
@@ -11,8 +11,8 @@ export type PaymentChannelFund = {

 function createPaymentChannelFundTransaction(account: string,
  fund: PaymentChannelFund
-): utils.TransactionJSON {
-  const txJSON: utils.TransactionJSON = {
+): TransactionJSON {
+  const txJSON: TransactionJSON = {
    Account: account,
    TransactionType: 'PaymentChannelFund',
    Channel: fund.channel,
--- a/src/transaction/payment.ts
+++ b/src/transaction/payment.ts
@@ -9,6 +9,7 @@ import {Amount, Adjustment, MaxAdjustment,
  MinAdjustment, Memo} from '../common/types/objects'
 import {xrpToDrops} from '../common'
 import {RippleAPI} from '..'
+import {getClassicAccountAndTag, ClassicAccountAndTag} from './utils'


 export interface Payment {
@@ -84,15 +85,49 @@ function createMaximalAmount(amount: Amount): Amount {
  return _.assign({}, amount, {value: maxValue})
 }

+/**
+ * Given an address and tag:
+ * 1. Get the classic account and tag;
+ * 2. If a tag is provided:
+ *    2a. If the address was an X-address, validate that the X-address has the expected tag;
+ *    2b. If the address was a classic address, return `expectedTag` as the tag.
+ * 3. If we do not want to use a tag in this case,
+ *    set the tag in the return value to `undefined`.
+ *
+ * @param address The address to parse.
+ * @param expectedTag If provided, and the `Account` is an X-address,
+ *                    this method throws an error if `expectedTag`
+ *                    does not match the tag of the X-address.
+ * @returns {ClassicAccountAndTag}
+ *          The classic account and tag.
+ */
+function validateAndNormalizeAddress(address: string, expectedTag: number | undefined): ClassicAccountAndTag {
+  const classicAddress = getClassicAccountAndTag(address, expectedTag)
+  classicAddress.tag = classicAddress.tag === false ? undefined : classicAddress.tag
+  return classicAddress
+}
+
 function createPaymentTransaction(address: string, paymentArgument: Payment
 ): TransactionJSON {
  const payment = _.cloneDeep(paymentArgument)
  applyAnyCounterpartyEncoding(payment)

-  if (address !== payment.source.address) {
+  const sourceAddressAndTag = validateAndNormalizeAddress(payment.source.address, payment.source.tag)
+  const addressToVerifyAgainst = validateAndNormalizeAddress(address, undefined)
+
+  if (addressToVerifyAgainst.classicAccount !== sourceAddressAndTag.classicAccount) {
    throw new ValidationError('address must match payment.source.address')
  }

+  if (addressToVerifyAgainst.tag !== undefined &&
+      sourceAddressAndTag.tag !== undefined &&
+      addressToVerifyAgainst.tag !== sourceAddressAndTag.tag) {
+    throw new ValidationError(
+      'address includes a tag that does not match payment.source.tag')
+  }
+
+  const destinationAddressAndTag = validateAndNormalizeAddress(payment.destination.address, payment.destination.tag)
+
  if (
    (isMaxAdjustment(payment.source) && isMinAdjustment(payment.destination))
    ||
@@ -119,8 +154,8 @@ function createPaymentTransaction(address: string, paymentArgument: Payment

  const txJSON: any = {
    TransactionType: 'Payment',
-    Account: payment.source.address,
-    Destination: payment.destination.address,
+    Account: sourceAddressAndTag.classicAccount,
+    Destination: destinationAddressAndTag.classicAccount,
    Amount: toRippledAmount(amount),
    Flags: 0
  }
@@ -128,11 +163,11 @@ function createPaymentTransaction(address: string, paymentArgument: Payment
  if (payment.invoiceID !== undefined) {
    txJSON.InvoiceID = payment.invoiceID
  }
-  if (payment.source.tag !== undefined) {
-    txJSON.SourceTag = payment.source.tag
+  if (sourceAddressAndTag.tag !== undefined) {
+    txJSON.SourceTag = sourceAddressAndTag.tag
  }
-  if (payment.destination.tag !== undefined) {
-    txJSON.DestinationTag = payment.destination.tag
+  if (destinationAddressAndTag.tag !== undefined) {
+    txJSON.DestinationTag = destinationAddressAndTag.tag
  }
  if (payment.memos !== undefined) {
    txJSON.Memos = _.map(payment.memos, utils.convertMemo)
--- a/src/transaction/settings.ts
+++ b/src/transaction/settings.ts
@@ -4,13 +4,13 @@ import * as utils from './utils'
 const validate = utils.common.validate
 const AccountFlagIndices = utils.common.constants.AccountFlagIndices
 const AccountFields = utils.common.constants.AccountFields
-import {Instructions, Prepare, SettingsTransaction} from './types'
+import {Instructions, Prepare, SettingsTransaction, TransactionJSON} from './types'
 import {FormattedSettings, WeightedSigner} from '../common/types/objects'
 import {RippleAPI} from '..'

-function setTransactionFlags(txJSON: utils.TransactionJSON, values: FormattedSettings) {
+function setTransactionFlags(txJSON: TransactionJSON, values: FormattedSettings) {
  const keys = Object.keys(values)
-  assert(keys.length === 1, 'ERROR: can only set one setting per transaction')
+  assert.ok(keys.length === 1, 'ERROR: can only set one setting per transaction')
  const flagName = keys[0]
  const value = values[flagName]
  const index = AccountFlagIndices[flagName]
@@ -24,7 +24,7 @@ function setTransactionFlags(txJSON: utils.TransactionJSON, values: FormattedSet
 }

 // Sets `null` fields to their `default`.
-function setTransactionFields(txJSON: utils.TransactionJSON, input: FormattedSettings) {
+function setTransactionFields(txJSON: TransactionJSON, input: FormattedSettings) {
  const fieldSchema = AccountFields
  for (const fieldName in fieldSchema) {
    const field = fieldSchema[fieldName]
@@ -62,7 +62,7 @@ function setTransactionFields(txJSON: utils.TransactionJSON, input: FormattedSet
 */

 function convertTransferRate(transferRate: number): number {
-  return (new BigNumber(transferRate)).shift(9).toNumber()
+  return (new BigNumber(transferRate)).shiftedBy(9).toNumber()
 }

 function formatSignerEntry(signer: WeightedSigner): object {
--- a/src/transaction/sign.ts
+++ b/src/transaction/sign.ts
@@ -1,13 +1,13 @@
-import * as isEqual from '../common/js/lodash.isequal'
+import isEqual from 'lodash.isequal'
 import * as utils from './utils'
-import keypairs = require('ripple-keypairs')
-import binaryCodec = require('ripple-binary-codec')
-import {computeBinaryTransactionHash} from 'ripple-hashes'
-import {SignOptions, KeyPair} from './types'
+import keypairs from 'ripple-keypairs'
+import binaryCodec from 'ripple-binary-codec'
+import {computeBinaryTransactionHash} from '../common/hashes'
+import {SignOptions, KeyPair, TransactionJSON} from './types'
 import {BigNumber} from 'bignumber.js'
 import {xrpToDrops} from '../common'
 import {RippleAPI} from '..'
-const validate = utils.common.validate
+const validate = utils.common.validate 

 function computeSignature(tx: object, privateKey: string, signAs?: string) {
  const signingData = signAs
@@ -60,16 +60,82 @@ function signWithKeypair(
  }
 }

+/**
+ * Compares two objects and creates a diff.
+ *
+ * @param a An object to compare.
+ * @param b The other object to compare with.
+ *
+ * @returns An object containing the differences between the two objects.
+ */
+function objectDiff(a: object, b: object): object {
+  const diffs = {}
+
+  // Compare two items and push non-matches to object
+  const compare = function (i1: any, i2: any, k: string): void {
+    const type1 = Object.prototype.toString.call(i1)
+    const type2 = Object.prototype.toString.call(i2)
+    if (type2 === '[object Undefined]') {
+      diffs[k] = null // Indicate that the item has been removed
+      return
+    }
+    if (type1 !== type2) {
+      diffs[k] = i2 // Indicate that the item has changed types
+      return
+    }
+    if (type1 === '[object Object]') {
+      const objDiff = objectDiff(i1, i2)
+      if (Object.keys(objDiff).length > 0) {
+        diffs[k] = objDiff
+      }
+      return
+    }
+    if (type1 === '[object Array]') {
+      if (!isEqual(i1, i2)) {
+        diffs[k] = i2 // If arrays do not match, add second item to diffs
+      }
+      return
+    }
+    if (type1 === '[object Function]') {
+      if (i1.toString() !== i2.toString()) {
+        diffs[k] = i2 // If functions differ, add second one to diffs
+      }
+      return
+    }
+    if (i1 !== i2) {
+      diffs[k] = i2
+    }
+  }
+
+  // Check items in first object
+  for (const key in a) {
+    if (a.hasOwnProperty(key)) {
+      compare(a[key], b[key], key)
+    }
+  }
+
+  // Get items that are in the second object but not the first
+  for (const key in b) {
+    if (b.hasOwnProperty(key)) {
+      if (!a[key] && a[key] !== b[key]) {
+        diffs[key] = b[key]
+      }
+    }
+  }
+
+  return diffs
+}
+
 /**
 *  Decode a serialized transaction, remove the fields that are added during the signing process,
 *  and verify that it matches the transaction prior to signing.
 *
 *  @param {string} serialized A signed and serialized transaction.
- *  @param {utils.TransactionJSON} tx The transaction prior to signing.
+ *  @param {TransactionJSON} tx The transaction prior to signing.
 *
 *  @returns {void} This method does not return a value, but throws an error if the check fails.
 */
-function checkTxSerialization(serialized: string, tx: utils.TransactionJSON): void {
+function checkTxSerialization(serialized: string, tx: TransactionJSON): void {
  // Decode the serialized transaction:
  const decoded = binaryCodec.decode(serialized)

@@ -93,11 +159,12 @@ function checkTxSerialization(serialized: string, tx: utils.TransactionJSON): vo

  if (!isEqual(decoded, tx)) {
    const error = new utils.common.errors.ValidationError(
-      'Serialized transaction does not match original txJSON'
+      'Serialized transaction does not match original txJSON. See `error.data`'
    )
    error.data = {
      decoded,
-      tx
+      tx,
+      diff: objectDiff(tx, decoded)
    }
    throw error
  }
@@ -116,7 +183,7 @@ function checkTxSerialization(serialized: string, tx: utils.TransactionJSON): vo
 function checkFee(api: RippleAPI, txFee: string): void {
  const fee = new BigNumber(txFee)
  const maxFeeDrops = xrpToDrops(api._maxFeeXRP)
-  if (fee.greaterThan(maxFeeDrops)) {
+  if (fee.isGreaterThan(maxFeeDrops)) {
    throw new utils.common.errors.ValidationError(
      `"Fee" should not exceed "${maxFeeDrops}". ` +
      'To use a higher fee, set `maxFeeXRP` in the RippleAPI constructor.'
--- a/src/transaction/trustline.ts
+++ b/src/transaction/trustline.ts
@@ -9,7 +9,7 @@ import {
 import {RippleAPI} from '..'

 function convertQuality(quality) {
-  return (new BigNumber(quality)).shift(9).truncated().toNumber()
+  return (new BigNumber(quality)).shiftedBy(9).integerValue(BigNumber.ROUND_DOWN).toNumber()
 }

 function createTrustlineTransaction(account: string,
--- a/src/transaction/types.ts
+++ b/src/transaction/types.ts
@@ -9,10 +9,16 @@ import {
 } from '../common/types/objects'
 import {
  ApiMemo,
-  TransactionJSON
 } from './utils'

-export type TransactionJSON = TransactionJSON
+export type TransactionJSON = {
+  Account: string,
+  TransactionType: string,
+  Memos?: {Memo: ApiMemo}[],
+  Flags?: number,
+  Fulfillment?: string,
+  [Field: string]: string | number | Array<any> | RippledAmount | undefined
+}

 export type Instructions = {
  sequence?: number,
--- a/src/transaction/utils.ts
+++ b/src/transaction/utils.ts
@@ -1,10 +1,13 @@
 import BigNumber from 'bignumber.js'
 import * as common from '../common'
-import {Memo, RippledAmount} from '../common/types/objects'
-const txFlags = common.txFlags
-import {Instructions, Prepare} from './types'
+import {Memo} from '../common/types/objects'
+import {Instructions, Prepare, TransactionJSON} from './types'
 import {RippleAPI} from '..'
 import {ValidationError} from '../common/errors'
+import {xAddressToClassicAddress, isValidXAddress} from 'ripple-address-codec'
+
+const txFlags = common.txFlags
+const TRANSACTION_TYPES_WITH_DESTINATION_TAG_FIELD = ['Payment', 'CheckCreate', 'EscrowCreate', 'PaymentChannelCreate']

 export type ApiMemo = {
  MemoData?: string,
@@ -12,15 +15,6 @@ export type ApiMemo = {
  MemoFormat?: string
 }

-export type TransactionJSON = {
-  Account: string,
-  TransactionType: string,
-  Memos?: {Memo: ApiMemo}[],
-  Flags?: number,
-  Fulfillment?: string,
-  [Field: string]: string | number | Array<any> | RippledAmount | undefined
-}
-
 function formatPrepareResponse(txJSON: any): Prepare {
  const instructions = {
    fee: common.dropsToXrp(txJSON.Fee),
@@ -56,6 +50,49 @@ function scaleValue(value, multiplier, extra = 0) {
  return (new BigNumber(value)).times(multiplier).plus(extra).toString()
 }

+/**
+ * @typedef {Object} ClassicAccountAndTag
+ * @property {string} classicAccount - The classic account address.
+ * @property {number | false | undefined } tag - The destination tag;
+ *                    `false` if no tag should be used;
+ *                    `undefined` if the input could not specify whether a tag should be used.
+ */
+export interface ClassicAccountAndTag {
+  classicAccount: string,
+  tag: number | false | undefined
+}
+
+/**
+ * Given an address (account), get the classic account and tag.
+ * If an `expectedTag` is provided:
+ * 1. If the `Account` is an X-address, validate that the tags match.
+ * 2. If the `Account` is a classic address, return `expectedTag` as the tag.
+ *
+ * @param Account The address to parse.
+ * @param expectedTag If provided, and the `Account` is an X-address,
+ *                    this method throws an error if `expectedTag`
+ *                    does not match the tag of the X-address.
+ * @returns {ClassicAccountAndTag}
+ *          The classic account and tag.
+ */
+function getClassicAccountAndTag(Account: string, expectedTag?: number): ClassicAccountAndTag {
+  if (isValidXAddress(Account)) {
+    const classic = xAddressToClassicAddress(Account)
+    if (expectedTag !== undefined && classic.tag !== expectedTag) {
+      throw new ValidationError('address includes a tag that does not match the tag specified in the transaction')
+    }
+    return {
+      classicAccount: classic.classicAddress,
+      tag: classic.tag
+    }
+  } else {
+    return {
+      classicAccount: Account,
+      tag: expectedTag
+    }
+  }
+}
+
 function prepareTransaction(txJSON: TransactionJSON, api: RippleAPI,
  instructions: Instructions
 ): Promise<Prepare> {
@@ -68,110 +105,159 @@ function prepareTransaction(txJSON: TransactionJSON, api: RippleAPI,
      '" exists in instance when not allowed'))
  }

-  // To remove the signer list, SignerEntries field should be omitted.
+  const newTxJSON = Object.assign({}, txJSON)
+
+  // To remove the signer list, `SignerEntries` field should be omitted.
  if (txJSON['SignerQuorum'] === 0) {
-    delete txJSON.SignerEntries;
+    delete newTxJSON.SignerEntries
  }

-  const account = txJSON.Account
-  setCanonicalFlag(txJSON)
+  // Sender:
+  const {classicAccount, tag: sourceTag} = getClassicAccountAndTag(txJSON.Account)
+  newTxJSON.Account = classicAccount
+  if (sourceTag !== undefined) {
+    if (txJSON.SourceTag && txJSON.SourceTag !== sourceTag) {
+      return Promise.reject(new ValidationError(
+        'The `SourceTag`, if present, must match the tag of the `Account` X-address'))
+    }
+    if (sourceTag) {
+      newTxJSON.SourceTag = sourceTag
+    }
+  }

-  function prepareMaxLedgerVersion(): Promise<TransactionJSON> {
+  // Destination:
+  if (typeof txJSON.Destination === 'string') {
+    const {classicAccount: destinationAccount, tag: destinationTag} = getClassicAccountAndTag(txJSON.Destination)
+    newTxJSON.Destination = destinationAccount
+    if (destinationTag !== undefined) {
+      if (TRANSACTION_TYPES_WITH_DESTINATION_TAG_FIELD.includes(txJSON.TransactionType)) {
+        if (txJSON.DestinationTag && txJSON.DestinationTag !== destinationTag) {
+          return Promise.reject(new ValidationError(
+            'The Payment `DestinationTag`, if present, must match the tag of the `Destination` X-address'))
+        }
+        if (destinationTag) {
+          newTxJSON.DestinationTag = destinationTag
+        }
+      }
+    }
+  }
+
+  function convertToClassicAccountIfPresent(fieldName: string): void {
+    const account = txJSON[fieldName]
+    if (typeof account === 'string') {
+      const {classicAccount: ca} = getClassicAccountAndTag(account)
+      newTxJSON[fieldName] = ca
+    }
+  }
+
+  // DepositPreauth:
+  convertToClassicAccountIfPresent('Authorize')
+  convertToClassicAccountIfPresent('Unauthorize')
+
+  // EscrowCancel, EscrowFinish:
+  convertToClassicAccountIfPresent('Owner')
+
+  // SetRegularKey:
+  convertToClassicAccountIfPresent('RegularKey')
+
+  setCanonicalFlag(newTxJSON)
+
+  function prepareMaxLedgerVersion(): Promise<void> {
    // Up to one of the following is allowed:
    //   txJSON.LastLedgerSequence
    //   instructions.maxLedgerVersion
    //   instructions.maxLedgerVersionOffset
-    if (txJSON.LastLedgerSequence && instructions.maxLedgerVersion) {
+    if (newTxJSON.LastLedgerSequence && instructions.maxLedgerVersion) {
      return Promise.reject(new ValidationError('`LastLedgerSequence` in txJSON and `maxLedgerVersion`' +
        ' in `instructions` cannot both be set'))
    }
-    if (txJSON.LastLedgerSequence && instructions.maxLedgerVersionOffset) {
+    if (newTxJSON.LastLedgerSequence && instructions.maxLedgerVersionOffset) {
      return Promise.reject(new ValidationError('`LastLedgerSequence` in txJSON and `maxLedgerVersionOffset`' +
        ' in `instructions` cannot both be set'))
    }
-    if (txJSON.LastLedgerSequence) {
-      return Promise.resolve(txJSON)
+    if (newTxJSON.LastLedgerSequence) {
+      return Promise.resolve()
    }
    if (instructions.maxLedgerVersion !== undefined) {
      if (instructions.maxLedgerVersion !== null) {
-        txJSON.LastLedgerSequence = instructions.maxLedgerVersion
+        newTxJSON.LastLedgerSequence = instructions.maxLedgerVersion
      }
-      return Promise.resolve(txJSON)
+      return Promise.resolve()
    }
    const offset = instructions.maxLedgerVersionOffset !== undefined ?
      instructions.maxLedgerVersionOffset : 3
    return api.connection.getLedgerVersion().then(ledgerVersion => {
-      txJSON.LastLedgerSequence = ledgerVersion + offset
-      return txJSON
+      newTxJSON.LastLedgerSequence = ledgerVersion + offset
+      return
    })
  }

-  function prepareFee(): Promise<TransactionJSON> {
+  function prepareFee(): Promise<void> {
    // instructions.fee is scaled (for multi-signed transactions) while txJSON.Fee is not.
    // Due to this difference, we do NOT allow both to be set, as the behavior would be complex and
    // potentially ambiguous.
    // Furthermore, txJSON.Fee is in drops while instructions.fee is in XRP, which would just add to
    // the confusion. It is simpler to require that only one is used.
-    if (txJSON.Fee && instructions.fee) {
+    if (newTxJSON.Fee && instructions.fee) {
      return Promise.reject(new ValidationError('`Fee` in txJSON and `fee` in `instructions` cannot both be set'))
    }
-    if (txJSON.Fee) {
+    if (newTxJSON.Fee) {
      // txJSON.Fee is set. Use this value and do not scale it.
-      return Promise.resolve(txJSON)
+      return Promise.resolve()
    }
    const multiplier = instructions.signersCount === undefined ? 1 :
      instructions.signersCount + 1
    if (instructions.fee !== undefined) {
      const fee = new BigNumber(instructions.fee)
-      if (fee.greaterThan(api._maxFeeXRP)) {
+      if (fee.isGreaterThan(api._maxFeeXRP)) {
        return Promise.reject(new ValidationError(`Fee of ${fee.toString(10)} XRP exceeds ` +
          `max of ${api._maxFeeXRP} XRP. To use this fee, increase ` +
          '`maxFeeXRP` in the RippleAPI constructor.'))
      }
-      txJSON.Fee = scaleValue(common.xrpToDrops(instructions.fee), multiplier)
-      return Promise.resolve(txJSON)
+      newTxJSON.Fee = scaleValue(common.xrpToDrops(instructions.fee), multiplier)
+      return Promise.resolve()
    }
    const cushion = api._feeCushion
    return api.getFee(cushion).then(fee => {
      return api.connection.getFeeRef().then(feeRef => {
        const extraFee =
-          (txJSON.TransactionType !== 'EscrowFinish' ||
-            txJSON.Fulfillment === undefined) ? 0 :
+          (newTxJSON.TransactionType !== 'EscrowFinish' ||
+          newTxJSON.Fulfillment === undefined) ? 0 :
            (cushion * feeRef * (32 + Math.floor(
-              Buffer.from(txJSON.Fulfillment, 'hex').length / 16)))
+              Buffer.from(newTxJSON.Fulfillment, 'hex').length / 16)))
        const feeDrops = common.xrpToDrops(fee)
        const maxFeeXRP = instructions.maxFee ?
          BigNumber.min(api._maxFeeXRP, instructions.maxFee) : api._maxFeeXRP
        const maxFeeDrops = common.xrpToDrops(maxFeeXRP)
        const normalFee = scaleValue(feeDrops, multiplier, extraFee)
-        txJSON.Fee = BigNumber.min(normalFee, maxFeeDrops).toString(10)
+        newTxJSON.Fee = BigNumber.min(normalFee, maxFeeDrops).toString(10)

-        return txJSON
+        return
      })
    })
  }

-  async function prepareSequence(): Promise<TransactionJSON> {
+  async function prepareSequence(): Promise<void> {
    if (instructions.sequence !== undefined) {
-      if (txJSON.Sequence === undefined || instructions.sequence === txJSON.Sequence) {
-        txJSON.Sequence = instructions.sequence
-        return Promise.resolve(txJSON)
+      if (newTxJSON.Sequence === undefined || instructions.sequence === newTxJSON.Sequence) {
+        newTxJSON.Sequence = instructions.sequence
+        return Promise.resolve()
      } else {
        // Both txJSON.Sequence and instructions.sequence are defined, and they are NOT equal
        return Promise.reject(new ValidationError('`Sequence` in txJSON must match `sequence` in `instructions`'))
      }
    }
-    if (txJSON.Sequence !== undefined) {
-      return Promise.resolve(txJSON)
+    if (newTxJSON.Sequence !== undefined) {
+      return Promise.resolve()
    }

    try {
      // Consider requesting from the 'current' ledger (instead of 'validated').
      const response = await api.request('account_info', {
-        account
+        account: classicAccount
      })
-      txJSON.Sequence = response.account_data.Sequence
-      return Promise.resolve(txJSON)
+      newTxJSON.Sequence = response.account_data.Sequence
+      return Promise.resolve()
    } catch (e) {
      return Promise.reject(e)
    }
@@ -181,7 +267,7 @@ function prepareTransaction(txJSON: TransactionJSON, api: RippleAPI,
    prepareMaxLedgerVersion(),
    prepareFee(),
    prepareSequence()
-  ]).then(() => formatPrepareResponse(txJSON))
+  ]).then(() => formatPrepareResponse(newTxJSON))
 }

 function convertStringToHex(string: string): string {
@@ -203,5 +289,6 @@ export {
  convertMemo,
  prepareTransaction,
  common,
-  setCanonicalFlag
+  setCanonicalFlag,
+  getClassicAccountAndTag
 }
--- a/test/api-test.js
+++ b/test/api-test.js
--- a/test/api/combine/index.ts
+++ b/test/api/combine/index.ts
@@ -0,0 +1,29 @@
+import assert from 'assert-diff'
+import binary from 'ripple-binary-codec'
+import requests from '../../fixtures/requests'
+import responses from '../../fixtures/responses'
+import { assertResultMatch, TestSuite } from '../../utils'
+const { combine: REQUEST_FIXTURES } = requests
+const { combine: RESPONSE_FIXTURES } = responses
+
+/**
+ * Every test suite exports their tests in the default object.
+ * - Check out the "TestSuite" type for documentation on the interface.
+ * - Check out "test/api/index.ts" for more information about the test runner.
+ */
+export default <TestSuite>{
+  'combine': async (api, address) => {
+    const combined = api.combine(REQUEST_FIXTURES.setDomain)
+    assertResultMatch(combined, RESPONSE_FIXTURES.single, 'sign')
+  },
+
+  'combine - different transactions': async (api, address) => {
+    const request = [REQUEST_FIXTURES.setDomain[0]]
+    const tx = binary.decode(REQUEST_FIXTURES.setDomain[0])
+    tx.Flags = 0
+    request.push(binary.encode(tx))
+    assert.throws(() => {
+      api.combine(request)
+    }, /txJSON is not the same for all signedTransactions/)
+  }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Elliot Lee	f5bad5d28e	Release 1.5.0	2019-12-14 22:45:12 -08:00
Elliot Lee	9b7d255200	Update webpack (#1112 )	2019-12-14 10:24:32 -08:00
Elliot Lee	7a027bdd93	Update README (#1111 )	2019-12-14 10:24:05 -08:00
FKSRipple	439a611a9e	Add a heartbeat to detect hung connections (#1101 ) * disconnect is now reconnect on heartbeat fail	2019-12-14 10:23:09 -08:00
RareData	5f92b230aa	Add support for WalletLocator (#1083 ) Being able to fetch the WalletLocator field opens up new use-cases. The field can store for example a transaction hash, referencing a transaction with memos containing useful data.	2019-12-11 23:47:41 -08:00
Elliot Lee	29bc5303ae	Fix tests (#1109 ) * Revert "[docs] Update getTransactions example request/response (#1106)" This reverts commit `5314e5e7e9`. * Redo #1106 but with passing tests	2019-12-11 22:54:33 -08:00
Elliot Lee	5314e5e7e9	[docs] Update getTransactions example request/response (#1106 )	2019-12-11 14:45:04 -08:00
Elliot Lee	c88462c99b	[package.json] Require node 8 and yarn (#1107 )	2019-12-11 14:43:04 -08:00
Elliot Lee	0b552f1a7e	Update yarn.lock ripple-lib-transactionparser@0.8.1	2019-12-10 11:36:34 -08:00
FKSRipple	552635a3c7	Merge pull request #1104 from ripple/all-tests Migrate RippleAPI tests to new test runner	2019-12-09 11:00:34 -08:00
FKSRipple	ca769bee39	Merge pull request #1103 from ripple/test-runner-02 Make improvements to test runner	2019-12-09 11:00:06 -08:00
Elliot Lee	b7ca0a0a14	Merge pull request #1102 from ripple/test-runner-01 Small source fixes, based on issues found with test improvements	2019-12-09 09:16:58 -08:00
Fred K. Schott	84097a3179	move the remaining RippleAPI tests to the new test runner	2019-11-26 16:52:21 -08:00
Fred K. Schott	8ba36b2588	fix bad path	2019-11-26 16:52:05 -08:00
Fred K. Schott	e1d4ebc5f6	add docs	2019-11-26 16:50:12 -08:00
Fred K. Schott	9e712d6089	fix old ref	2019-11-26 16:44:11 -08:00
Fred K. Schott	90bea3dc6b	fix old utils ref	2019-11-26 16:41:16 -08:00
Fred K. Schott	bf480bb971	remove outdated test utils	2019-11-26 16:37:56 -08:00
Fred K. Schott	a94b48be50	improve the test runner	2019-11-26 16:34:17 -08:00
Fred K. Schott	abed42d848	fix source directory, based on issues found with test improvements	2019-11-26 16:01:03 -08:00
FKSRipple	3d6e795ca5	Merge pull request #1096 from magmel48/typescript3.7-TransactionJSON-conflict-fix TransactionJSON conflict fix	2019-11-19 15:04:10 -08:00
magmel	a3cbe8e9d4	back to ts3.6.4	2019-11-18 15:39:45 +03:00
FKSRipple	0a2000098a	Merge pull request #1097 from r0bertz/develop Bump ripple-lib-transactionparser to 0.8.1	2019-11-18 00:02:11 -08:00
FKSRipple	a2348b5133	revert package version change	2019-11-18 00:01:18 -08:00
FKSRipple	20d2f9d894	Merge pull request #1086 from ripple/refactor-tests Add RippleAPI test runner, with support for multiple address testing	2019-11-17 23:49:22 -08:00
FKSRipple	321f908e76	Merge pull request #1084 from ripple/tests-to-ts-04 Complete move of tests to TS	2019-11-17 23:42:38 -08:00
FKSRipple	49875cb0e5	Update api-test.ts	2019-11-17 23:42:21 -08:00
Le Zhang	1074c00b60	Bump ripple-lib-transactionparser to 0.8.1	2019-11-16 01:05:48 -08:00
magmel	8a8b10541e	yarn.lock	2019-11-15 15:47:14 +03:00
magmel	46cf4d677c	typescript ^ in package.json	2019-11-15 15:46:11 +03:00
magmel	94587d7515	moved TransactionJSON to proper types.ts file	2019-11-15 15:44:31 +03:00
Elliot Lee	14ec58ef9a	Fix link	2019-11-14 21:00:33 -08:00
Elliot Lee	8f4f6f3de0	Release 1.4.2	2019-11-14 20:50:29 -08:00
Elliot Lee	f8c0ac3ce0	Update docs * Add tickSize parameter * Fix formatting	2019-11-14 20:38:40 -08:00
RareData	8ebad98912	Add support for tick size (#1090 )	2019-11-14 20:13:58 -08:00
FKSRipple	08429b6110	Merge pull request #1092 from nickewansmith/fix-unhandled-rejection-warning-on-send Fix Unhandled Promise Rejection Warning on message _send	2019-11-13 19:54:48 -08:00
FKSRipple	0e128e15f1	Merge pull request #1089 from RareData/patch-2 Update email hash default to allow proper clearing	2019-11-13 19:51:53 -08:00
Fred K. Schott	b77a12fd0d	Add test runner for RippleAPI, begin to break up large test file	2019-11-13 19:47:49 -08:00
Fred K. Schott	a98526b398	Revert "Revert "Merge pull request #1052 from FredKSchott/tests-to-ts-03"" This reverts commit `b648387a57`.	2019-11-13 19:47:18 -08:00
Fred K. Schott	5639bf9d48	merge xaddress tests into main test file	2019-11-13 19:47:18 -08:00
Fred K. Schott	c626685103	start running test/x-address-api-test.ts	2019-11-13 19:47:18 -08:00
FKSRipple	e233d15fbb	Merge pull request #1087 from ripple/prettier Add a prettier config	2019-11-13 09:51:45 -08:00
Fred K. Schott	a5d83900d9	set trailing trailingComma to none	2019-11-13 09:50:13 -08:00
Nicholas Smith	d8dbeedcc2	Adds an immediate catch to the _send promise passed to _whenReady in case there is rejection before async handlers are added	2019-11-13 01:24:09 -05:00
FKSRipple	56b67d62a3	Update Node.js Testing Versions (#1085 ) Updated our testing matrix based on: https://nodejs.org/en/about/releases/ - Node 11 is no longer supported (not LTS) - Node 12 added (active LTS) - Node 13 added ("current" release)	2019-11-11 13:56:22 -08:00
RareData	dc084b4bd9	Add XRP Toolkit reference (#1088 )	2019-11-11 13:54:27 -08:00
RareData	1bc0eab7ae	Update email hash default to fix clearing bug	2019-11-11 19:09:32 +01:00
Fred K. Schott	ca14d1b108	add a prettier config	2019-11-10 13:56:42 -08:00
Elliot Lee	d6757aced2	Release 1.4.1 (#1079 )	2019-11-06 21:30:14 -08:00
Keefer Taylor	5c84eed292	Fix Travis Build (#1076 ) * Drop support for node 6 * Add build badge * Remove `compile` command, no longer used	2019-11-06 16:44:57 -08:00
Elliot Lee	b648387a57	Revert "Merge pull request #1052 from FredKSchott/tests-to-ts-03" This reverts commit `e08367365f`, reversing changes made to `36a9e7a7cf`.	2019-11-06 10:34:05 -08:00
Tyler Levine	5232f95c3f	Change TypeScript compile target to es6 (#1071 ) This allows for the use of Node 6. Note that Node v6 is no longer supported by Node.js (End-of-life'd in April 2019). We recommend updating to Node v8/v10 ASAP, to keep getting security updates and fixes from the Node.js team.	2019-11-05 09:05:47 -08:00
FKSRipple	0742960ec4	Merge pull request #1061 from ripple/webpack-update Update Webpack	2019-11-05 08:13:44 -08:00
Fred K. Schott	4c41b7f8df	revert name change	2019-11-05 08:13:27 -08:00
Fred K. Schott	c5d0c24237	update webpack flow	2019-11-04 21:33:39 -08:00
FKSRipple	8b5c51ceaa	Merge pull request #1073 from ripple/update-ws update ws dependency	2019-11-04 19:38:05 -08:00
Fred K. Schott	c09bceb66a	fix type	2019-11-04 19:36:34 -08:00
Fred K. Schott	e7afd3ec76	respond to comments	2019-11-04 19:33:43 -08:00
Fred K. Schott	3d30be3472	update ws dependency	2019-11-04 19:33:43 -08:00
FKSRipple	e08367365f	Merge pull request #1052 from FredKSchott/tests-to-ts-03 Convert the rest of the test helpers to TS	2019-11-04 19:30:02 -08:00
Fred K. Schott	6692fbeed4	respond to comments	2019-11-04 19:20:40 -08:00
FKSRipple	36a9e7a7cf	Merge pull request #1074 from ripple/update-bignumber update bignumber dependency	2019-11-04 18:59:43 -08:00
FKSRipple	49b5ff5fd9	Merge pull request #1075 from ripple/update-keypairs update ripple-keypairs	2019-11-04 18:58:16 -08:00
Fred K. Schott	1bde56a11a	update ripple-keypairs	2019-11-02 08:54:46 -07:00
Fred K. Schott	f47d7b6935	update bignumber dependency	2019-11-02 08:36:46 -07:00
Fred K. Schott	2dbad40a34	update assert-diff	2019-11-02 07:51:39 -07:00
Fred K. Schott	39f6a51794	convert the rest of the helper files to ts	2019-11-02 07:40:52 -07:00
Fred K. Schott	7ec128c2e4	move tests to TypeScript	2019-11-02 07:40:52 -07:00
FKSRipple	b55f0e849e	Merge pull request #1069 from mDuo13/getAccountObjects_doc getAccountObjects doc fix	2019-11-02 06:54:13 -07:00
mDuo13	f158390ba1	getAccountObjects doc fix Add necessary blank line for the list to render properly. (xrpl.org's Markdown parser won't recognize the list without it.)	2019-10-29 14:23:10 -07:00
Elliot Lee	e4b245104a	Release 1.4.0	2019-10-28 17:10:03 -07:00
Elliot Lee	789497b07e	Fix lint errors	2019-10-28 17:01:32 -07:00
FKSRipple	5cf01ba099	Merge pull request #1051 from FredKSchott/tests-to-ts-02 Move tests to TypeScript	2019-10-28 10:54:39 -07:00
Fred K. Schott	e8669891f8	small typo fixes	2019-10-28 10:54:06 -07:00
Fred K. Schott	ac0f265a5b	move tests to TypeScript	2019-10-28 10:53:36 -07:00
Elliot Lee	fcd6b430e1	Reduce dependency size (#1057 ) - Remove .npmignore since it is overridden by package.json 'files' - Include build/ripple-latest-min.js, not everything in build/	2019-10-25 13:57:45 -07:00
Elliot Lee	f3ad8a9b80	Merge pull request #1060 from fix-test Fix broken tests	2019-10-25 13:56:43 -07:00
Fred K. Schott	43ff824da1	fix broken tests	2019-10-25 10:18:46 -07:00
Fairy	b8022610ca	Fix error in Safari (#869 ) * Safari minify fix * Update browser-hacks.ts	2019-10-24 10:41:21 -07:00
FKSRipple	03defe203a	Merge pull request #773 from aMoniker/develop unref timer so it doesnt hang the node process	2019-10-23 18:29:20 -07:00
FKSRipple	aedcbe56b3	Added small style changes	2019-10-23 18:29:07 -07:00
FKSRipple	c365db460a	Merge pull request #1044 from ripple/connection-timeout Add a 2-second timeout for connect()	2019-10-23 18:19:39 -07:00
Elliot Lee	cfdc4752d0	let -> const and reject with error	2019-10-23 12:25:02 -07:00
Elliot Lee	e1964ac5ed	Add support for the X-address format (#1041 ) * Update schema-validator * Update to ripple-address-codec 4.0.0 * Update ./src/common/hashes/index.ts * Add generateXAddress method * Deprecate generateAddress method * Add unit tests * Add documentation	2019-10-23 12:03:59 -07:00
James Greenleaf	e17ab9cd8f	Add conditional to timer.unref	2019-10-23 14:44:20 -04:00
James Greenleaf	edc15b8727	Merge remote-tracking branch 'upstream/develop' into develop	2019-10-23 14:42:05 -04:00
Fred K. Schott	034f8d41fc	remove bad semicolon	2019-10-23 00:33:09 -07:00
Fred K. Schott	0fa70db1e1	Merge branch 'develop' into connection-timeout	2019-10-23 00:32:03 -07:00
FKSRipple	fa7ba9b72b	Update connection.ts	2019-10-23 00:27:17 -07:00
FKSRipple	3a20123e0f	Merge pull request #1046 from ripple/improve-tx-not-found Improve getTransaction() error when tx has not been validated yet	2019-10-23 00:22:07 -07:00
FKSRipple	03510d1bc4	Update index.ts	2019-10-23 00:21:35 -07:00
Elliot Lee	8b116f637a	Update yarn.lock	2019-10-22 00:57:26 -07:00
Elliot Lee	9c49de6552	Merge pull request #1054 from tylerlevine/update-https-proxy-agent Update https-proxy-agent to 3.0.0	2019-10-22 00:56:33 -07:00
Elliot Lee	842347bcab	Merge branch 'develop' into update-https-proxy-agent	2019-10-22 00:56:07 -07:00
Elliot Lee	628b9c4853	Merge pull request #1049 from FredKSchott/eslint Replace tslint (since deprecated) with eslint	2019-10-21 11:01:53 -07:00
Fred K. Schott	d60b6ee33f	Merge remote-tracking branch 'myfork/eslint' into eslint	2019-10-21 10:03:27 -07:00
Fred K. Schott	4f4fcbbc70	add tests to linting	2019-10-21 10:02:14 -07:00
Tyler Levine	cc896670dc	Update https-proxy-agent to 3.0.0	2019-10-18 16:16:54 -07:00
Elliot Lee	eb2a497dee	Release 1.3.4	2019-10-18 14:41:58 -07:00
Fred K. Schott	0cf5ce1416	Merge branch 'develop' into eslint	2019-10-17 11:23:26 -07:00
Elliot Lee	988381d584	Merge pull request #1048 from FredKSchott/tsc-update Update TypeScript	2019-10-16 23:04:20 -07:00
Elliot Lee	0b163eae23	XRP Ledger Hashes: create README.md	2019-10-15 16:34:48 -07:00
Fred K. Schott	3a3ff8a65e	Update utils.ts	2019-10-15 13:49:03 -07:00
Fred K. Schott	9f183a6dfc	replace tslint (deprecated) with eslint	2019-10-13 16:44:22 -07:00
Fred K. Schott	fadfd4e06c	update typescript	2019-10-13 16:19:45 -07:00
Sohail Salehi	eb521faa8d	Doc update for sign() method (#1010 ) * Add multi-signing example to the sign() method Explains why the `signAs` option is compulsory for multi-signing scenarios.	2019-10-08 11:59:12 -07:00
Elliot Lee	6b572ca862	Improve getTransaction() error when tx has not been validated yet	2019-10-04 23:56:09 -07:00
Elliot Lee	d075ec6716	Add a 2-second timeout for connect()	2019-10-03 00:02:55 -07:00
Tyler Storm	14e6bf5ef9	Integrate ripple-hashes (#1039 ) * Update TxParser and Mocha * Convert ripple-hashes to TypeScript and add into ripple-lib along with unit tests * Switch casing to camelCase * Document intToVuc * Convert Slots to numbers, add exception if number is outside 0-15 * Remove Shamap v2 support * Improve naming	2019-10-01 23:35:11 -07:00
Elliot Lee	b6bddd3b0e	[MINOR] Remove unnecessary semicolon	2019-09-26 03:18:54 -07:00
Elliot Lee	d5ed9b6cf5	Improve error message when signing fails When there are multiple representations of the same value (for example, trailing zeros) the verification will fail. This points users to the error.data object for details about the failure, and adds a diff so that the cause of the discrepancy can be seen at a glance.	2019-09-24 09:58:24 -07:00
Tyler Storm	7a9912d4e0	Update TxParser and Mocha	2019-09-24 09:57:56 -07:00
Mo Morsi	4d2ddceb4e	Change "wipple" to "xrp1ntel" (#1036 ) The Wipple Analytics Engine is now accessed through the xrp1ntel website	2019-09-12 13:15:26 -07:00
Elliot Lee	ae2aed675a	v1.3.3	2019-09-10 19:30:11 -07:00
Elliot Lee	1d7cb41218	Add rippleTimeToISO8601.md.ejs	2019-09-04 00:31:02 -07:00
Elliot Lee	76db002eb5	Expand node version compatibility Previously the library could not be installed with node 12: https://github.com/ripple/ripple-binary-codec/pull/33	2019-09-04 00:17:53 -07:00
Elliot Lee	ebb64ba177	v1.3.2	2019-09-03 16:43:31 -07:00
Elliot Lee	1a685e2b68	Fix #1032 (#1033 ) * Update ripple-address-codec@latest * Export and document rippleTimeToISO8601	2019-09-03 16:38:56 -07:00
Rome Reginelli	9c561885a1	Docs: update recommended Node ver. (#1031 )	2019-08-29 20:34:25 -07:00
Elliot Lee	612e98b198	Release 1.3.1	2019-08-26 13:58:09 -07:00
Jim Greenleaf	0c98082b25	unref timer so it doesnt hang the node process	2017-06-19 15:30:49 -04:00