release: add checksums; update name, description

AffectedNodes may have not only ModifiedNode, but also CreatedNode and DeletedNode.

https://xrpl.org/transaction-metadata.html

Co-authored-by: Mayukha Vadari <mvadari@gmail.com>

.eslintrc.json

@@ -8,6 +8,9 @@
   "extends": [
     "eslint:recommended"
   ],
+  "globals": {
+    "NodeJS": true
+  },
   "parser": "@typescript-eslint/parser",
   "parserOptions": {
     "ecmaVersion": 2018,

.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: monthly
+    time: "15:00"
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: jsonschema
+    versions:
+    - "> 1.2.2"
+    - "< 2"

.github/pull_request_template.md

@@ -0,0 +1,50 @@
+## High Level Overview of Change
+
+<!--
+Please include a summary/list of the changes.
+If too broad, please consider splitting into multiple PRs.
+If a relevant Asana task, please link it here.
+-->
+
+### Context of Change
+
+<!--
+Please include the context of a change.
+If a bug fix, when was the bug introduced? What was the behavior?
+If a new feature, why was this architecture chosen? What were the alternatives?
+If a refactor, how is this better than the previous implementation?
+
+If there is a design document for this feature, please link it here.
+-->
+
+### Type of Change
+
+<!--
+Please check relevant options, delete irrelevant ones.
+-->
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Refactor (non-breaking change that only restructures code)
+- [ ] Tests (You added tests for code that already exists, or your new feature included in this PR)
+- [ ] Documentation Updates
+- [ ] Release
+
+## Before / After
+
+<!--
+If just refactoring / back-end changes, this can be just an in-English description of the change at a technical level.
+If a UI change, screenshots should be included.
+-->
+
+## Test Plan
+
+<!--
+Please describe the tests that you ran to verify your changes and provide instructions so that others can reproduce.
+-->
+
+<!--
+## Future Tasks
+For future tasks related to PR.
+-->

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ develop, master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ develop ]
+  schedule:
+    - cron: '44 5 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/nodejs.yml

@@ -0,0 +1,81 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ develop, master ]
+  pull_request:
+    branches: [ develop ]
+
+jobs:
+  unit:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 16.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install
+    - run: yarn test
+    - run: yarn lint
+    - run: yarn build
+
+  integration:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 16.x]
+
+    services:
+      rippled:
+        image: natenichols/rippled-standalone:latest
+        ports:
+        - 6006:6006
+        options:
+          --health-cmd="wget localhost:6006 || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s 
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install
+    - run: yarn test:integration
+      env:
+        HOST: localhost
+        PORT: ${{ job.services.rippled.ports['6006'] }}
+
+  browser:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x] # This just needs to be compatible w/ puppeteer
+
+    services:
+      rippled:
+        image: natenichols/rippled-standalone:latest
+        ports:
+        - 6006:6006
+        options:
+          --health-cmd="wget localhost:6006 || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s 
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: yarn install
+    - run: yarn test:browser

.gitignore

@@ -68,3 +68,6 @@ scripts/cache
 
 # nyc (istanbul)
 .nyc_output
+
+# browser tests
+test-compiled-for-web 

.nvmrc

@@ -1 +1 @@
-v10
+v12

.prettierrc

@@ -7,4 +7,4 @@
   "trailingComma": "none",
   "quoteProps": "consistent",
   "bracketSpacing": false
-  }
+}

.travis.yml

@@ -1,6 +1,5 @@
 language: node_js
 node_js:
-  - 8
   - 10
   - 12
   - 13

APPLICATIONS.md

