Merge branch 'master' into develop

Add 1.8.2 checksums
Release 1.8.2 (#1320 )
2025-11-17 19:05:47 +00:00 · 2020-10-23 13:53:33 -07:00 · 2020-10-23 13:51:49 -07:00 · 2020-10-23 13:48:13 -07:00 · 2020-10-23 13:37:39 -07:00 · 2020-10-16 14:45:53 -07:00
32 changed files with 1403 additions and 826 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,5 @@
 language: node_js
 node_js:
-  - 8
  - 10
  - 12
  - 13
--- a/APPLICATIONS.md
+++ b/APPLICATIONS.md
@@ -10,9 +10,19 @@ These sites are independent of Ripple and have not been authorized, endorsed, sp

 Warning: Use at your own risk.

+## Exchanges
+
+- **[The World Exchange](https://www.theworldexchange.net/)**
+
+  Trade, issue, and send directly on the XRP Ledger. A user interface for the XRPL's decentralized exchange.
+
+- **[Bitso](https://bitso.com/)**
+
+  Exchange allowing clients to buy and sell XRP, based in Mexico.
+
 ## Data and visualizations

- **[xrp1ntel - XRP Intelligence](https://xrp1ntel.com/)**
+- **[xrpintel - XRP Intelligence](https://xrpintel.com/)**

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

@@ -39,27 +49,25 @@ Warning: Use at your own risk.
 - **[XRP Scan - XRP Ledger explorer](https://xrpscan.com)**

  XRP Ledger explorer, metrics and analytics.
+  
+- **[xrplorer](https://xrplorer.com)**

-## Send and request payments
+  XRP Ledger explorer, API, metrics, and analytics using a graph database that is synchronized live with the XRPL.

- **[XRP Tip Bot](https://www.xrptipbot.com/)**
+- **[zerptracker](https://zerptracker.com)**

-  A bot that enables users on reddit, Twitter and Discord to send XRP to each other through reddit comments and Twitter tweets.
-
- **[XRP Text](https://xrptext.com/)**
-
-  Send XRP using SMS text messages.
-
- **[XRParrot](https://xrparrot.com/)** (uses `ripple-address-codec`)
-
-  Easy EUR (SEPA) to XRP transfer (currency conversion).
-
- **[XRP Payment](https://xrpayments.co/)** (xrpayments.co)
-
-  Tool for generating a XRP payment request URI in a QR code, with currency converter.
+  Monitor the XRPL using powerful JSONPath expressions, and receive notifications via email, SMS, webhooks, and more.

 ## Wallets and wallet tools

+- **[XUMM](https://xumm.app/)**
+
+  Users can use the xumm application to track their accounts, balances and transactions. The true power of xumm is the platform available for developers.
+
+- **[Xpring Wallet](https://xpring.io)** (uses `ripple-keypairs`)
+
+  Non-custodial XRP wallet.
+
 - **[XRP Toolkit](https://www.xrptoolkit.com)**

  A web interface to the XRP Ledger, supporting both hardware and software wallets.
@@ -88,11 +96,29 @@ Warning: Use at your own risk.

  Recover a 24 word mnemonic if one word is wrong or one word is missing.

+## Send and request payments
+
+- **[XRP Tip Bot](https://www.xrptipbot.com/)**
+
+  A bot that enables users on reddit, Twitter and Discord to send XRP to each other through reddit comments and Twitter tweets.
+
+- **[XRP Text](https://xrptext.com/)**
+
+  Send XRP using SMS text messages.
+
+- **[XRParrot](https://xrparrot.com/)** (uses `ripple-address-codec`)
+
+  Easy EUR (SEPA) to XRP transfer (currency conversion).
+
+- **[XRP Payment](https://xrpayments.co/)** (xrpayments.co)
+
+  Tool for generating a XRP payment request URI in a QR code, with currency converter.
+
 ## Development tools

- **[XRP Test Net Faucet](https://developers.ripple.com/xrp-test-net-faucet.html)**
+- **[XRP Faucets for Testnet and Devnet](https://xrpl.org/xrp-testnet-faucet.html)**

-  Get some test funds for development on the test network. The faucet was built using `ripple-lib`.
+  Get some test funds for development on the test network. The faucet uses `ripple-lib`.

 ## Code samples and libraries

--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,5 +1,69 @@
 # ripple-lib Release History

+Subscribe to [the **ripple-lib-announce** mailing list](https://groups.google.com/forum/#!forum/ripple-lib-announce) for release announcements. We recommend that ripple-lib users stay up-to-date with the latest stable release.
+
+## 1.8.2 (2020-10-23)
+
+* Bug fixes
+  * Browser compatibility: Use ripple-binary-codec 0.2.x to prevent browser issues (#1321)
+  * Memory leak: Clear awaiting response promises to prevent memory leak (#1302)
+* Feature: getSettings() - allow ledgerVersion to be 'validated', 'closed', or 'current' (#1298)
+* Docs: Update APPLICATIONS.md
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 *
+ba760c36028b8a3ce267386e188a422890dfb1b03bc87c852a4c2034ea9bac2e  ripple-latest-min.js
+7e5281eb9623602284b9f11564f0f3a36cfde305f2c2f7a32e0d29a04913c817  ripple-latest.js
+```
+
+## 1.8.1 (2020-09-25)
+
+* Internal
+  * Bump elliptic to 6.5.3 (this patches a potential security issue, although we do not believe that the issue affects ripple-lib)
+  * Bump ripple-binary-codec to 1.0.2
+  * Bump lodash to 4.17.19
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 *
+0895f349944fa11bb1976b2c350c0eb143dfd09abbfc7c2be33aed5c2a4b9ee8  ripple-latest-min.js
+7c00188a28f9d295d8e66aa08b340294d2fe49f635d154fb0df049ae8572c195  ripple-latest.js
+```
+
+## 1.8.0 (2020-07-06)
+
+* [Document `request('submit', ...)` method](https://github.com/ripple/ripple-lib/blob/develop/docs/index.md#submit), which includes additional useful information in the response
+* Update [list of applications using ripple-lib](https://github.com/ripple/ripple-lib/blob/1.7.0/APPLICATIONS.md)
+
+## 1.7.1 (2020-05-26)
+
+* Fix preparePayment when using source.amount/destination.minAmount (#1295) (Fix #1237) (Thanks to @leobel)
+* Docs
+  * Fix generateXAddress example (#1286)
+  * Update Transaction Streams link (#1278)
+* Dependencies
+  * Update assert-diff, mocha, webpack-bundle-analyzer, @typescript-eslint/parser, @typescript-eslint/eslint-plugin, @types/ws, @types/node, ws, ts-node, eventemitter2
+
+## 1.7.0 (2020-04-28)
+
+* Export hashing functions (#1275)
+* Add failHard (fail_hard) option in `submit` method (#1029)
+* Add type for parseAccountFlags (#1258)
+* Add api.connection.getReserveBase() (#1259)
+* Travis: remove node 8 (#1257)
+* Dependencies
+  * Update ripple-address-codec, @types/ws, @types/lodash, https-proxy-agent
+  * Update devDependencies: eventemitter2, nyc, ejs, @types/node, webpack, ts-node, prettier, @typescript-eslint/eslint-plugin
+
+## 1.6.5 (2020-03-23)
+
+* APPLICATIONS.md: Add xrplorer.com
+* Internal: Fix typos
+* Dependencies
+  * Update @types/ws, @types/node, @typescript-eslint/eslint-plugin, @types/mocha, webpack, typescript, mocha, assert-diff
+  * Remove mocha-junit-reporter
+
 ## 1.6.4 (2020-02-18)

 * Fix generateXAddress() and generateAddress() with no entropy (#1211, #1209)
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ For details, see the `scripts` in `package.json`.

 ### Linting

-Run `yarn lint` to lint the code with `tslint`.
+Run `yarn lint` to lint the code with `eslint`.

 ## Generating Documentation

--- a/docs/index.md
+++ b/docs/index.md
@@ -39,6 +39,7 @@
  - [hasNextPage](#hasnextpage)
  - [requestNextPage](#requestnextpage)
 - [Static Methods](#static-methods)
+  - [computeBinaryTransactionHash](#computebinarytransactionhash)
  - [renameCounterpartyToIssuer](#renamecounterpartytoissuer)
  - [formatBidsAndAsks](#formatbidsandasks)
 - [API Methods](#api-methods)
@@ -833,7 +834,7 @@ Type | Description
 `ledgerClosed` | Sent by the `ledger` stream when the consensus process declares a new fully validated ledger. The message identifies the ledger and provides some information about its contents.
 `validationReceived` | Sent by the `validations` stream when the server receives a validation message, also called a validation vote, regardless of whether the server trusts the validator.
 `manifestReceived` | Sent by the `manifests` stream when the server receives a manifest.
-`transaction` | Sent by many subscriptions including `transactions`, `transactions_proposed`, `accounts`, `accounts_proposed`, and `book` (Order Book). See [Transaction Streams](https://ripple.com/build/rippled-apis/#transaction-streams) for details.
+`transaction` | Sent by many subscriptions including `transactions`, `transactions_proposed`, `accounts`, `accounts_proposed`, and `book` (Order Book). See [Transaction Streams](https://xrpl.org/subscribe.html#transaction-streams) for details.
 `peerStatusChange` | (Admin-only) Reports a large amount of information on the activities of other `rippled` servers to which the server is connected.
 `path_find` | Asynchronous follow-up response to the currently open path\_find request. See [rippled path\_find method](https://xrpl.org/path_find.html) for details.

@@ -842,7 +843,7 @@ To register your listener function, use `connection.on(type, handler)`.
 Here is an example of listening for transactions on given account(s):
 ```
 const account = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn' // Replace with the account you want notifications for
-api.connect().then(() => { // Omit this if you are already connected
+api.connect().then(() => {

  // 'transaction' can be replaced with the relevant `type` from the table above
  api.connection.on('transaction', (event) => {
@@ -854,9 +855,7 @@ api.connect().then(() => { // Omit this if you are already connected
  api.request('subscribe', {
      accounts: [ account ]
  }).then(response => {
-      if (response.status === 'success') {
-          console.log('Successfully subscribed')
-      }
+      console.log('Successfully subscribed')
  }).catch(error => {
      // Handle `error`
  })
@@ -982,6 +981,40 @@ return api.request(command, params).then(response => {

 # Static Methods

+ripple-lib features a number of static methods that you can access directly on the `RippleAPI` object. The most commonly-used one is `computeBinaryTransactionHash`, described below. For the full list, see the [XRP Ledger Hashes README](https://github.com/ripple/ripple-lib/blob/develop/src/common/hashes/README.md).
+
+## computeBinaryTransactionHash
+
+`computeBinaryTransactionHash(txBlobHex: string): string`
+
+Returns the hash (id) of a binary transaction blob.
+
+This is a static method on the `RippleAPI` class.
+
+### Parameters
+
+This method takes one parameter, a string containing a binary transaction in hex.
+
+### Return Value
+
+This method returns a string representing the transaction's id (hash).
+
+### Example
+
+```javascript
+const signed_blob = '120000228000000024000B2E5A201B0066374B61400000003B9ACA0068400000000000000C732102356E89059A75438887F9FEE2056A2890DB82A68353BE9C0C0C8F89C0018B37FC74473045022100B3721EEB1ED6DFF29FB8B209E2DE6B54A0A6E44D52D926342F3D334BE98F08640220367A74107AD5DEAEFA3AB2984C161FC23F30B2704BB5CC984358BA262177A4568114F667B0CA50CC7709A220B0561B85E53A48461FA883142B71D8B09B4EE8DAA68FB936C23E3A974713BDAC'
+if (typeof signed_blob === 'string' && signed_blob.match(/^[A-F0-9]+$/)) {
+  const id = RippleAPI.computeBinaryTransactionHash(signed_blob)
+  console.log('Transaction hash:', id')
+}
+```
+
+```
+Transaction hash: 80C5E11E1A21A626759D6CB944B33DBAAC66BD704A289C86E330B847904F5C13
+```
+
+[RunKit Example: computeBinaryTransactionHash](https://runkit.com/intelliot/computebinarytransactionhash-example)
+
 ## renameCounterpartyToIssuer

 `renameCounterpartyToIssuer(issue: {currency: string, counterparty: address}): {currency: string, issuer: address}`
@@ -5591,66 +5624,87 @@ return api.combine(signedTransactions);

 ## submit

-`submit(signedTransaction: string): Promise<object>`
+`request('submit', {tx_blob: string, fail_hard: boolean}): Promise<object>`

-Submits a signed transaction. The transaction is not guaranteed to succeed; it must be verified with [getTransaction](#gettransaction).
+The `submit` method applies a transaction and sends it to the network to be confirmed and included in future ledgers.
+
+This method takes a signed, serialized transaction as a binary blob, and submits it to the network as-is. Since signed transaction objects are immutable, no part of the transaction can be modified or automatically filled in after submission.
+
+To send a transaction as robustly as possible, you should construct and sign it in advance, persist it somewhere that you can access even after a power outage, then `submit` it as a `tx_blob`. After submission, monitor the network with the `tx` method to see if the transaction was successfully applied; if a restart or other problem occurs, you can safely re-submit the `tx_blob` transaction: it won't be applied twice since it has the same sequence number as the old transaction.

 ### Parameters

-Name | Type | Description
---- | ---- | -----------
-signedTransaction | string | A signed transaction as returned by [sign](#sign).
+| `Field`     | Type    | Description                                          |
+|:------------|:--------|:-----------------------------------------------------|
+| `tx_blob`   | String  | Hex representation of the signed transaction to submit. This can be a multi-signed transaction. |
+| `fail_hard` | Boolean | (Optional, defaults to false) If true, and the transaction fails locally, do not retry or relay the transaction to other servers |

 ### Return Value

-This method returns an object with the following structure:
+When successful, this method returns an object containing the following fields:

-Name | Type | Description
---- | ---- | -----------
-resultCode | string | Deprecated: Use `engine_result` instead.
-resultMessage | string | Deprecated: Use `engine_result_message` instead.
-engine_result | string | Code indicating the preliminary result of the transaction, for example `tesSUCCESS`. [List of transaction responses](https://developers.ripple.com/transaction-results.html)
-engine_result_code | integer | Numeric code indicating the preliminary result of the transaction, directly correlated to `engine_result`
-engine_result_message | string | Human-readable explanation of the transaction's preliminary result.
-tx_blob | string | The complete transaction in hex string format.
-tx_json | [tx-json](https://developers.ripple.com/transaction-formats.html) | The complete transaction in JSON format.
+| `Field`                 | Type    | Description                              |
+|:------------------------|:--------|:-----------------------------------------|
+| `engine_result`         | String  | Text [result code](https://xrpl.org/transaction-results.html) indicating the preliminary result of the transaction, for example `tesSUCCESS` |
+| `engine_result_code`    | Integer | Numeric version of the [result code](https://xrpl.org/transaction-results.html). **Not recommended.** |
+| `engine_result_message` | String  | Human-readable explanation of the transaction's preliminary result |
+| `tx_blob`               | String  | The complete transaction in hex string format |
+| `tx_json`               | Object  | The complete transaction in JSON format  |
+| `accepted`              | Boolean | The value `true` indicates that the transaction was applied, queued, broadcast, or kept for later. The value `false` indicates that none of those happened, so the transaction cannot possibly succeed as long as you do not submit it again and have not already submitted it another time. [New in: rippled 1.5.0] |
+| `account_sequence_available` | Number | The next [Sequence Number](https://xrpl.org/basic-data-types.html#account-sequence) available for the sending account after all pending and [queued](https://xrpl.org/transaction-queue.html) transactions. [New in: rippled 1.5.0] |
+| `account_sequence_next` | number  | The next [Sequence Number](https://xrpl.org/basic-data-types.html#account-sequence) for the sending account after all transactions that have been provisionally applied, but not transactions in the [queue](https://xrpl.org/transaction-queue.html). [New in: rippled 1.5.0] |
+| `applied`               | Boolean | The value `true` indicates that this transaction was applied to the open ledger. In this case, the transaction is likely, but not guaranteed, to be validated in the next ledger version. [New in: rippled 1.5.0] |
+| `broadcast`             | Boolean | The value `true` indicates this transaction was broadcast to peer servers in the peer-to-peer XRP Ledger network. (Note: if the server has no peers, such as in [stand-alone mode](https://xrpl.org/rippled-server-modes.html#reasons-to-run-a-rippled-server-in-stand-alone-mode), the server uses the value `true` for cases where it _would_ have broadcast the transaction.) The value `false` indicates the transaction was not broadcast to any other servers. [New in: rippled 1.5.0] |
+| `kept`                  | Boolean | The value `true` indicates that the transaction was kept to be retried later. [New in: rippled 1.5.0] |
+| `queued`                | Boolean | The value `true` indicates the transaction was put in the [Transaction Queue](https://xrpl.org/transaction-queue.html), which means it is likely to be included in a future ledger version. [New in: rippled 1.5.0] |
+| `open_ledger_cost`      | String  | The current [open ledger cost](https://xrpl.org/transaction-cost.html#open-ledger-cost) before processing this transaction. Transactions with a lower cost are likely to be [queued](https://xrpl.org/transaction-queue.html). [New in: rippled 1.5.0] |
+| `validated_ledger_index` | Integer  | The [ledger index](https://xrpl.org/basic-data-types.html#ledger-index) of the newest validated ledger at the time of submission. This provides a lower bound on the ledger versions that the transaction can appear in as a result of this request. (The transaction could only have been validated in this ledger version or earlier if it had already been submitted before.) |
+
+Note: Many situations can prevent a transaction from processing successfully, such as a lack of trust lines connecting the two accounts in a payment, or changes in the state of the ledger since the time the transaction was constructed. Even if nothing is wrong, it may take several seconds to close and validate the ledger version that includes the transaction. Do not consider the transaction's results final until they appear in a validated ledger version.

 ### Example

 ```javascript
-const signedTransaction = '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100BDE09A1F6670403F341C21A77CF35BA47E45CDE974096E1AA5FC39811D8269E702203D60291B9A27F1DCABA9CF5DED307B4F23223E0B6F156991DB601DFB9C41CE1C770A726970706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304';
-return api.submit(signedTransaction)
-  .then(result => {/* ... */});
+const signedTransaction = '12000022800000002400000007201B007008BC61400000000754D4C068400000000000000C732103E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F824832874473045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22811492F80A3F3849DBB5714A4F2C691CE7D47BEED58083141266204CFBC657E65D9B4D30301FF98644693935';
+const failHard = false;
+const result = await api.request('submit', {
+  tx_blob: signedTransaction,
+  fail_hard: failHard // optional
+});
 ```

-
 ```json
 {
-  "resultCode": "tesSUCCESS",
-  "resultMessage": "The transaction was applied. Only final in a validated ledger.",
+  "accepted": true,
+  "account_sequence_available": 8,
+  "account_sequence_next": 8,
+  "applied": true,
+  "broadcast": true,
  "engine_result": "tesSUCCESS",
  "engine_result_code": 0,
  "engine_result_message": "The transaction was applied. Only final in a validated ledger.",
-  "tx_blob": "1200002280000000240000016861D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA9684000000000002710732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB7446304402200E5C2DD81FDF0BE9AB2A8D797885ED49E804DBF28E806604D878756410CA98B102203349581946B0DDA06B36B35DBC20EDA27552C1F167BCF5C6ECFF49C6A46F858081144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754",
+  "kept": true,
+  "open_ledger_cost": "10",
+  "queued": false,
+  "tx_blob": "12000022800000002400000007201B007008BC61400000000754D4C068400000000000000C732103E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F824832874473045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22811492F80A3F3849DBB5714A4F2C691CE7D47BEED58083141266204CFBC657E65D9B4D30301FF98644693935",
  "tx_json": {
-    "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
-    "Amount": {
-      "currency": "USD",
-      "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
-      "value": "1"
-    },
-    "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
-    "Fee": "10000",
-    "Flags": 2147483648,
-    "Sequence": 360,
-    "SigningPubKey": "03AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB",
-    "TransactionType": "Payment",
-    "TxnSignature": "304402200E5C2DD81FDF0BE9AB2A8D797885ED49E804DBF28E806604D878756410CA98B102203349581946B0DDA06B36B35DBC20EDA27552C1F167BCF5C6ECFF49C6A46F8580",
-    "hash": "4D5D90890F8D49519E4151938601EF3D0B30B16CD6A519D9C99102C9FA77F7E0"
-  }
+      "Account": "rNQao3Z1irwRjKWSs8heL4a8WKLPKfLrXs",
+      "Amount": "123000000",
+      "Destination": "rpgHWJdXkSvvzikdJCpuMzU7zWnuqsJRCZ",
+      "Fee": "12",
+      "Flags": 2147483648,
+      "LastLedgerSequence": 7342268,
+      "Sequence": 7,
+      "SigningPubKey": "03E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F8248328",
+      "TransactionType": "Payment",
+      "TxnSignature": "3045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22",
+      "hash": "FE8D68D7FF5805EB07AF15A1ADF07FB5463CCD2C6C0A15981EB3D26A02E1551C"
+  },
+  "validated_ledger_index": 7341775
 }
 ```

+(In ripple-lib 1.8.0, [the old `submit` method](https://github.com/ripple/ripple-lib/blob/1.7.0/docs/index.md#submit) was deprecated.)

 ## generateXAddress

@@ -5680,7 +5734,7 @@ secret | secret string | The secret corresponding to the address.
 ### Example

 ```javascript
-return api.generateAddress();
+return api.generateXAddress();
 ```


--- a/docs/src/generateXAddress.md.ejs
+++ b/docs/src/generateXAddress.md.ejs
@@ -17,7 +17,7 @@ This method returns an object with the following structure:
 ### Example

 ```javascript
-return api.generateAddress();
+return api.generateXAddress();
 ```

 <%- renderFixture('responses/generate-x-address.json') %>
--- a/docs/src/rippledAPIs.md.ejs
+++ b/docs/src/rippledAPIs.md.ejs
@@ -37,7 +37,7 @@ Type | Description
 `ledgerClosed` | Sent by the `ledger` stream when the consensus process declares a new fully validated ledger. The message identifies the ledger and provides some information about its contents.
 `validationReceived` | Sent by the `validations` stream when the server receives a validation message, also called a validation vote, regardless of whether the server trusts the validator.
 `manifestReceived` | Sent by the `manifests` stream when the server receives a manifest.
-`transaction` | Sent by many subscriptions including `transactions`, `transactions_proposed`, `accounts`, `accounts_proposed`, and `book` (Order Book). See [Transaction Streams](https://ripple.com/build/rippled-apis/#transaction-streams) for details.
+`transaction` | Sent by many subscriptions including `transactions`, `transactions_proposed`, `accounts`, `accounts_proposed`, and `book` (Order Book). See [Transaction Streams](https://xrpl.org/subscribe.html#transaction-streams) for details.
 `peerStatusChange` | (Admin-only) Reports a large amount of information on the activities of other `rippled` servers to which the server is connected.
 `path_find` | Asynchronous follow-up response to the currently open path\_find request. See [rippled path\_find method](https://xrpl.org/path_find.html) for details.

@@ -46,7 +46,7 @@ To register your listener function, use `connection.on(type, handler)`.
 Here is an example of listening for transactions on given account(s):
 ```
 const account = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn' // Replace with the account you want notifications for
-api.connect().then(() => { // Omit this if you are already connected
+api.connect().then(() => {

  // 'transaction' can be replaced with the relevant `type` from the table above
  api.connection.on('transaction', (event) => {
@@ -58,9 +58,7 @@ api.connect().then(() => { // Omit this if you are already connected
  api.request('subscribe', {
      accounts: [ account ]
  }).then(response => {
-      if (response.status === 'success') {
-          console.log('Successfully subscribed')
-      }
+      console.log('Successfully subscribed')
  }).catch(error => {
      // Handle `error`
  })
--- a/docs/src/staticMethods.md.ejs
+++ b/docs/src/staticMethods.md.ejs
@@ -1 +1,35 @@
 # Static Methods
+
+ripple-lib features a number of static methods that you can access directly on the `RippleAPI` object. The most commonly-used one is `computeBinaryTransactionHash`, described below. For the full list, see the [XRP Ledger Hashes README](https://github.com/ripple/ripple-lib/blob/develop/src/common/hashes/README.md).
+
+## computeBinaryTransactionHash
+
+`computeBinaryTransactionHash(txBlobHex: string): string`
+
+Returns the hash (id) of a binary transaction blob.
+
+This is a static method on the `RippleAPI` class.
+
+### Parameters
+
+This method takes one parameter, a string containing a binary transaction in hex.
+
+### Return Value
+
+This method returns a string representing the transaction's id (hash).
+
+### Example
+
+```javascript
+const signed_blob = '120000228000000024000B2E5A201B0066374B61400000003B9ACA0068400000000000000C732102356E89059A75438887F9FEE2056A2890DB82A68353BE9C0C0C8F89C0018B37FC74473045022100B3721EEB1ED6DFF29FB8B209E2DE6B54A0A6E44D52D926342F3D334BE98F08640220367A74107AD5DEAEFA3AB2984C161FC23F30B2704BB5CC984358BA262177A4568114F667B0CA50CC7709A220B0561B85E53A48461FA883142B71D8B09B4EE8DAA68FB936C23E3A974713BDAC'
+if (typeof signed_blob === 'string' && signed_blob.match(/^[A-F0-9]+$/)) {
+  const id = RippleAPI.computeBinaryTransactionHash(signed_blob)
+  console.log('Transaction hash:', id')
+}
+```
+
+```
+Transaction hash: 80C5E11E1A21A626759D6CB944B33DBAAC66BD704A289C86E330B847904F5C13
+```
+
+[RunKit Example: computeBinaryTransactionHash](https://runkit.com/intelliot/computebinarytransactionhash-example)
--- a/docs/src/submit.md.ejs
+++ b/docs/src/submit.md.ejs
@@ -1,25 +1,83 @@
 ## submit

-`submit(signedTransaction: string): Promise<object>`
+`request('submit', {tx_blob: string, fail_hard: boolean}): Promise<object>`

-Submits a signed transaction. The transaction is not guaranteed to succeed; it must be verified with [getTransaction](#gettransaction).
+The `submit` method applies a transaction and sends it to the network to be confirmed and included in future ledgers.
+
+This method takes a signed, serialized transaction as a binary blob, and submits it to the network as-is. Since signed transaction objects are immutable, no part of the transaction can be modified or automatically filled in after submission.
+
+To send a transaction as robustly as possible, you should construct and sign it in advance, persist it somewhere that you can access even after a power outage, then `submit` it as a `tx_blob`. After submission, monitor the network with the `tx` method to see if the transaction was successfully applied; if a restart or other problem occurs, you can safely re-submit the `tx_blob` transaction: it won't be applied twice since it has the same sequence number as the old transaction.

 ### Parameters

-<%- renderSchema('input/submit.json') %>
+| `Field`     | Type    | Description                                          |
+|:------------|:--------|:-----------------------------------------------------|
+| `tx_blob`   | String  | Hex representation of the signed transaction to submit. This can be a multi-signed transaction. |
+| `fail_hard` | Boolean | (Optional, defaults to false) If true, and the transaction fails locally, do not retry or relay the transaction to other servers |

 ### Return Value

-This method returns an object with the following structure:
+When successful, this method returns an object containing the following fields:

-<%- renderSchema('output/submit.json') %>
+| `Field`                 | Type    | Description                              |
+|:------------------------|:--------|:-----------------------------------------|
+| `engine_result`         | String  | Text [result code](https://xrpl.org/transaction-results.html) indicating the preliminary result of the transaction, for example `tesSUCCESS` |
+| `engine_result_code`    | Integer | Numeric version of the [result code](https://xrpl.org/transaction-results.html). **Not recommended.** |
+| `engine_result_message` | String  | Human-readable explanation of the transaction's preliminary result |
+| `tx_blob`               | String  | The complete transaction in hex string format |
+| `tx_json`               | Object  | The complete transaction in JSON format  |
+| `accepted`              | Boolean | The value `true` indicates that the transaction was applied, queued, broadcast, or kept for later. The value `false` indicates that none of those happened, so the transaction cannot possibly succeed as long as you do not submit it again and have not already submitted it another time. [New in: rippled 1.5.0] |
+| `account_sequence_available` | Number | The next [Sequence Number](https://xrpl.org/basic-data-types.html#account-sequence) available for the sending account after all pending and [queued](https://xrpl.org/transaction-queue.html) transactions. [New in: rippled 1.5.0] |
+| `account_sequence_next` | number  | The next [Sequence Number](https://xrpl.org/basic-data-types.html#account-sequence) for the sending account after all transactions that have been provisionally applied, but not transactions in the [queue](https://xrpl.org/transaction-queue.html). [New in: rippled 1.5.0] |
+| `applied`               | Boolean | The value `true` indicates that this transaction was applied to the open ledger. In this case, the transaction is likely, but not guaranteed, to be validated in the next ledger version. [New in: rippled 1.5.0] |
+| `broadcast`             | Boolean | The value `true` indicates this transaction was broadcast to peer servers in the peer-to-peer XRP Ledger network. (Note: if the server has no peers, such as in [stand-alone mode](https://xrpl.org/rippled-server-modes.html#reasons-to-run-a-rippled-server-in-stand-alone-mode), the server uses the value `true` for cases where it _would_ have broadcast the transaction.) The value `false` indicates the transaction was not broadcast to any other servers. [New in: rippled 1.5.0] |
+| `kept`                  | Boolean | The value `true` indicates that the transaction was kept to be retried later. [New in: rippled 1.5.0] |
+| `queued`                | Boolean | The value `true` indicates the transaction was put in the [Transaction Queue](https://xrpl.org/transaction-queue.html), which means it is likely to be included in a future ledger version. [New in: rippled 1.5.0] |
+| `open_ledger_cost`      | String  | The current [open ledger cost](https://xrpl.org/transaction-cost.html#open-ledger-cost) before processing this transaction. Transactions with a lower cost are likely to be [queued](https://xrpl.org/transaction-queue.html). [New in: rippled 1.5.0] |
+| `validated_ledger_index` | Integer  | The [ledger index](https://xrpl.org/basic-data-types.html#ledger-index) of the newest validated ledger at the time of submission. This provides a lower bound on the ledger versions that the transaction can appear in as a result of this request. (The transaction could only have been validated in this ledger version or earlier if it had already been submitted before.) |
+
+Note: Many situations can prevent a transaction from processing successfully, such as a lack of trust lines connecting the two accounts in a payment, or changes in the state of the ledger since the time the transaction was constructed. Even if nothing is wrong, it may take several seconds to close and validate the ledger version that includes the transaction. Do not consider the transaction's results final until they appear in a validated ledger version.

 ### Example

 ```javascript
-const signedTransaction = '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100BDE09A1F6670403F341C21A77CF35BA47E45CDE974096E1AA5FC39811D8269E702203D60291B9A27F1DCABA9CF5DED307B4F23223E0B6F156991DB601DFB9C41CE1C770A726970706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304';
-return api.submit(signedTransaction)
-  .then(result => {/* ... */});
+const signedTransaction = '12000022800000002400000007201B007008BC61400000000754D4C068400000000000000C732103E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F824832874473045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22811492F80A3F3849DBB5714A4F2C691CE7D47BEED58083141266204CFBC657E65D9B4D30301FF98644693935';
+const failHard = false;
+const result = await api.request('submit', {
+  tx_blob: signedTransaction,
+  fail_hard: failHard // optional
+});
 ```

-<%- renderFixture('responses/submit.json') %>
+```json
+{
+  "accepted": true,
+  "account_sequence_available": 8,
+  "account_sequence_next": 8,
+  "applied": true,
+  "broadcast": true,
+  "engine_result": "tesSUCCESS",
+  "engine_result_code": 0,
+  "engine_result_message": "The transaction was applied. Only final in a validated ledger.",
+  "kept": true,
+  "open_ledger_cost": "10",
+  "queued": false,
+  "tx_blob": "12000022800000002400000007201B007008BC61400000000754D4C068400000000000000C732103E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F824832874473045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22811492F80A3F3849DBB5714A4F2C691CE7D47BEED58083141266204CFBC657E65D9B4D30301FF98644693935",
+  "tx_json": {
+      "Account": "rNQao3Z1irwRjKWSs8heL4a8WKLPKfLrXs",
+      "Amount": "123000000",
+      "Destination": "rpgHWJdXkSvvzikdJCpuMzU7zWnuqsJRCZ",
+      "Fee": "12",
+      "Flags": 2147483648,
+      "LastLedgerSequence": 7342268,
+      "Sequence": 7,
+      "SigningPubKey": "03E8110048477E60F292DEDA67CF518511E70A15E1E3771B3C024026E1F8248328",
+      "TransactionType": "Payment",
+      "TxnSignature": "3045022100D659C836C24FF346A87054E463078D805B19EFE9F10348FD4C6ED6C3F3C4D750022060BE0BFD5E2C4963A1B0E0F21D5BA800969863BA486F71E75C08D76D77C45B22",
+      "hash": "FE8D68D7FF5805EB07AF15A1ADF07FB5463CCD2C6C0A15981EB3D26A02E1551C"
+  },
+  "validated_ledger_index": 7341775
+}
+```
+
+(In ripple-lib 1.8.0, [the old `submit` method](https://github.com/ripple/ripple-lib/blob/1.7.0/docs/index.md#submit) was deprecated.)
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "ripple-lib",
-  "version": "1.6.4",
+  "version": "1.8.2",
  "license": "ISC",
  "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
  "files": [
@@ -23,34 +23,33 @@
    "@types/lodash": "^4.14.136",
    "@types/ws": "^7.2.0",
    "bignumber.js": "^9.0.0",
-    "https-proxy-agent": "^4.0.0",
+    "https-proxy-agent": "^5.0.0",
    "jsonschema": "1.2.2",
    "lodash": "^4.17.4",
    "lodash.isequal": "^4.5.0",
-    "ripple-address-codec": "^4.0.0",
-    "ripple-binary-codec": "^0.2.5",
+    "ripple-address-codec": "^4.1.1",
+    "ripple-binary-codec": "^0.2.7",
    "ripple-keypairs": "^1.0.0",
    "ripple-lib-transactionparser": "0.8.2",
    "ws": "^7.2.0"
  },
  "devDependencies": {
    "@types/mocha": "^7.0.1",
-    "@types/node": "^13.1.1",
+    "@types/node": "^14.0.1",
    "@typescript-eslint/eslint-plugin": "^2.3.3",
-    "@typescript-eslint/parser": "^2.3.3",
-    "assert-diff": "^2.0.3",
+    "@typescript-eslint/parser": "^2.27.0",
+    "assert-diff": "^3.0.0",
    "doctoc": "^1.4.0",
    "ejs": "^3.0.1",
    "eslint": "^6.5.1",
    "eventemitter2": "^6.0.0",
    "json-schema-to-markdown-table": "^0.4.0",
-    "mocha": "7.0.1",
-    "mocha-junit-reporter": "^1.9.1",
+    "mocha": "^7.1.1",
    "nyc": "^15.0.0",
-    "prettier": "^1.19.1",
+    "prettier": "^2.0.5",
    "ts-node": "^8.4.1",
    "typescript": "^3.7.5",
-    "webpack": "^4.41.2",
+    "webpack": "^4.42.0",
    "webpack-bundle-analyzer": "^3.6.0",
    "webpack-cli": "^3.3.9"
  },
--- a/scripts/ci.sh
+++ b/scripts/ci.sh
@@ -14,7 +14,10 @@ lint() {

 unittest() {
  # test "src"
-  mocha test --reporter mocha-junit-reporter --reporter-options mochaFile=$CIRCLE_TEST_REPORTS/test-results.xml
+
+  # TODO: replace/upgrade mocha-junit-reporter
+  #mocha test --reporter mocha-junit-reporter --reporter-options mochaFile=$CIRCLE_TEST_REPORTS/test-results.xml
+
  yarn test --coverage
  #yarn run coveralls

--- a/src/api.ts
+++ b/src/api.ts
@@ -89,6 +89,19 @@ import {clamp, renameCounterpartyToIssuer} from './ledger/utils'
 import {TransactionJSON, Instructions, Prepare} from './transaction/types'
 import {ConnectionUserOptions} from './common/connection'
 import {isValidXAddress, isValidClassicAddress} from 'ripple-address-codec'
+import {
+  computeBinaryTransactionHash,
+  computeTransactionHash,
+  computeBinaryTransactionSigningHash,
+  computeAccountLedgerObjectID,
+  computeSignerListLedgerObjectID,
+  computeOrderID,
+  computeTrustlineHash,
+  computeTransactionTreeHash,
+  computeStateTreeHash,
+  computeEscrowHash,
+  computePaymentChannelHash
+} from './common/hashes'

 export interface APIOptions extends ConnectionUserOptions {
  server?: string
@@ -252,7 +265,7 @@ class RippleAPI extends EventEmitter {
  /**
   * Prepare a transaction.
   *
-   * You can later submit the transaction with `submit()`.
+   * You can later submit the transaction with a `submit` request.
   */
  async prepareTransaction(
    txJSON: TransactionJSON,
@@ -385,7 +398,8 @@ class RippleAPI extends EventEmitter {
  prepareSettings = prepareSettings
  sign = sign
  combine = combine
-  submit = submit
+
+  submit = submit // @deprecated Use api.request('submit', { tx_blob: signedTransaction }) instead

  deriveKeypair = deriveKeypair
  deriveAddress = deriveAddress
@@ -402,6 +416,31 @@ class RippleAPI extends EventEmitter {
  static isValidXAddress = isValidXAddress
  static isValidClassicAddress = isValidClassicAddress

+  /**
+   * Static methods that replace functionality from the now-deprecated ripple-hashes library
+   */
+  // Compute the hash of a binary transaction blob.
+  static computeBinaryTransactionHash = computeBinaryTransactionHash // (txBlobHex: string): string
+  // Compute the hash of a transaction in txJSON format.
+  static computeTransactionHash = computeTransactionHash // (txJSON: any): string
+  static computeBinaryTransactionSigningHash = computeBinaryTransactionSigningHash // (txBlobHex: string): string
+  // Compute the hash of an account, given the account's classic address (starting with `r`).
+  static computeAccountLedgerObjectID = computeAccountLedgerObjectID // (address: string): string
+  // Compute the hash (ID) of an account's SignerList.
+  static computeSignerListLedgerObjectID = computeSignerListLedgerObjectID // (address: string): 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.
+  static computeOrderID = computeOrderID // (address: string, sequence: number): string
+  // Compute the hash of a trustline, given the two parties' classic addresses (starting with `r`) and the currency code.
+  static computeTrustlineHash = computeTrustlineHash // (address1: string, address2: string, currency: string): string
+  static computeTransactionTreeHash = computeTransactionTreeHash // (transactions: any[]): string
+  static computeStateTreeHash = computeStateTreeHash // (entries: any[]): string
+  // Compute the hash of a ledger.
+  static computeLedgerHash = computeLedgerHash // (ledgerHeader): 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.
+  static computeEscrowHash = computeEscrowHash // (address, 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.
+  static computePaymentChannelHash = computePaymentChannelHash // (address, dstAddress, sequence): string
+
  xrpToDrops = xrpToDrops
  dropsToXrp = dropsToXrp
  rippleTimeToISO8601 = rippleTimeToISO8601
--- a/src/common/backoff.ts
+++ b/src/common/backoff.ts
@@ -7,7 +7,7 @@
 */

 /**
- * A Back off strategy that increases exponentionally. Useful with repeated
+ * A Back off strategy that increases exponentially. Useful with repeated
 * setTimeout calls over a network (where the destination may be down).
 */
 export class ExponentialBackoff {
--- a/src/common/connection.ts
+++ b/src/common/connection.ts
@@ -13,7 +13,7 @@ import {
  RippledNotInitializedError,
  RippleError
 } from './errors'
-import {ExponentialBackoff} from './backoff';
+import {ExponentialBackoff} from './backoff'

 /**
 * ConnectionOptions is the configuration for the Connection class.
@@ -38,6 +38,23 @@ export interface ConnectionOptions {
 */
 export type ConnectionUserOptions = Partial<ConnectionOptions>

+/**
+ * Ledger Stream Message
+ * https://xrpl.org/subscribe.html#ledger-stream
+ */
+interface LedgerStreamMessage {
+  type?: 'ledgerClosed' // not present in initial `subscribe` response
+  fee_base: number
+  fee_ref: number
+  ledger_hash: string
+  ledger_index: number
+  ledger_time: number
+  reserve_base: number
+  reserve_inc: number
+  txn_count?: number // not present in initial `subscribe` response
+  validated_ledgers?: string
+}
+
 /**
 * Represents an intentionally triggered web-socket disconnect code.
 * WebSocket spec allows 4xxx codes for app/library specific codes.
@@ -118,10 +135,11 @@ function websocketSendAsync(ws: WebSocket, message: string) {
 * captured by the Connection class over time.
 */
 class LedgerHistory {
-  private availableVersions = new RangeSet()
-  latestVersion: null | number = null
  feeBase: null | number = null
  feeRef: null | number = null
+  latestVersion: null | number = null
+  reserveBase: null | number = null
+  private availableVersions = new RangeSet()

  /**
   * Returns true if the given version exists.
@@ -143,25 +161,22 @@ class LedgerHistory {
   * of whether ledger history data exists or not. If relevant ledger data
   * is found, we'll update our history (ex: from a "ledgerClosed" event).
   */
-  update(responseData: {
-    ledger_index?: string
-    validated_ledgers?: string
-    fee_base?: string
-    fee_ref?: string
-  }) {
-    this.latestVersion = Number(responseData.ledger_index)
-    if (responseData.validated_ledgers) {
+  update(ledgerMessage: LedgerStreamMessage) {
+    // type: ignored
+    this.feeBase = ledgerMessage.fee_base
+    this.feeRef = ledgerMessage.fee_ref
+    // ledger_hash: ignored
+    this.latestVersion = ledgerMessage.ledger_index
+    // ledger_time: ignored
+    this.reserveBase = ledgerMessage.reserve_base
+    // reserve_inc: ignored (may be useful for advanced use cases)
+    // txn_count: ignored
+    if (ledgerMessage.validated_ledgers) {
      this.availableVersions.reset()
-      this.availableVersions.parseAndAddRanges(responseData.validated_ledgers)
+      this.availableVersions.parseAndAddRanges(ledgerMessage.validated_ledgers)
    } else {
      this.availableVersions.addValue(this.latestVersion)
    }
-    if (responseData.fee_base) {
-      this.feeBase = Number(responseData.fee_base)
-    }
-    if (responseData.fee_ref) {
-      this.feeRef = Number(responseData.fee_ref)
-    }
  }
 }

@@ -210,18 +225,21 @@ class RequestManager {
  cancel(id: number) {
    const {timer} = this.promisesAwaitingResponse[id]
    clearTimeout(timer)
+    delete this.promisesAwaitingResponse[id]
  }

  resolve(id: number, data: any) {
    const {timer, resolve} = this.promisesAwaitingResponse[id]
    clearTimeout(timer)
    resolve(data)
+    delete this.promisesAwaitingResponse[id]
  }

  reject(id: number, error: Error) {
    const {timer, reject} = this.promisesAwaitingResponse[id]
    clearTimeout(timer)
    reject(error)
+    delete this.promisesAwaitingResponse[id]
  }

  rejectAll(error: Error) {
@@ -263,7 +281,7 @@ class RequestManager {
      throw new ResponseFormatError('valid id not found in response', data)
    }
    if (!this.promisesAwaitingResponse[data.id]) {
-      throw new ResponseFormatError('response handler not found', data)
+      return
    }
    if (data.status === 'error') {
      const error = new RippledError(data.error_message || data.error, data)
@@ -371,10 +389,10 @@ export class Connection extends EventEmitter {
   * 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().catch((error) => {
-          this.emit('error', 'reconnect', error.message, error)
-        })
+    return this.request({command: 'ping'}).catch(() => {
+      this.reconnect().catch(error => {
+        this.emit('error', 'reconnect', error.message, error)
+      })
    })
  }

@@ -406,7 +424,7 @@ export class Connection extends EventEmitter {
      } catch (error) {
        // Ignore this error, propagate the root cause.
      } finally {
-        // Throw the root error (takes precendence over try/catch).
+        // Throw the root error (takes precedence over try/catch).
        // eslint-disable-next-line no-unsafe-finally
        throw new RippledNotInitializedError('Rippled not initialized')
      }
@@ -535,8 +553,8 @@ export class Connection extends EventEmitter {
   * If no open websocket connection exists, resolve with no code (`undefined`).
   */
  disconnect(): Promise<number | undefined> {
-    clearTimeout(this._reconnectTimeoutID);
-    this._reconnectTimeoutID = null;
+    clearTimeout(this._reconnectTimeoutID)
+    this._reconnectTimeoutID = null
    if (this._state === WebSocket.CLOSED || !this._ws) {
      return Promise.resolve(undefined)
    }
@@ -563,11 +581,6 @@ export class Connection extends EventEmitter {
    await this.connect()
  }

-  async getLedgerVersion(): Promise<number> {
-    await this._waitForReady()
-    return this._ledger.latestVersion!
-  }
-
  async getFeeBase(): Promise<number> {
    await this._waitForReady()
    return this._ledger.feeBase!
@@ -578,6 +591,16 @@ export class Connection extends EventEmitter {
    return this._ledger.feeRef!
  }

+  async getLedgerVersion(): Promise<number> {
+    await this._waitForReady()
+    return this._ledger.latestVersion!
+  }
+
+  async getReserveBase(): Promise<number> {
+    await this._waitForReady()
+    return this._ledger.reserveBase!
+  }
+
  /**
   * Returns true if the given range of ledger versions exist in history
   * (inclusive).
--- a/src/common/constants.ts
+++ b/src/common/constants.ts
@@ -58,6 +58,18 @@ const AccountFlags = {
  defaultRipple: accountRootFlags.DefaultRipple
 }

+export interface Settings {
+  passwordSpent?: boolean
+  requireDestinationTag?: boolean
+  requireAuthorization?: boolean
+  depositAuth?: boolean
+  disallowIncomingXRP?: boolean
+  disableMasterKey?: boolean
+  noFreeze?: boolean
+  globalFreeze?: boolean
+  defaultRipple?: boolean
+}
+
 const AccountFlagIndices = {
  requireDestinationTag: txFlagIndices.AccountSet.asfRequireDest,
  requireAuthorization: txFlagIndices.AccountSet.asfRequireAuth,
--- a/src/common/hashes/README.md
+++ b/src/common/hashes/README.md
@@ -2,7 +2,7 @@

 Methods to hash XRP Ledger objects

-## Methods
+## Computing a transaction hash (ID)

 ### computeBinaryTransactionHash = (txBlobHex: string): string

@@ -12,19 +12,35 @@ Compute the hash of a binary transaction blob.

 Compute the hash of a transaction in txJSON format.

+## [Hash Prefixes](https://xrpl.org/basic-data-types.html#hash-prefixes)
+
+In many cases, the XRP Ledger prefixes an object's binary data with a 4-byte code before calculating its hash, so that objects of different types have different hashes even if the binary data is the same. The existing 4-byte codes are structured as 3 alphabetic characters, encoded as ASCII, followed by a zero byte.
+
+Some types of hashes appear in API requests and responses. Others are only calculated as the first step of signing a certain type of data, or calculating a higher-level hash. Some of following methods internally use some of the 4-byte hash prefixes in order to calculate the appropriate hash.
+
 ### computeBinaryTransactionSigningHash = (txBlobHex: string): string

-### computeTransactionSigningHash = (txJSON: any): string
+In order to single-sign a transaction, you must perform these steps:

-### computeAccountHash = (address: string): string
+1. Assuming the transaction is in JSON format (txJSON), `encode` the transaction in the XRP Ledger's binary format.
+2. Hash the data with the appropriate prefix (`0x53545800` if single-signing, or `0x534D5400` if multi-signing).
+3. After signing, you must re-serialize the transaction with the `TxnSignature` field included.
+
+The `computeBinaryTransactionSigningHash` helps with step 2, automatically using the `0x53545800` prefix needed for single-signing a transaction.
+
+For details, see [Serialization Format](https://xrpl.org/serialization.html).
+
+_Removed:_ `computeTransactionSigningHash`, which took txJSON as a parameter. It was part of the deprecated ripple-hashes library. If you have txJSON, `encode` it with [ripple-binary-codec](https://github.com/ripple/ripple-binary-codec) first. Example: `return computeBinaryTransactionSigningHash(encode(txJSON))`
+
+### computeAccountLedgerObjectID = (address: string): string

 Compute the hash of an account, given the account's classic address (starting with `r`).

-### computeSignerListHash = (address: string): string
+### computeSignerListLedgerObjectID = (address: string): string

 Compute the hash of an account's SignerList.

-### computeOrderHash = (address: string, sequence: number): string
+### computeOrderID = (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.

--- a/src/common/hashes/index.ts
+++ b/src/common/hashes/index.ts
@@ -71,6 +71,14 @@ export const computeTransactionHash = (txJSON: any): string => {
  return computeBinaryTransactionHash(encode(txJSON))
 }

+/**
+ * Hash the given binary transaction data with the single-signing prefix.
+ *
+ * See [Serialization Format](https://xrpl.org/serialization.html)
+ *
+ * @param txBlobHex The binary transaction blob as a hexadecimal string
+ * @returns {string} The hash to sign
+ */
 export const computeBinaryTransactionSigningHash = (
  txBlobHex: string
 ): string => {
@@ -78,21 +86,56 @@ export const computeBinaryTransactionSigningHash = (
  return sha512Half(prefix + txBlobHex)
 }

-export const computeTransactionSigningHash = (txJSON: any): string => {
-  return computeBinaryTransactionSigningHash(encode(txJSON))
-}
-
-export const computeAccountHash = (address: string): string => {
+/**
+ * Compute Account Ledger Object ID
+ *
+ * All objects in a ledger's state tree have a unique ID.
+ * The Account Ledger Object ID is derived by hashing the
+ * address with a namespace identifier. This ensures every
+ * ID is unique.
+ *
+ * See [Ledger Object IDs](https://xrpl.org/ledger-object-ids.html)
+ *
+ * @param address The classic account address
+ * @returns {string} The Ledger Object ID for the account
+ */
+export const computeAccountLedgerObjectID = (address: string): string => {
  return sha512Half(ledgerSpaceHex('account') + addressToHex(address))
 }

-export const computeSignerListHash = (address: string): string => {
+/**
+ * [SignerList ID Format](https://xrpl.org/signerlist.html#signerlist-id-format)
+ *
+ * The ID of a SignerList object is the SHA-512Half of the following values, concatenated in order:
+ *   * The RippleState space key (0x0053)
+ *   * The AccountID of the owner of the SignerList
+ *   * The SignerListID (currently always 0)
+ *
+ * This method computes a SignerList Ledger Object ID.
+ *
+ * @param address The classic account address of the SignerList owner (starting with r)
+ * @return {string} The ID of the account's SignerList object
+ */
+export const computeSignerListLedgerObjectID = (address: string): string => {
  return sha512Half(
    ledgerSpaceHex('signerList') + addressToHex(address) + '00000000'
  ) // uint32(0) signer list index
 }

-export const computeOrderHash = (address: string, sequence: number): string => {
+/**
+ * [Offer ID Format](https://xrpl.org/offer.html#offer-id-format)
+ *
+ * The ID of a Offer object is the SHA-512Half of the following values, concatenated in order:
+ *   * The Offer space key (0x006F)
+ *   * The AccountID of the account placing the offer
+ *   * The Sequence number of the OfferCreate transaction that created the offer
+ *
+ * This method computes an Offer ID (aka Order ID).
+ *
+ * @param address The classic account address of the SignerList owner (starting with r)
+ * @returns {string} The ID of the account's Offer object
+ */
+export const computeOrderID = (address: string, sequence: number): string => {
  const prefix = '00' + intToHex(ledgerspaces.offer.charCodeAt(0), 1)
  return sha512Half(prefix + addressToHex(address) + intToHex(sequence, 4))
 }
--- a/src/common/hashes/ledgerspaces.ts
+++ b/src/common/hashes/ledgerspaces.ts
@@ -1,10 +1,12 @@
 /**
- * Ripple ledger namespace prefixes.
+ * XRP Ledger namespace prefixes.
 *
- * The Ripple ledger is a key-value store. In order to avoid name collisions,
+ * The XRP 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.
+ *
+ * See [LedgerNameSpace enum](https://github.com/ripple/rippled/blob/master/src/ripple/protocol/LedgerFormats.h#L100)
 */
 export default {
  account: 'a',
@@ -16,9 +18,12 @@ export default {
  bookDir: 'B', // Directory of order books.
  contract: 'c',
  skipList: 's',
+  escrow: 'u',
  amendment: 'f',
  feeSettings: 'e',
+  ticket: 'T',
  signerList: 'S',
-  escrow: 'u',
-  paychan: 'x'
+  paychan: 'x',
+  check: 'C',
+  depositPreauth: 'p'
 }
--- a/src/common/schemas/input/submit.json
+++ b/src/common/schemas/input/submit.json
@@ -6,6 +6,10 @@
    "signedTransaction": {
      "$ref": "blob",
      "description": "A signed transaction as returned by [sign](#sign)."
+    },
+    "failHard": {
+      "type": "boolean",
+      "description": "If `true`, and the transaction fails locally, do not retry or relay the transaction to other servers. Defaults to `false`."
    }
  },
  "additionalProperties": false,
--- a/src/ledger/settings.ts
+++ b/src/ledger/settings.ts
@@ -4,17 +4,18 @@ import {validate, constants, ensureClassicAddress} from '../common'
 import {FormattedSettings} from '../common/types/objects'
 import {AccountInfoResponse} from '../common/types/commands'
 import {RippleAPI} from '..'
+import {Settings} from '../common/constants'

 const AccountFlags = constants.AccountFlags

 export type SettingsOptions = {
-  ledgerVersion?: number
+  ledgerVersion?: number | 'validated' | 'closed' | 'current'
 }

 export function parseAccountFlags(
  value: number,
  options: {excludeFalse?: boolean} = {}
-) {
+): Settings {
  const settings = {}
  for (const flagName in AccountFlags) {
    if (value & AccountFlags[flagName]) {
--- a/src/offline/generate-address.ts
+++ b/src/offline/generate-address.ts
@@ -28,7 +28,10 @@ export interface GenerateAddressOptions {
 function generateAddressAPI(options: GenerateAddressOptions): GeneratedAddress {
  validate.generateAddress({options})
  try {
-    const generateSeedOptions: { entropy?: Uint8Array; algorithm?: "ecdsa-secp256k1" | "ed25519"; } = {
+    const generateSeedOptions: {
+      entropy?: Uint8Array
+      algorithm?: 'ecdsa-secp256k1' | 'ed25519'
+    } = {
      algorithm: options.algorithm
    }
    if (options.entropy) {
--- a/src/transaction/payment.ts
+++ b/src/transaction/payment.ts
@@ -87,7 +87,12 @@ function applyAnyCounterpartyEncoding(payment: Payment): void {

 function createMaximalAmount(amount: Amount): Amount {
  const maxXRPValue = '100000000000'
-  const maxIOUValue = '9999999999999999e80'
+
+  // Equivalent to '9999999999999999e80' but we cannot use that because sign()
+  // now checks that the encoded representation exactly matches the transaction
+  // as it was originally provided.
+  const maxIOUValue = '999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000'
+
  let maxValue
  if (amount.currency === 'XRP') {
    maxValue = maxXRPValue
--- a/src/transaction/submit.ts
+++ b/src/transaction/submit.ts
@@ -1,3 +1,9 @@
+// Deprecated - use api.request instead:
+//   const response = await api.request('submit', {
+//     tx_blob: signedTransaction,
+//     fail_hard: failHard
+//   });
+
 import * as _ from 'lodash'
 import * as utils from './utils'
 import {validate} from '../common'
@@ -36,14 +42,19 @@ function formatSubmitResponse(response): FormattedSubmitResponse {
  return data
 }

+// @deprecated Use api.request('submit', { tx_blob: signedTransaction }) instead
 async function submit(
  this: RippleAPI,
-  signedTransaction: string
+  signedTransaction: string,
+  failHard?: boolean
 ): Promise<FormattedSubmitResponse> {
  // 1. Validate
  validate.submit({signedTransaction})
  // 2. Make Request
-  const response = await this.request('submit', {tx_blob: signedTransaction})
+  const response = await this.request('submit', {
+    tx_blob: signedTransaction,
+    ...(failHard ? {fail_hard: failHard} : {})
+  })
  // 3. Return Formatted Response
  return formatSubmitResponse(response)
 }
--- a/test/api/generateAddress/index.ts
+++ b/test/api/generateAddress/index.ts
@@ -1,7 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
-import { GenerateAddressOptions } from '../../../src/offline/generate-address'
+import {GenerateAddressOptions} from '../../../src/offline/generate-address'
 const {generateAddress: RESPONSE_FIXTURES} = responses

 /**
@@ -10,7 +10,7 @@ const {generateAddress: RESPONSE_FIXTURES} = responses
 * - Check out "test/api/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'generateAddress': async (api) => {
+  'generateAddress': async api => {
    // GIVEN entropy of all zeros
    function random() {
      return new Array(16).fill(0)
@@ -25,7 +25,7 @@ export default <TestSuite>{
    )
  },

-  'generateAddress invalid entropy': async (api) => {
+  'generateAddress invalid entropy': async api => {
    assert.throws(() => {
      // GIVEN entropy of 1 byte
      function random() {
@@ -40,7 +40,7 @@ export default <TestSuite>{
    }, api.errors.UnexpectedError)
  },

-  'generateAddress with no options object': async (api) => {
+  'generateAddress with no options object': async api => {
    // GIVEN no options

    // WHEN generating an address
@@ -51,7 +51,7 @@ export default <TestSuite>{
    assert(account.secret.startsWith('s'), 'Secret must start with `s`')
  },

-  'generateAddress with empty options object': async (api) => {
+  'generateAddress with empty options object': async api => {
    // GIVEN an empty options object
    const options = {}

@@ -63,7 +63,7 @@ export default <TestSuite>{
    assert(account.secret.startsWith('s'), 'Secret must start with `s`')
  },

-  'generateAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1`': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1'
    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}

@@ -72,11 +72,19 @@ export default <TestSuite>{

    // THEN we get an object with an address starting with 'r' and a secret starting with 's' (not 'sEd')
    assert(account.address.startsWith('r'), 'Address must start with `r`')
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
-    assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`)
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
+    assert.notStrictEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `secp256k1 secret ${account.secret} must not start with 'sEd'`
+    )
  },

-  'generateAddress with algorithm `ed25519`': async (api) => {
+  'generateAddress with algorithm `ed25519`': async api => {
    // GIVEN we want to use 'ed25519'
    const options: GenerateAddressOptions = {algorithm: 'ed25519'}

@@ -85,12 +93,19 @@ export default <TestSuite>{

    // THEN we get an object with an address starting with 'r' and a secret starting with 'sEd'
    assert(account.address.startsWith('r'), 'Address must start with `r`')
-    assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`)
+    assert.deepEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `Ed25519 secret ${account.secret} must start with 'sEd'`
+    )
  },

-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0)
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)
@@ -99,28 +114,34 @@ export default <TestSuite>{
    assert.deepEqual(account, responses.generateAddress)
  },

-  'generateAddress with algorithm `ed25519` and given entropy': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0)
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)

    // THEN we get the expected return value
    assert.deepEqual(account, {
-
      // generateAddress return value always includes xAddress to encourage X-address adoption
      xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',

-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE'
    })
  },

-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)
@@ -129,62 +150,72 @@ export default <TestSuite>{
    assert.deepEqual(account, responses.generateAddress)
  },

-  'generateAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy; include classic address': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)

    // THEN we get the expected return value
    assert.deepEqual(account, {
-
      // generateAddress return value always includes xAddress to encourage X-address adoption
      xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',

      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
    })
  },

-  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => {
+  'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)

    // THEN we get the expected return value
    const response = Object.assign({}, responses.generateAddress, {
-
      // generateAddress return value always includes xAddress to encourage X-address adoption
      xAddress: 'TVG3TcCD58BD6MZqsNuTihdrhZwR8SzvYS8U87zvHsAcNw4'
-
    })
    assert.deepEqual(account, response)
  },

-  'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => {
+  'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }

    // WHEN generating an address
    const account = api.generateAddress(options)

    // THEN we get the expected return value
    assert.deepEqual(account, {
-
      // generateAddress return value always includes xAddress to encourage X-address adoption
      xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo',

      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
    })
  },

-  'generateAddress for test network use': async (api) => {
+  'generateAddress for test network use': async api => {
    // GIVEN we want an address for test network use
    const options: GenerateAddressOptions = {test: true}

@@ -194,8 +225,16 @@ export default <TestSuite>{
    // THEN we get an object with xAddress starting with 'T' and a secret starting with 's'

    // generateAddress return value always includes xAddress to encourage X-address adoption
-    assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test addresses start with T')
+    assert.deepEqual(
+      account.xAddress.slice(0, 1),
+      'T',
+      'Test addresses start with T'
+    )

-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
  }
 }
--- a/test/api/generateXAddress/index.ts
+++ b/test/api/generateXAddress/index.ts
@@ -1,7 +1,7 @@
 import assert from 'assert-diff'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
-import { GenerateAddressOptions } from '../../../src/offline/generate-address'
+import {GenerateAddressOptions} from '../../../src/offline/generate-address'

 /**
 * Every test suite exports their tests in the default object.
@@ -9,7 +9,7 @@ import { GenerateAddressOptions } from '../../../src/offline/generate-address'
 * - Check out "test/api/index.ts" for more information about the test runner.
 */
 export default <TestSuite>{
-  'generateXAddress': async (api) => {
+  'generateXAddress': async api => {
    // GIVEN entropy of all zeros
    function random() {
      return new Array(16).fill(0)
@@ -24,7 +24,7 @@ export default <TestSuite>{
    )
  },

-  'generateXAddress invalid entropy': async (api) => {
+  'generateXAddress invalid entropy': async api => {
    assert.throws(() => {
      // GIVEN entropy of 1 byte
      function random() {
@@ -39,18 +39,21 @@ export default <TestSuite>{
    }, api.errors.UnexpectedError)
  },

-  'generateXAddress with no options object': async (api) => {
+  'generateXAddress with no options object': async api => {
    // GIVEN no options

    // WHEN generating an X-address
    const account = api.generateXAddress()

    // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
    assert(account.secret.startsWith('s'), 'Secrets start with s')
  },

-  'generateXAddress with empty options object': async (api) => {
+  'generateXAddress with empty options object': async api => {
    // GIVEN an empty options object
    const options = {}

@@ -58,11 +61,14 @@ export default <TestSuite>{
    const account = api.generateXAddress(options)

    // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
    assert(account.secret.startsWith('s'), 'Secrets start with s')
  },

-  'generateXAddress with algorithm `ecdsa-secp256k1`': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1`': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1'
    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'}

@@ -70,12 +76,23 @@ export default <TestSuite>{
    const account = api.generateXAddress(options)

    // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
-    assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`)
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
+    assert.notStrictEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `secp256k1 secret ${account.secret} must not start with 'sEd'`
+    )
  },

-  'generateXAddress with algorithm `ed25519`': async (api) => {
+  'generateXAddress with algorithm `ed25519`': async api => {
    // GIVEN we want to use 'ed25519'
    const options: GenerateAddressOptions = {algorithm: 'ed25519'}

@@ -83,13 +100,23 @@ export default <TestSuite>{
    const account = api.generateXAddress(options)

    // THEN we get an object with an xAddress starting with 'X' and a secret starting with 'sEd'
-    assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X')
-    assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`)
+    assert(
+      account.xAddress.startsWith('X'),
+      'By default X-addresses start with X'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 3),
+      'sEd',
+      `Ed25519 secret ${account.secret} must start with 'sEd'`
+    )
  },

-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0)
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -98,9 +125,12 @@ export default <TestSuite>{
    assert.deepEqual(account, responses.generateXAddress)
  },

-  'generateXAddress with algorithm `ed25519` and given entropy': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0)
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -112,9 +142,13 @@ export default <TestSuite>{
    })
  },

-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -123,9 +157,13 @@ export default <TestSuite>{
    assert.deepEqual(account, responses.generateAddress)
  },

-  'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -134,14 +172,19 @@ export default <TestSuite>{
    assert.deepEqual(account, {
      xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB',
      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
    })
  },

-  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => {
+  'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => {
    // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ecdsa-secp256k1',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -153,9 +196,14 @@ export default <TestSuite>{
    assert.deepEqual(account, response)
  },

-  'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => {
+  'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => {
    // GIVEN we want to use 'ed25519' with entropy of zero
-    const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true}
+    const options: GenerateAddressOptions = {
+      algorithm: 'ed25519',
+      entropy: new Array(16).fill(0),
+      includeClassicAddress: true,
+      test: true
+    }

    // WHEN generating an X-address
    const account = api.generateXAddress(options)
@@ -164,12 +212,12 @@ export default <TestSuite>{
    assert.deepEqual(account, {
      xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo',
      secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE',
-      classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7",
-      address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7"
+      classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7',
+      address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7'
    })
  },

-  'generateXAddress for test network use': async (api) => {
+  'generateXAddress for test network use': async api => {
    // GIVEN we want an X-address for test network use
    const options: GenerateAddressOptions = {test: true}

@@ -177,7 +225,15 @@ export default <TestSuite>{
    const account = api.generateXAddress(options)

    // THEN we get an object with xAddress starting with 'T' and a secret starting with 's'
-    assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test X-addresses start with T')
-    assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`)
+    assert.deepEqual(
+      account.xAddress.slice(0, 1),
+      'T',
+      'Test X-addresses start with T'
+    )
+    assert.deepEqual(
+      account.secret.slice(0, 1),
+      's',
+      `Secret ${account.secret} must start with 's'`
+    )
  }
 }
--- a/test/api/getTransaction/index.ts
+++ b/test/api/getTransaction/index.ts
@@ -355,7 +355,8 @@ export default <TestSuite>{
  },

  'AccountDelete': async (api, address) => {
-    const hash = 'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9'
+    const hash =
+      'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9'
    const response = await api.getTransaction(hash)
    assertResultMatch(
      response,
--- a/test/api/preparePayment/index.ts
+++ b/test/api/preparePayment/index.ts
@@ -2,6 +2,11 @@ import {assertResultMatch, TestSuite, assertRejects} from '../../utils'
 import responses from '../../fixtures/responses'
 import requests from '../../fixtures/requests'
 import {ValidationError} from 'ripple-api/common/errors'
+import binary from 'ripple-binary-codec'
+import assert from 'assert-diff'
+import {RippleAPI} from 'ripple-api'
+
+const {schemaValidator} = RippleAPI._PRIVATE
 const instructionsWithMaxLedgerVersionOffset = {maxLedgerVersionOffset: 100}
 const {preparePayment: REQUEST_FIXTURES} = requests
 const {preparePayment: RESPONSE_FIXTURES} = responses
@@ -288,6 +293,55 @@ export default <TestSuite>{
    assertResultMatch(response, RESPONSE_FIXTURES.noCounterparty, 'prepare')
  },

+  'preparePayment with source.amount/destination.minAmount can be signed': async (api, address) => {
+    // See also: 'sign succeeds with source.amount/destination.minAmount'
+
+    const localInstructions = {
+      ...instructionsWithMaxLedgerVersionOffset,
+      sequence: 23
+    }
+    const response = await api.preparePayment(
+      address,
+      {
+        "source": {
+          address,
+          "amount": {
+            "currency": "GBP",
+            "value": "0.1",
+            "counterparty": "rpat5TmYjDsnFSStmgTumFgXCM9eqsWPro"
+          }
+        },
+        "destination": {
+          "address": "rEX4LtGJubaUcMWCJULcy4NVxGT9ZEMVRq",
+          "minAmount": {
+            "currency": "USD",
+            "value": "0.1248548562296331",
+            "counterparty": "rMaa8VLBTjwTJWA2kSme4Sqgphhr6Lr6FH"
+          }
+        }
+      },
+      localInstructions
+    )
+
+    // Important: check that the prepared transaction can actually be signed
+    // https://github.com/ripple/ripple-lib/issues/1237#issuecomment-631670946
+
+    const secret = 'shotKgaEotpcYsshSE39vmSnBDRim'
+    const result = api.sign(response.txJSON, secret)
+    const expectedResult = {
+      signedTransaction:
+        '12000022800200002400000017201B0086955361EC6386F26FC0FFFF0000000000000000000000005553440000000000DC596C88BCDE4E818D416FCDEEBF2C8656BADC9A68400000000000000C69D4438D7EA4C6800000000000000000000000000047425000000000000C155FFE99C8C91F67083CEFFDB69EBFE76348CA6AD4446F8C5D8A5E0B0000000000000000000000005553440000000000DC596C88BCDE4E818D416FCDEEBF2C8656BADC9A7321022B05847086686F9D0499B13136B94AD4323EE1B67D4C429ECC987AB35ACFA34574473045022100D9634523D8E232D4A7807A71856023D82AC928FA29848571B820867898413B5F022041AC00EC1F81A26A6504EBF844A38CC3204694EF2CC1A97A87632721631F93DA81145E7B112523F68D2F5E879DB4EAC51C6698A6930483149F500E50C2F016CA01945E5A1E5846B61EF2D376',
+      id: '1C558AA9B926C24FB6BBD6950B2DB1350A83F9F12E4385208867907019761A2D'
+    }
+    const decoded = binary.decode(result.signedTransaction)
+    assert(
+      decoded.Flags === 2147614720,
+      `Flags = ${decoded.Flags}, should be 2147614720`
+    )
+    assert.deepEqual(result, expectedResult)
+    schemaValidator.schemaValidate('sign', result)
+  },
+
  'destination.minAmount': async (api, address) => {
    const response = await api.preparePayment(
      address,
--- a/test/api/sign/index.ts
+++ b/test/api/sign/index.ts
@@ -4,6 +4,7 @@ import binary from 'ripple-binary-codec'
 import requests from '../../fixtures/requests'
 import responses from '../../fixtures/responses'
 import {TestSuite} from '../../utils'
+
 const {schemaValidator} = RippleAPI._PRIVATE
 const {sign: REQUEST_FIXTURES} = requests
 const {sign: RESPONSE_FIXTURES} = responses
@@ -145,6 +146,27 @@ export default <TestSuite>{
    schemaValidator.schemaValidate('sign', result)
  },

+  'sign succeeds with source.amount/destination.minAmount': async (api, address) => {
+    // See also: 'preparePayment with source.amount/destination.minAmount'
+
+    const txJSON =
+      '{"TransactionType":"Payment","Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Destination":"rEX4LtGJubaUcMWCJULcy4NVxGT9ZEMVRq","Amount":{"currency":"USD","issuer":"rMaa8VLBTjwTJWA2kSme4Sqgphhr6Lr6FH","value":"999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000"},"Flags":2147614720,"SendMax":{"currency":"GBP","issuer":"rpat5TmYjDsnFSStmgTumFgXCM9eqsWPro","value":"0.1"},"DeliverMin":{"currency":"USD","issuer":"rMaa8VLBTjwTJWA2kSme4Sqgphhr6Lr6FH","value":"0.1248548562296331"},"Sequence":23,"LastLedgerSequence":8820051,"Fee":"12"}'
+    const secret = 'shotKgaEotpcYsshSE39vmSnBDRim'
+    const result = api.sign(txJSON, secret)
+    const expectedResult = {
+      signedTransaction:
+        '12000022800200002400000017201B0086955361EC6386F26FC0FFFF0000000000000000000000005553440000000000DC596C88BCDE4E818D416FCDEEBF2C8656BADC9A68400000000000000C69D4438D7EA4C6800000000000000000000000000047425000000000000C155FFE99C8C91F67083CEFFDB69EBFE76348CA6AD4446F8C5D8A5E0B0000000000000000000000005553440000000000DC596C88BCDE4E818D416FCDEEBF2C8656BADC9A7321022B05847086686F9D0499B13136B94AD4323EE1B67D4C429ECC987AB35ACFA34574473045022100D9634523D8E232D4A7807A71856023D82AC928FA29848571B820867898413B5F022041AC00EC1F81A26A6504EBF844A38CC3204694EF2CC1A97A87632721631F93DA81145E7B112523F68D2F5E879DB4EAC51C6698A6930483149F500E50C2F016CA01945E5A1E5846B61EF2D376',
+      id: '1C558AA9B926C24FB6BBD6950B2DB1350A83F9F12E4385208867907019761A2D'
+    }
+    const decoded = binary.decode(result.signedTransaction)
+    assert(
+      decoded.Flags === 2147614720,
+      `Flags = ${decoded.Flags}, should be 2147614720`
+    )
+    assert.deepEqual(result, expectedResult)
+    schemaValidator.schemaValidate('sign', result)
+  },
+
  'throws when encoded tx does not match decoded tx - prepared payment': async (
    api,
    address
--- a/test/connection-test.ts
+++ b/test/connection-test.ts
@@ -98,6 +98,7 @@ describe('Connection', function() {
    )
    assert.strictEqual(await this.api.connection.getFeeBase(), 10)
    assert.strictEqual(await this.api.connection.getFeeRef(), 10)
+    assert.strictEqual(await this.api.connection.getReserveBase(), 20000000) // 20 XRP
  })

  it('with proxy', function(done) {
@@ -223,26 +224,29 @@ describe('Connection', function() {
  it('DisconnectedError on initial _onOpen send', async function() {
    // _onOpen previously could throw PromiseRejectionHandledWarning: Promise rejection was handled asynchronously
    // do not rely on the api.setup hook to test this as it bypasses the case, disconnect api connection first
-    await this.api.disconnect();
+    await this.api.disconnect()

    // stub _onOpen to only run logic relevant to test case
    this.api.connection._onOpen = () => {
      // overload websocket send on open when _ws exists
      this.api.connection._ws.send = function(data, options, cb) {
        // recent ws throws this error instead of calling back
-        throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+        throw new Error('WebSocket is not open: readyState 0 (CONNECTING)')
      }
-      const request = {command: 'subscribe', streams: ['ledger']};
-      return this.api.connection.request(request);
+      const request = {command: 'subscribe', streams: ['ledger']}
+      return this.api.connection.request(request)
    }

    try {
-      await this.api.connect();
+      await this.api.connect()
    } catch (error) {
-      assert(error instanceof this.api.errors.DisconnectedError);
-      assert.strictEqual(error.message, 'WebSocket is not open: readyState 0 (CONNECTING)');
+      assert(error instanceof this.api.errors.DisconnectedError)
+      assert.strictEqual(
+        error.message,
+        'WebSocket is not open: readyState 0 (CONNECTING)'
+      )
    }
-  });
+  })

  it('ResponseFormatError', function() {
    return this.api
@@ -378,8 +382,8 @@ describe('Connection', function() {
      throw new Error('error on reconnect')
    }
    // Hook up a listener for the reconnect error event
-    this.api.on('error', (error, message) => { 
-      if(error === 'reconnect' && message === 'error on reconnect') {
+    this.api.on('error', (error, message) => {
+      if (error === 'reconnect' && message === 'error on reconnect') {
        return done()
      }
      return done(new Error('Expected error on reconnect'))
@@ -591,20 +595,20 @@ describe('Connection', function() {
  )

  it('should clean up websocket connection if error after websocket is opened', async function() {
-    await this.api.disconnect();
+    await this.api.disconnect()
    // fail on connection
    this.api.connection._subscribeToLedger = async () => {
      throw new Error('error on _subscribeToLedger')
    }
    try {
-      await this.api.connect();
+      await this.api.connect()
      throw new Error('expected connect() to reject, but it resolved')
    } catch (err) {
-      assert(err.message === 'error on _subscribeToLedger');
+      assert(err.message === 'error on _subscribeToLedger')
      // _ws.close event listener should have cleaned up the socket when disconnect _ws.close is run on connection error
      // do not fail on connection anymore
      this.api.connection._subscribeToLedger = async () => {}
-      await this.api.connection.reconnect();
+      await this.api.connection.reconnect()
    }
  })

--- a/test/fixtures/responses/prepare-payment-min-amount.json
+++ b/test/fixtures/responses/prepare-payment-min-amount.json
@@ -1,5 +1,5 @@
 {
-  "txJSON": "{\"Flags\":2147614720,\"TransactionType\":\"Payment\",\"Account\":\"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59\",\"Destination\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\",\"Amount\":{\"value\":\"9999999999999999e80\",\"currency\":\"USD\",\"issuer\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\"},\"SendMax\":{\"value\":\"5\",\"currency\":\"USD\",\"issuer\":\"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59\"},\"DeliverMin\":{\"value\":\"4.93463759481038\",\"currency\":\"USD\",\"issuer\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\"},\"Paths\":[[{\"account\":\"rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B\"},{\"currency\":\"XRP\"},{\"issuer\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\",\"currency\":\"USD\"},{\"account\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\"},{\"account\":\"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn\"}],[{\"account\":\"rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B\"},{\"currency\":\"XRP\"},{\"issuer\":\"rfsEoNBUBbvkf4jPcFe2u9CyaQagLVHGfP\",\"currency\":\"USD\"},{\"account\":\"rfsEoNBUBbvkf4jPcFe2u9CyaQagLVHGfP\"},{\"account\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\"}]],\"LastLedgerSequence\":8820051,\"Fee\":\"12\",\"Sequence\":23}",
+  "txJSON": "{\"Flags\":2147614720,\"TransactionType\":\"Payment\",\"Account\":\"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59\",\"Destination\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\",\"Amount\":{\"value\":\"999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"currency\":\"USD\",\"issuer\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\"},\"SendMax\":{\"value\":\"5\",\"currency\":\"USD\",\"issuer\":\"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59\"},\"DeliverMin\":{\"value\":\"4.93463759481038\",\"currency\":\"USD\",\"issuer\":\"ra5nK24KXen9AHvsdFTKHSANinZseWnPcX\"},\"Paths\":[[{\"account\":\"rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B\"},{\"currency\":\"XRP\"},{\"issuer\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\",\"currency\":\"USD\"},{\"account\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\"},{\"account\":\"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn\"}],[{\"account\":\"rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B\"},{\"currency\":\"XRP\"},{\"issuer\":\"rfsEoNBUBbvkf4jPcFe2u9CyaQagLVHGfP\",\"currency\":\"USD\"},{\"account\":\"rfsEoNBUBbvkf4jPcFe2u9CyaQagLVHGfP\"},{\"account\":\"rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q\"}]],\"LastLedgerSequence\":8820051,\"Fee\":\"12\",\"Sequence\":23}",
  "instructions": {
    "fee": "0.000012",
    "sequence": 23,
--- a/test/hashes-test.ts
+++ b/test/hashes-test.ts
@@ -47,7 +47,7 @@ describe('Ledger', function() {
      var account = 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'
      var expectedEntryHash =
        '2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8'
-      var actualEntryHash = hashes.computeAccountHash(account)
+      var actualEntryHash = hashes.computeAccountLedgerObjectID(account)

      assert.equal(actualEntryHash, expectedEntryHash)
    })
@@ -105,18 +105,18 @@ describe('Ledger', function() {
      var sequence = 137
      var expectedEntryHash =
        '03F0AED09DEEE74CEF85CD57A0429D6113507CF759C597BABB4ADB752F734CE3'
-      var actualEntryHash = hashes.computeOrderHash(account, sequence)
+      var actualEntryHash = hashes.computeOrderID(account, sequence)

      assert.equal(actualEntryHash, expectedEntryHash)
    })
  })

-  describe('computeSignerListHash', function() {
+  describe('computeSignerListLedgerObjectID', function() {
    it('will calculate the SignerList index for r32UufnaCGL82HubijgJGDmdE5hac7ZvLw', function() {
      var account = 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'
      var expectedEntryHash =
        '778365D5180F5DF3016817D1F318527AD7410D83F8636CF48C43E8AF72AB49BF'
-      var actualEntryHash = hashes.computeSignerListHash(account)
+      var actualEntryHash = hashes.computeSignerListLedgerObjectID(account)
      assert.equal(actualEntryHash, expectedEntryHash)
    })
  })
--- a/yarn.lock
+++ b/yarn.lock