@@ -1,127 +1 @@
-# Applications using ripple-lib (RippleAPI)
-
-A curated list of some of the projects and apps that leverage `ripple-lib` in some way.
-
-**Have one to add?** Please edit this file and open a PR!
-
-## Notice (disclaimer)
-
-These sites are independent of Ripple and have not been authorized, endorsed, sponsored or otherwise approved by Ripple or its affiliates.
-
-Warning: Use at your own risk.
-
-## Data and visualizations
-
-- **[xrp1ntel - XRP Intelligence](https://xrp1ntel.com/)**
-
-  Monitor the XRP Network in real time and explore historical statistics.
-
-- **[XRP Charts](https://xrpcharts.ripple.com/)** (xrpcharts.ripple.com)
-
-  XRP Charts provides information based on public data, including trade volume, top markets, metrics, transactions, and more.
-
-- **[Ripple Live](https://gatehub.net/live)** (gatehub.net/live)
-
-  Visualize XRP network transactions.
-
-- **[XRPL Dev. Dashboard](https://xrp.fans/)** (xrp.fans)
-
-  Debugging dashboard for `rippled-ws-client-pool`, transaction and query explorer, and transaction signing and submission tool.
-
-- **[XRP Value](http://xrpvalue.com/)**
-
-  Real-time XRP price, trades, and orderbook data from the XRP Ledger.
-
-- **[Bithomp - XRPL validators](https://bithomp.com/validators)**
-
-  List of XRPL validators, nodes, and testnet validators.
-
-- **[XRP Scan - XRP Ledger explorer](https://xrpscan.com)**
-
-  XRP Ledger explorer, metrics and analytics.
-
-## 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.
-
-## Wallets and wallet tools
-
-- **[XRP Toolkit](https://www.xrptoolkit.com)**
-
-  A web interface to the XRP Ledger, supporting both hardware and software wallets.
-
-- **[Toast Wallet](https://toastwallet.com/)**
-
-  A free, open source XRP Wallet for iOS, Android, Windows, Mac and Linux.
-
-- **[Toastify Ledger](https://github.com/WietseWind/toastify-ledger)** (uses `ripple-keypairs`)
-
-  Add a Regular Key to a mnemonic XRP Wallet (e.g. Ledger Nano S) to use the account with a Family Seed (secret).
-
-- **[Bithomp-submit](https://github.com/Bithomp/bithomp-submit)** (GitHub)
-
-  A tool to submit an offline-signed XRPL transaction.
-
-- **[Kyte](https://kyteapp.co/)** (kyteapp.co) ([Source](https://github.com/WietseWind/Zerp-Wallet)) (Deprecated)
-
-  Web-based XRP wallet.
-
-- **[XRP Vanity Address Generator](https://github.com/WietseWind/xrp-vanity-generator)** (Node.js)
-
-  A vanity address is a wallet address containing a few characters you like at the beginning or the end of the wallet address.
-
-- **[XRP Account Mnemonic Recovery](https://github.com/WietseWind/xrp-mnemonic-recovery)** (uses `ripple-keypairs`)
-
-  Recover a 24 word mnemonic if one word is wrong or one word is missing.
-
-## Development tools
-
-- **[XRP Test Net Faucet](https://developers.ripple.com/xrp-test-net-faucet.html)**
-
-  Get some test funds for development on the test network. The faucet was built using `ripple-lib`.
-
-## Code samples and libraries
-
-- **[ilp-plugin-xrp-paychan](https://github.com/interledgerjs/ilp-plugin-xrp-paychan)**
-
-  Send ILP payments using XRP and payment channels (PayChan).
-
-- **[RunKit: WietseWind](https://runkit.com/wietsewind/)**
-
-  XRP Ledger code samples for Node.js.
-
-- **[GitHub Gist: WietseWind](https://gist.github.com/WietseWind)**
-
-  XRP Ledger code samples for Node.js and the web (mostly).
-
-- **[rippled-ws-client-sign](https://github.com/WietseWind/rippled-ws-client-sign)**
-
-  Sign transactions, with support for MultiSign.
-
-- **[ILP-enabled power switch](https://xrpcommunity.blog/raspberry-pi-interledger-xp-powerswitch-howto/)** ([video](https://www.youtube.com/watch?v=c-eS0HQUuJg)) (uses [`moneyd-uplink-xrp`](https://github.com/interledgerjs/moneyd-uplink-xrp))
-
-  For about $30 in parts (Raspberry Pi, 3.3V Relay board and a few wires) you can build your own power switch that will switch on if a streaming ILP payment comes in. When the payment stream stops, the power turns off.
-
-## Related apps that do not appear to use ripple-lib
-
-- **[XRP Stats](https://ledger.exposed/)** (ledger.exposed)
-
-  Rich list, live ledger stats and XRP distribution. Visualize escrows and flow of funds.
-
-- **[XRP Vanity](https://xrpvanity.com/)** (xrpvanity.com)
-
-  Custom XRP addresses for sale, delivered by SetRegularKey.
+# [Moved to xrpl.js](https://github.com/XRPLF/xrpl.js/blob/main/APPLICATIONS.md)

HISTORY.md

@@ -1,5 +1,324 @@
 # ripple-lib Release History
 
+# Deprecation Notice
+
+This library (ripple-lib 1.x) has been deprecated in favor of [xrpl.js version 2+](https://github.com/XRPLF/xrpl.js).
+
+## 1.10.1 (2022-05-31)
+
+* Fix bug in parseSettings: AffectedNodes can contain CreatedNode and DeletedNode ([#1907](https://github.com/XRPLF/xrpl.js/pull/1907))
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+368ad4fe29bfeee7dd59e319eded72d486f57a2c05a2314d9e5c42db1fd70fcd  build/ripple-latest-min.js
+f8328b2b687757112b63675b1af272ee08bea15df2a392d1c50637604e938a22  build/ripple-latest-min.js.LICENSE.txt
+2631590b53ddee9a68cb4149af07b20a1135606a8b5d3d746594359e003411d4  build/ripple-latest.js
+```
+
+## 1.10.0 (2021-08-12)
+
+* Add address generation from Devnet/Testnet faucets (#1497)
+* Fix bug with `getBalances()` ledgerVersion (#1505)
+* Include lodash in webpack build (#1500)
+* Documentation Updates:
+  * Export and document AccountSetFlags (#1525)
+  * Add links to example keypair derivation (#1523)
+
+## 1.9.8 (2021-07-30)
+
+* Export offline methods to top level of package (#1479)
+* Remove deprecated ledger fields (#1160)
+  * These fields have been deprecated for many years: accepted, hash (use ledger_hash instead), seqNum (use ledger_index instead), totalCoins (use total_coins instead)
+* Docs improvements (#1251, #1420, #1463)
+* Reduce dependencies on lodash (#1467)
+* Bug fixes
+  * Allow lowercase hex for memos (#1475)
+  * Add type argument to Promise (#1474)
+  * Fix miscommunication with ripplingDisabled in trustlines (#1481)
+  * Allow X-address for issuer (#1471)
+* Dependencies
+  * ws, ripple-binary-codec
+  * deps-dev: typescript, @types/node, ts-node
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+f3a0efb9f8bb618da6b10425a9b55a8492359a331a22d0ab4de7d3551870eb3d  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+fd40457a89a14732ce261148e129cdda5aa963d9a433c57700353083faa1bffe  build/ripple-latest.js
+```
+
+## 1.9.7 (2021-07-14)
+
+* Bug fixes
+  * TypeScript: fix TrustlineTransaction type (#1458) (#1460) (thanks @mrosendin)
+* Docs
+  * Update boilerplate (#1459) (thanks @mDuo13)
+* Dependencies
+  * @types/node, @types/ws, @types/lodash, @types/mocha, prettier, mocha, webpack, ripple-binary-codec, ws, webpack-cli, doctoc
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+a994422648c040076251c9a040fd494bc2ee30de23867607985b953022853afc  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+2e22b6187ff5f9300520c29a538013067609b439181f1f2184d6a80fcfa2449c  build/ripple-latest.js
+```
+
+## 1.9.6 (2021-07-01)
+
+* Bug fixes
+  * Use 'current' ledger when preparing txs (#1429) (#999)
+  * Allow multiple settings at once (#1435)
+* Dependencies
+  * ripple-address-codec, prettier, mocha
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+cac7f6f3be93efbd61dc5fd527c40f0d1baec06f2f9faa64e9eeb191cc85a710  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+5737483e940dca8b73768d8a1de8217c7e921a9cebaadef02d2b16867658f331  build/ripple-latest.js
+```
+
+## 1.9.5 (2021-06-01)
+
+* Bug fixes
+  * Prevent getFee from returning NaN from Reporting Mode (#1401) (#1398)
+  * Return promise inside catch block of reconnect to propagate promise (#1418) (#1113) (thanks @camposfyi)
+  * Internal
+    * Update mocha to use RC file config (#1417) (#1210) (thanks @camposfyi)
+* Dependencies
+  * @types/ws, ws, browserslist, @types/lodash
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+fcdc4aa1e1df7cb788b68f3d036e168aa64f9e818f441b99fef62d4571c0387d  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+dfb7a92c4156fb3ee367254b5ea0935cda741cd3b5c36cdca695e7d89f88605e  build/ripple-latest.js
+```
+
+## 1.9.4 (2021-04-18)
+
+* Add memos support for all transaction types for getTransactions (#1353, #1397)
+* Add Deno and React instructions (#1387)
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+daa2b892a18037e89fea6fcf7de67624a782971956cb8df17cd765a4b0201ee9  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+b1d0bab54c6dbc76091610ede54a4269e73dea8cc6a9c25738d62bd7671920e4  build/ripple-latest.js
+```
+
+## 1.9.3 (2021-03-16)
+
+* Expose ripple-address-codec methods. These are static methods on RippleAPI, so you do not need to create a RippleAPI instance.
+  * `classicAddressToXAddress` / `xAddressToClassicAddress`
+  * `isValidXAddress` / `isValidClassicAddress`
+  * `encodeSeed` / `decodeSeed`
+  * `encodeAccountID` / `decodeAccountID`
+  * `encodeNodePublic` / `decodeNodePublic`
+  * `encodeAccountPublic` / `decodeAccountPublic`
+  * `encodeXAddress` / `decodeXAddress`
+
+Example 1. Encode an X-address with tag 4294967295:
+```js
+const RippleAPI = require('ripple-lib').RippleAPI
+const xAddress = RippleAPI.classicAddressToXAddress('rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf', 4294967295)
+console.log(xAddress)
+```
+
+Output for Example 1:
+```
+XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi
+```
+
+Example 2. Encode a test address for use with Testnet or Devnet:
+```js
+const RippleAPI = require('ripple-lib').RippleAPI
+const address = RippleAPI.classicAddressToXAddress('r3SVzk8ApofDJuVBPKdmbbLjWGCCXpBQ2g', 123, true)
+console.log(address)
+```
+
+Output for Example 2:
+```
+T7oKJ3q7s94kDH6tpkBowhetT1JKfcfdSCmAXbS75iATyLD
+```
+
+Example 3. Decode an X-address:
+```js
+const RippleAPI = require('ripple-lib').RippleAPI
+const address = RippleAPI.xAddressToClassicAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi')
+console.log(address)
+```
+
+Output for Example 3:
+```js
+{
+  classicAddress: 'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+  tag: 4294967295,
+  test: false
+}
+```
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+bcc8db4e5464197151a267d9f240693794bf1eb4d26a4e0b3637f82a1d66e440  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+99c2825685d249c074abe7b59abaf197afce67ece7ad08ded6db67185e916dd2  build/ripple-latest.js
+```
+
+## 1.9.2 (2021-03-12)
+
+* Docs
+  * Add missing transaction type links (#1378)
+* Bug fixes
+  * Deserialization and verification of payment paths (#1382) (#1347) (#1376)
+* Dependencies
+  * Bump ripple-binary-codec to 1.1.2
+    * Fix edge case when constructing a value from "0", which can occur when using rippled v1.7.0
+  * Bump lodash, ripple-address-codec
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+a1fd24b65d81ea5dbc36d74da7a6317267a048bba084effff5380d47299c3c63  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+410f78105c4f23c13671ec94f963ef47179393bfcad65ff610bc838c5a3c6a65  build/ripple-latest.js
+```
+
+## 1.9.1 (2021-02-25)
+
+* Docs
+  * Add transaction specifications: (#1352)
+    * Ticket Create
+    * Account Delete
+    * Deposit Preauth
+  * Update link to subscribe page (#1354)
+* Bug fixes
+  * Allow connectionTimeout option to be customized (#1355)
+* Dependencies
+  * Bump ripple-keypairs to 1.0.3
+  * Bump elliptic to 6.5.4 (this patches a potential security issue, although we do not believe that the issue affects ripple-lib: [details](https://github.com/ripple/ripple-keypairs/security/advisories/GHSA-w6x3-9ph2-7x54))
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+f59e0221a7218460eea59b0441a0ee2d2a14484dd473ed5373283852798516c7  build/ripple-latest-min.js
+fc17a5572001d814ea6b81aa701fcb66882ec031c68afb769a8ea8b71c6529a6  build/ripple-latest-min.js.LICENSE.txt
+731ed44cbff8db26bcf256e0e3f3ac3fe90a10b6c227701d67918a5d643c5b29  build/ripple-latest.js
+```
+
+## 1.9.0 (2020-12-07)
+
+* New features
+  * Support for tickets (TicketBatch amendment required - not yet activated on live/main network)
+    * `prepareTicketCreate`
+  * Types: Add LedgerClosedEvent and export more types
+* Docs
+  * Improve descriptions of get-ledger response time fields
+  * Applications
+    * Add Bithomp explorer
+    * Add example of reliable transaction submission
+* Node.js
+  * Require Node.js version 10.13.0+
+* Internal
+  * Update webpack, webpack-cli, mocha, nyc, ripple-binary-codec
+  * Run prettier to format code
+
+The SHA-256 checksums for the browser version of this release can be found below.
+```
+% shasum -a 256 build/*
+2d3ae057ad637df272f98cfe940ea9e1317588e5bbf4fee47c8b16d6e6e71d85  build/ripple-latest-min.js
+8cbbc7bb482f68bcc8d411bae2e42effdb14ddfa562fcbc329a373910b85cf8c  build/ripple-latest.js
+```
+
+## 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)
+* Internal
+  * Improve unit tests
+* Dependencies
+  * Update webpack-cli, @types/node, webpack, @typescript-eslint/eslint-plugin,
+    typescript, ripple-keypairs
+
+## 1.6.3 (2020-02-05)
+
+* Update ripple-keypairs to 1.0.0
+* Bug fix: Assign event listener to socket close event on open before attempting post-open logic (#1186)
+  * Protects against possible unhandled rejection in disconnect
+  * Adds the Connection `_ws.close` event listener post `_ws.open` before executing any post `_ws.open` logic, i.e. `Connection._subscribeToLedger`
+  * This prevents a reconnection error loop that occurs if `Connection._ws` is never cleaned up by the unreachable `_ws.close` event listener
+  * Also ensures that a possible disconnect() promise rejection is not unhandled if any `_ws.open` logic in `Connection.connect()` throws
+* Dependencies
+  * Update mocha-junit-reporter, @types/node, mocha, @typescript-eslint/eslint-plugin, ripple-address-codec
+
 ## 1.6.2 (2020-01-17)
 
 * Bug fix: Catch possible error in reconnect() on _heartbeat(), emit reconnect error (#1179)

LICENSE

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2012-2015 Ripple Labs Inc.
+Copyright (c) 2012-2021 Contributers to xrpl.js
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

README.md

@@ -1,12 +1,18 @@
+## Deprecated
+
+This library (ripple-lib 1.x) has been deprecated in favor of [xrpl.js version 2+](https://github.com/XRPLF/xrpl.js).
+
 # ripple-lib (RippleAPI)
 
 A JavaScript/TypeScript API for interacting with the XRP Ledger
 
 [![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)
 
-This is the recommended library for integrating a JavaScript/TypeScript app with the XRP Ledger, especially if you intend to use advanced functionality such as IOUs, payment paths, the decentralized exchange, account settings, payment channels, escrows, multi-signing, and more.
+This library is for integrating a JavaScript/TypeScript app with the XRP Ledger and supports functionality such as IOUs, payment paths, the decentralized exchange, account settings, payment channels, escrows, multi-signing, and more.
 
-**What is ripple-lib used for?** Here's a [list of applications](APPLICATIONS.md) that use `ripple-lib`. Open a PR to add your app or project to the list!
+## [➡️ Reference Documentation](https://github.com/XRPLF/xrpl.js/blob/1.x/docs/index.md)
+
+Use the above link to view the full reference documentation.
 
 ### Features
 
@@ -18,27 +24,92 @@ This is the recommended library for integrating a JavaScript/TypeScript app with
 
 ### Requirements
 
-+ **[Node v10](https://nodejs.org/)** is recommended. Other versions may work but are not frequently tested.
++ **[Node.js v14](https://nodejs.org/)** is recommended. Other versions may work but are not frequently tested.
 + **[Yarn](https://yarnpkg.com/)** is recommended. `npm` may work but we use `yarn.lock`.
 
-### Install
+## Getting Started
+
+See also: [RippleAPI Beginners Guide](https://xrpl.org/get-started-with-rippleapi-for-javascript.html)
 
 In an existing project (with `package.json`), install `ripple-lib`:
 ```
 $ yarn add ripple-lib
 ```
 
+Then see the [documentation](#documentation).
+
+### Using ripple-lib with React Native
+
+If you want to use `ripple-lib` with React Native you will need to have some of the NodeJS modules available. To help with this you can use a module like [rn-nodeify](https://github.com/tradle/rn-nodeify).
+
+1. Install dependencies (you can use `npm` as well):
+
+    ```shell
+    yarn add react-native-crypto
+    yarn add ripple-lib 
+    # install peer deps
+    yarn add react-native-randombytes
+    # install latest rn-nodeify
+    yarn add rn-nodeify@latest --dev
+    ```
+
+2. After that, run the following command:
+
+    ```shell
+    # install node core shims and recursively hack package.json files
+    # in ./node_modules to add/update the "browser"/"react-native" field with relevant mappings
+    ./node_modules/.bin/rn-nodeify --hack --install
+    ```
+
+3. Enable `crypto`:
+
+    `rn-nodeify` will create a `shim.js` file in the project root directory.
+    Open it and uncomment the line that requires the crypto module:
+
+    ```javascript
+    // If using the crypto shim, uncomment the following line to ensure
+    // crypto is loaded first, so it can populate global.crypto
+    require('crypto')
+    ```
+
+4. Import `shim` in your project (it must be the first line):
+
+  ```javascript
+  import './shim'
+  ...
+  ```
+
+### Using ripple-lib with Deno
+
+Until official support for [Deno](https://deno.land) is added, you can use the following work-around to use `ripple-lib` with Deno:
+
+```javascript
+import ripple from 'https://dev.jspm.io/npm:ripple-lib';
+
+(async () => {
+  const api = new (ripple as any).RippleAPI({ server: 'wss://s.altnet.rippletest.net:51233' });
+  const address = 'rH8NxV12EuV...khfJ5uw9kT';
+
+  api.connect().then(() => {
+    api.getBalances(address).then((balances: any) => {
+      console.log(JSON.stringify(balances, null, 2));
+    });
+  });
+})();
+```
+
 ## Documentation
 
 + [RippleAPI Beginners Guide](https://xrpl.org/get-started-with-rippleapi-for-javascript.html)
 + [RippleAPI Full Reference Documentation](https://xrpl.org/rippleapi-reference.html) ([in this repo](https://github.com/ripple/ripple-lib/blob/develop/docs/index.md))
 + [Code Samples](https://github.com/ripple/ripple-lib/tree/develop/docs/samples)
++ [XRP Ledger Dev Portal](https://xrpl.org/)
 
 ### Mailing Lists
 
 We have a low-traffic mailing list for announcements of new ripple-lib releases. (About 1 email per week)
 
-+ [Subscribe to ripple-lib-announce](https://groups.google.com/forum/#!forum/ripple-lib-announce)
++ [Subscribe to xrpl-announce](https://groups.google.com/g/xrpl-announce)
 
 If you're using the XRP Ledger in production, you should run a [rippled server](https://github.com/ripple/rippled) and subscribe to the ripple-server mailing list as well.
 
@@ -67,7 +138,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
 
@@ -76,11 +147,3 @@ Do not edit `./docs/index.md` directly because it is a generated file.
 Instead, edit the appropriate `.md.ejs` files in `./docs/src/`.
 
 If you make changes to the JSON schemas, fixtures, or documentation sources, update the documentation by running `yarn run docgen`.
-
-## More Information
-
-+ [ripple-lib-announce mailing list](https://groups.google.com/forum/#!forum/ripple-lib-announce) - subscribe for release announcements
-+ [RippleAPI Reference](https://xrpl.org/rippleapi-reference.html) - XRP Ledger Dev Portal
-+ [XRP Ledger Dev Portal](https://xrpl.org/)
-
- [![Build Status](https://travis-ci.org/ripple/ripple-lib.svg?branch=master)](https://travis-ci.org/ripple/ripple-lib)

docs/samples/README.md

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

docs/samples/ticket.js

@@ -0,0 +1,31 @@
+'use strict';
+const RippleAPI = require('../../src').RippleAPI; // require('ripple-lib')
+
+const address = 'INSERT ADDRESS HERE';
+const secret = 'INSERT SECRET HERE';
+
+const api = new RippleAPI({server: 'wss://s1.ripple.com:443'});
+const instructions = {
+  maxLedgerVersionOffset: 5
+};
+const numberOfTickets = 1;
+
+function quit(message) {
+  console.log(message);
+  process.exit(0);
+}
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+api.connect().then(() => {
+  console.log('Connected...');
+  return api.prepareTicketCreate(address, numberOfTickets, instructions).then(prepared => {
+    console.log('Ticket transaction prepared...');
+    const {signedTransaction} = api.sign(prepared.txJSON, secret);
+    console.log('Ticket transaction signed...');
+    api.submit(signedTransaction).then(quit, fail);
+  });
+}).catch(fail);

docs/src/accountSetFlags.md.ejs

@@ -0,0 +1,23 @@
+## AccountSet Flags
+
+To modify account flags, you can use an AccountSet transaction and its `SetFlag` or `ClearFlag` fields.
+	
+The flags are called [AccountSet flags (asf*)](https://xrpl.org/accountset.html#accountset-flags):
+
+`RippleAPI.accountSetFlags.requireDestinationTag`: Require a destination tag to send transactions to this account.
+
+`RippleAPI.accountSetFlags.requireAuthorization`: Require authorization for users to hold balances issued by this address. Can only be enabled if the address has no trust lines connected to it.
+
+`RippleAPI.accountSetFlags.disallowIncomingXRP`: XRP should not be sent to this account. (Enforced by client applications, not by rippled)
+
+`RippleAPI.accountSetFlags.disableMasterKey`: Disallow use of the master key pair. Can only be enabled if the account has configured another way to sign transactions.
+
+`RippleAPI.accountSetFlags.enableTransactionIDTracking`: Track the ID of this account's most recent transaction.
+
+`RippleAPI.accountSetFlags.noFreeze`: Permanently give up the ability to freeze individual trust lines or disable Global Freeze. This flag can never be disabled after being enabled.
+
+`RippleAPI.accountSetFlags.globalFreeze`:	Freeze all assets issued by this account.
+
+`RippleAPI.accountSetFlags.defaultRipple`: Enable [rippling](https://xrpl.org/rippling.html) on this account's trust lines by default.
+
+`RippleAPI.accountSetFlags.depositAuth`:Enable Deposit Authorization on this account.

docs/src/basictypes.md.ejs

@@ -22,7 +22,7 @@ An *X-address* encodes a hash of the account's public key, a tag, and a checksum
 
 ## Account Sequence Number
 
-Every XRP Ledger account has a *sequence number* that is used to keep transactions in order. Every transaction must have a sequence number. A transaction can only be executed if it has the next sequence number in order, of the account sending it. This prevents one transaction from executing twice and transactions executing out of order. The sequence number starts at `1` and increments for each transaction that the account makes.
+Every XRP Ledger account has a *sequence number* that is used to keep transactions in order. Every transaction must have a sequence or a ticketSequence number. A transaction can only be executed if it has the next sequence number in order, of the account sending it, or uses a previously generated ticketSequence number. This prevents one transaction from executing twice and transactions executing out of order. The sequence number starts at `1` and increments for each transaction that the account makes.
 
 ## Currency
 
@@ -31,7 +31,7 @@ Currencies are represented as either 3-character currency codes or 40-character
 ## Value
 A *value* is a quantity of a currency represented as a decimal string. Be careful: JavaScript's native number format does not have sufficient precision to represent all values. XRP has different precision from other currencies.
 
-**XRP** has 6 significant digits past the decimal point. In other words, XRP cannot be divided into positive values smaller than `0.000001` (1e-6). This smallest unit is called a "drop". XRP has a maximum value of `100000000000` (1e11). Some RippleAPI methods accept XRP in order to maintain compatibility with older versions of the API. For consistency with the `rippled` APIs, we recommend formally specifying XRP values in *drops* in all API requests, and converting them to XRP for display. This is similar to Bitcoin's *satoshis* and Ethereum's *wei*. 1 XRP = 1,000,000 drops.
+**XRP** has 6 significant digits past the decimal point. In other words, XRP cannot be divided into positive values smaller than `0.000001` (1e-6). This smallest unit is called a "drop". XRP has a maximum value of `100000000000` (1e11). Some RippleAPI methods accept XRP to maintain compatibility with older versions of the API. For consistency with the `rippled` APIs, we recommend formally specifying XRP values in *drops* in all API requests, and converting them to XRP for display. This is like Bitcoin's *satoshis* and Ethereum's *wei*. 1 XRP = 1,000,000 drops.
 
 **Non-XRP values** have 16 decimal digits of precision, with a maximum value of `9999999999999999e80`. The smallest positive non-XRP value is `1e-81`.
 

docs/src/boilerplate.md.ejs

@@ -6,7 +6,7 @@ Use the following [boilerplate code](https://en.wikipedia.org/wiki/Boilerplate_c
 const RippleAPI = require('ripple-lib').RippleAPI;
 
 const api = new RippleAPI({
-  server: 'wss://s1.ripple.com' // Public rippled server hosted by Ripple, Inc.
+  server: 'wss://xrplcluster.com' // Public cluster
 });
 api.on('error', (errorCode, errorMessage) => {
   console.log(errorCode + ': ' + errorMessage);
@@ -16,7 +16,7 @@ api.on('connected', () => {
 });
 api.on('disconnected', (code) => {
   // code - [close code](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent) sent by the server
-  // will be 1000 if this was normal closure
+  // the code is 1000 for a normal closure
   console.log('disconnected, code:', code);
 });
 api.connect().then(() => {
@@ -26,9 +26,7 @@ api.connect().then(() => {
 }).catch(console.error);
 ```
 
-RippleAPI is designed to work in [Node.js](https://nodejs.org) version 6 or higher. Ripple recommends Node.js v10 LTS.
-
-The code samples in this documentation are written with ECMAScript 6 (ES6) features, but `RippleAPI` also works with ECMAScript 5 (ES5). Regardless of whether you use ES5 or ES6, the methods that return Promises return [ES6-style promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
+[Node.js v14](https://nodejs.org/) is recommended. Other versions may work but are not frequently tested.
 
 <aside class="notice">
 All the code snippets in this documentation assume that you have surrounded them with this boilerplate.
@@ -39,7 +37,7 @@ If you omit the "catch" section, errors may not be visible.
 </aside>
 
 <aside class="notice">
-The "error" event is emitted whenever an error occurs that cannot be associated with a specific request. If the listener is not registered, an exception will be thrown whenever the event is emitted.
+The API emits an "error" event whenever an error occurs that cannot be associated with a specific request. If there is no listener registered for this event, the API throws an exception whenever the event is emitted.
 </aside>
 
 ### Parameters

docs/src/combine.md.ejs

@@ -2,7 +2,7 @@
 
 `combine(signedTransactions: Array<string>): {signedTransaction: string, id: string}`
 
-Combines signed transactions from multiple accounts for a multisignature transaction. The signed transaction must subsequently be [submitted](#submit).
+Combines signed transactions from multiple accounts for a multisignature transaction into a form that can be [submitted](#submit).
 
 ### Parameters
 

docs/src/events.md.ejs

@@ -27,7 +27,7 @@ This event is emitted when there is an error on the connection to the server tha
 The first parameter is a string indicating the error type:
 * `badMessage` - rippled returned a malformed message
 * `websocket` - the websocket library emitted an error
-* one of the error codes found in the [rippled Universal Errors](https://ripple.com/build/rippled-apis/#universal-errors).
+* one of the error codes found in the [`rippled` Universal Errors](https://xrpl.org/error-formatting.html#universal-errors).
 
 The second parameter is a message explaining the error.
 

docs/src/formatBidsAndAsks.md.ejs

@@ -15,7 +15,7 @@ This method takes two parameters.
 
 ### Return Value
 
-This method returns an object with two properties: `bids` and `asks`, each of which is an array of bids (buy orders) or asks (sell orders), respectively. (Note: the structures of `bids` and `asks` are identical.)
+This method returns an object with two properties: `bids` and `asks`, each of which is an array of bids (buy orders) or asks (sell orders), respectively. Both `bids` and `asks` are formatted the same way.
 
 Object structure:
 
@@ -23,7 +23,7 @@ Object structure:
 
 **Raw order data:** The response includes a `data` property containing the raw order data. This may include `owner_funds`, `Flags`, and other fields.
 
-For details, see the rippled method [book_offers](https://ripple.com/build/rippled-apis/#book-offers).
+For details, see the `rippled` [book_offers method](https://xrpl.org/book_offers.html).
 
 ### Example
 

docs/src/generateFaucetWallet.md.ejs

@@ -0,0 +1,19 @@
+## generateFaucetWallet
+
+`generateFaucetWallet(onTestnet = true)`
+
+Calls the Testnet or Devnet faucet API in order to generate a new, random wallet with some amount of test XRP. This is for testing purposes only.
+
+### Example
+
+**Request**
+
+Create a new wallet on the Testnet:
+
+```javascript
+const wallet = await api.generateFaucetWallet()
+```
+
+**Response**
+
+<%- renderFixture('responses/generate-faucet-wallet.json') %>

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') %>

docs/src/getFee.md.ejs

@@ -4,7 +4,7 @@
 
 Returns the estimated transaction fee for the rippled server the RippleAPI instance is connected to.
 
-This will use the [feeCushion parameter](#parameters) provided to the RippleAPI constructor, or the default value of `1.2`.
+This uses the [feeCushion parameter](#parameters) provided to the RippleAPI constructor, or the default value of `1.2`.
 
 ### Parameters
 

docs/src/getOrderbook.md.ejs

@@ -14,13 +14,13 @@ Returns open orders for the specified account. Open orders are orders that have
 
 ### Return Value
 
-This method returns a promise that resolves with an object with the following structure (Note: the structures of `bids` and `asks` are identical):
+This method returns a promise that resolves with an object with the following structure Both `bids` and `asks` have the same format:
 
 <%- renderSchema('output/get-orderbook.json') %>
 
 **Raw order data:** The response includes a `data` property containing the raw order data. This may include `owner_funds`, `Flags`, and other fields.
 
-For details, see the rippled method [book_offers](https://ripple.com/build/rippled-apis/#book-offers).
+For details, see the `rippled` [book_offers method](https://xrpl.org/book_offers.html).
 
 ### Example
 

docs/src/getSettings.md.ejs

@@ -10,7 +10,7 @@ Returns settings for the specified account. Note: For account data that is not m
 
 ### Return Value
 
-This method returns a promise that resolves with an array of objects with the following structure (Note: all fields are optional as they will not be shown if they are set to their default value):
+This method returns a promise that resolves with an array of objects with the following structure. All fields are optional, and are omitted if they are set to their default value.
 
 <%- renderSchema('output/get-settings.json') %>
 

docs/src/hasNextPage.md.ejs

@@ -6,7 +6,7 @@ Returns `true` when there are more pages available.
 
 When there are more results than contained in the response, the response includes a `marker` field. You can use this convenience method, or check for `marker` yourself.
 
-See [Markers and Pagination](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+See [Markers and Pagination](https://xrpl.org/markers-and-pagination.html).
 
 ### Return Value
 

docs/src/index.md.ejs

@@ -49,6 +49,7 @@
 <%- include('prepareCheckCreate.md.ejs') %>
 <%- include('prepareCheckCancel.md.ejs') %>
 <%- include('prepareCheckCash.md.ejs') %>
+<%- include('prepareTicketCreate.md.ejs') %>
 <%- include('sign.md.ejs') %>
 <%- include('combine.md.ejs') %>
 <%- include('submit.md.ejs') %>
@@ -58,6 +59,7 @@
 <%- include('isValidSecret.md.ejs') %>
 <%- include('deriveKeypair.md.ejs') %>
 <%- include('deriveAddress.md.ejs') %>
+<%- include('generateFaucetWallet.md.ejs') %>
 <%- include('signPaymentChannelClaim.md.ejs') %>
 <%- include('verifyPaymentChannelClaim.md.ejs') %>
 <%- include('computeLedgerHash.md.ejs') %>
@@ -65,5 +67,6 @@
 <%- include('iso8601ToRippleTime.md.ejs') %>
 <%- include('rippleTimeToISO8601.md.ejs') %>
 <%- include('txFlags.md.ejs') %>
+<%- include('accountSetFlags.md.ejs') %>
 <%- include('schemaValidator.md.ejs') %>
 <%- include('events.md.ejs') %>

docs/src/offline.md.ejs

@@ -1,8 +1,8 @@
 ## Offline functionality
 
-RippleAPI can also function without internet connectivity. This can be useful in order to generate secrets and sign transactions from a secure, isolated machine.
+RippleAPI can also function without internet connectivity, so you can generate secrets and sign transactions from a secure, isolated machine.
 
-To instantiate RippleAPI in offline mode, use the following boilerplate code:
+To instantiate RippleAPI in offline mode, use the following code:
 
 ```javascript
 const RippleAPI = require('ripple-lib').RippleAPI;

docs/src/parseAccountFlags.md.ejs

@@ -2,7 +2,7 @@
 
 `parseAccountFlags(Flags: number): object`
 
-Parse an `AccountRoot` object's [`Flags`](https://developers.ripple.com/accountroot.html#accountroot-flags).
+Parse an `AccountRoot` object's [`Flags`](https://xrpl.org/accountroot.html#accountroot-flags).
 
 ### Parameters
 

docs/src/prepareCheckCancel.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareCheckCancel(address: string, checkCancel: object, instructions: object): Promise<object>`
 
-Prepare a Check cancellation transaction. This cancels an unredeemed Check, removing it from the ledger without sending any money. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a Check cancellation transaction. This type of transaction cancels an unredeemed Check, removing it from the ledger without sending any money. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareCheckCash.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareCheckCash(address: string, checkCash: object, instructions: object): Promise<object>`
 
-Prepare a Check cashing transaction. This redeems a Check to receive up to the amount authorized by the corresponding CheckCreate transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a Check cashing transaction. This redeems a Check to receive up to the amount authorized by the corresponding CheckCreate transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareCheckCreate.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareCheckCreate(address: string, checkCreate: object, instructions: object): Promise<object>`
 
-Prepare a Check creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a Check creation transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareEscrowCancellation.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareEscrowCancellation(address: string, escrowCancellation: object, instructions: object): Promise<object>`
 
-Prepare an escrow cancellation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare an escrow cancellation transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareEscrowCreation.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareEscrowCreation(address: string, escrowCreation: object, instructions: object): Promise<object>`
 
-Prepare an escrow creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare an escrow creation transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareEscrowExecution.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareEscrowExecution(address: string, escrowExecution: object, instructions: object): Promise<object>`
 
-Prepare an escrow execution transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare an escrow execution transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareOrder.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareOrder(address: string, order: object, instructions: object): Promise<object>`
 
-Prepare an order transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare an order transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareOrderCancellation.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareOrderCancellation(address: string, orderCancellation: object, instructions: object): Promise<object>`
 
-Prepare an order cancellation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare an order cancellation transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/preparePayment.md.ejs

@@ -2,7 +2,7 @@
 
 `preparePayment(address: string, payment: object, instructions: object): Promise<object>`
 
-Prepare a payment transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a payment transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/preparePaymentChannelClaim.md.ejs

@@ -2,7 +2,7 @@
 
 `preparePaymentChannelClaim(address: string, paymentChannelClaim: object, instructions: object): Promise<object>`
 
-Prepare a payment channel claim transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a payment channel claim transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/preparePaymentChannelCreate.md.ejs

@@ -2,7 +2,7 @@
 
 `preparePaymentChannelCreate(address: string, paymentChannelCreate: object, instructions: object): Promise<object>`
 
-Prepare a payment channel creation transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a payment channel creation transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/preparePaymentChannelFund.md.ejs

@@ -2,7 +2,7 @@
 
 `preparePaymentChannelFund(address: string, paymentChannelFund: object, instructions: object): Promise<object>`
 
-Prepare a payment channel fund transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a payment channel fund transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareSettings.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareSettings(address: string, settings: object, instructions: object): Promise<object>`
 
-Prepare a settings transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a settings transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/prepareTicketCreate.md.ejs

@@ -0,0 +1,34 @@
+## prepareTicketCreate
+
+`prepareTicketCreate(address: string, ticketCount: number, instructions: object): Promise<object>`
+
+Prepare a ticket transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
+
+Ticket functionality requires the [TicketBatch amendment](https://github.com/ripple/xrpl-dev-portal/issues/898). As of 2020-11-24, this amendment is not activated on the Mainnet, Testnet, or Devnet.
+
+### Parameters
+
+<%- renderSchema("input/prepare-ticket-create.json") %>
+
+### Return Value
+
+This method returns a promise that resolves with an object with the following structure:
+
+<aside class="notice">
+All "prepare*" methods have the same return type.
+</aside>
+
+<%- renderSchema("output/prepare.json") %>
+
+### Example
+
+```javascript
+const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';
+return api.prepareTicketCreate(address, 2).then(prepared => {
+    /* ... */
+  }).catch(error => {
+    /* ... as with all prepare* methods, use a Promise catch block to handle errors ... */
+  })
+```
+
+<%- renderFixture("responses/prepare-ticket-create.json") %>

docs/src/prepareTransaction.md.ejs

@@ -2,9 +2,9 @@
 
 `prepareTransaction(transaction: object, instructions: object): Promise<object>`
 
-Prepare a transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
-This method works with any of [the transaction types supported by rippled](https://developers.ripple.com/transaction-types.html).
+This method works with any of [the transaction types supported by rippled](https://xrpl.org/transaction-types.html).
 
 Notably, this is the preferred method for preparing `DepositPreauth` or `AccountDelete` transactions.
 
@@ -12,8 +12,8 @@ Notably, this is the preferred method for preparing `DepositPreauth` or `Account
 
 Name | Type | Description
 ---- | ---- | -----------
-transaction | [transaction](https://developers.ripple.com/transaction-formats.html) | The specification (JSON) of the transaction to prepare. Set `Account` to the address of the account that is creating the transaction. You may omit auto-fillable fields like `Fee`, `Flags`, and `Sequence` to have them set automatically.
-instructions | [instructions](#transaction-instructions) | *Optional* Instructions for executing the transaction.
+transaction | [Transaction](https://xrpl.org/transaction-formats.html) | The specification (JSON) of the transaction to prepare. Set `Account` to the address of the account that is creating the transaction. You may omit auto-fillable fields like `Fee`, `Flags`, and `Sequence` to have them set automatically.
+instructions | [Instructions](#transaction-instructions) | *Optional* Instructions for executing the transaction.
 
 ### Return Value
 

docs/src/prepareTrustline.md.ejs

@@ -2,7 +2,7 @@
 
 `prepareTrustline(address: string, trustline: object, instructions: object): Promise<object>`
 
-Prepare a trustline transaction. The prepared transaction must subsequently be [signed](#sign) and [submitted](#submit).
+Prepare a trustline transaction. The prepared transaction can then be [signed](#sign) and [submitted](#submit).
 
 ### Parameters
 

docs/src/renameCounterpartyToIssuer.md.ejs

@@ -12,7 +12,7 @@ This method takes one parameter, an object with a `counterparty` field.
 
 ### Return Value
 
-This method returns a new object similar to the source object, but with `issuer` instead of `counterparty`.
+This method returns a new object based on the source object, but with `issuer` instead of `counterparty`.
 
 ### Example
 

docs/src/request.md.ejs

@@ -4,7 +4,7 @@
 
 Returns the response from invoking the specified command, with the specified options, on the connected rippled server.
 
-Refer to [rippled APIs](https://ripple.com/build/rippled-apis/) for commands and options. All XRP amounts must be specified in drops. One drop is equal to 0.000001 XRP. See [Specifying Currency Amounts](https://ripple.com/build/rippled-apis/#specifying-currency-amounts).
+Refer to [HTTP / WebSocket APIs](https://xrpl.org/rippled-api.html) for commands and options. All XRP amounts must be specified in drops. One drop is equal to 0.000001 XRP. See [Specifying Currency Amounts](https://xrpl.org/basic-data-types.html#specifying-currency-amounts).
 
 Most commands return data for the `current` (in-progress, open) ledger by default. Do not rely on this. Always specify a ledger version in your request. In the example below, the 'validated' ledger is requested, which is the most recent ledger that has been validated by the whole network. See [Specifying Ledgers](https://xrpl.org/basic-data-types.html#specifying-ledgers).
 

docs/src/requestNextPage.md.ejs

@@ -6,13 +6,13 @@ Requests the next page of data.
 
 You can use this convenience method, or include `currentResponse.marker` in `params` yourself, when using `request`.
 
-See [Markers and Pagination](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+See [Markers and Pagination](https://xrpl.org/markers-and-pagination.html).
 
 ### Return Value
 
 This method returns a promise that resolves with the next page of data from rippled.
 
-If the response does not have a next page, the promise will reject with `new errors.NotFoundError('response does not have a next page')`.
+If the response does not have a next page, the promise rejects with `new errors.NotFoundError('response does not have a next page')`.
 
 ### Example
 

docs/src/rippledAPIs.md.ejs

@@ -1,20 +1,21 @@
 # rippled APIs
 
-ripple-lib relies on [rippled APIs](https://ripple.com/build/rippled-apis/) for online functionality. In addition to ripple-lib's own methods, you can also access rippled APIs through ripple-lib. Use the `request()`, `hasNextPage()`, and `requestNextPage()` methods:
+ripple-lib uses the XRP Ledger's [WebSocket API](https://xrpl.org/rippled-api.html) for online functionality. You can use ripple-lib to call these APIs directly. Use the `request()`, `hasNextPage()`, and `requestNextPage()` methods:
 
-* Use `request()` to issue any `rippled` command, including `account_currencies`, `subscribe`, and `unsubscribe`. [Full list of API Methods](https://ripple.com/build/rippled-apis/#api-methods).
-* Use `hasNextPage()` to determine whether a response has more pages. This is true when the response includes a [`marker` field](https://ripple.com/build/rippled-apis/#markers-and-pagination).
+* Use `request()` to issue any `rippled` command, including `account_currencies`, `subscribe`, and `unsubscribe`. [Full list of API Methods](https://xrpl.org/public-rippled-methods.html).
+* Use `hasNextPage()` to determine whether a response has more pages. This is true when the response includes a [`marker` field](https://xrpl.org/markers-and-pagination.html).
 * Use `requestNextPage()` to request the next page of data.
 
 When using rippled APIs:
 
-* [Specify XRP amounts in drops](https://developers.ripple.com/basic-data-types.html#specifying-currency-amounts).
-* [Specify timestamps as the number of seconds since the "Ripple Epoch"](https://developers.ripple.com/basic-data-types.html#specifying-time).
+* [Specify XRP amounts in drops](https://xrpl.org/basic-data-types.html#specifying-currency-amounts).
+* [Specify timestamps as the number of seconds since the "Ripple Epoch"](https://xrpl.org/basic-data-types.html#specifying-time).
 * Instead of `counterparty`, use `issuer`.
 
 ## Listening to streams
 
-The `rippled` server can push updates to your client when various events happen. Refer to [Subscriptions in the `rippled` API docs](https://developers.ripple.com/subscription-methods.html) for details.
+The `rippled` server can push updates to your client when various events happen.
+Refer to [Subscriptions in the `rippled` API docs](https://xrpl.org/subscribe.html) for details.
 
 Note that the `streams` parameter for generic streams takes an array. For example, to subscribe to the `validations` stream, use `{ streams: [ 'validations' ] }`.
 
@@ -37,7 +38,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 +47,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 +59,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`
   })
@@ -69,4 +68,4 @@ api.connect().then(() => { // Omit this if you are already connected
 
 The subscription ends when you unsubscribe or the WebSocket connection is closed.
 
-For full details, see [rippled Subscriptions](https://ripple.com/build/rippled-apis/#subscriptions).
+For full details, see the [subscribe method](https://xrpl.org/subscribe.html).

docs/src/schemaValidator.md.ejs

@@ -6,14 +6,14 @@ Unlike the rest of the ripple-lib API, schemaValidator is a static object on Rip
 
 `RippleAPI.schemaValidator.schemaValidate(schemaName: string, object: any): void`
 
-This method checks an object for conformance to a specified schema. It does not return anything, but will throw a `ValidationError` if the object does not conform to the schema.
+This method checks an object for conformance to a specified schema. It does not return anything, but throws a `ValidationError` if the object does not conform to the schema.
 
 ### Example
 
 ```javascript
 RippleAPI.schemaValidator.schemaValidate('sign', {
-    signedTransaction: '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100BDE09A1F6670403F341C21A77CF35BA47E45CDE974096E1AA5FC39811D8269E702203D60291B9A27F1DCABA9CF5DED307B4F23223E0B6F156991DB601DFB9C41CE1C770A726970706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304',
-    id: '02ACE87F1996E3A23690A5BB7F1774BF71CCBA68F79805831B42ABAD5913D6F4'
+    signedTransaction: '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8744630440220680070A157682D9EB510E8AD58C35DC9C8346B155077D73792E88120B7A3B6B1022079537D3300C9B4D2D3D62ACCE1E66CDA893F9612CB2577ADEC8154B933765336770B6578616D706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304',
+    id: '10B54D31384A49336C36A5907E3C28227139E282D3C7F734FEA351DE446F3674'
 })
 ```
 
@@ -25,7 +25,7 @@ If the object is valid (conforms to the schema), nothing is returned. Otherwise,
 
 ```javascript
 RippleAPI.schemaValidator.schemaValidate('sign', {
-    signedTransaction: '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100BDE09A1F6670403F341C21A77CF35BA47E45CDE974096E1AA5FC39811D8269E702203D60291B9A27F1DCABA9CF5DED307B4F23223E0B6F156991DB601DFB9C41CE1C770A726970706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304',
+    signedTransaction: '12000322800000002400000017201B0086955368400000000000000C732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8744630440220680070A157682D9EB510E8AD58C35DC9C8346B155077D73792E88120B7A3B6B1022079537D3300C9B4D2D3D62ACCE1E66CDA893F9612CB2577ADEC8154B933765336770B6578616D706C652E636F6D81145E7B112523F68D2F5E879DB4EAC51C6698A69304',
     id: '123'
 })
 ```

docs/src/sign.md.ejs

@@ -5,9 +5,9 @@ sign(txJSON: string, secret: string, options: object): {signedTransaction: strin
 sign(txJSON: string, keypair: object, options: object): {signedTransaction: string, id: string}
 ```
 
-Sign a prepared transaction. The signed transaction must subsequently be [submitted](#submit).
+Sign a prepared transaction. The signed transaction can then be [submitted](#submit).
 
-This method can sign any of [the transaction types supported by ripple-binary-codec](https://github.com/ripple/ripple-binary-codec/blob/cfcde79c19c359e9a0466d7bc3dc9a3aef47bb99/src/enums/definitions.json#L1637). When a new transaction type is added to the XRP Ledger, it will be unrecognized until `ripple-binary-codec` is updated. If you try to sign an unrecognized transaction type, this method throws an error similar to the following:
+This method can sign any of [the transaction types supported by ripple-binary-codec](https://github.com/ripple/ripple-binary-codec/blob/cfcde79c19c359e9a0466d7bc3dc9a3aef47bb99/src/enums/definitions.json#L1637). When a new transaction type is added to the XRP Ledger, it is unrecognized until `ripple-binary-codec` is updated. If you try to sign an unrecognized transaction type, this method throws an error like the following:
 
 `Error: [TRANSACTION_TYPE] is not a valid name or ordinal for TransactionType`
 
@@ -15,7 +15,7 @@ This method can sign any of [the transaction types supported by ripple-binary-co
 
 <%- renderSchema("input/sign.json") %>
 
-When this method is used for multisigning, the `options` parameter is required. See the multisigning example in this section for more details.
+When this method is used for multi-signing, the `options` parameter is required. See the multi-signing example in this section for more details.
 
 ### Return Value
 
@@ -26,7 +26,8 @@ This method returns an object with the following structure:
 ### Example
 
 ```javascript
-const txJSON = '{"Flags":2147483648,"TransactionType":"AccountSet","Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Domain":"726970706C652E636F6D","LastLedgerSequence":8820051,"Fee":"12","Sequence":23}';
+// AccountSet transaction that sets Domain to example.com:
+const txJSON = '{"Flags":2147483648,"TransactionType":"AccountSet","Account":"r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59","Domain":"6578616D706C652E636F6D","LastLedgerSequence":8820051,"Fee":"12","Sequence":23}';
 const secret = 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV';
 const keypair = { privateKey: '00ACCD3309DB14D1A4FC9B1DAE608031F4408C85C73EE05E035B7DC8B25840107A', publicKey: '02F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D8' };
 return api.sign(txJSON, secret); // or: api.sign(txJSON, keypair);
@@ -34,7 +35,20 @@ return api.sign(txJSON, secret); // or: api.sign(txJSON, keypair);
 
 <%- renderFixture("responses/sign.json") %>
 
-### Example (multisigning)
+### Example Keypairs
+
+To learn how keypairs are derived read [here](https://xrpl.org/cryptographic-keys.html#generating-keys).
+```javascript
+// secp25519 (33 bytes)
+const privateKey = "002512BBDFDBB77510883B7DCCBEF270B86DEAC8B64AC762873D75A1BEE6298665"
+const publicKey = "0390A196799EE412284A5D80BF78C3E84CBB80E1437A0AECD9ADF94D7FEAAFA284"
+
+// ed25519 (Note the 0xED prefixes a 32 byte value for a total of 33 bytes)
+const privateKey = "ED0B6CBAC838DFE7F47EA1BD0DF00EC282FDF45510C92161072CCFB84035390C4D"
+const publicKey = "ED1A7C082846CFF58FF9A892BA4BA2593151CCF1DBA59F37714CC9ED39824AF85F"
+```
+
+### Example (multi-signing)
 
 ```javascript
 const RippleAPI = require('ripple-lib').RippleAPI;
@@ -84,6 +98,10 @@ const multiSignPaymentTransaction = {
     Amount: '88000000'
 };
 
+const multiSignPaymentInstruction = {
+  signersCount: 2
+};
+
 const api = new RippleAPI({
     server: 'wss://s.altnet.rippletest.net:51233'
 });
@@ -97,7 +115,7 @@ api.connect().then(() => {
             console.log(response.resultCode, response.resultMessage);
 
             // multi sign a transaction
-            api.prepareTransaction(multiSignPaymentTransaction).then(prepared => {
+            api.prepareTransaction(multiSignPaymentTransaction, multiSignPaymentInstruction).then(prepared => {
                 console.log(prepared);
 
                 // Aya and Bran sign it too but with 'signAs' set to their own account
@@ -116,8 +134,8 @@ api.connect().then(() => {
 }).catch(console.error);
 ```
 
-Assuming the multisigning account was setup properly, the above example will respond with `resultCode: 'tesSUCCESS'` and the hash for the transaction.
-If any of `{signAs: some_address}` options were missing the code will return a validation error as follow:
+If the multi-signing account was setup properly, the above example logs `resultCode: 'tesSUCCESS'` and the hash for the transaction. If any of `{signAs: some_address}` options were missing, the code returns a validation error such as:
+
 ```
 [ValidationError(txJSON is not the same for all signedTransactions)]
 ```

docs/src/signPaymentChannelClaim.md.ejs

@@ -2,7 +2,7 @@
 
 `signPaymentChannelClaim(channel: string, amount: string, privateKey: string): string`
 
-Sign a payment channel claim. The signature can be submitted in a subsequent [PaymentChannelClaim](#preparepaymentchannelclaim) transaction.
+Sign a payment channel claim. A [PaymentChannelClaim](#preparepaymentchannelclaim) transaction can use the resulting signature to withdraw XRP from a payment channel.
 
 ### Parameters
 

docs/src/specifications.md.ejs

@@ -1,145 +1,185 @@
 # Transaction Specifications
 
-A *transaction specification* specifies what a transaction should do. Each [Transaction Type](#transaction-types) has its own type of specification.
+A *transaction specification* specifies what a transaction should do. Each [Transaction Type](#transaction-types) has its own type of specification, which corresponds to the [native XRP Ledger transaction types](https://xrpl.org/transaction-types.html).
 
-## Payment
+## Account Delete
 
-See [Transaction Types](#transaction-types) for a description.
+Delete your account and send the remaining XRP elsewhere. (Native transaction type: [AccountDelete](https://xrpl.org/accountdelete.html))
 
-<%- renderSchema('specifications/payment.json') %>
+<%- renderSchema('specifications/account-delete.json') %>
 
-### Example
+> **Note:** To prepare an Account Delete transaction, use [`prepareTransaction()`](#preparetransaction) with the [native transaction format](https://xrpl.org/accountdelete.html).
 
-<%- renderFixture('requests/prepare-payment.json') %>
+## Check Cancel
 
-## Trustline
+Cancel a Check that has not been redeemed. (Native transaction type: [CheckCancel](https://xrpl.org/checkcancel.html))
 
-See [Transaction Types](#transaction-types) for a description.
+<%- renderSchema('specifications/check-cancel.json') %>
 
-<%- renderSchema('specifications/trustline.json') %>
+#### Example
 
-### Example
+<%- renderFixture('requests/prepare-check-cancel.json') %>
+
+
+## Check Cash
+
+Redeem a Check for up to its stated value. (Native transaction type: [CheckCash](https://xrpl.org/checkcash.html))
+
+<%- renderSchema('specifications/check-cash.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-check-cash-amount.json') %>
+
+
+## Check Create
+
+Create a Check, a deferred payment that can be redeemed by the destination. (Native transaction type: [CheckCreate](https://xrpl.org/checkcreate.html))
+
+<%- renderSchema('specifications/check-create.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-check-create.json') %>
+
+
+## Deposit Preauth
+
+Preauthorize an sender to deposit money at an account using [Deposit Authorization](https://xrpl.org/depositauth.html). (Native transaction type: [DepositPreauth](https://xrpl.org/depositpreauth.html))
+
+<%- renderSchema('specifications/deposit-preauth.json') %>
+
+> **Note:** To prepare a Deposit Preauth transaction, use [`prepareTransaction()`](#preparetransaction) with the [native transaction format](https://xrpl.org/depositpreauth.html).
+
+
+## Escrow Cancellation
+
+Cancel an Escrow that has passed its expiration. (Native transaction type: [EscrowCancel](https://xrpl.org/escrowcancel.html))
+
+<%- renderSchema('specifications/escrow-cancellation.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-escrow-cancellation.json') %>
+
+
+## Escrow Creation
+
+Create an Escrow that locks up XRP until a given time or condition is met. (Native transaction type: [EscrowCreate](https://xrpl.org/escrowcreate.html))
+
+<%- renderSchema('specifications/escrow-creation.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-escrow-creation.json') %>
+
+
+## Escrow Execution
+
+Deliver XRP from an Escrow after its conditions have been met. (Native transaction type: [EscrowFinish](https://xrpl.org/escrowfinish.html))
+
+<%- renderSchema('specifications/escrow-execution.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-escrow-execution.json') %>
 
-<%- renderFixture('requests/prepare-trustline.json') %>
 
 ## Order
 
-See [Transaction Types](#transaction-types) for a description.
+Create and execute a limit order in the decentralized exchange. (Native transaction type: [OfferCreate](https://xrpl.org/offercreate.html))
 
 <%- renderSchema('specifications/order.json') %>
 
 The following invalid flag combination causes a `ValidationError`: `immediateOrCancel` and `fillOrKill`. These fields are mutually exclusive, and cannot both be set at the same time.
 
-### Example
+#### Example
 
 <%- renderFixture('requests/prepare-order.json') %>
 
+
 ## Order Cancellation
 
-See [Transaction Types](#transaction-types) for a description.
+Cancel an order in the decentralized exchange. (Native transaction type: [OfferCancel](https://xrpl.org/offercancel.html))
 
 <%- renderSchema('specifications/order-cancellation.json') %>
 
-### Example
+#### Example
 
 <%- renderFixture('requests/prepare-order-cancellation.json') %>
 
-## Settings
 
-See [Transaction Types](#transaction-types) for a description.
+## Payment
 
-<%- renderSchema('output/get-settings.json') %>
+Send value from one account to another. (Native transaction type: [Payment](https://xrpl.org/payment.html))
 
-### Example
+<%- renderSchema('specifications/payment.json') %>
 
-<%- renderFixture('requests/prepare-settings.json') %>
+#### Example
 
-## Escrow Creation
+<%- renderFixture('requests/prepare-payment.json') %>
 
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/escrow-creation.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-escrow-creation.json') %>
-
-## Escrow Cancellation
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/escrow-cancellation.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-escrow-cancellation.json') %>
-
-## Escrow Execution
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/escrow-execution.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-escrow-execution.json') %>
-
-## Check Create
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/check-create.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-check-create.json') %>
-
-## Check Cancel
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/check-cancel.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-check-cancel.json') %>
-
-## Check Cash
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/check-cash.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-check-cash-amount.json') %>
-
-## Payment Channel Create
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/payment-channel-create.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-payment-channel-create.json') %>
-
-## Payment Channel Fund
-
-See [Transaction Types](#transaction-types) for a description.
-
-<%- renderSchema('specifications/payment-channel-fund.json') %>
-
-### Example
-
-<%- renderFixture('requests/prepare-payment-channel-fund.json') %>
 
 ## Payment Channel Claim
 
-See [Transaction Types](#transaction-types) for a description.
+Redeem XRP from a Payment Channel. (Native transaction type: [PaymentChannelClaim](https://xrpl.org/paymentchannelclaim.html))
 
 <%- renderSchema('specifications/payment-channel-claim.json') %>
 
-### Example
+#### Example
 
 <%- renderFixture('requests/prepare-payment-channel-claim.json') %>
+
+
+## Payment Channel Create
+
+Create a Payment Channel with XRP set aside for asynchronous payments. (Native transaction type: [PaymentChannelCreate](https://xrpl.org/paymentchannelcreate.html))
+
+<%- renderSchema('specifications/payment-channel-create.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-payment-channel-create.json') %>
+
+
+## Payment Channel Fund
+
+Add XRP to a Payment Channel. (Native transaction type: [PaymentChannelFund](https://xrpl.org/paymentchannelfund.html))
+
+<%- renderSchema('specifications/payment-channel-fund.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-payment-channel-fund.json') %>
+
+
+
+## Settings
+
+Change account settings. (Native transaction types: [AccountSet](https://xrpl.org/accountset.html), [SetRegularKey](https://xrpl.org/setregularkey.html), [SignerListSet](https://xrpl.org/signerlistset.html))
+
+<%- renderSchema('output/get-settings.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-settings.json') %>
+
+
+## Ticket Create
+
+Set aside account Sequence numbers as Tickets to be used by later transactions.
+
+> **Caution:** As of 2021-01-22, Tickets are not yet available on the XRP Ledger.
+
+> **Note:** To prepare a Ticket Create transaction, use [`prepareTransaction()`](#preparetransaction) with the native transaction format. <!-- Future link: https://xrpl.org/ticketcreate.html -->
+
+
+## Trustline
+
+Create or modify a trust line between two accounts, for an issued currency. (Native transaction type: [TrustSet](https://xrpl.org/trustset.html))
+
+<%- renderSchema('specifications/trustline.json') %>
+
+#### Example
+
+<%- renderFixture('requests/prepare-trustline.json') %>

docs/src/staticMethods.md.ejs

@@ -1 +1,100 @@
 # Static Methods
+
+You can access static methods directly on the `RippleAPI` class. For example, `RippleAPI.computeBinaryTransactionHash(...)`.
+
+A few of the most commonly-used methods are documented below.
+
+For a full list, refer to these docs:
+
+- [XRP Ledger Hashes](https://github.com/ripple/ripple-lib/blob/develop/src/common/hashes/README.md)
+- [ripple-address-codec API](https://github.com/ripple/ripple-address-codec/blob/master/README.md#api)
+
+## 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)
+
+## classicAddressToXAddress
+
+`classicAddressToXAddress(classicAddress: string, tag: number | false[, test: boolean]): string`
+
+Convert a classic address and tag to an X-address.
+
+If `test` is `true`, the address starts with `T` to show that the address is intended for use on a test network.
+
+### Example: Encode an X-address with tag 4294967295
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI
+const xAddress = RippleAPI.classicAddressToXAddress('rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf', 4294967295)
+console.log(xAddress)
+```
+
+```
+XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi
+```
+
+### Example: Encode a test address for use with Testnet or Devnet
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI
+const address = RippleAPI.classicAddressToXAddress('r3SVzk8ApofDJuVBPKdmbbLjWGCCXpBQ2g', 123, true)
+console.log(address)
+```
+
+```
+T7oKJ3q7s94kDH6tpkBowhetT1JKfcfdSCmAXbS75iATyLD
+```
+
+## xAddressToClassicAddress
+
+`xAddressToClassicAddress(xAddress: string): {classicAddress: string, tag: number | false, test: boolean}`
+
+Convert an X-address to a classic address and tag.
+
+Since `0` is a valid tag, use `if (tag !== false)` to you want to check for a tag.
+
+If the address is intended for use on a test network, `test === true`. Otherwise, `test === false`.
+
+### Example
+
+```javascript
+const RippleAPI = require('ripple-lib').RippleAPI
+const address = RippleAPI.xAddressToClassicAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi')
+console.log(address)
+```
+
+```
+{
+  classicAddress: 'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+  tag: 4294967295,
+  test: false
+}
+```

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

docs/src/transactions.md.ejs

@@ -6,20 +6,21 @@ A transaction type is specified by the strings in the first column in the table
 
 Type | Description
 ---- | -----------
-[payment](#payment) | A `payment` transaction represents a transfer of value from one account to another. Depending on the [path](https://ripple.com/build/paths/) taken, additional exchanges of value may occur atomically to facilitate the payment.
+[payment](#payment) | A `payment` transaction represents a transfer of value from one account to another. Depending on the [path](https://xrpl.org/paths.html) taken, additional exchanges of value may occur atomically to enable the payment.
 [order](#order) | An `order` transaction creates a limit order. It defines an intent to exchange currencies, and creates an order in the XRP Ledger's order book if not completely fulfilled when placed. Orders can be partially fulfilled.
 [orderCancellation](#order-cancellation) | An `orderCancellation` transaction cancels an order in the XRP Ledger's order book.
-[trustline](#trustline) | A `trustline` transactions creates or modifies a trust line between two accounts.
+[trustline](#trustline) | A `trustline` transaction creates or modifies a trust line between two accounts.
 [settings](#settings) | A `settings` transaction modifies the settings of an account in the XRP Ledger.
 [escrowCreation](#escrow-creation) | An `escrowCreation` transaction creates an escrow on the ledger, which locks XRP until a cryptographic condition is met or it expires. It is like an escrow service where the XRP Ledger acts as the escrow agent.
-[escrowCancellation](#escrow-cancellation) | An `escrowCancellation` transaction unlocks the funds in an escrow and sends them back to the creator of the escrow, but it will only work after the escrow expires.
-[escrowExecution](#escrow-execution) | An `escrowExecution` transaction unlocks the funds in an escrow and sends them to the destination of the escrow, but it will only work if the cryptographic condition is provided.
+[escrowCancellation](#escrow-cancellation) | An `escrowCancellation` transaction unlocks the funds in an escrow and sends them back to the creator of the escrow, if the escrow has expired.
+[escrowExecution](#escrow-execution) | An `escrowExecution` transaction unlocks the funds in an escrow and sends them to the destination of the escrow, if the conditions for the escrow are met.
 [checkCreate](#check-create) | A `checkCreate` transaction creates a check on the ledger, which is a deferred payment that can be cashed by its intended destination.
 [checkCancel](#check-cancel) | A `checkCancel` transaction cancels an unredeemed Check, removing it from the ledger without sending any money.
 [checkCash](#check-cash) | A `checkCash` transaction redeems a Check to receive up to the amount authorized by the corresponding `checkCreate` transaction. Only the `destination` address of a Check can cash it.
 [paymentChannelCreate](#payment-channel-create) | A `paymentChannelCreate` transaction opens a payment channel between two addresses with XRP set aside for asynchronous payments.
 [paymentChannelFund](#payment-channel-fund) | A `paymentChannelFund` transaction adds XRP to a payment channel and optionally sets a new expiration for the channel.
 [paymentChannelClaim](#payment-channel-claim) | A `paymentChannelClaim` transaction withdraws XRP from a channel and optionally requests to close it.
+[ticketCreate](#ticket-create) | A successful `ticketCreate` transaction adds a Ticket in the directory of the owning account.
 
 ## Transaction Flow
 
@@ -37,6 +38,7 @@ Executing a transaction with `RippleAPI` requires the following four steps:
     * [prepareCheckCreate](#preparecheckcreate)
     * [prepareCheckCancel](#preparecheckcancel)
     * [prepareCheckCash](#preparecheckcash)
+    * [prepareTicketCreate](#prepareticketcreate)
 2. [Sign](#sign) - Cryptographically sign the transaction locally and save the [transaction ID](#transaction-id). Signing is how the owner of an account authorizes a transaction to take place. For multisignature transactions, the `signedTransaction` fields returned by `sign` must be collected and passed to the [combine](#combine) method.
 3. [Submit](#submit) - Submit the transaction to the connected server.
 4. Verify - Verify that the transaction got validated by querying with [getTransaction](#gettransaction). This is necessary because transactions may fail even if they were successfully submitted.
@@ -47,7 +49,7 @@ Every transaction must destroy a small amount of XRP as a cost to apply the tran
 
 You can choose the size of the fee you want to pay or let a default be used. You can get an estimate of the fee required to be included in the next ledger closing with the [getFee](#getfee) method.
 
-For a multi-signed transaction, ripple-lib automatically multiplies the `fee` by (1 + Number of Signatures Provided). For example, if you set `instructions.fee = '0.000020'` and `instructions.signersCount = 2`, the prepared transaction's `Fee` will be 20 drops × (1 + 2 Signatures) = 60 drops. See [Transaction Cost](https://developers.ripple.com/transaction-cost.html).
+For a multi-signed transaction, ripple-lib automatically multiplies the `fee` by (1 + Number of Signatures Provided). For example, if you set `instructions.fee = '0.000020'` and `instructions.signersCount = 2`, the prepared transaction's `Fee` is 20 drops × (1 + 2 Signatures) = 60 drops. See [Transaction Cost](https://xrpl.org/transaction-cost.html).
 
 ## Transaction Instructions
 
@@ -55,7 +57,7 @@ Transaction instructions indicate how to execute a transaction, complementary wi
 
 <%- renderSchema("objects/instructions.json") %>
 
-We recommend that you specify a `maxLedgerVersion` so that you can quickly determine that a failed transaction will never succeed in the future. It is impossible for a transaction to succeed after the XRP Ledger's consensus-validated ledger version exceeds the transaction's `maxLedgerVersion`. If you omit `maxLedgerVersion`, the "prepare\*" method automatically supplies a `maxLedgerVersion` equal to the current ledger plus 3, which it includes in the return value from the "prepare\*" method.
+We recommend that you specify a `maxLedgerVersion` so that you can quickly determine that a failed transaction can never succeed in the future. It is impossible for a transaction to succeed after the XRP Ledger's consensus-validated ledger version exceeds the transaction's `maxLedgerVersion`. If you omit `maxLedgerVersion`, the "prepare\*" method automatically supplies a `maxLedgerVersion` equal to the current ledger plus 3, which it includes in the return value from the "prepare\*" method.
 
 ## Transaction ID
 

docs/src/txFlags.md.ejs

@@ -18,9 +18,9 @@ Applies globally to all transactions.
 
 `txFlags.Payment.NoRippleDirect`: Do not use the default path; only use specified paths. This is intended to force the transaction to take arbitrage opportunities. Most clients do not need this.
 
-`txFlags.Payment.PartialPayment`: If the specified destination amount cannot be sent without spending more than the source maxAmount, reduce the received amount instead of failing outright. See [Partial Payments](https://developers.ripple.com/partial-payments.html) for more details.
+`txFlags.Payment.PartialPayment`: If the specified destination amount cannot be sent without spending more than the source maxAmount, reduce the received amount instead of failing outright. See [Partial Payments](https://xrpl.org/partial-payments.html) for more details.
 
-`txFlags.Payment.LimitQuality`: Only take paths where all the conversions have an input:output ratio that is equal or better than the ratio of `destination.amount`:`source.maxAmount`. See [Limit Quality](https://developers.ripple.com/payment.html#limit-quality) for details.
+`txFlags.Payment.LimitQuality`: Only take paths where all the conversions have an input:output ratio that is equal or better than the ratio of `destination.amount`:`source.maxAmount`. See [Limit Quality](https://xrpl.org/payment.html#limit-quality) for details.
 
 ### OfferCreate Flags
 
@@ -38,9 +38,9 @@ Applies globally to all transactions.
 
 `txFlags.TrustSet.NoRipple`:  Obsolete.
 
-`txFlags.TrustSet.SetNoRipple`: Blocks [rippling](https://developers.ripple.com/rippling.html) between two trustlines of the same currency, if this flag is set on both.
+`txFlags.TrustSet.SetNoRipple`: Blocks [rippling](https://xrpl.org/rippling.html) between two trustlines of the same currency, if this flag is set on both.
 
-`txFlags.TrustSet.ClearNoRipple`: Clears the No-[Rippling](https://developers.ripple.com/rippling.html) flag.
+`txFlags.TrustSet.ClearNoRipple`: Clears the No-[Rippling](https://xrpl.org/rippling.html) flag.
 
 `txFlags.TrustSet.SetFreeze`: Freeze the trustline. A non-XRP currency can be frozen by the exchange or gateway that issued it. XRP cannot be frozen.
 
@@ -50,7 +50,7 @@ Applies globally to all transactions.
 
 You can use the `prepareSettings` method to change your account flags. This method uses AccountSet flags internally.
 
-In the rippled API, Account Flags can be enabled and disabled with the SetFlag and ClearFlag parameters. See [AccountSet Flags](https://developers.ripple.com/accountset.html#accountset-flags).
+In the rippled API, Account Flags can be enabled and disabled with the SetFlag and ClearFlag parameters. See [AccountSet Flags](https://xrpl.org/accountset.html#accountset-flags).
 
 The AccountSet transaction type has some transaction flags, but their use is discouraged.
 

package.json

@@ -1,8 +1,8 @@
 {
   "name": "ripple-lib",
-  "version": "1.6.2",
+  "version": "1.10.1",
   "license": "ISC",
-  "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
+  "description": "Deprecated - consider migrating to xrpl.js: https://xrpl.org/xrpljs2-migration-guide.html",
   "files": [
     "dist/npm/*",
     "build/ripple-latest-min.js",
@@ -23,36 +23,48 @@
     "@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-keypairs": "^0.11.0",
+    "ripple-address-codec": "^4.1.1",
+    "ripple-binary-codec": "^1.1.3",
+    "ripple-keypairs": "^1.0.3",
     "ripple-lib-transactionparser": "0.8.2",
     "ws": "^7.2.0"
   },
+  "resolutions": {
+    "elliptic": "^6.5.4"
+  },
   "devDependencies": {
-    "@types/mocha": "^5.2.7",
-    "@types/node": "^13.1.1",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.4.3",
     "@typescript-eslint/eslint-plugin": "^2.3.3",
-    "@typescript-eslint/parser": "^2.3.3",
-    "assert-diff": "^2.0.3",
-    "doctoc": "^1.4.0",
+    "@typescript-eslint/parser": "^2.27.0",
+    "assert": "^2.0.0",
+    "assert-diff": "^3.0.0",
+    "buffer": "^6.0.2",
+    "crypto-browserify": "^3.12.0",
+    "doctoc": "^2.0.0",
     "ejs": "^3.0.1",
     "eslint": "^6.5.1",
     "eventemitter2": "^6.0.0",
+    "https-browserify": "^1.0.0",
     "json-schema-to-markdown-table": "^0.4.0",
-    "mocha": "7.0.0",
-    "mocha-junit-reporter": "^1.9.1",
-    "nyc": "^15.0.0",
-    "prettier": "^1.19.1",
-    "ts-node": "^8.4.1",
-    "typescript": "^3.6.4",
-    "webpack": "^4.41.2",
-    "webpack-bundle-analyzer": "^3.6.0",
-    "webpack-cli": "^3.3.9"
+    "mocha": "^9",
+    "nyc": "^15",
+    "path-browserify": "1.0.1",
+    "prettier": "^2.0.5",
+    "process": "^0.11.10",
+    "puppeteer": "10.2.0",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "3.2.0",
+    "ts-loader": "^9.2.5",
+    "ts-node": "^10.1.0",
+    "typescript": "^3.9.9",
+    "url": "^0.11.0",
+    "webpack": "^5.6.0",
+    "webpack-bundle-analyzer": "^4.1.0",
+    "webpack-cli": "^4.2.0"
   },
   "scripts": {
     "build:schemas": "mkdir -p dist/npm/common && cp -r src/common/schemas dist/npm/common/",
@@ -65,20 +77,24 @@
     "doctoc": "doctoc docs/index.md --title '# RippleAPI Reference' --github --maxlevel 2",
     "docgen": "node --harmony scripts/build_docs.js",
     "prepublish": "yarn clean && yarn build",
-    "test": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha --exit",
-    "test:watch": "TS_NODE_PROJECT=src/tsconfig.json mocha --watch --reporter dot",
+    "test": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha --config=test/.mocharc.json --exit",
+    "test:integration": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha ./test/integration/*.ts",
+    "test:browser": "TS_NODE_PROJECT=src/tsconfig.json nyc mocha ./test/browser/*.ts",
+    "test:watch": "TS_NODE_PROJECT=src/tsconfig.json mocha --config=test/.mocharc.json --watch --reporter dot",
     "format": "prettier --write '{src,test}/**/*.ts'",
     "lint": "eslint 'src/**/*.ts' 'test/*-test.{ts,js}'",
     "perf": "./scripts/perf_test.sh",
-    "start": "node scripts/http.js"
+    "compile:snippets": "tsc -p snippets/tsconfig.json",
+    "start:snippet": "npm run compile:snippets && node ./snippets/dist/start.js",
+    "inspect:snippet": "npm run compile:snippets && node inspect ./snippets/dist/start.js"
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/ripple/ripple-lib.git"
+    "url": "git@github.com:XRPLF/xrpl.js.git"
   },
   "readmeFilename": "README.md",
   "engines": {
-    "node": ">=8",
+    "node": ">=10.13.0",
     "yarn": "^1.15.2"
   }
 }

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
 

snippets/src/decoder.ts

@@ -0,0 +1,9 @@
+import * as codec from 'ripple-binary-codec'
+
+const original = codec.decode('12000022800200002400000001201B00EF81E661EC6386F26FC0FFFF0000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D166461968400000000000000C6940000000000000646AD3504529A0465E2E0000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D1664619732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D87446304402200A693FB5CA6B21250EBDFD8CFF526EE0DF7C9E4E31EB0660692E75E6A93BF5F802203CC39463DDA21386898CA31E18AD1A6828647D65741DD637BAD71BC83E29DB9481145E7B112523F68D2F5E879DB4EAC51C6698A693048314CA6EDC7A28252DAEA6F2045B24F4D7C333E146170112300000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D166461900')
+
+const test = codec.decode('12000022800200002400000017201B008694F261EC6386F26FC0FFFF0000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D166461968400000000000000C6940000000000000646AD3504529A0465E2E0000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D1664619732102F89EAEC7667B30F33D0687BBA86C3FE2A08CCA40A9186C5BDE2DAA6FA97A37D874473045022100D8B57E8E06EAE27B1343AF8CAD3F501E18260CCF8BCED08066074106F0F191A3022058FEA6CE9E7FA69D1244C3A70F18983CC2DAF0B10CBB86A6677CF2A5D2B8A68081145E7B112523F68D2F5E879DB4EAC51C6698A693048314CA6EDC7A28252DAEA6F2045B24F4D7C333E146170112300000000000000000000000005553440000000000054F6F784A58F9EFB0A9EB90B83464F9D166461900')
+
+console.log('original:', JSON.stringify(original))
+
+console.log('test:', JSON.stringify(test))

snippets/src/paths.ts

@@ -0,0 +1,47 @@
+import {RippleAPI} from '../../dist/npm'
+
+const api = new RippleAPI({
+  // server: 'wss://s.altnet.rippletest.net:51233'
+  // server: 'ws://35.158.96.209:51233'
+  server: 'ws://34.210.87.206:51233'
+})
+
+sign()
+
+async function sign() {
+  await api.connect()
+  const pathfind: any = {
+    source: {
+      address: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+      amount: {
+        currency: 'drops',
+        value: '100'
+      }
+    },
+    destination: {
+      address: 'rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj',
+      amount: {
+        currency: 'USD',
+        counterparty: 'rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc'
+      }
+    }
+  }
+
+  await api.getPaths(pathfind).then(async (data) => {
+    console.log('paths:', JSON.stringify(data))
+    const fakeSecret = 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV'
+
+    pathfind.paths = data[0].paths
+    pathfind.destination = data[0].destination
+    await api.preparePayment('r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59', pathfind).then(ret => {
+      const signed = api.sign(ret.txJSON, fakeSecret)
+      console.log('signed:', signed)
+    }).catch(err => {
+        console.log('ERR 1:', JSON.stringify(err))
+    })
+  }).catch(err => {
+      console.log('ERR 2:', err)
+  })
+
+  api.disconnect()
+}

snippets/src/reliableTransactionSubmission.ts

@@ -0,0 +1,200 @@
+import {
+  RippleAPI,
+  AccountInfoResponse,
+  LedgerClosedEvent
+} from '../../dist/npm'
+import https = require('https')
+
+/**
+ * When implementing Reliable Transaction Submission, there are many potential solutions, each with different trade-offs. The main decision points are:
+ * 1) Transaction preparation:
+ *    - How do we decide which account sequence and LastLedgerSequence numbers to use?
+ *      (To prevent unintentional duplicate transactions, an {account, account_sequence} pair can be used as a transaction's idempotency key)
+ *    - How do we decide how much to pay for the transaction fee? (If our transactions have been failing due to low fee, we should consider increasing this value)
+ * 2) Transaction status retrieval. Options include:
+ *    - Poll for transaction status:
+ *      - On a regular interval (e.g. every 3-5 seconds), or
+ *      - When a new validated ledger is detected
+ *      + (To accommodate an edge case in transaction retrieval, check the sending account's Sequence number to confirm that it has the expected value;
+ *         alternatively, wait until a few additional ledgers have been validated before deciding that a transaction has definitively not been included in a validated ledger)
+ *    - Listen for transaction status: scan all validated transactions to see if our transactions are among them
+ * 3) What do we do when a transaction fails? It is possible to implement retry logic, but caution is advised. Note that there are a few ways for a transaction to fail:
+ *    A) `tec`: The transaction was included in a ledger but only claimed the transaction fee
+ *    B) `tesSUCCESS` but unexpected result: The transaction was successful but did not have the expected result. This generally does not occur for XRP-to-XRP payments
+ *    C) The transaction was not, and never will be, included in a validated ledger [3C]
+ *
+ * References:
+ * - https://xrpl.org/reliable-transaction-submission.html
+ * - https://xrpl.org/send-xrp.html
+ * - https://xrpl.org/look-up-transaction-results.html
+ * - https://xrpl.org/get-started-with-rippleapi-for-javascript.html
+ * - https://xrpl.org/monitor-incoming-payments-with-websocket.html
+ *
+ * For the implementation in this example, we have made the following decisions:
+ * 1) The script will choose the account sequence and LastLedgerSequence numbers automatically. We allow ripple-lib to choose the fee.
+ *    Payments are defined upfront, and idempotency is not needed. If the script is run a second time, duplicate payments will result.
+ * 2) We will listen for notification that a new validated ledger has been found, and poll for transaction status at that time.
+ *    Futhermore, as a precaution, we will wait until the server is 3 ledgers past the transaction's LastLedgerSequence
+ *    (with the transaction nowhere to be seen) before deciding that it has definitively failed per [3C]
+ * 3) Transactions will not be automatically retried. Transactions are limited to XRP-to-XRP payments and cannot "succeed" in an unexpected way.
+ */
+reliableTransactionSubmissionExample()
+
+async function reliableTransactionSubmissionExample() {
+  /**
+   * Array of payments to execute.
+   *
+   * For brevity, these are XRP-to-XRP payments, taking a source, destination, and an amount in drops.
+   *
+   * The script will attempt to make all of these payments as quickly as possible, and report the final status of each. Transactions that fail are NOT retried.
+   */
+  const payments = []
+
+  const sourceAccount = (await generateTestnetAccount()).account
+  console.log(`Generated new Testnet account: ${sourceAccount.classicAddress}/${sourceAccount.secret}`)
+  // Send amounts from 1 drop to 10 drops
+  for (let i = 1; i <= 10; i++) {
+    payments.push({
+      source: sourceAccount,
+      destination: 'rhsoCozhUxwcyQgzFi1FVRoMVQgk7cZd4L', // Random Testnet destination
+      amount_drops: i.toString(),
+    })
+  }
+  const results = await performPayments(payments)
+  console.log(JSON.stringify(results, null, 2))
+  process.exit(0)
+}
+
+async function performPayments(payments) {
+  const finalResults = []
+  const txFinalizedPromises = []
+  const api = new RippleAPI({server: 'wss://s.altnet.rippletest.net:51233'})
+  await api.connect()
+
+  for (let i = 0; i < payments.length; i++) {
+    const payment = payments[i]
+    const account_info: AccountInfoResponse = await api.request('account_info', {
+      account: payment.source.classicAddress,
+      ledger_index: 'current'})
+    const sequence = account_info.account_data.Sequence
+    const preparedPayment = await api.preparePayment(payment.source.classicAddress, {
+      source: {
+        address: payment.source.classicAddress,
+        amount: {
+          value: payment.amount_drops,
+          currency: 'drops'
+        }
+      },
+      destination: {
+        address: payment.destination,
+        minAmount: {
+          value: payment.amount_drops,
+          currency: 'drops'
+        }
+      }
+    }, {
+      sequence
+    })
+    const signed = api.sign(preparedPayment.txJSON, payment.source.secret)
+    finalResults.push({
+      id: signed.id
+    })
+    const result = await api.submit(signed.signedTransaction)
+
+    // Most of the time we'll get 'tesSUCCESS' or (after many submissions) 'terQUEUED'
+    console.log(`tx ${i} - tentative: ${result.resultCode}`)
+
+    const txFinalizedPromise = new Promise<void>((resolve) => {
+      const ledgerClosedCallback = async (event: LedgerClosedEvent) => {
+        let status
+        try {
+          status = await api.getTransaction(signed.id)
+        } catch (e) {
+          // Typical error when the tx hasn't been validated yet:
+          if (e.name !== 'MissingLedgerHistoryError') {
+            console.log(e)
+          }
+
+          if (event.ledger_index > preparedPayment.instructions.maxLedgerVersion + 3) {
+            // Assumptions:
+            // - We are still connected to the same rippled server
+            // - No ledger gaps occurred
+            // - All ledgers between the time we submitted the tx and now have been checked for the tx
+            status = {
+              finalResult: 'Transaction was not, and never will be, included in a validated ledger'
+            }
+          } else {
+            // Check again later:
+            api.connection.once('ledgerClosed', ledgerClosedCallback)
+            return
+          }
+        }
+
+        for (let j = 0; j < finalResults.length; j++) {
+          if (finalResults[j].id === signed.id) {
+            finalResults[j].result = status.address ? {
+              source: status.address,
+              destination: status.specification.destination.address,
+              deliveredAmount: status.outcome.deliveredAmount,
+              result: status.outcome.result,
+              timestamp: status.outcome.timestamp,
+              ledgerVersion: status.outcome.ledgerVersion
+            } : status
+            process.stdout.write('.')
+            return resolve()
+          }
+        }
+      }
+      api.connection.once('ledgerClosed', ledgerClosedCallback)
+    })
+    txFinalizedPromises.push(txFinalizedPromise)
+  }
+  await Promise.all(txFinalizedPromises)
+  return finalResults
+}
+
+/**
+ * Generate a new Testnet account by requesting one from the faucet
+ */
+async function generateTestnetAccount(): Promise<{
+  account: {
+    xAddress: string,
+    classicAddress, string,
+    secret: string
+  },
+  balance: number
+ }> {
+  const options = {
+    hostname: 'faucet.altnet.rippletest.net',
+    port: 443,
+    path: '/accounts',
+    method: 'POST'
+  }
+  return new Promise((resolve, reject) => {
+    const request = https.request(options, response => {
+      const chunks = []
+      response.on('data', d => {
+        chunks.push(d)
+      })
+      response.on('end', () => {
+        const body = Buffer.concat(chunks).toString()
+
+        // "application/json; charset=utf-8"
+        if (response.headers['content-type'].startsWith('application/json')) {
+          resolve(JSON.parse(body))
+        } else {
+          reject({
+            statusCode: response.statusCode,
+            contentType: response.headers['content-type'],
+            body
+          })
+        }
+      })
+    })
+    request.on('error', error => {
+      console.error(error)
+      reject(error)
+    })
+    request.end()
+  })
+}

src/api.ts

@@ -1,6 +1,7 @@
 import {EventEmitter} from 'events'
 import {
   Connection,
+  constants,
   errors,
   validate,
   xrpToDrops,
@@ -43,14 +44,11 @@ import prepareCheckCreate from './transaction/check-create'
 import prepareCheckCancel from './transaction/check-cancel'
 import prepareCheckCash from './transaction/check-cash'
 import prepareSettings from './transaction/settings'
+import prepareTicketCreate from './transaction/ticket'
 import sign from './transaction/sign'
 import combine from './transaction/combine'
 import submit from './transaction/submit'
-import {
-  generateAddressAPI,
-  GenerateAddressOptions,
-  GeneratedAddress
-} from './offline/generate-address'
+import {generateAddress, generateXAddress} from './offline/utils'
 import {deriveKeypair, deriveAddress, deriveXAddress} from './offline/derive'
 import computeLedgerHash from './offline/ledgerhash'
 import signPaymentChannelClaim from './offline/sign-payment-channel-claim'
@@ -88,7 +86,37 @@ import {getServerInfo, getFee} from './common/serverinfo'
 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 {
+  classicAddressToXAddress,
+  xAddressToClassicAddress,
+  isValidXAddress,
+  isValidClassicAddress,
+  encodeSeed,
+  decodeSeed,
+  encodeAccountID,
+  decodeAccountID,
+  encodeNodePublic,
+  decodeNodePublic,
+  encodeAccountPublic,
+  decodeAccountPublic,
+  encodeXAddress,
+  decodeXAddress
+} from 'ripple-address-codec'
+import {
+  computeBinaryTransactionHash,
+  computeTransactionHash,
+  computeBinaryTransactionSigningHash,
+  computeAccountLedgerObjectID,
+  computeSignerListLedgerObjectID,
+  computeOrderID,
+  computeTrustlineHash,
+  computeTransactionTreeHash,
+  computeStateTreeHash,
+  computeEscrowHash,
+  computePaymentChannelHash
+} from './common/hashes'
+
+import generateFaucetWallet from './wallet/wallet-generation'
 
 export interface APIOptions extends ConnectionUserOptions {
   server?: string
@@ -140,9 +168,9 @@ class RippleAPI extends EventEmitter {
     this._feeCushion = options.feeCushion || 1.2
     this._maxFeeXRP = options.maxFeeXRP || '2'
     const serverURL = options.server
-    if (serverURL !== undefined) {
+    if (serverURL != null) {
       this.connection = new Connection(serverURL, options)
-      this.connection.on('ledgerClosed', message => {
+      this.connection.on('ledgerClosed', (message) => {
         this.emit('ledger', formatLedgerClose(message))
       })
       this.connection.on('error', (errorCode, errorMessage, data) => {
@@ -151,7 +179,7 @@ class RippleAPI extends EventEmitter {
       this.connection.on('connected', () => {
         this.emit('connected')
       })
-      this.connection.on('disconnected', code => {
+      this.connection.on('disconnected', (code) => {
         let finalCode = code
         // 1005: This is a backwards-compatible fix for this change in the ws library: https://github.com/websockets/ws/issues/1257
         // 4000: Connection uses a 4000 code internally to indicate a manual disconnect/close
@@ -252,7 +280,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,
@@ -310,7 +338,7 @@ class RippleAPI extends EventEmitter {
     }
     // If limit is not provided, fetches all data over multiple requests.
     // NOTE: This may return much more than needed. Set limit when possible.
-    const countTo: number = params.limit !== undefined ? params.limit : Infinity
+    const countTo: number = params.limit != null ? params.limit : Infinity
     let count: number = 0
     let marker: string = params.marker
     let lastBatchLength: number
@@ -338,14 +366,9 @@ class RippleAPI extends EventEmitter {
     return results
   }
 
-  // @deprecated Use X-addresses instead
-  generateAddress(options: GenerateAddressOptions = {}): GeneratedAddress {
-    return generateAddressAPI({...options, includeClassicAddress: true})
-  }
-
-  generateXAddress(options: GenerateAddressOptions = {}): GeneratedAddress {
-    return generateAddressAPI(options)
-  }
+  // @deprecated Use X-addresses instead & Invoke from top-level package instead
+  generateAddress = generateAddress
+  generateXAddress = generateXAddress // @deprecated Invoke from top-level package instead
 
   connect = connect
   disconnect = disconnect
@@ -382,16 +405,21 @@ class RippleAPI extends EventEmitter {
   prepareCheckCreate = prepareCheckCreate
   prepareCheckCash = prepareCheckCash
   prepareCheckCancel = prepareCheckCancel
+  prepareTicketCreate = prepareTicketCreate
   prepareSettings = prepareSettings
   sign = sign
   combine = combine
-  submit = submit
 
-  deriveKeypair = deriveKeypair
-  deriveAddress = deriveAddress
-  computeLedgerHash = computeLedgerHash
-  signPaymentChannelClaim = signPaymentChannelClaim
-  verifyPaymentChannelClaim = verifyPaymentChannelClaim
+  submit = submit // @deprecated Use api.request('submit', { tx_blob: signedTransaction }) instead
+
+  deriveKeypair = deriveKeypair // @deprecated Invoke from top-level package instead
+  deriveAddress = deriveAddress // @deprecated Invoke from top-level package instead
+  computeLedgerHash = computeLedgerHash // @deprecated Invoke from top-level package instead
+  signPaymentChannelClaim = signPaymentChannelClaim // @deprecated Invoke from top-level package instead
+  verifyPaymentChannelClaim = verifyPaymentChannelClaim // @deprecated Invoke from top-level package instead
+
+  generateFaucetWallet = generateFaucetWallet
+
   errors = errors
 
   static deriveXAddress = deriveXAddress
@@ -399,17 +427,96 @@ class RippleAPI extends EventEmitter {
   // RippleAPI.deriveClassicAddress (static) is a new name for api.deriveAddress
   static deriveClassicAddress = deriveAddress
 
+  /**
+   * Static methods to expose ripple-address-codec methods
+   */
+  static classicAddressToXAddress = classicAddressToXAddress
+  static xAddressToClassicAddress = xAddressToClassicAddress
   static isValidXAddress = isValidXAddress
   static isValidClassicAddress = isValidClassicAddress
+  static encodeSeed = encodeSeed
+  static decodeSeed = decodeSeed
+  static encodeAccountID = encodeAccountID
+  static decodeAccountID = decodeAccountID
+  static encodeNodePublic = encodeNodePublic
+  static decodeNodePublic = decodeNodePublic
+  static encodeAccountPublic = encodeAccountPublic
+  static decodeAccountPublic = decodeAccountPublic
+  static encodeXAddress = encodeXAddress
+  static decodeXAddress = decodeXAddress
 
-  xrpToDrops = xrpToDrops
-  dropsToXrp = dropsToXrp
-  rippleTimeToISO8601 = rippleTimeToISO8601
-  iso8601ToRippleTime = iso8601ToRippleTime
+  /**
+   * Static methods that replace functionality from the now-deprecated ripple-hashes library
+   */
+  // Compute the hash of a binary transaction blob.
+  // @deprecated Invoke from top-level package instead
+  static computeBinaryTransactionHash = computeBinaryTransactionHash // (txBlobHex: string): string
+  // Compute the hash of a transaction in txJSON format.
+  // @deprecated Invoke from top-level package instead
+  static computeTransactionHash = computeTransactionHash // (txJSON: any): string
+  // @deprecated Invoke from top-level package instead
+  static computeBinaryTransactionSigningHash =
+    computeBinaryTransactionSigningHash // (txBlobHex: string): string
+  // Compute the hash of an account, given the account's classic address (starting with `r`).
+  // @deprecated Invoke from top-level package instead
+  static computeAccountLedgerObjectID = computeAccountLedgerObjectID // (address: string): string
+  // Compute the hash (ID) of an account's SignerList.
+  // @deprecated Invoke from top-level package instead
+  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.
+  // @deprecated Invoke from top-level package instead
+  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.
+  // @deprecated Invoke from top-level package instead
+  static computeTrustlineHash = computeTrustlineHash // (address1: string, address2: string, currency: string): string
+  // @deprecated Invoke from top-level package instead
+  static computeTransactionTreeHash = computeTransactionTreeHash // (transactions: any[]): string
+  // @deprecated Invoke from top-level package instead
+  static computeStateTreeHash = computeStateTreeHash // (entries: any[]): string
+  // Compute the hash of a ledger.
+  // @deprecated Invoke from top-level package instead
+  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.
+  // @deprecated Invoke from top-level package instead
+  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.
+  // @deprecated Invoke from top-level package instead
+  static computePaymentChannelHash = computePaymentChannelHash // (address, dstAddress, sequence): string
+
+  xrpToDrops = xrpToDrops // @deprecated Invoke from top-level package instead
+  dropsToXrp = dropsToXrp // @deprecated Invoke from top-level package instead
+  rippleTimeToISO8601 = rippleTimeToISO8601 // @deprecated Invoke from top-level package instead
+  iso8601ToRippleTime = iso8601ToRippleTime // @deprecated Invoke from top-level package instead
   txFlags = txFlags
+  static txFlags = txFlags
+  accountSetFlags = constants.AccountSetFlags
+  static accountSetFlags = constants.AccountSetFlags
 
   isValidAddress = schemaValidator.isValidAddress
   isValidSecret = schemaValidator.isValidSecret
 }
 
 export {RippleAPI}
+
+export type {
+  AccountObjectsRequest,
+  AccountObjectsResponse,
+  AccountOffersRequest,
+  AccountOffersResponse,
+  AccountInfoRequest,
+  AccountInfoResponse,
+  AccountLinesRequest,
+  AccountLinesResponse,
+  BookOffersRequest,
+  BookOffersResponse,
+  GatewayBalancesRequest,
+  GatewayBalancesResponse,
+  LedgerRequest,
+  LedgerResponse,
+  LedgerDataRequest,
+  LedgerDataResponse,
+  LedgerEntryRequest,
+  LedgerEntryResponse,
+  ServerInfoRequest,
+  ServerInfoResponse
+}

src/broadcast.ts

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

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 {

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.
@@ -27,7 +27,7 @@ export interface ConnectionOptions {
   key?: string
   passphrase?: string
   certificate?: string
-  timeout: number
+  timeout: number // request timeout
   connectionTimeout: number
 }
 
@@ -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.
@@ -51,7 +68,7 @@ const INTENTIONAL_DISCONNECT_CODE = 4000
  */
 function createWebSocket(url: string, config: ConnectionOptions): WebSocket {
   const options: WebSocket.ClientOptions = {}
-  if (config.proxy !== undefined) {
+  if (config.proxy != null) {
     const parsedURL = parseUrl(url)
     const parsedProxyURL = parseUrl(config.proxy)
     const proxyOverrides = _.omitBy(
@@ -64,9 +81,9 @@ function createWebSocket(url: string, config: ConnectionOptions): WebSocket {
         passphrase: config.passphrase,
         cert: config.certificate
       },
-      _.isUndefined
+      (value) => value == null
     )
-    const proxyOptions = _.assign({}, parsedProxyURL, proxyOverrides)
+    const proxyOptions = Object.assign({}, parsedProxyURL, proxyOverrides)
     let HttpsProxyAgent
     try {
       HttpsProxyAgent = require('https-proxy-agent')
@@ -75,7 +92,7 @@ function createWebSocket(url: string, config: ConnectionOptions): WebSocket {
     }
     options.agent = new HttpsProxyAgent(proxyOptions)
   }
-  if (config.authorization !== undefined) {
+  if (config.authorization != null) {
     const base64 = Buffer.from(config.authorization).toString('base64')
     options.headers = {Authorization: `Basic ${base64}`}
   }
@@ -86,9 +103,9 @@ function createWebSocket(url: string, config: ConnectionOptions): WebSocket {
       passphrase: config.passphrase,
       cert: config.certificate
     },
-    _.isUndefined
+    (value) => value == null
   )
-  const websocketOptions = _.assign({}, options, optionsOverrides)
+  const websocketOptions = Object.assign({}, options, optionsOverrides)
   const websocket = new WebSocket(url, null, websocketOptions)
   // we will have a listener for each outstanding request,
   // so we have to raise the limit (the default is 10)
@@ -102,8 +119,8 @@ function createWebSocket(url: string, config: ConnectionOptions): WebSocket {
  * ws.send(), but promisified.
  */
 function websocketSendAsync(ws: WebSocket, message: string) {
-  return new Promise((resolve, reject) => {
-    ws.send(message, undefined, error => {
+  return new Promise<void>((resolve, reject) => {
+    ws.send(message, undefined, (error) => {
       if (error) {
         reject(new DisconnectedError(error.message, error))
       } else {
@@ -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)
@@ -308,7 +326,7 @@ export class Connection extends EventEmitter {
     this._url = url
     this._config = {
       timeout: 20 * 1000,
-      connectionTimeout: 2 * 1000,
+      connectionTimeout: 5 * 1000,
       ...options
     }
     if (typeof options.trace === 'function') {
@@ -327,7 +345,7 @@ export class Connection extends EventEmitter {
       this.emit('error', 'badMessage', error.message, message)
       return
     }
-    if (data.type === undefined && data.error) {
+    if (data.type == null && data.error) {
       this.emit('error', data.error, data.error_message, data) // e.g. slowDown
       return
     }
@@ -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(() => {
+      return 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')
       }
@@ -470,7 +488,8 @@ export class Connection extends EventEmitter {
       this._onConnectionFailed(
         new ConnectionError(
           `Error: connect() timed out after ${this._config.connectionTimeout} ms. ` +
-            `If your internet connection is working, the rippled server may be blocked or inaccessible.`
+            `If your internet connection is working, the rippled server may be blocked or inaccessible. ` +
+            `You can also try setting the 'connectionTimeout' option in the RippleAPI constructor.`
         )
       )
     }, this._config.connectionTimeout)
@@ -486,23 +505,11 @@ export class Connection extends EventEmitter {
       clearTimeout(connectionTimeoutID)
       // Add new, long-term connected listeners for messages and errors
       this._ws.on('message', (message: string) => this._onMessage(message))
-      this._ws.on('error', error =>
+      this._ws.on('error', (error) =>
         this.emit('error', 'websocket', error.message, error)
       )
-      // Finalize the connection and resolve all awaiting connect() requests
-      try {
-        this._retryConnectionBackoff.reset()
-        await this._subscribeToLedger()
-        this._startHeartbeatInterval()
-        this._connectionManager.resolveAllAwaiting()
-        this.emit('connected')
-      } catch (error) {
-        this._connectionManager.rejectAllAwaiting(error)
-        this.disconnect()
-        return
-      }
       // Handle a closed connection: reconnect if it was unexpected
-      this._ws.once('close', code => {
+      this._ws.once('close', (code) => {
         this._clearHeartbeatInterval()
         this._requestManager.rejectAll(
           new DisconnectedError('websocket was closed')
@@ -518,12 +525,23 @@ export class Connection extends EventEmitter {
           // Start the reconnect timeout, but set it to `this._reconnectTimeoutID`
           // so that we can cancel one in-progress on disconnect.
           this._reconnectTimeoutID = setTimeout(() => {
-            this.reconnect().catch(error => {
+            this.reconnect().catch((error) => {
               this.emit('error', 'reconnect', error.message, error)
             })
           }, retryTimeout)
         }
       })
+      // Finalize the connection and resolve all awaiting connect() requests
+      try {
+        this._retryConnectionBackoff.reset()
+        await this._subscribeToLedger()
+        this._startHeartbeatInterval()
+        this._connectionManager.resolveAllAwaiting()
+        this.emit('connected')
+      } catch (error) {
+        this._connectionManager.rejectAllAwaiting(error)
+        await this.disconnect().catch(() => {}) // Ignore this error, propagate the root cause.
+      }
     })
     return this._connectionManager.awaitConnection()
   }
@@ -536,13 +554,13 @@ 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)
     }
-    return new Promise(resolve => {
-      this._ws.once('close', code => resolve(code))
+    return new Promise((resolve) => {
+      this._ws.once('close', (code) => resolve(code))
       // Connection already has a disconnect handler for the disconnect logic.
       // Just close the websocket manually (with our "intentional" code) to
       // trigger that.
@@ -564,11 +582,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!
@@ -579,6 +592,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).
@@ -613,10 +636,19 @@ export class Connection extends EventEmitter {
       timeout || this._config.timeout
     )
     this._trace('send', message)
-    websocketSendAsync(this._ws, message).catch(error => {
+    websocketSendAsync(this._ws, message).catch((error) => {
       this._requestManager.reject(id, error)
     })
 
     return responsePromise
   }
+
+  /**
+   * Get the Websocket connection URL
+   *
+   * @returns The Websocket connection URL
+   */
+  getUrl(): string {
+    return this._url
+  }
 }

src/common/constants.ts

@@ -58,7 +58,19 @@ const AccountFlags = {
   defaultRipple: accountRootFlags.DefaultRipple
 }
 
-const AccountFlagIndices = {
+export interface Settings {
+  passwordSpent?: boolean
+  requireDestinationTag?: boolean
+  requireAuthorization?: boolean
+  depositAuth?: boolean
+  disallowIncomingXRP?: boolean
+  disableMasterKey?: boolean
+  noFreeze?: boolean
+  globalFreeze?: boolean
+  defaultRipple?: boolean
+}
+
+const AccountSetFlags = {
   requireDestinationTag: txFlagIndices.AccountSet.asfRequireDest,
   requireAuthorization: txFlagIndices.AccountSet.asfRequireAuth,
   depositAuth: txFlagIndices.AccountSet.asfDepositAuth,
@@ -84,4 +96,4 @@ const AccountFields = {
   TickSize: {name: 'tickSize', defaults: 0}
 }
 
-export {AccountFields, AccountFlagIndices, AccountFlags}
+export {AccountFields, AccountSetFlags, AccountFlags}

src/common/errors.ts

@@ -54,6 +54,8 @@ class ResponseFormatError extends ConnectionError {}
 
 class ValidationError extends RippleError {}
 
+class XRPLFaucetError extends RippleError {}
+
 class NotFoundError extends RippleError {
   constructor(message = 'Not found') {
     super(message)
@@ -90,5 +92,6 @@ export {
   NotFoundError,
   PendingLedgerVersionError,
   MissingLedgerHistoryError,
-  LedgerVersionError
+  LedgerVersionError,
+  XRPLFaucetError
 }

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.
 

src/common/hashes/index.ts

@@ -36,10 +36,7 @@ const addressToHex = (address: string): string => {
 
 const currencyToHex = (currency: string): string => {
   if (currency.length === 3) {
-    const bytes = new Array(20 + 1)
-      .join('0')
-      .split('')
-      .map(parseFloat)
+    const bytes = new Array(20 + 1).join('0').split('').map(parseFloat)
     bytes[12] = currency.charCodeAt(0) & 0xff
     bytes[13] = currency.charCodeAt(1) & 0xff
     bytes[14] = currency.charCodeAt(2) & 0xff
@@ -71,6 +68,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 +83,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))
 }
@@ -120,7 +160,7 @@ export const computeTrustlineHash = (
 export const computeTransactionTreeHash = (transactions: any[]): string => {
   const shamap = new SHAMap()
 
-  transactions.forEach(txJSON => {
+  transactions.forEach((txJSON) => {
     const txBlobHex = encode(txJSON)
     const metaHex = encode(txJSON.metaData)
     const txHash = computeBinaryTransactionHash(txBlobHex)
@@ -134,7 +174,7 @@ export const computeTransactionTreeHash = (transactions: any[]): string => {
 export const computeStateTreeHash = (entries: any[]): string => {
   const shamap = new SHAMap()
 
-  entries.forEach(ledgerEntry => {
+  entries.forEach((ledgerEntry) => {
     const data = encode(ledgerEntry)
     shamap.addItem(ledgerEntry.index, data, NodeType.ACCOUNT_STATE)
   })

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'
 }

src/common/rangeset.ts

@@ -5,7 +5,7 @@ type Interval = [number, number]
 
 function mergeIntervals(intervals: Interval[]): Interval[] {
   const stack: Interval[] = [[-Infinity, -Infinity]]
-  _.sortBy(intervals, x => x[0]).forEach(interval => {
+  _.sortBy(intervals, (x) => x[0]).forEach((interval) => {
     const lastInterval: Interval = stack.pop()!
     if (interval[0] <= lastInterval[1] + 1) {
       stack.push([lastInterval[0], Math.max(interval[1], lastInterval[1])])
@@ -30,7 +30,7 @@ class RangeSet {
 
   serialize() {
     return this.ranges
-      .map(range => range[0].toString() + '-' + range[1].toString())
+      .map((range) => range[0].toString() + '-' + range[1].toString())
       .join(',')
   }
 
@@ -45,14 +45,14 @@ class RangeSet {
 
   parseAndAddRanges(rangesString: string) {
     const rangeStrings = rangesString.split(',')
-    _.forEach(rangeStrings, rangeString => {
+    rangeStrings.forEach((rangeString) => {
       const range = rangeString.split('-').map(Number)
       this.addRange(range[0], range.length === 1 ? range[0] : range[1])
     })
   }
 
   containsRange(start: number, end: number) {
-    return _.some(this.ranges, range => range[0] <= start && range[1] >= end)
+    return this.ranges.some((range) => range[0] <= start && range[1] >= end)
   }
 
   containsValue(value: number) {

src/common/schema-validator.ts

@@ -13,6 +13,7 @@ function loadSchemas() {
     require('./schemas/objects/hash128.json'),
     require('./schemas/objects/hash256.json'),
     require('./schemas/objects/sequence.json'),
+    require('./schemas/objects/ticket-sequence.json'),
     require('./schemas/objects/signature.json'),
     require('./schemas/objects/issue.json'),
     require('./schemas/objects/ledger-version.json'),
@@ -115,6 +116,7 @@ function loadSchemas() {
     require('./schemas/input/prepare-check-create.json'),
     require('./schemas/input/prepare-check-cash.json'),
     require('./schemas/input/prepare-check-cancel.json'),
+    require('./schemas/input/prepare-ticket-create.json'),
     require('./schemas/input/compute-ledger-hash.json'),
     require('./schemas/input/sign.json'),
     require('./schemas/input/submit.json'),
@@ -123,8 +125,8 @@ function loadSchemas() {
     require('./schemas/input/verify-payment-channel-claim.json'),
     require('./schemas/input/combine.json')
   ]
-  const titles = schemas.map(schema => schema.title)
-  const duplicates = _.keys(_.pickBy(_.countBy(titles), count => count > 1))
+  const titles = schemas.map((schema) => schema.title)
+  const duplicates = Object.keys(_.pickBy(_.countBy(titles), (count) => count > 1))
   assert.ok(duplicates.length === 0, 'Duplicate schemas for: ' + duplicates)
   const validator = new Validator()
   // Register custom format validators that ignore undefined instances
@@ -132,30 +134,32 @@ function loadSchemas() {
   // (optional)  property
 
   // This relies on "format": "xAddress" in `x-address.json`!
-  validator.customFormats.xAddress = function(instance) {
-    if (instance === undefined) {
+  validator.customFormats.xAddress = function (instance) {
+    if (instance == null) {
       return true
     }
     return isValidXAddress(instance)
   }
 
   // This relies on "format": "classicAddress" in `classic-address.json`!
-  validator.customFormats.classicAddress = function(instance) {
-    if (instance === undefined) {
+  validator.customFormats.classicAddress = function (instance) {
+    if (instance == null) {
       return true
     }
     return isValidAddress(instance)
   }
 
-  validator.customFormats.secret = function(instance) {
-    if (instance === undefined) {
+  validator.customFormats.secret = function (instance) {
+    if (instance == null) {
       return true
     }
     return isValidSecret(instance)
   }
 
   // Register under the root URI '/'
-  _.forEach(schemas, schema => validator.addSchema(schema, '/' + schema.title))
+  schemas.forEach((schema) =>
+    validator.addSchema(schema, '/' + schema.title)
+  )
   return validator
 }
 
@@ -164,7 +168,7 @@ const schemaValidator = loadSchemas()
 function schemaValidate(schemaName: string, object: any): void {
   // Lookup under the root URI '/'
   const schema = schemaValidator.getSchema('/' + schemaName)
-  if (schema === undefined) {
+  if (schema == null) {
     throw new ValidationError('no schema for ' + schemaName)
   }
   const result = schemaValidator.validate(object, schema)

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

@@ -28,7 +28,12 @@
     },
     "timeout": {
       "type": "integer",
-      "description": "Timeout in milliseconds before considering a request to have failed.",
+      "description": "Request timeout in milliseconds before considering a request to have failed. See also: connectionTimeout.",
+      "minimum": 1
+    },
+    "connectionTimeout": {
+      "type": "integer",
+      "description": "Connection timeout, in milliseconds, before considering connect() to have failed.",
       "minimum": 1
     },
     "proxyAuthorization": {

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

@@ -23,11 +23,11 @@
         },
         "test": {
           "type": "boolean",
-          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`."
+          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and starts with `T`. If `false`, the address should only be used on Mainnet, and starts with `X`."
         },
         "includeClassicAddress": {
           "type": "boolean",
-          "description": "If `true`, return the classic address, in addition to the X-address."
+          "description": "If `true`, also return the classic address."
         }
       },
       "additionalProperties": false

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

@@ -23,7 +23,7 @@
         },
         "test": {
           "type": "boolean",
-          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and will start with `T`. If `false`, the address should only be used on mainnet, and will start with `X`."
+          "description": "Specifies whether the address is intended for use on a test network such as Testnet or Devnet. If `true`, the address should only be used for testing, and starts with `T`. If `false`, the address should only be used on Mainnet, and starts with `X`."
         },
         "includeClassicAddress": {
           "type": "boolean",

src/common/schemas/input/get-balance-sheet.json

@@ -21,7 +21,7 @@
           "description": "Get the balance sheet as of this historical ledger version."
         }
       },
-      "description": "Options to determine how the balances will be calculated.",
+      "description": "Options to determine how the balances are calculated.",
       "additionalProperties": false
     }
   },

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

@@ -17,15 +17,15 @@
         },
         "includeAllData": {
           "type": "boolean",
-          "description": "Include full transactions and/or state information if `includeTransactions` and/or `includeState` is set."
+          "description": "Include the details of the transactions or state information if `includeTransactions` or `includeState` is set."
         },
         "includeTransactions": {
           "type": "boolean",
-          "description": "Return an array of hashes for each transaction or an array of all transactions that were validated in this ledger version, depending on whether `includeAllData` is set."
+          "description": "Return an array of transactions in this ledger. By default, provides the identifying hashes for each transaction. If `includeAllData` is true, include the entire transaction JSON for each transaction instead."
         },
         "includeState": {
           "type": "boolean",
-          "description": "Return an array of hashes for all state data or an array of all state data in this ledger version, depending on whether `includeAllData` is set."
+          "description": "Return an array of state data in this ledger. By default, provides the identifying hashes of state data. If `includeAllData` is true, return the state data in JSON form instead. **Admin required:** This is a very large amount of data."
         }
       },
       "additionalProperties": false

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

@@ -9,12 +9,12 @@
       "description": "The XRP Ledger address of the account to get open orders for."
     },
     "options": {
-      "description": "Options that determine what orders will be returned.",
+      "description": "Options that determine what orders to return.",
       "properties": {
         "limit": {
           "type": "integer",
           "minimum": 1,
-          "description": "At most this many orders will be returned."
+          "description": "Return at most this many orders."
         },
         "ledgerVersion": {
           "$ref": "ledgerVersion",

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

@@ -12,7 +12,7 @@
           "properties": {
             "address": {
               "$ref": "address",
-              "description": "The XRP Ledger address of the account where funds will come from."
+              "description": "The XRP Ledger address of the planned sender."
             },
             "amount": {
               "$ref": "laxAmount",

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

@@ -6,7 +6,7 @@
   "properties": {
     "id": {"$ref": "transactionHash"},
     "options": {
-      "description": "Options to limit the ledger versions to search and/or to include raw transaction data.",
+      "description": "Options to limit the ledger versions to search or include raw transaction data.",
       "properties": {
         "minLedgerVersion": {
           "$ref": "ledgerVersion",

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

@@ -13,7 +13,7 @@
       "properties": {
         "start": {
           "$ref": "hash256",
-          "description": "If specified, this transaction will be the first transaction in the result. You cannot use `start` with `minLedgerVersion` or `maxLedgerVersion`. When `start` is specified, these ledger versions will be determined internally."
+          "description": "If specified, start the results from this transaction. You cannot use `start` with `minLedgerVersion` or `maxLedgerVersion`. When `start` is specified, these ledger versions are determined internally."
         },
         "limit": {
           "type": "integer",
@@ -30,11 +30,11 @@
         },
         "earliestFirst": {
           "type": "boolean",
-          "description": "If true, sort transactions so that the earliest ones come first. By default, the newest transactions will come first."
+          "description": "If true, sort transactions so that the earliest ones come first. By default, the newest transactions come first."
         },
         "excludeFailures": {
           "type": "boolean",
-          "description": "If true, the result will omit transactions that did not succeed."
+          "description": "If true, the result omits transactions that did not succeed."
         },
         "initiated": {
           "type": "boolean",
@@ -54,7 +54,7 @@
         },
         "binary": {
           "type": "boolean",
-          "description": "If true, the transactions will be sent from the server in a condensed binary format rather than JSON."
+          "description": "If true, return transactions in binary format rather than JSON."
         }
       },
       "additionalProperties": false,

src/common/schemas/input/prepare-ticket-create.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "prepareTicketParameters",
+  "type": "object",
+  "properties": {
+    "address": {
+      "$ref": "address",
+      "description": "The address of the account that is creating the transaction."
+    },
+    "ticketCount": {
+      "type": "number",
+      "description": "The number of tickets to be created."
+    },
+    "instructions": {"$ref": "instructions"}
+  },
+  "additionalProperties": false,
+  "required": ["address", "ticketCount"]
+}

src/common/schemas/input/sign.json

@@ -17,11 +17,11 @@
       "properties": {
         "privateKey": {
           "type": "privateKey",
-          "description": "The uppercase hexadecimal representation of the secp256k1 or Ed25519 private key."
+          "description": "The uppercase hexadecimal representation of the secp256k1 or Ed25519 private key. Ed25519 keys are prefixed with 0xED. You can read about how keys are derived [here](https://xrpl.org/cryptographic-keys.html)."
         },
         "publicKey": {
           "type": "publicKey",
-          "description": "The uppercase hexadecimal representation of the secp256k1 or Ed25519 public key."
+          "description": "The uppercase hexadecimal representation of the secp256k1 or Ed25519 public key. Ed25519 keys are prefixed with 0xED. You can read about how keys are derived [here](https://xrpl.org/cryptographic-keys.html)."
         }
       },
       "description": "The private and public key of the account that is initiating the transaction. (This field cannot be used with secret).",
@@ -30,7 +30,7 @@
     },
     "options": {
       "type": "object",
-      "description": "Options that control the type of signature that will be generated.",
+      "description": "Options that control the type of signature to create.",
       "properties": {
         "signAs": {
           "$ref": "address",

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,

src/common/schemas/objects/amountbase.json

@@ -5,7 +5,7 @@
   "type": "object",
   "properties": {
     "value": {
-      "description": "The quantity of the currency, denoted as a string to retain floating point precision",
+      "description": "The quantity of the currency, denoted as a string so that it does not lose precision",
       "$ref": "value"
     },
     "currency": {

src/common/schemas/objects/instructions.json

@@ -6,19 +6,23 @@
   "type": "object",
   "properties": {
     "sequence": {
-      "description": "The initiating account's sequence number for this transaction.",
+      "description": "The initiating account's sequence number for this transaction. `sequence` and `ticketSequence` are mutually exclusive, only one of them can be set.",
       "$ref": "sequence"
     },
+    "ticketSequence": {
+      "description": "The ticket sequence to be used for this transaction. `sequence` and `ticketSequence` are mutually exclusive, only one of them can be set.",
+      "$ref": "ticket-sequence"
+    },
     "fee": {
       "description": "An exact fee to pay for the transaction, before multiplying for multi-signed transactions. See [Transaction Fees](#transaction-fees) for more information.",
       "$ref": "value"
     },
     "maxFee": {
-      "description": "Deprecated: Use `maxFeeXRP` in the RippleAPI constructor instead. The maximum fee to pay for this transaction. If this exceeds `maxFeeXRP`, `maxFeeXRP` will be used instead. See [Transaction Fees](#transaction-fees) for more information.",
+      "description": "Deprecated: Use `maxFeeXRP` in the RippleAPI constructor instead. The maximum fee to pay for this transaction. If this exceeds `maxFeeXRP`, use `maxFeeXRP` instead. See [Transaction Fees](#transaction-fees) for more information.",
       "$ref": "value"
     },
     "maxLedgerVersion": {
-      "description": "The highest ledger version that the transaction can be included in. If this option and `maxLedgerVersionOffset` are both omitted, the `maxLedgerVersion` option will default to 3 greater than the current validated ledger version (equivalent to `maxLedgerVersionOffset=3`). Use `null` to not set a maximum ledger version. If not null, this must be an integer greater than 0, or one of the following strings: 'validated', 'closed', 'current'.",
+      "description": "The highest ledger version that the transaction can be included in. If this option and `maxLedgerVersionOffset` are both omitted, the default is 3 greater than the current validated ledger version (equivalent to `maxLedgerVersionOffset=3`). Use `null` to not set a maximum ledger version. If not null, this must be an integer greater than 0, or one of the following strings: 'validated', 'closed', 'current'.",
       "oneOf": [
         {"$ref": "ledgerVersion"},
         {"type": "null"}
@@ -30,7 +34,7 @@
       "minimum": 0
     },
     "signersCount": {
-      "description": "Number of signers that will be signing this transaction.",
+      "description": "Number of signers that can multi-sign this transaction.",
       "type": "integer",
       "minimum": 1
     }
@@ -45,6 +49,10 @@
       {
         "description": "maxLedgerVersion and maxLedgerVersionOffset are mutually exclusive",
         "required": ["maxLedgerVersion", "maxLedgerVersionOffset"]
+      },
+      {
+        "description": "sequence and ticketSequence are mutually exclusive",
+        "required": ["sequence", "ticketSequence"]
       }
     ]
   }

src/common/schemas/objects/issue.json

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

src/common/schemas/objects/sequence.json

@@ -4,5 +4,5 @@
   "link": "account-sequence-number",
   "description": "An account transaction sequence number",
   "type": "integer",
-  "minimum": 1
+  "minimum": 0
 }

src/common/schemas/objects/settings-plus-memos.json

@@ -5,15 +5,15 @@
   "properties": {
     "defaultRipple": {
       "type": "boolean",
-      "description": "Enable [rippling](https://ripple.com/build/understanding-the-noripple-flag/) on this account’s trust lines by default. (New in [rippled 0.27.3](https://github.com/ripple/rippled/releases/tag/0.27.3))"
+      "description": "Enable [rippling](https://xrpl.org/rippling.html) on this account’s trust lines by default. Currency issuers should enable this setting; most others should not."
     },
     "depositAuth": {
       "type": "boolean",
-      "description": "Enable [Deposit Authorization](https://ripple.com/build/deposit-authorization/) on this account. If set, transactions cannot send value of any kind to this account unless the sender of those transactions is the account itself. (Requires the [DepositAuth amendment](https://ripple.com/build/known-amendments/#depositauth))"
+      "description": "Enable [Deposit Authorization](https://xrpl.org/depositauth.html) on this account. If set, transactions cannot send value of any kind to this account unless the sender of those transactions is the account itself. (Requires the [DepositAuth amendment](https://xrpl.org/known-amendments.html#depositauth))"
     },
     "disableMasterKey": {
       "type": "boolean",
-      "description": "Disallows use of the master key to sign transactions for this account. To disable the master key, you must authorize the transaction by signing it with the master key pair. You cannot use a regular key pair or a multi-signature. You can re-enable the master key pair using a regular key pair or multi-signature. See [AccountSet](https://developers.ripple.com/accountset.html)."
+      "description": "Disallows use of the master key to sign transactions for this account. To disable the master key, you must authorize the transaction by signing it with the master key pair. You cannot use a regular key pair or a multi-signature. You can re-enable the master key pair using a regular key pair or multi-signature. See [AccountSet](https://xrpl.org/accountset.html)."
     },
     "disallowIncomingXRP": {
       "type": "boolean",
@@ -67,7 +67,7 @@
     },
     "requireAuthorization": {
       "type": "boolean",
-      "description": "If set, this account must individually approve other users in order for those users to hold this account’s issuances."
+      "description": "If set, this account must individually give other users permission to hold this account’s issued tokens."
     },
     "requireDestinationTag": {
       "type": "boolean",

src/common/schemas/objects/ticket-sequence.json

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

src/common/schemas/objects/tx-json.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-04/schema#",
   "title": "tx-json",
-  "link": "https://developers.ripple.com/transaction-formats.html",
+  "link": "https://xrpl.org/transaction-formats.html",
   "description": "An object in rippled txJSON format",
   "type": "object",
   "properties": {

src/common/schemas/output/get-balance-sheet.json

@@ -7,7 +7,7 @@
     "balances": {
       "type": "array",
       "items": {"$ref": "amount"},
-      "description": "Amounts issued to the hotwallet accounts from the request. The keys are hot wallet addresses and the values are arrays of currency amounts they hold. The issuer (omitted from the currency amounts) is the account from the request."
+      "description": "Amounts issued to the \"hotwallet\" accounts from the request. The keys are the accounts' addresses, and the values are arrays of currency amounts they hold. The issuer (omitted from the currency amounts) is the account from the request."
     },
     "assets": {
       "type": "array",

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

@@ -10,17 +10,17 @@
     "closeTime": {
       "type": "string",
       "format": "date-time",
-      "description": "The time at which this ledger was closed."
+      "description": "The approximate time when this ledger was closed. This number is rounded based on the `closeTimeResolution`. If it would have been rounded to the same time as a previous ledger, the close time is recorded as 1 second later instead."
     },
     "closeTimeResolution": {
       "type": "integer",
       "minimum": 1,
-      "description": "Approximate number of seconds between closing one ledger version and closing the next one."
+      "description": "A number of seconds, indicating how much the `closeTime` could be rounded. Ledger close times are approximate so that small differences in servers clocks don't hinder consensus."
     },
     "closeFlags": {
       "type": "integer",
       "minimum": 0,
-      "description": "A bit-map of flags relating to the closing of this ledger. Currently, the ledger has only one flag defined for `closeFlags`: **sLCF_NoConsensusTime** (value 1). If this flag is enabled, it means that validators were in conflict regarding the correct close time for the ledger, but built otherwise the same ledger, so they declared consensus while \"agreeing to disagree\" on the close time. In this case, the consensus ledger contains a `closeTime` value that is 1 second after that of the previous ledger. (In this case, there is no official close time, but the actual real-world close time is probably 3-6 seconds later than the specified `closeTime`.)"
+      "description": "A bit-map of flags relating to the closing of this ledger. Currently, the ledger has only one flag defined for `closeFlags`: **sLCF_NoConsensusTime** (value 1). If this flag is enabled, it means that validators disagreed on the correct close time for the ledger, but built otherwise the same ledger, so they declared consensus while \"agreeing to disagree\" on the close time. In this case, the consensus ledger contains a `closeTime` value that is 1 second after that of the previous ledger. (In this case, there is no official close time, but the actual real-world close time is probably 3-6 seconds later than the specified `closeTime`.)"
     },
     "ledgerHash": {
       "$ref": "hash256",
@@ -37,7 +37,7 @@
     "parentCloseTime": {
       "type": "string",
       "format": "date-time",
-      "description": "The time at which the previous ledger was closed."
+      "description": "The previous ledger's recorded close time."
     },
     "totalDrops": {
       "$ref": "value",

src/common/schemas/output/get-payment-channel.json

@@ -30,7 +30,7 @@
     },
     "publicKey": {
       "$ref": "publicKey",
-      "description": "Public key of the key pair the source will use to sign claims against this channel."
+      "description": "Public key of the key pair the source uses to sign claims against this channel."
     },
     "cancelAfter": {
       "type": "string",

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

@@ -18,7 +18,7 @@
     },
     "ioLatencyMs": {
       "type": "number",
-      "description": "Amount of time spent waiting for I/O operations to be performed, in milliseconds. If this number is not very, very low, then the rippled server is probably having serious load issues."
+      "description": "Amount of time spent waiting for I/O operations, in milliseconds. If this number is not very, very low, then the rippled server is probably having serious load issues."
     },
     "load": {
       "type": "object",
@@ -26,7 +26,7 @@
       "properties": {
         "jobTypes": {
           "type": "array",
-          "description": "*(Admin only)* Information about the rate of different types of jobs being performed by the server and how much time it spends on each.",
+          "description": "*(Admin only)* Information about the rate of different types of jobs the server is doing and how much time it spends on each.",
           "items": {"type": "object"}
         },
         "threads": {
@@ -62,7 +62,7 @@
     },
     "pubkeyNode": {
       "type": "string",
-      "description": "Public key used to verify this node for internal communications; this key is automatically generated by the server the first time it starts up. (If deleted, the node can just create a new pair of keys.)"
+      "description": "Public key used to verify this node for internal communications; this key is automatically generated by the server the first time it starts up."
     },
     "pubkeyValidator": {
       "type": "string",
@@ -70,7 +70,7 @@
     },
     "serverState": {
       "type": "string",
-      "description": "A string indicating to what extent the server is participating in the network. See [Possible Server States](https://developers.ripple.com/rippled-server-states.html) for more details.",
+      "description": "A string indicating to what extent the server is participating in the network. See [Possible Server States](https://xrpl.org/rippled-server-states.html) for more details.",
       "enum": ["disconnected", "connected", "syncing", "tracking", "full", "validating", "proposing"]
     },
     "validatedLedger": {
@@ -96,12 +96,12 @@
         },
         "reserveIncrementXRP": {
           "$ref": "value",
-          "description": "Amount of XRP added to the account reserve for each object an account is responsible for in the ledger."
+          "description": "Amount of XRP added to the account reserve for each object an account owns in the ledger."
         },
         "ledgerVersion": {
           "type": "integer",
           "minimum": 0,
-          "description": "Identifying sequence number of this ledger version."
+          "description": "Identifying ledger index of this ledger version."
         }
       },
       "additionalProperties": false,
@@ -109,7 +109,7 @@
     },
     "validationQuorum": {
       "type": "number",
-      "description": "Minimum number of trusted validations required in order to validate a ledger version. Some circumstances may cause the server to require more validations."
+      "description": "Minimum number of trusted validations required to validate a ledger version. Some circumstances may cause the server to require more validations."
     }
   },
   "required": ["buildVersion", "completeLedgers", "hostID", "ioLatencyMs", "lastClose", "loadFactor", "peers", "pubkeyNode", "serverState", "validatedLedger", "validationQuorum"],

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

@@ -6,13 +6,13 @@
     "properties": {
       "specification": {
         "$ref": "trustline",
-        "description": "A trustline specification that would produce this trustline in its current state."
+        "description": "A trust line specification that would produce this trust line in its current state."
       },
       "counterparty": {
         "properties": {
           "limit": {
             "$ref": "value",
-            "description": "The maximum amount that the counterparty can be owed through the trustline."
+            "description": "The maximum amount that the counterparty can be owed through the trust line."
           },
           "ripplingDisabled": {
             "type": "boolean",
@@ -20,7 +20,7 @@
           },
           "frozen": {
             "type": "boolean",
-            "description": "If true, the trustline is frozen, which means that funds can only be sent to the counterparty."
+            "description": "If true, the trust line is frozen, which means that funds can only be sent directly to the counterparty."
           },
           "authorized": {
             "type": "boolean",
@@ -35,10 +35,10 @@
         "properties": {
           "balance": {
             "$ref": "signedValue",
-            "description": "The balance on the trustline, representing which party owes the other and by how much."
+            "description": "The balance on the trust line, representing which party owes the other and by how much."
           }
         },
-        "description": "Properties of the trustline regarding it's current state that are not part of the specification.",
+        "description": "Non-settings details of the trust line's state.",
         "required": ["balance"],
         "additionalProperties": false
       }

src/common/schemas/output/outcome.json

@@ -6,7 +6,7 @@
   "properties": {
     "result": {
       "type": "string",
-      "description": "Result code returned by rippled. See [Transaction Results](https://developers.ripple.com/transaction-results.html) for a complete list."
+      "description": "Result code returned by rippled. See [Transaction Results](https://xrpl.org/transaction-results.html) for a complete list."
     },
     "timestamp": {
       "type": "string",