Publish

- ripple-address-codec@4.2.0
 - ripple-binary-codec@1.2.0
 - ripple-keypairs@1.1.0
 - xrpl@2.0.2

.github/workflows/nodejs.yml

@@ -23,9 +23,10 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install
-    - run: npm run lint
+    - run: npm install -g npm@7
+    - run: npm ci
     - run: npm run build
+    - run: npm run lint
 
   unit:
     runs-on: ubuntu-latest
@@ -41,7 +42,9 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install --ignore-engines
+    - run: npm install -g npm@7
+    - run: npm ci
+    - run: npm run build
     - run: npm test
 
   integration:
@@ -65,7 +68,9 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install --ignore-engines
+    - run: npm install -g npm@7
+    - run: npm ci
+    - run: npm run build
     - run: npm run test:integration
       env:
         HOST: localhost
@@ -92,5 +97,7 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install
+    - run: npm install -g npm@7
+    - run: npm ci 
+    - run: npm run build
     - run: npm run test:browser

.gitignore

@@ -71,3 +71,6 @@ scripts/cache
 
 # browser tests
 testCompiledForWeb
+
+# lerna debug
+lerna-debug.log

.travis.yml

@@ -1,9 +0,0 @@
-language: node_js
-node_js:
-  - 10
-  - 12
-  - 13
-script:
-  - npm test
-  - npm build
-  - npm lint

.vscode/settings.json

@@ -1,5 +1,8 @@
 {
     "editor.tabSize": 2,
+    "cSpell.words": [
+      "secp256k1"
+    ],
     "[javascript]": {
         "editor.defaultFormatter": "esbenp.prettier-vscode",
         "editor.formatOnSave": true

CONTRIBUTING.md

@@ -2,14 +2,29 @@
 
 ## Set up your dev environment
 
-We use Node v14 for development - that is the version that our linters require.
+### Requirements
+
+We use Node v14 for development - that is the version that our linters require.
+You must also use `npm` v7. You can check your `npm` version with:
+
+```bash
+npm -v
+```
+
+If your `npm` version is too old, use this command to update it:
+
+```bash
+npm -g i npm@7
+```
+
+### Set up
 
-To set up the repository:
 1. Clone the repository
 2. `cd` into the repository
 3. Install dependencies with `npm install`
 
-To build the library:
+### Build
+
 ```bash
 npm run build
 ```
@@ -18,17 +33,18 @@ npm run build
 
 ```bash
 npm install
+npm run build
 npm run lint
 ```
 
 ## Running Tests
-
 For integration and browser tests, we use a `rippled` node in standalone mode to test xrpl.js code against. To set this up, you can either run `rippled` locally, or set up the Docker container `natenichols/rippled-standalone:latest` for this purpose. The latter will require you to [install Docker](https://docs.docker.com/get-docker/).
 
 ### Unit Tests
 
 ```bash
 npm install
+npm run build
 npm test
 ```
 
@@ -38,6 +54,7 @@ npm test
 npm install
 # sets up the rippled standalone Docker container - you can skip this step if you already have it set up
 docker run -p 6006:6006 -it natenichols/rippled-standalone:latest
+npm run build
 npm run test:integration
 ```
 
@@ -50,7 +67,7 @@ One is in the browser - run `npm run build:browserTests` and open `test/localInt
 The other is in the command line (this is what we use for CI) -
 
 ```bash
-npm run build:browserTests
+npm run build
 # sets up the rippled standalone Docker container - you can skip this step if you already have it set up
 docker run -p 6006:6006 -it natenichols/rippled-standalone:latest
 npm run test:browser
@@ -64,6 +81,37 @@ You can see the complete reference documentation at [`xrpl.js` docs](js.xrpl.org
 npm run docgen
 ```
 
+## Adding and removing packages
+
+`xrpl.js` uses `lerna` and `npm`'s workspaces features to manage a monorepo.
+Adding and removing packages requires a slightly different process than normal
+as a result.
+
+### Adding or removing development dependencies
+
+`xrpl.js` strives to use the same development dependencies in all packages.
+You may add and remove dev dependencies like normal:
+
+```bash
+### adding a new dependency
+npm install --save-dev abbrev
+### removing a dependency
+npm uninstall --save-dev abbrev
+```
+
+### Adding or removing runtime dependencies
+
+You need to specify which package is changing using the `-w` flag:
+
+```bash
+### adding a new dependency to `xrpl`
+npm install abbrev -w xrpl
+### adding a new dependency to `ripple-keypairs`
+npm install abbrev -w ripple-keypairs
+### removing a dependency
+npm uninstall abbrev -w xrpl
+```
+
 ## Release process
 
 ### Editing the Code
@@ -79,7 +127,7 @@ npm run docgen
 
 1. Ensure that all tests passed on the last CI that ran on `develop`.
 2. Open a PR to update the docs if docs were modified.
-3. Create a branch off `develop` that properly increments the version in `package.json` and ensures that `HISTORY.md` is updated appropriately. We follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+3. Create a branch off `develop` that ensures that `HISTORY.md` is updated appropriately for each package.
   * Use `shasum -a 256 build/*` to get the SHA-256 checksums. Add these to `HISTORY.md` as well.
 4. Merge this branch into `develop`.
 5. If this is not a beta release: Merge `develop` into `master` (`--ff-only`) and push to github. This is important because we have docs telling developers to use master to get the latest release.

README.md

@@ -26,14 +26,19 @@ What is `xrpl.js` used for? The applications on the list linked above use `xrpl.
 ### Requirements
 
 + **[Node.js v14](https://nodejs.org/)** is recommended. We also support v12 and v16. Other versions may work but are not frequently tested.
-+ **[npm](https://www.npmjs.com/)** is recommended. `yarn` may work but we use `package-lock.json`.
 
 ## Getting Started
 
 In an existing project (with `package.json`), install `xrpl.js`:
 
 ```
-$ npm install xrpl
+$ npm install --save xrpl
+```
+
+Or with `yarn`:
+
+```
+$ yarn add xrpl
 ```
 
 Example usage:
@@ -41,7 +46,7 @@ Example usage:
 ```js
 const xrpl = require("xrpl")
 async function main() {
-  const client = new xrpl.Client("https://s.altnet.rippletest.net:51234/")
+  const client = new xrpl.Client("wss://s.altnet.rippletest.net:51233")
   await client.connect()
 
   const response = await client.request({
@@ -122,7 +127,7 @@ import xrpl from 'https://dev.jspm.io/npm:xrpl';
 
 + [Get Started in Node.js](https://xrpl.org/get-started-using-node-js.html)
 + [Full Reference Documentation](https://js.xrpl.org)
-+ [Code Samples](https://github.com/XRPLF/xrpl.js/tree/develop/snippets/src)
++ [Code Samples](https://github.com/XRPLF/xrpl.js/tree/develop/packages/xrpl/snippets/src)
 
 ### Mailing Lists
 

lerna.json

@@ -0,0 +1,5 @@
+{
+  "version": "independent",
+  "useWorkspaces": true,
+  "npmClient": "npm"
+}

package.json

@@ -1,36 +1,20 @@
 {
-  "name": "xrpl",
-  "version": "2.0.1",
-  "license": "ISC",
-  "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
-  "files": [
-    "dist/npm/*",
-    "build/xrpl-latest-min.js",
-    "build/xrpl-latest.js"
-  ],
-  "main": "dist/npm/",
-  "unpkg": "build/xrpl-latest-min.js",
-  "jsdelivr": "build/xrpl-latest-min.js",
-  "types": "dist/npm/index.d.ts",
-  "directories": {
-    "test": "test"
-  },
-  "browser": {
-    "ws": "./dist/npm/client/WSWrapper.js"
+  "name": "xrpl.js",
+  "private": true,
+  "scripts": {
+    "test": "lerna run test --stream",
+    "test:browser": "lerna run test:browser --stream",
+    "test:integration": "lerna run test:integration --stream",
+    "lint": "lerna run lint --stream",
+    "clean": "lerna run clean --stream",
+    "build": "lerna run build --stream",
+    "docgen": "lerna run docgen --stream"
   },
   "dependencies": {
-    "bignumber.js": "^9.0.0",
-    "bip32": "^2.0.6",
-    "bip39": "^3.0.4",
-    "https-proxy-agent": "^5.0.0",
-    "lodash": "^4.17.4",
-    "ripple-address-codec": "^4.1.1",
-    "ripple-binary-codec": "^1.1.3",
-    "ripple-keypairs": "^1.0.3",
-    "ws": "^8.2.2"
-  },
-  "resolutions": {
-    "elliptic": "^6.5.4"
+    "ripple-address-codec": "file:packages/ripple-address-codec",
+    "ripple-binary-codec": "file:packages/ripple-binary-codec",
+    "ripple-keypairs": "file:packages/ripple-keypairs",
+    "xrpl": "file:packages/xrpl"
   },
   "devDependencies": {
     "@types/chai": "^4.2.21",
@@ -41,7 +25,7 @@
     "@types/ws": "^8.2.0",
     "@typescript-eslint/eslint-plugin": "^4.30.0",
     "@typescript-eslint/parser": "^4.0.0",
-    "@xrplf/eslint-config": "^1.5.0",
+    "@xrplf/eslint-config": "^1.6.0",
     "@xrplf/prettier-config": "^1.5.0",
     "assert": "^2.0.0",
     "buffer": "^6.0.2",
@@ -60,6 +44,8 @@
     "eslint-plugin-tsdoc": "^0.2.14",
     "eventemitter2": "^6.0.0",
     "https-browserify": "^1.0.0",
+    "jest": "^26.0.1",
+    "lerna": "^4.0.0",
     "mocha": "^9",
     "npm-run-all": "^4.1.5",
     "nyc": "^15",
@@ -67,8 +53,10 @@
     "prettier": "^2.3.2",
     "process": "^0.11.10",
     "puppeteer": "10.4.0",
+    "source-map-support": "^0.5.16",
     "stream-browserify": "^3.0.0",
     "stream-http": "3.2.0",
+    "ts-jest": "^26.4.4",
     "ts-loader": "^9.2.5",
     "ts-node": "^10.2.1",
     "typedoc": "^0.22.5",
@@ -78,36 +66,11 @@
     "webpack-bundle-analyzer": "^4.1.0",
     "webpack-cli": "^4.2.0"
   },
-  "scripts": {
-    "build": "run-s build:lib build:snippets build:web",
-    "build:snippets": "tsc --build ./snippets/tsconfig.json",
-    "build:lib": "tsc --build tsconfig.build.json",
-    "build:web": "webpack",
-    "build:browserTests": "webpack --config ./test/webpack.config.js",
-    "analyze": "run-s build:web --analyze",
-    "watch": "run-s build:lib --watch",
-    "clean": "rm -rf dist",
-    "docgen": "typedoc && echo js.xrpl.org >> ./docs/CNAME",
-    "prepublish": "run-s clean build",
-    "test": "nyc mocha --config=test/.mocharc.json --exit",
-    "test:integration": "TS_NODE_PROJECT=tsconfig.build.json nyc mocha ./test/integration/**/*.ts ./test/integration/*.ts",
-    "test:browser": "npm run build:browserTests && TS_NODE_PROJECT=tsconfig.build.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 . --ext .ts --max-warnings 0",
-    "perf": "./scripts/perf_test.sh",
-    "compile:snippets": "tsc -p snippets/tsconfig.json",
-    "start:snippet": "npm run compile:snippets && node",
-    "inspect:snippet": "npm run compile:snippets && node inspect"
-  },
-  "prettier": "@xrplf/prettier-config",
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:XRPLF/xrpl.js.git"
-  },
-  "readmeFilename": "README.md",
+  "workspaces": [
+    "packages/*"
+  ],
   "engines": {
-    "node": ">=10.13.0",
-    "npm": ">=7.14.0 <8.0.0"
+    "node": ">=10.0.0",
+    "npm": ">=7.0.0 < 8.0.0"
   }
 }

packages/ripple-address-codec/.eslintignore

@@ -0,0 +1,12 @@
+# Don't ever lint node_modules
+node_modules
+
+# Don't lint build output
+dist
+
+# don't lint nyc coverage output
+coverage
+.nyc_output
+
+# Don't lint NYC configuration
+nyc.config.js

packages/ripple-address-codec/.eslintrc.js

@@ -0,0 +1,85 @@
+module.exports = {
+  root: true,
+
+  parser: '@typescript-eslint/parser', // Make ESLint compatible with TypeScript
+  parserOptions: {
+    // Enable linting rules with type information from our tsconfig
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig.json'],
+
+    sourceType: 'module', // Allow the use of imports / ES modules
+
+    ecmaFeatures: {
+      impliedStrict: true, // Enable global strict mode
+    },
+  },
+
+  // Specify global variables that are predefined
+  env: {
+    browser: true, // Enable browser global variables
+    node: true, // Enable node global variables & Node.js scoping
+    es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020
+  },
+
+  plugins: [],
+  extends: ['@xrplf/eslint-config/base'],
+
+  rules: {
+    // ** TODO **
+    // all of the below are turned off for now during the migration to a
+    // monorepo. They need to actually be addressed!
+    // **
+    '@typescript-eslint/no-for-in-array': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    '@typescript-eslint/no-unnecessary-condition': 'off',
+    '@typescript-eslint/prefer-for-of': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/no-unused-vars': 'off',
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-magic-numbers': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    '@typescript-eslint/promise-function-async': 'off',
+    '@typescript-eslint/prefer-nullish-coalescing': 'off',
+    '@typescript-eslint/naming-convention': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/array-type': 'off',
+    '@typescript-eslint/restrict-plus-operands': 'off',
+    '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+    'jsdoc/require-returns': 'off',
+    'jsdoc/check-param-names': 'off',
+    'jsdoc/require-throws': 'off',
+    'jsdoc/require-hyphen-before-param-description': 'off',
+    'jsdoc/require-jsdoc': 'off',
+    'jsdoc/require-description-complete-sentence': 'off',
+    'jsdoc/require-param': 'off',
+    'jsdoc/no-types': 'off',
+    'tsdoc/syntax': 'off',
+    'import/no-commonjs': 'off',
+    'import/order': 'off',
+    'no-restricted-syntax': 'off',
+    'guard-for-in': 'off',
+    'object-shorthand': 'off',
+    'no-negated-condition': 'off',
+    'no-loop-func': 'off',
+    'id-length': 'off',
+    'no-inline-comments': 'off',
+    'max-lines-per-function': 'off',
+    'max-len': 'off',
+    'no-nested-ternary': 'off',
+    'no-param-reassign': 'off',
+    'no-bitwise': 'off',
+    'multiline-comment-style': 'off',
+    'id-blacklist': 'off',
+    'func-names': 'off',
+    'max-params': 'off',
+    'prefer-template': 'off',
+    'no-else-return': 'off',
+  },
+}

packages/ripple-address-codec/.gitignore

@@ -0,0 +1,61 @@
+# .gitignore
+
+# Ignore vim swap files.
+*.swp
+
+# Ignore SCons support files.
+.sconsign.dblite
+
+# Ignore python compiled files.
+*.pyc
+
+# Ignore Macintosh Desktop Services Store files.
+.DS_Store
+
+# Ignore backup/temps
+*~
+
+# Ignore object files.
+*.o
+build/
+tags
+bin/rippled
+Debug/*.*
+Release/*.*
+
+# Ignore locally installed node_modules
+node_modules
+!test/node_modules
+
+# Ignore tmp directory.
+tmp
+
+# Ignore database directory.
+db/*.db
+db/*.db-*
+
+# Ignore customized configs
+rippled.cfg
+validators.txt
+test/config.js
+
+# Ignore coverage files
+/lib-cov
+/src-cov
+/coverage.html
+/coverage
+
+# Ignore IntelliJ files
+.idea
+
+# Ignore npm-debug
+npm-debug.log
+
+# Ignore dist folder
+dist/
+
+# Ignore flow output directory
+out/
+
+# Ignore perf test cache
+scripts/cache

packages/ripple-address-codec/HISTORY.md

@@ -0,0 +1,64 @@
+# ripple-address-cod
+
+## 4.1.3 (2021-05-10)
+
+* Update dependencies
+* Add `build` script as an alias for `compile`
+* Update README
+
+## 4.1.2 (2021-01-11)
+
+* Internal dependencies
+  * Update jest, ts-jest, typescript, lodash
+    * Fix potential moderate severity vulnerabilities
+  * Update @types/node, @types/jest, base-x
+* Docs
+  * Update example for encoding test address
+  * Document functions (#73)
+  * xAddressToClassicAddress when there is no tag (#114)
+  * Add README badges (#120)
+  * Add LICENSE (#138)
+* Cleanup and polish
+  * Add GitHub CI (#115)
+  * Fix linting
+
+## 4.1.1 (2020-04-03)
+
+* Require node v10+
+* CI: Drop node 6 & 8 and add node 13
+* Update dependencies
+  * Bump @types/node to 13.7.7 (#60)
+  * Bump jest and ts-jest (#40)
+  * Bump @types/jest to 25.1.2 (#51)
+  * Bump ts-jest from 25.0.0 to 25.2.0 (#50)
+  * Bump typescript from 3.7.5 to 3.8.3 (#61)
+  * Update all dependencies in yarn.lock
+
+## 4.1.0 (2020-01-22)
+
+* Throwable 'unexpected_payload_length' error: The message has been expanded with ' Ensure that the bytes are a Buffer.'
+* Docs (readme): Correct X-address to classic address example (#15) (thanks @RareData)
+
+### New Features
+
+* `encodeAccountPublic` - Encode a public key, as for payment channels
+* `decodeAccountPublic` - Decode a public key, as for payment channels
+
+* Internal
+  * Update dependencies: ts-jest, @types/jest, @types/node, typescript, tslint,
+    base-x
+
+## 4.0.0 (2019-10-08)
+
+### Breaking Changes
+
+* `decodeAddress` has been renamed to `decodeAccountID`
+* `isValidAddress` has been renamed to `isValidClassicAddress`
+
+### New Features
+
+* `classicAddressToXAddress` - Derive X-address from classic address, tag, and network ID
+* `encodeXAddress` - Encode account ID, tag, and network ID as an X-address
+* `xAddressToClassicAddress` - Decode an X-address to account ID, tag, and network ID
+* `decodeXAddress` - Convert X-address to classic address, tag, and network ID
+* `isValidXAddress` - Check whether an X-address (X...) is valid

packages/ripple-address-codec/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 Ripple Labs Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

packages/ripple-address-codec/README.md

@@ -0,0 +1,196 @@
+# ripple-address-codec
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Functions for encoding and decoding XRP Ledger addresses and seeds.
+
+Also includes support for encoding/decoding [rippled validator (node) public keys](https://xrpl.org/run-rippled-as-a-validator.html).
+
+[![NPM](https://nodei.co/npm/ripple-address-codec.png)](https://www.npmjs.org/package/ripple-address-codec)
+
+## X-address Conversion
+
+All tools and apps in the XRP Ledger ecosystem are encouraged to adopt support for the X-address format. The X-address format is a single Base58 string that encodes an 'Account ID', a (destination) tag, and whether the address is intended for a test network. This prevents users from unintentionally omitting the destination tag when sending and receiving payments and other transactions.
+
+## API
+
+### classicAddressToXAddress(classicAddress: string, tag: number | false, test: boolean): string
+
+Convert a classic address and (optional) tag to an X-address. If `tag` is `false`, the returned X-address explicitly indicates that the recipient does not want a tag to be used. If `test` is `true`, consumers of the address will know that the address is intended for use on test network(s) and the address will start with `T`.
+
+```js
+> const api = require('ripple-address-codec')
+> api.classicAddressToXAddress('rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf', 4294967295)
+'XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi'
+```
+
+Encode a test address e.g. for use with [Testnet or Devnet](https://xrpl.org/xrp-testnet-faucet.html):
+
+```js
+> const api = require('ripple-address-codec')
+> api.classicAddressToXAddress('r3SVzk8ApofDJuVBPKdmbbLjWGCCXpBQ2g', 123, true)
+'T7oKJ3q7s94kDH6tpkBowhetT1JKfcfdSCmAXbS75iATyLD'
+```
+
+### xAddressToClassicAddress(xAddress: string): {classicAddress: string, tag: number | false, test: boolean}
+
+Convert an X-address to a classic address and tag. If the X-address did not have a tag, the returned object's `tag` will be `false`. (Since `0` is a valid tag, instead of `if (tag)`, use `if (tag !== false)` if you want to check for a tag.) If the X-address is intended for use on test network(s), `test` will be `true`; if it is intended for use on the main network (mainnet), `test` will be `false`.
+
+```js
+> const api = require('ripple-address-codec')
+> api.xAddressToClassicAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi')
+{
+  classicAddress: 'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+  tag: 4294967295,
+  test: false
+}
+```
+
+### isValidXAddress(xAddress: string): boolean
+
+Returns `true` if the provided X-address is valid, or `false` otherwise.
+
+```js
+> const api = require('ripple-address-codec')
+> api.isValidXAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi')
+true
+```
+
+Returns `false` for classic addresses (starting with `r`). To validate a classic address, use `isValidClassicAddress`.
+
+### isValidClassicAddress(address: string): boolean
+
+Check whether a classic address (starting with `r`...) is valid.
+
+Returns `false` for X-addresses (extended addresses). To validate an X-address, use `isValidXAddress`.
+
+### encodeSeed(entropy: Buffer, type: 'ed25519' | 'secp256k1'): string
+
+Encode the given entropy as an XRP Ledger seed (secret). The entropy must be exactly 16 bytes (128 bits). The encoding includes which elliptic curve digital signature algorithm (ECDSA) the seed is intended to be used with. The seed is used to produce the private key.
+
+### decodeSeed(seed: string): object
+
+Decode a seed into an object with its version, type, and bytes.
+
+Return object type:
+```
+{
+  version: number[],
+  bytes: Buffer,
+  type: string | null
+}
+```
+
+### encodeAccountID(bytes: Buffer): string
+
+Encode bytes as a classic address (starting with `r`...).
+
+### decodeAccountID(accountId: string): Buffer
+
+Decode a classic address (starting with `r`...) to its raw bytes.
+
+### encodeNodePublic(bytes: Buffer): string
+
+Encode bytes to the XRP Ledger "node public key" format (base58).
+
+This is useful for rippled validators.
+
+### decodeNodePublic(base58string: string): Buffer
+
+Decode an XRP Ledger "node public key" (in base58 format) into its raw bytes.
+
+### encodeAccountPublic(bytes: Buffer): string
+
+Encode a public key, as for payment channels.
+
+### decodeAccountPublic(base58string: string): Buffer
+
+Decode a public key, as for payment channels.
+
+### encodeXAddress(accountId: Buffer, tag: number | false, test: boolean): string
+
+Encode account ID, tag, and network ID to X-address.
+
+`accountId` must be 20 bytes because it is a RIPEMD160 hash, which is 160 bits (160 bits = 20 bytes).
+
+At this time, `tag` must be <= MAX_32_BIT_UNSIGNED_INT (4294967295) as the XRP Ledger only supports 32-bit tags.
+
+If `test` is `true`, this address is intended for use with a test network such as Testnet or Devnet.
+
+### decodeXAddress(xAddress: string): {accountId: Buffer, tag: number | false, test: boolean}
+
+Convert an X-address to its classic address, tag, and network ID.
+
+### Other functions
+
+```js
+> var api = require('ripple-address-codec');
+> api.decodeSeed('sEdTM1uX8pu2do5XvTnutH6HsouMaM2')
+{ version: [ 1, 225, 75 ],
+  bytes: [ 76, 58, 29, 33, 63, 189, 251, 20, 199, 194, 141, 96, 148, 105, 179, 65 ],
+  type: 'ed25519' }
+> api.decodeSeed('sn259rEFXrQrWyx3Q7XneWcwV6dfL')
+{ version: 33,
+  bytes: [ 207, 45, 227, 120, 251, 221, 126, 46, 232, 125, 72, 109, 251, 90, 123, 255 ],
+  type: 'secp256k1' }
+> api.decodeAccountID('rJrRMgiRgrU6hDF4pgu5DXQdWyPbY35ErN')
+[ 186,
+  142,
+  120,
+  98,
+  110,
+  228,
+  44,
+  65,
+  180,
+  109,
+  70,
+  195,
+  4,
+  141,
+  243,
+  161,
+  195,
+  200,
+  112,
+  114 ]
+```
+
+## Tests
+
+Run unit tests with:
+
+    npm test
+
+Use `--watch` to run in watch mode, so that when you modify the tests, they are automatically re-run:
+
+    npm test -- --watch
+
+Use `--coverage` to generate and display code coverage information:
+
+    npm test -- --coverage
+
+This tells jest to output code coverage info in the `./coverage` directory, in addition to showing it on the command line.
+
+## Releases
+
+Use the [ripple-lib release checklist](https://github.com/ripple/ripple-lib/wiki/Release-Checklist), but just use `master` instead of `develop` as this project does not use a develop branch.
+
+## Acknowledgements
+
+This library references and adopts code and standards from the following sources:
+
+- [XLS-5d Standard for Tagged Addresses](https://github.com/xrp-community/standards-drafts/issues/6) by @nbougalis
+- [XRPL Tagged Address Codec](https://github.com/xrp-community/xrpl-tagged-address-codec) by @WietseWind
+- [X-Address transaction functions](https://github.com/codetsunami/xrpl-tools/tree/master/xaddress-functions) by @codetsunami
+
+[coveralls-image]: https://badgen.net/coveralls/c/github/ripple/ripple-address-codec/master
+[coveralls-url]: https://coveralls.io/r/ripple/ripple-address/codec?branch=master
+[npm-downloads-image]: https://badgen.net/npm/dm/ripple-address-codec
+[npm-url]: https://npmjs.org/package/ripple-address-codec
+[npm-version-image]: https://badgen.net/npm/v/ripple-address-codec
+[travis-image]: https://badgen.net/travis/ripple/ripple-address-codec/master
+[travis-url]: https://travis-ci.org/github/ripple/ripple-address-codec

packages/ripple-address-codec/examples/bitcoin.js

@@ -0,0 +1,10 @@
+var api = require('../');
+var pubVersion = [0x04, 0x88, 0xB2, 0x1E];
+var options = {version: pubVersion, alphabet: 'bitcoin'};
+var key = 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5e4cp9LB';
+var decoded = api.decode(key, options);
+var reencoded = api.encode(decoded, options);
+console.log(key);
+// 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5e4cp9LB'
+console.log(reencoded);
+// 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5e4cp9LB'

packages/ripple-address-codec/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  "roots": [
+    "<rootDir>/src"
+  ],
+  "transform": {
+    "^.+\\.tsx?$": "ts-jest"
+  },
+}

packages/ripple-address-codec/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ripple-address-codec",
+  "version": "4.2.0",
+  "description": "encodes/decodes base58 encoded XRP Ledger identifiers",
+  "files": [
+    "dist/*",
+    "build/*"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "ISC",
+  "dependencies": {
+    "base-x": "3.0.9",
+    "create-hash": "^1.1.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:XRPLF/xrpl.js.git"
+  },
+  "prepublish": "tsc -b",
+  "prepublishOnly": "tslint -b ./ && jest",
+  "scripts": {
+    "build": "tsc -b",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "clean": "rm -rf ./dist && rm -rf tsconfig.tsbuildinfo"
+  },
+  "prettier": "@xrplf/prettier-config",
+  "engines": {
+    "node": ">= 10",
+    "npm": ">=7.0.0"
+  }
+}

packages/ripple-address-codec/src/index.test.js

@@ -0,0 +1,259 @@
+const {
+  classicAddressToXAddress,
+  xAddressToClassicAddress,
+  isValidXAddress,
+  encodeXAddress
+} = require('./index')
+
+const testCases = [
+  [
+    'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+    false,
+    'X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ',
+    'T719a5UwUCnEs54UsxG9CJYYDhwmFCqkr7wxCcNcfZ6p5GZ'
+  ],
+  [
+    'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+    1,
+    'X7AcgcsBL6XDcUb289X4mJ8djcdyKaGZMhc9YTE92ehJ2Fu',
+    'T719a5UwUCnEs54UsxG9CJYYDhwmFCvbJNZbi37gBGkRkbE'
+  ],
+  [
+    'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+    14,
+    'X7AcgcsBL6XDcUb289X4mJ8djcdyKaGo2K5VpXpmCqbV2gS',
+    'T719a5UwUCnEs54UsxG9CJYYDhwmFCvqXVCALUGJGSbNV3x'
+  ],
+  [
+    'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
+    11747,
+    'X7AcgcsBL6XDcUb289X4mJ8djcdyKaLFuhLRuNXPrDeJd9A',
+    'T719a5UwUCnEs54UsxG9CJYYDhwmFCziiNHtUukubF2Mg6t'
+  ],
+  [
+    'rLczgQHxPhWtjkaQqn3Q6UM8AbRbbRvs5K',
+    false,
+    'XVZVpQj8YSVpNyiwXYSqvQoQqgBttTxAZwMcuJd4xteQHyt',
+    'TVVrSWtmQQssgVcmoMBcFQZKKf56QscyWLKnUyiuZW8ALU4'
+  ],
+  [
+    'rpZc4mVfWUif9CRoHRKKcmhu1nx2xktxBo',
+    false,
+    'X7YenJqxv3L66CwhBSfd3N8RzGXxYqPopMGMsCcpho79rex',
+    'T77wVQzA8ntj9wvCTNiQpNYLT5hmhRsFyXDoMLqYC4BzQtV'
+  ],
+  [
+    'rpZc4mVfWUif9CRoHRKKcmhu1nx2xktxBo',
+    58,
+    'X7YenJqxv3L66CwhBSfd3N8RzGXxYqV56ZkTCa9UCzgaao1',
+    'T77wVQzA8ntj9wvCTNiQpNYLT5hmhR9kej6uxm4jGcQD7rZ'
+  ],
+  [
+    'rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW',
+    23480,
+    'X7d3eHCXzwBeWrZec1yT24iZerQjYL8m8zCJ16ACxu1BrBY',
+    'T7YChPFWifjCAXLEtg5N74c7fSAYsvSokwcmBPBUZWhxH5P'
+  ],
+  [
+    'rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW',
+    11747,
+    'X7d3eHCXzwBeWrZec1yT24iZerQjYLo2CJf8oVC5CMWey5m',
+    'T7YChPFWifjCAXLEtg5N74c7fSAYsvTcc7nEfwuEEvn5Q4w'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    false,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV5fdx1mHp98tDMoQXb',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQn49b3qD26PK7FcGSKE'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    0,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV8AqEL4xcZj5whKbmc',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnSy8RHqGHoGJ59spi2'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    1,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV8xvjGQTYPiAx6gwDC',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnSz1uDimDdPYXzSpyw'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    2,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV8zpDURx7DzBCkrQE7',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnTryP9tG9TW8GeMBmd'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    32,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtVoYiC9UvKfjKar4LJe',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnT2oqaCDzMEuCDAj1j'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    276,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtVoKj3MnFGMXEFMnvJV',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnTMgJJYfAbsiPsc6Zg'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    65591,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtVozpjdhPQVdt3ghaWw',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQn7ryu2W6njw7mT1jmS'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    16781933,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtVqrDUk2vDpkTjPsY73',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnVsw45sDtGHhLi27Qa'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    4294967294,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV1kAsixQTdMjbWi39u',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnX8tDFQ53itLNqs6vU'
+  ],
+  [
+    'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    4294967295,
+    'XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8yuPT7y4xaEHi',
+    'TVE26TYGhfLC7tQDno7G8dGtxSkYQnXoy6kSDh6rZzApc69'
+  ],
+  [
+    'rPEPPER7kfTD9w2To4CQk6UCfuHM9c6GDY',
+    false,
+    'XV5sbjUmgPpvXv4ixFWZ5ptAYZ6PD2gYsjNFQLKYW33DzBm',
+    'TVd2rqMkYL2AyS97NdELcpeiprNBjwLZzuUG5rZnaewsahi'
+  ],
+  [
+    'rPEPPER7kfTD9w2To4CQk6UCfuHM9c6GDY',
+    0,
+    'XV5sbjUmgPpvXv4ixFWZ5ptAYZ6PD2m4Er6SnvjVLpMWPjR',
+    'TVd2rqMkYL2AyS97NdELcpeiprNBjwRQUBetPbyrvXSTuxU'
+  ],
+  [
+    'rPEPPER7kfTD9w2To4CQk6UCfuHM9c6GDY',
+    13371337,
+    'XV5sbjUmgPpvXv4ixFWZ5ptAYZ6PD2qwGkhgc48zzcx6Gkr',
+    'TVd2rqMkYL2AyS97NdELcpeiprNBjwVUDvp3vhpXbNhLwJi'
+  ]
+]
+
+;[false, true].forEach(isTestAddress => {
+  const MAX_32_BIT_UNSIGNED_INT = 4294967295
+  const network = isTestAddress ? ' (test)' : ' (main)'
+
+  for (const i in testCases) {
+    const testCase = testCases[i]
+    const classicAddress = testCase[0]
+    const tag = testCase[1] !== false ? testCase[1] : false
+    const xAddress = isTestAddress ? testCase[3] : testCase[2]
+    test(`Converts ${classicAddress}${tag ? ':' + tag : ''} to ${xAddress}${network}`, () => {
+      expect(classicAddressToXAddress(classicAddress, tag, isTestAddress)).toBe(xAddress)
+      const myClassicAddress = xAddressToClassicAddress(xAddress)
+      expect(myClassicAddress).toEqual({
+        classicAddress,
+        tag,
+        test: isTestAddress
+      })
+      expect(isValidXAddress(xAddress)).toBe(true)
+    })
+  }
+
+  {
+    const classicAddress = 'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf'
+    const tag = MAX_32_BIT_UNSIGNED_INT + 1
+
+    test(`Converting ${classicAddress}:${tag}${network} throws`, () => {
+      expect(() => {
+        classicAddressToXAddress(classicAddress, tag, isTestAddress)
+      }).toThrowError(new Error('Invalid tag'))
+    })
+  }
+
+  {
+    const classicAddress = 'r'
+    test(`Invalid classic address: Converting ${classicAddress}${network} throws`, () => {
+      expect(() => {
+        classicAddressToXAddress(classicAddress, false, isTestAddress)
+      }).toThrowError(new Error('invalid_input_size: decoded data must have length >= 5'))
+    })
+  }
+
+  {
+    const highAndLowAccounts = [
+      Buffer.from('00'.repeat(20), 'hex'),
+      Buffer.from('00'.repeat(19) + '01', 'hex'),
+      Buffer.from('01'.repeat(20), 'hex'),
+      Buffer.from('FF'.repeat(20), 'hex')
+    ]
+
+    highAndLowAccounts.forEach(accountId => {
+      [false, 0, 1, MAX_32_BIT_UNSIGNED_INT].forEach(t => {
+        const tag = (t | false)
+        const xAddress = encodeXAddress(accountId, tag, isTestAddress)
+        test(`Encoding ${accountId.toString('hex')}${tag ? ':' + tag : ''} to ${xAddress} has expected length`, () => {
+          expect(xAddress.length).toBe(47)
+        })
+      })
+    })
+  }
+})
+
+{
+  const xAddress = 'XVLhHMPHU98es4dbozjVtdWzVrDjtV5fdx1mHp98tDMoQXa'
+  test(`Invalid X-address (bad checksum): Converting ${xAddress} throws`, () => {
+    expect(() => {
+      xAddressToClassicAddress(xAddress)
+    }).toThrowError(new Error('checksum_invalid'))
+  })
+}
+
+{
+  const xAddress = 'dGzKGt8CVpWoa8aWL1k18tAdy9Won3PxynvbbpkAqp3V47g'
+  test(`Invalid X-address (bad prefix): Converting ${xAddress} throws`, () => {
+    expect(() => {
+      xAddressToClassicAddress(xAddress)
+    }).toThrowError(new Error('Invalid X-address: bad prefix'))
+  })
+}
+
+test(`Invalid X-address (64-bit tag) throws`, () => {
+  expect(() => {
+    // Encoded from:
+    // {
+    //   classicAddress: 'rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf',
+    //   tag: MAX_32_BIT_UNSIGNED_INT + 1
+    // }
+    xAddressToClassicAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8zeUygYrCgrPh')
+  }).toThrowError('Unsupported X-address')
+})
+
+test(`Invalid Account ID throws`, () => {
+  expect(() => {
+    encodeXAddress(Buffer.from('00'.repeat(19), 'hex'), false, false)
+  }).toThrowError('Account ID must be 20 bytes')
+})
+
+test(`isValidXAddress returns false for invalid X-address`, () => {
+  expect(isValidXAddress('XVLhHMPHU98es4dbozjVtdWzVrDjtV18pX8zeUygYrCgrPh')).toBe(false)
+})
+
+test(`Converts X7AcgcsBL6XDcUb... to r9cZA1mLK5R5A... and tag: false`, () => {
+  const classicAddress = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59'
+  const tag = false
+  const xAddress = 'X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ'
+  const isTestAddress = false
+  expect(classicAddressToXAddress(classicAddress, tag, isTestAddress)).toBe(xAddress)
+  const myClassicAddress = xAddressToClassicAddress(xAddress)
+  expect(myClassicAddress).toEqual({
+    classicAddress,
+    tag,
+    test: isTestAddress
+  })
+  expect(isValidXAddress(xAddress)).toBe(true)
+
+  // Notice that converting an X-address to a classic address has `result.tag === false` (not undefined)
+  expect(myClassicAddress.tag).toEqual(false)
+})

packages/ripple-address-codec/src/index.ts

@@ -0,0 +1,149 @@
+import {
+  codec,
+  encodeSeed,
+  decodeSeed,
+  encodeAccountID,
+  decodeAccountID,
+  encodeNodePublic,
+  decodeNodePublic,
+  encodeAccountPublic,
+  decodeAccountPublic,
+  isValidClassicAddress,
+} from './xrp-codec'
+import * as assert from 'assert'
+
+const PREFIX_BYTES = {
+  MAIN: Buffer.from([0x05, 0x44]), // 5, 68
+  TEST: Buffer.from([0x04, 0x93]), // 4, 147
+}
+
+function classicAddressToXAddress(
+  classicAddress: string,
+  tag: number | false,
+  test: boolean,
+): string {
+  const accountId = decodeAccountID(classicAddress)
+  return encodeXAddress(accountId, tag, test)
+}
+
+function encodeXAddress(
+  accountId: Buffer,
+  tag: number | false,
+  test: boolean,
+): string {
+  if (accountId.length !== 20) {
+    // RIPEMD160 is 160 bits = 20 bytes
+    throw new Error('Account ID must be 20 bytes')
+  }
+  const MAX_32_BIT_UNSIGNED_INT = 4294967295
+  const flag = tag === false ? 0 : tag <= MAX_32_BIT_UNSIGNED_INT ? 1 : 2
+  if (flag === 2) {
+    throw new Error('Invalid tag')
+  }
+  if (tag === false) {
+    tag = 0
+  }
+  const bytes = Buffer.concat([
+    test ? PREFIX_BYTES.TEST : PREFIX_BYTES.MAIN,
+    accountId,
+    Buffer.from([
+      flag, // 0x00 if no tag, 0x01 if 32-bit tag
+      tag & 0xff, // first byte
+      (tag >> 8) & 0xff, // second byte
+      (tag >> 16) & 0xff, // third byte
+      (tag >> 24) & 0xff, // fourth byte
+      0,
+      0,
+      0,
+      0, // four zero bytes (reserved for 64-bit tags)
+    ]),
+  ])
+  const xAddress = codec.encodeChecked(bytes)
+  return xAddress
+}
+
+function xAddressToClassicAddress(xAddress: string): {
+  classicAddress: string
+  tag: number | false
+  test: boolean
+} {
+  const { accountId, tag, test } = decodeXAddress(xAddress)
+  const classicAddress = encodeAccountID(accountId)
+  return {
+    classicAddress,
+    tag,
+    test,
+  }
+}
+
+function decodeXAddress(xAddress: string): {
+  accountId: Buffer
+  tag: number | false
+  test: boolean
+} {
+  const decoded = codec.decodeChecked(xAddress)
+  const test = isBufferForTestAddress(decoded)
+  const accountId = decoded.slice(2, 22)
+  const tag = tagFromBuffer(decoded)
+  return {
+    accountId,
+    tag,
+    test,
+  }
+}
+
+function isBufferForTestAddress(buf: Buffer): boolean {
+  const decodedPrefix = buf.slice(0, 2)
+  if (PREFIX_BYTES.MAIN.equals(decodedPrefix)) {
+    return false
+  } else if (PREFIX_BYTES.TEST.equals(decodedPrefix)) {
+    return true
+  } else {
+    throw new Error('Invalid X-address: bad prefix')
+  }
+}
+
+function tagFromBuffer(buf: Buffer): number | false {
+  const flag = buf[22]
+  if (flag >= 2) {
+    // No support for 64-bit tags at this time
+    throw new Error('Unsupported X-address')
+  }
+  if (flag === 1) {
+    // Little-endian to big-endian
+    return buf[23] + buf[24] * 0x100 + buf[25] * 0x10000 + buf[26] * 0x1000000
+  }
+  assert.strictEqual(flag, 0, 'flag must be zero to indicate no tag')
+  assert.ok(
+    Buffer.from('0000000000000000', 'hex').equals(buf.slice(23, 23 + 8)),
+    'remaining bytes must be zero',
+  )
+  return false
+}
+
+function isValidXAddress(xAddress: string): boolean {
+  try {
+    decodeXAddress(xAddress)
+  } catch (e) {
+    return false
+  }
+  return true
+}
+
+export {
+  codec, // Codec with XRP alphabet
+  encodeSeed, // Encode entropy as a "seed"
+  decodeSeed, // Decode a seed into an object with its version, type, and bytes
+  encodeAccountID, // Encode bytes as a classic address (r...)
+  decodeAccountID, // Decode a classic address to its raw bytes
+  encodeNodePublic, // Encode bytes to XRP Ledger node public key format
+  decodeNodePublic, // Decode an XRP Ledger node public key into its raw bytes
+  encodeAccountPublic, // Encode a public key, as for payment channels
+  decodeAccountPublic, // Decode a public key, as for payment channels
+  isValidClassicAddress, // Check whether a classic address (r...) is valid
+  classicAddressToXAddress, // Derive X-address from classic address, tag, and network ID
+  encodeXAddress, // Encode account ID, tag, and network ID to X-address
+  xAddressToClassicAddress, // Decode X-address to account ID, tag, and network ID
+  decodeXAddress, // Convert X-address to classic address, tag, and network ID
+  isValidXAddress, // Check whether an X-address (X...) is valid
+}

packages/ripple-address-codec/src/utils.test.js

@@ -0,0 +1,40 @@
+const {seqEqual, concatArgs} = require('./utils')
+
+test('two sequences are equal', () => {
+  expect(seqEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+})
+
+test('elements must be in the same order', () => {
+  expect(seqEqual([3, 2, 1], [1, 2, 3])).toBe(false)
+})
+
+test('sequences do not need to be the same type', () => {
+  expect(seqEqual(Buffer.from([1, 2, 3]), [1, 2, 3])).toBe(true)
+  expect(seqEqual(Buffer.from([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true)
+})
+
+test('sequences with a single element', () => {
+  expect(seqEqual(Buffer.from([1]), [1])).toBe(true)
+  expect(seqEqual(Buffer.from([1]), new Uint8Array([1]))).toBe(true)
+})
+
+test('empty sequences', () => {
+  expect(seqEqual(Buffer.from([]), [])).toBe(true)
+  expect(seqEqual(Buffer.from([]), new Uint8Array([]))).toBe(true)
+})
+
+test('plain numbers are concatenated', () => {
+  expect(concatArgs(10, 20, 30, 40)).toStrictEqual([10, 20, 30, 40])
+})
+
+test('a variety of values are concatenated', () => {
+  expect(concatArgs(1, [2, 3], Buffer.from([4,5]), new Uint8Array([6, 7]))).toStrictEqual([1,2,3,4,5,6,7])
+})
+
+test('a single value is returned as an array', () => {
+  expect(concatArgs(Buffer.from([7]))).toStrictEqual([7])
+})
+
+test('no arguments returns an empty array', () => {
+  expect(concatArgs()).toStrictEqual([])
+})

packages/ripple-address-codec/src/utils.ts

@@ -0,0 +1,54 @@
+type Sequence = number[] | Buffer | Uint8Array
+
+/**
+ * Check whether two sequences (e.g. arrays of numbers) are equal.
+ *
+ * @param arr1 One of the arrays to compare.
+ * @param arr2 The other array to compare.
+ */
+export function seqEqual(arr1: Sequence, arr2: Sequence): boolean {
+  if (arr1.length !== arr2.length) {
+    return false
+  }
+
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Check whether a value is a sequence (e.g. array of numbers).
+ *
+ * @param val The value to check.
+ */
+function isSequence(val: Sequence | number): val is Sequence {
+  return (val as Sequence).length !== undefined
+}
+
+/**
+ * Concatenate all `arguments` into a single array. Each argument can be either
+ * a single element or a sequence, which has a `length` property and supports
+ * element retrieval via sequence[ix].
+ *
+ * > concatArgs(1, [2, 3], Buffer.from([4,5]), new Uint8Array([6, 7]));
+ *  [1,2,3,4,5,6,7]
+ *
+ * @returns {number[]} Array of concatenated arguments
+ */
+export function concatArgs(...args: (number | Sequence)[]): number[] {
+  const ret: number[] = []
+
+  args.forEach(function (arg) {
+    if (isSequence(arg)) {
+      for (let j = 0; j < arg.length; j++) {
+        ret.push(arg[j])
+      }
+    } else {
+      ret.push(arg)
+    }
+  })
+  return ret
+}

packages/ripple-address-codec/src/xrp-codec.test.js

@@ -0,0 +1,246 @@
+const api = require('./xrp-codec')
+
+function toHex(bytes) {
+  return Buffer.from(bytes).toString('hex').toUpperCase()
+}
+
+function toBytes(hex) {
+  return Buffer.from(hex, 'hex')
+}
+
+/**
+ * Create a test case for encoding data and a test case for decoding data.
+ *
+ * @param encoder Encoder function to test
+ * @param decoder Decoder function to test
+ * @param base58 Base58-encoded string to decode
+ * @param hex Hexadecimal representation of expected decoded data
+ */
+function makeEncodeDecodeTest(encoder, decoder, base58, hex) {
+  test(`can translate between ${hex} and ${base58}`, function() {
+    const actual = encoder(toBytes(hex))
+    expect(actual).toBe(base58)
+  })
+  test(`can translate between ${base58} and ${hex})`, function() {
+    const buf = decoder(base58)
+    expect(toHex(buf)).toBe(hex)
+  })
+}
+
+makeEncodeDecodeTest(api.encodeAccountID, api.decodeAccountID, 'rJrRMgiRgrU6hDF4pgu5DXQdWyPbY35ErN',
+  'BA8E78626EE42C41B46D46C3048DF3A1C3C87072')
+
+makeEncodeDecodeTest(api.encodeNodePublic, api.decodeNodePublic,
+  'n9MXXueo837zYH36DvMc13BwHcqtfAWNJY5czWVbp7uYTj7x17TH',
+  '0388E5BA87A000CB807240DF8C848EB0B5FFA5C8E5A521BC8E105C0F0A44217828')
+
+  makeEncodeDecodeTest(api.encodeAccountPublic, api.decodeAccountPublic,
+    'aB44YfzW24VDEJQ2UuLPV2PvqcPCSoLnL7y5M1EzhdW4LnK5xMS3',
+    '023693F15967AE357D0327974AD46FE3C127113B1110D6044FD41E723689F81CC6')
+
+test('can decode arbitrary seeds', function() {
+  const decoded = api.decodeSeed('sEdTM1uX8pu2do5XvTnutH6HsouMaM2')
+  expect(toHex(decoded.bytes)).toBe('4C3A1D213FBDFB14C7C28D609469B341')
+  expect(decoded.type).toBe('ed25519')
+
+  const decoded2 = api.decodeSeed('sn259rEFXrQrWyx3Q7XneWcwV6dfL')
+  expect(toHex(decoded2.bytes)).toBe('CF2DE378FBDD7E2EE87D486DFB5A7BFF')
+  expect(decoded2.type).toBe('secp256k1')
+})
+
+test('can pass a type as second arg to encodeSeed', function() {
+  const edSeed = 'sEdTM1uX8pu2do5XvTnutH6HsouMaM2'
+  const decoded = api.decodeSeed(edSeed)
+  const type = 'ed25519'
+  expect(toHex(decoded.bytes)).toBe('4C3A1D213FBDFB14C7C28D609469B341')
+  expect(decoded.type).toBe(type)
+  expect(api.encodeSeed(decoded.bytes, type)).toBe(edSeed)
+})
+
+test('isValidClassicAddress - secp256k1 address valid', function() {
+  expect(api.isValidClassicAddress('rU6K7V3Po4snVhBBaU29sesqs2qTQJWDw1')).toBe(true)
+})
+
+test('isValidClassicAddress - ed25519 address valid', function() {
+  expect(api.isValidClassicAddress('rLUEXYuLiQptky37CqLcm9USQpPiz5rkpD')).toBe(true)
+})
+
+test('isValidClassicAddress - invalid', function() {
+  expect(api.isValidClassicAddress('rU6K7V3Po4snVhBBaU29sesqs2qTQJWDw2')).toBe(false)
+})
+
+test('isValidClassicAddress - empty', function() {
+  expect(api.isValidClassicAddress('')).toBe(false)
+})
+
+describe('encodeSeed', function() {
+
+  it('encodes a secp256k1 seed', function() {
+    const result = api.encodeSeed(Buffer.from('CF2DE378FBDD7E2EE87D486DFB5A7BFF', 'hex'), 'secp256k1')
+    expect(result).toBe('sn259rEFXrQrWyx3Q7XneWcwV6dfL')
+  })
+
+  it('encodes low secp256k1 seed', function() {
+    const result = api.encodeSeed(Buffer.from('00000000000000000000000000000000', 'hex'), 'secp256k1')
+    expect(result).toBe('sp6JS7f14BuwFY8Mw6bTtLKWauoUs')
+  })
+
+  it('encodes high secp256k1 seed', function() {
+    const result = api.encodeSeed(Buffer.from('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', 'hex'), 'secp256k1')
+    expect(result).toBe('saGwBRReqUNKuWNLpUAq8i8NkXEPN')
+  })
+
+  it('encodes an ed25519 seed', function() {
+    const result = api.encodeSeed(Buffer.from('4C3A1D213FBDFB14C7C28D609469B341', 'hex'), 'ed25519')
+    expect(result).toBe('sEdTM1uX8pu2do5XvTnutH6HsouMaM2')
+  })
+
+  it('encodes low ed25519 seed', function() {
+    const result = api.encodeSeed(Buffer.from('00000000000000000000000000000000', 'hex'), 'ed25519')
+    expect(result).toBe('sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE')
+  })
+
+  it('encodes high ed25519 seed', function() {
+    const result = api.encodeSeed(Buffer.from('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', 'hex'), 'ed25519')
+    expect(result).toBe('sEdV19BLfeQeKdEXyYA4NhjPJe6XBfG')
+  })
+
+  test('attempting to encode a seed with less than 16 bytes of entropy throws', function() {
+    expect(() => {
+      api.encodeSeed(Buffer.from('CF2DE378FBDD7E2EE87D486DFB5A7B', 'hex'), 'secp256k1')
+    }).toThrow('entropy must have length 16')
+  })
+
+  test('attempting to encode a seed with more than 16 bytes of entropy throws', function() {
+    expect(() => {
+      api.encodeSeed(Buffer.from('CF2DE378FBDD7E2EE87D486DFB5A7BFFFF', 'hex'), 'secp256k1')
+    }).toThrow('entropy must have length 16')
+  })
+})
+
+describe('decodeSeed', function() {
+
+  it('can decode an Ed25519 seed', function() {
+    const decoded = api.decodeSeed('sEdTM1uX8pu2do5XvTnutH6HsouMaM2')
+    expect(toHex(decoded.bytes)).toBe('4C3A1D213FBDFB14C7C28D609469B341')
+    expect(decoded.type).toBe('ed25519')
+  })
+
+  it('can decode a secp256k1 seed', function() {
+    const decoded = api.decodeSeed('sn259rEFXrQrWyx3Q7XneWcwV6dfL')
+    expect(toHex(decoded.bytes)).toBe('CF2DE378FBDD7E2EE87D486DFB5A7BFF')
+    expect(decoded.type).toBe('secp256k1')
+  })
+})
+
+describe('encodeAccountID', function() {
+
+  it('can encode an AccountID', function() {
+    const encoded = api.encodeAccountID(Buffer.from('BA8E78626EE42C41B46D46C3048DF3A1C3C87072', 'hex'))
+    expect(encoded).toBe('rJrRMgiRgrU6hDF4pgu5DXQdWyPbY35ErN')
+  })
+
+  test('unexpected length should throw', function() {
+    expect(() => {
+      api.encodeAccountID(Buffer.from('ABCDEF', 'hex'))
+    }).toThrow(
+      'unexpected_payload_length: bytes.length does not match expectedLength'
+    )
+  })
+})
+
+describe('decodeNodePublic', function() {
+
+  it('can decode a NodePublic', function() {
+    const decoded = api.decodeNodePublic('n9MXXueo837zYH36DvMc13BwHcqtfAWNJY5czWVbp7uYTj7x17TH')
+    expect(toHex(decoded)).toBe('0388E5BA87A000CB807240DF8C848EB0B5FFA5C8E5A521BC8E105C0F0A44217828')
+  })
+})
+
+test('encodes 123456789 with version byte of 0', () => {
+  expect(api.codec.encode(Buffer.from('123456789'), {
+    versions: [0],
+    expectedLength: 9
+  })).toBe('rnaC7gW34M77Kneb78s')
+})
+
+test('multiple versions with no expected length should throw', () => {
+  expect(() => {
+    api.codec.decode('rnaC7gW34M77Kneb78s', {
+      versions: [0, 1]
+    })
+  }).toThrow('expectedLength is required because there are >= 2 possible versions')
+})
+
+test('attempting to decode data with length < 5 should throw', () => {
+  expect(() => {
+    api.codec.decode('1234', {
+      versions: [0]
+    })
+  }).toThrow('invalid_input_size: decoded data must have length >= 5')
+})
+
+test('attempting to decode data with unexpected version should throw', () => {
+  expect(() => {
+    api.codec.decode('rnaC7gW34M77Kneb78s', {
+      versions: [2]
+    })
+  }).toThrow('version_invalid: version bytes do not match any of the provided version(s)')
+})
+
+test('invalid checksum should throw', () => {
+  expect(() => {
+    api.codec.decode('123456789', {
+      versions: [0, 1]
+    })
+  }).toThrow('checksum_invalid')
+})
+
+test('empty payload should throw', () => {
+  expect(() => {
+    api.codec.decode('', {
+      versions: [0, 1]
+    })
+  }).toThrow('invalid_input_size: decoded data must have length >= 5')
+})
+
+test('decode data', () => {
+  expect(api.codec.decode('rnaC7gW34M77Kneb78s', {
+    versions: [0]
+  })).toStrictEqual({
+    version: [0],
+    bytes: Buffer.from('123456789'),
+    type: null
+  })
+})
+
+test('decode data with expected length', function() {
+  expect(api.codec.decode('rnaC7gW34M77Kneb78s', {
+      versions: [0],
+      expectedLength: 9
+    })
+    ).toStrictEqual({
+      version: [0],
+      bytes: Buffer.from('123456789'),
+      type: null
+    })
+})
+
+test('decode data with wrong expected length should throw', function() {
+  expect(() => {
+    api.codec.decode('rnaC7gW34M77Kneb78s', {
+      versions: [0],
+      expectedLength: 8
+    })
+  }).toThrow(
+    'version_invalid: version bytes do not match any of the provided version(s)'
+  )
+  expect(() => {
+    api.codec.decode('rnaC7gW34M77Kneb78s', {
+      versions: [0],
+      expectedLength: 10
+    })
+  }).toThrow(
+    'version_invalid: version bytes do not match any of the provided version(s)'
+  )
+})

packages/ripple-address-codec/src/xrp-codec.ts

@@ -0,0 +1,241 @@
+/**
+ * Codec class
+ */
+
+import * as baseCodec from 'base-x'
+import { seqEqual, concatArgs } from './utils'
+
+class Codec {
+  sha256: (bytes: Uint8Array) => Buffer
+  alphabet: string
+  codec: any
+  base: number
+
+  constructor(options: {
+    sha256: (bytes: Uint8Array) => Buffer
+    alphabet: string
+  }) {
+    this.sha256 = options.sha256
+    this.alphabet = options.alphabet
+    this.codec = baseCodec(this.alphabet)
+    this.base = this.alphabet.length
+  }
+
+  /**
+   * Encoder.
+   *
+   * @param bytes Buffer of data to encode.
+   * @param opts Options object including the version bytes and the expected length of the data to encode.
+   */
+  encode(
+    bytes: Buffer,
+    opts: {
+      versions: number[]
+      expectedLength: number
+    },
+  ): string {
+    const versions = opts.versions
+    return this.encodeVersioned(bytes, versions, opts.expectedLength)
+  }
+
+  encodeVersioned(
+    bytes: Buffer,
+    versions: number[],
+    expectedLength: number,
+  ): string {
+    if (expectedLength && bytes.length !== expectedLength) {
+      throw new Error(
+        'unexpected_payload_length: bytes.length does not match expectedLength.' +
+          ' Ensure that the bytes are a Buffer.',
+      )
+    }
+    return this.encodeChecked(Buffer.from(concatArgs(versions, bytes)))
+  }
+
+  encodeChecked(buffer: Buffer): string {
+    const check = this.sha256(this.sha256(buffer)).slice(0, 4)
+    return this.encodeRaw(Buffer.from(concatArgs(buffer, check)))
+  }
+
+  encodeRaw(bytes: Buffer): string {
+    return this.codec.encode(bytes)
+  }
+
+  /**
+   * Decoder.
+   *
+   * @param base58string Base58Check-encoded string to decode.
+   * @param opts Options object including the version byte(s) and the expected length of the data after decoding.
+   */
+  decode(
+    base58string: string,
+    opts: {
+      versions: (number | number[])[]
+      expectedLength?: number
+      versionTypes?: ['ed25519', 'secp256k1']
+    },
+  ): {
+    version: number[]
+    bytes: Buffer
+    type: string | null
+  } {
+    const versions = opts.versions
+    const types = opts.versionTypes
+
+    const withoutSum = this.decodeChecked(base58string)
+
+    if (versions.length > 1 && !opts.expectedLength) {
+      throw new Error(
+        'expectedLength is required because there are >= 2 possible versions',
+      )
+    }
+    const versionLengthGuess =
+      typeof versions[0] === 'number' ? 1 : (versions[0] as number[]).length
+    const payloadLength =
+      opts.expectedLength || withoutSum.length - versionLengthGuess
+    const versionBytes = withoutSum.slice(0, -payloadLength)
+    const payload = withoutSum.slice(-payloadLength)
+
+    for (let i = 0; i < versions.length; i++) {
+      const version: number[] = Array.isArray(versions[i])
+        ? (versions[i] as number[])
+        : [versions[i] as number]
+      if (seqEqual(versionBytes, version)) {
+        return {
+          version,
+          bytes: payload,
+          type: types ? types[i] : null,
+        }
+      }
+    }
+
+    throw new Error(
+      'version_invalid: version bytes do not match any of the provided version(s)',
+    )
+  }
+
+  decodeChecked(base58string: string): Buffer {
+    const buffer = this.decodeRaw(base58string)
+    if (buffer.length < 5) {
+      throw new Error('invalid_input_size: decoded data must have length >= 5')
+    }
+    if (!this.verifyCheckSum(buffer)) {
+      throw new Error('checksum_invalid')
+    }
+    return buffer.slice(0, -4)
+  }
+
+  decodeRaw(base58string: string): Buffer {
+    return this.codec.decode(base58string)
+  }
+
+  verifyCheckSum(bytes: Buffer): boolean {
+    const computed = this.sha256(this.sha256(bytes.slice(0, -4))).slice(0, 4)
+    const checksum = bytes.slice(-4)
+    return seqEqual(computed, checksum)
+  }
+}
+
+/**
+ * XRP codec
+ */
+
+// Pure JavaScript hash functions in the browser, native hash functions in Node.js
+const createHash = require('create-hash')
+
+// base58 encodings: https://xrpl.org/base58-encodings.html
+const ACCOUNT_ID = 0 // Account address (20 bytes)
+const ACCOUNT_PUBLIC_KEY = 0x23 // Account public key (33 bytes)
+const FAMILY_SEED = 0x21 // 33; Seed value (for secret keys) (16 bytes)
+const NODE_PUBLIC = 0x1c // 28; Validation public key (33 bytes)
+
+const ED25519_SEED = [0x01, 0xe1, 0x4b] // [1, 225, 75]
+
+const codecOptions = {
+  sha256: function (bytes: Uint8Array) {
+    return createHash('sha256').update(Buffer.from(bytes)).digest()
+  },
+  alphabet: 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz',
+}
+
+const codecWithXrpAlphabet = new Codec(codecOptions)
+
+export const codec = codecWithXrpAlphabet
+
+// entropy is a Buffer of size 16
+// type is 'ed25519' or 'secp256k1'
+export function encodeSeed(
+  entropy: Buffer,
+  type: 'ed25519' | 'secp256k1',
+): string {
+  if (entropy.length !== 16) {
+    throw new Error('entropy must have length 16')
+  }
+  const opts = {
+    expectedLength: 16,
+
+    // for secp256k1, use `FAMILY_SEED`
+    versions: type === 'ed25519' ? ED25519_SEED : [FAMILY_SEED],
+  }
+
+  // prefixes entropy with version bytes
+  return codecWithXrpAlphabet.encode(entropy, opts)
+}
+
+export function decodeSeed(
+  seed: string,
+  opts: {
+    versionTypes: ['ed25519', 'secp256k1']
+    versions: (number | number[])[]
+    expectedLength: number
+  } = {
+    versionTypes: ['ed25519', 'secp256k1'],
+    versions: [ED25519_SEED, FAMILY_SEED],
+    expectedLength: 16,
+  },
+) {
+  return codecWithXrpAlphabet.decode(seed, opts)
+}
+
+export function encodeAccountID(bytes: Buffer): string {
+  const opts = { versions: [ACCOUNT_ID], expectedLength: 20 }
+  return codecWithXrpAlphabet.encode(bytes, opts)
+}
+
+export const encodeAddress = encodeAccountID
+
+export function decodeAccountID(accountId: string): Buffer {
+  const opts = { versions: [ACCOUNT_ID], expectedLength: 20 }
+  return codecWithXrpAlphabet.decode(accountId, opts).bytes
+}
+
+export const decodeAddress = decodeAccountID
+
+export function decodeNodePublic(base58string: string): Buffer {
+  const opts = { versions: [NODE_PUBLIC], expectedLength: 33 }
+  return codecWithXrpAlphabet.decode(base58string, opts).bytes
+}
+
+export function encodeNodePublic(bytes: Buffer): string {
+  const opts = { versions: [NODE_PUBLIC], expectedLength: 33 }
+  return codecWithXrpAlphabet.encode(bytes, opts)
+}
+
+export function encodeAccountPublic(bytes: Buffer): string {
+  const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 }
+  return codecWithXrpAlphabet.encode(bytes, opts)
+}
+
+export function decodeAccountPublic(base58string: string): Buffer {
+  const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 }
+  return codecWithXrpAlphabet.decode(base58string, opts).bytes
+}
+
+export function isValidClassicAddress(address: string): boolean {
+  try {
+    decodeAccountID(address)
+  } catch (e) {
+    return false
+  }
+  return true
+}

packages/ripple-address-codec/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "target": "es6",
+    "lib": [
+      "es2017"
+    ],
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "removeComments": false,
+    "preserveConstEnums": false,
+    "suppressImplicitAnyIndexErrors": false,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*.ts"]
+}

packages/ripple-binary-codec/.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+.github
+coverage

packages/ripple-binary-codec/.eslintrc.js

@@ -0,0 +1,124 @@
+module.exports = {
+  root: true,
+
+  parser: '@typescript-eslint/parser', // Make ESLint compatible with TypeScript
+  parserOptions: {
+    // Enable linting rules with type information from our tsconfig
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig.eslint.json'],
+
+    sourceType: 'module', // Allow the use of imports / ES modules
+
+    ecmaFeatures: {
+      impliedStrict: true, // Enable global strict mode
+    },
+  },
+
+  // Specify global variables that are predefined
+  env: {
+    browser: true, // Enable browser global variables
+    node: true, // Enable node global variables & Node.js scoping
+    es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020
+    jest: true, // Add Mocha testing global variables
+  },
+
+  plugins: [],
+  extends: ['@xrplf/eslint-config/base'],
+
+  rules: {
+    // ** TODO **
+    // all of the below are turned off for now during the migration to a
+    // monorepo. They need to actually be addressed!
+    // **
+    '@typescript-eslint/naming-convention': 'off',
+    '@typescript-eslint/prefer-readonly': 'off',
+    '@typescript-eslint/no-parameter-properties': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    '@typescript-eslint/restrict-plus-operands': 'off',
+    '@typescript-eslint/unbound-method': 'off',
+    '@typescript-eslint/restrict-template-expressions': 'off',
+    '@typescript-eslint/no-base-to-string': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/promise-function-async': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    '@typescript-eslint/array-type': 'off',
+    '@typescript-eslint/no-magic-numbers': 'off',
+    '@typescript-eslint/no-useless-constructor': 'off',
+    '@typescript-eslint/no-unnecessary-condition': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    '@typescript-eslint/prefer-for-of': 'off',
+    '@typescript-eslint/prefer-nullish-coalescing': 'off',
+    '@typescript-eslint/require-array-sort-compare': 'off',
+    '@typescript-eslint/prefer-includes': 'off',
+    '@typescript-eslint/dot-notation': 'off',
+    '@typescript-eslint/consistent-type-definitions': 'off',
+    '@typescript-eslint/no-type-alias': 'off',
+    '@typescript-eslint/member-ordering': 'off',
+    '@typescript-eslint/prefer-string-starts-ends-with': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-extraneous-class': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    'import/unambiguous': 'off',
+    'import/extensions': 'off',
+    'import/prefer-default-export': 'off',
+    'import/no-useless-path-segments': 'off',
+    'import/no-unused-modules': 'off',
+    'import/no-cycle': 'off',
+    'import/order': 'off',
+    'import/no-commonjs': 'off',
+    'import/newline-after-import': 'off',
+    'node/global-require': 'off',
+    'consistent-default-export-name/default-import-match-filename': 'off',
+    'jsdoc/require-throws': 'off',
+    'jsdoc/require-description-complete-sentence': 'off',
+    'jsdoc/require-jsdoc': 'off',
+    'jsdoc/check-tag-names': 'off',
+    'jsdoc/require-returns': 'off',
+    'jsdoc/require-hyphen-before-param-description': 'off',
+    'jsdoc/require-description': 'off',
+    'jsdoc/require-param': 'off',
+    'jsdoc/check-param-names': 'off',
+    'jsdoc/newline-after-description': 'off',
+    'jsdoc/require-returns-check': 'off',
+    'tsdoc/syntax': 'off',
+    'eslint-comments/require-description': 'off',
+    'eslint-comments/no-unused-disable': 'off',
+    'prefer-const': 'off',
+    'global-require': 'off',
+    'id-length': 'off',
+    'no-shadow': 'off',
+    'no-bitwise': 'off',
+    'spaced-comment': 'off',
+    'prefer-template': 'off',
+    'prefer-object-spread': 'off',
+    'no-inline-comments': 'off',
+    'no-plusplus': 'off',
+    'new-cap': 'off',
+    'id-blacklist': 'off',
+    'max-lines-per-function': 'off',
+    'require-unicode-regexp': 'off',
+    'no-undef-init': 'off',
+    'curly': 'off',
+    'eqeqeq': 'off',
+    'no-console': 'off',
+    'max-classes-per-file': 'off',
+    'operator-assignment': 'off',
+    'class-methods-use-this': 'off',
+    'no-else-return': 'off',
+    'yoda': 'off',
+    'max-depth': 'off',
+    'multiline-comment-style': 'off',
+    'one-var': 'off',
+    'no-negated-condition': 'off',
+    'radix': 'off',
+    'no-nested-ternary': 'off',
+    'no-useless-concat': 'off',
+    'object-shorthand': 'off',
+    'no-param-reassign': 'off',
+  },
+}

packages/ripple-binary-codec/.gitignore

@@ -0,0 +1,64 @@
+# .gitignore
+
+# Ignore vim swap files.
+*.swp
+
+# Ignore SCons support files.
+.sconsign.dblite
+
+# Ignore python compiled files.
+*.pyc
+
+# Ignore Macintosh Desktop Services Store files.
+.DS_Store
+
+# Ignore backup/temps
+*~
+
+# Ignore object files.
+*.o
+build/
+distrib/
+tags
+bin/rippled
+Debug/*.*
+Release/*.*
+
+# Ignore locally installed node_modules
+node_modules
+!test/node_modules
+
+# Ignore tmp directory.
+tmp
+
+# Ignore database directory.
+db/*.db
+db/*.db-*
+
+# Ignore customized configs
+rippled.cfg
+validators.txt
+test/config.js
+
+# Ignore coverage files
+/lib-cov
+/src-cov
+/coverage.html
+/coverage
+
+# Ignore IntelliJ files
+.idea
+
+# Ignore npm-debug
+npm-debug.log
+
+# Ignore dist folder, build for bower
+dist/
+
+# Ignore flow output directory
+out/
+
+# Ignore perf test cache
+scripts/cache
+
+eslintrc

packages/ripple-binary-codec/.nvmrc

@@ -0,0 +1 @@
+10.22.0

packages/ripple-binary-codec/HISTORY.md

@@ -0,0 +1,90 @@
+# ripple-binary-codec Release History
+
+## 1.1.3 (2021-06-11)
+- Fix for case UInt64.from string allowing lowercase hex (#135)
+- Fix for `ValidatorToReEnable` field code (#130)
+
+## 1.1.2 (2021-03-10)
+- Fix for case UInt64.from string '0' due to changes in rippled 1.7.0
+
+## 1.1.1 (2021-02-12)
+- PathSet.toJSON() does not return undefined values
+- Add support for X-Addresses in Issued Currency Amounts
+- Fix STArray error message
+
+## 1.1.0 (2020-12-03)
+- Add support for Tickets (TicketBatch amendment)
+- Fix web browser compatibility
+
+## 1.0.2 (2020-09-11)
+- Allow currencies to be encoded from any 3 character ASCII code
+
+## 1.0.1 (2020-09-08)
+- Filter out fields with undefined values
+
+## 1.0.0 (2020-08-17)
+
+- Migrate to TypeScript
+  - Javascript classes used
+  - Generics for constructing core types
+- Reduced dependencies
+  - Dependent on create-hash, decimal.js, ripple-address-codec
+- Migrate testing to Jest and added tests
+  - Tests for pseudo-transactions
+- Added support for NegativeUNL pseudo-transactions
+
+## 0.2.6 (2019-12-31)
+
+- Update dependencies
+  - decimal.js, fs-extra, mocha, handlebars, bn.js, babel-eslint, ripple-address-codec
+
+## 0.2.5 (2019-12-14)
+
+- Add support for AccountDelete (#37)
+
+## 0.2.4 (2019-09-04)
+
+- Update ripple-address-codec to 3.0.4
+
+## 0.2.3 (2019-08-29)
+
+- Expand node version compatibility (#32, #33)
+
+## 0.2.2 (2019-07-26)
+
+- Input validation - Amount and Fee should not allow fractional XRP drops ([#31](https://github.com/ripple/ripple-binary-codec/issues/31))
+- Fix lint errors
+- Update dependencies (including lodash and mocha)
+- Require node 10 (.nvmrc)
+- Remove assert-diff
+- Remove codecov.io as it did not appear to work. The `package.json` script was:
+  - `"codecov": "cat ./coverage/coverage.json | ./node_modules/codecov.io/bin/codecov.io.js"`
+
+## 0.2.1
+
+- Add tecKILLED from amendment fix1578 (PR #27 fixes #25)
+
+## 0.2.0
+
+- Add DepositPreauth fields
+  - https://developers.ripple.com/depositauth.html
+
+## 0.1.14
+
+- Skip amount validation when deserializing f72c115
+
+## 0.1.13
+
+- Add Check, CheckCreate, CheckCash, CheckCancel
+
+## 0.1.11
+
+- Add ledger header decode function
+
+## 0.1.8
+
+## 0.1.7
+
+## 0.1.6
+
+## 0.1.3

packages/ripple-binary-codec/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2015 Ripple Labs Inc.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

packages/ripple-binary-codec/README.md

@@ -0,0 +1,107 @@
+# ripple-binary-codec [![NPM](https://img.shields.io/npm/v/ripple-binary-codec.svg)](https://npmjs.org/package/ripple-binary-codec)
+
+Functions to encode/decode to/from the ripple [binary serialization format](https://xrpl.org/serialization.html)
+
+[![NPM](https://nodei.co/npm/ripple-binary-codec.png)](https://www.npmjs.org/package/ripple-binary-codec)
+
+## API
+```js
+> const api = require('ripple-binary-codec')
+```
+
+
+### decode(binary: string): object
+Decode a hex-string into a transaction object.
+```js
+> api.decode('1100612200000000240000000125000000072D0000000055DF530FB14C5304852F20080B0A8EEF3A6BDD044F41F4EBBD68B8B321145FE4FF6240000002540BE4008114D0F5430B66E06498D4CEEC816C7B3337F9982337')
+{
+  LedgerEntryType: 'AccountRoot',
+  Flags: 0,
+  Sequence: 1,
+  PreviousTxnLgrSeq: 7,
+  OwnerCount: 0,
+  PreviousTxnID: 'DF530FB14C5304852F20080B0A8EEF3A6BDD044F41F4EBBD68B8B321145FE4FF',
+  Balance: '10000000000',
+  Account: 'rLs1MzkFWCxTbuAHgjeTZK4fcCDDnf2KRv'
+}
+```
+
+### encode(json: object): string
+Encode a transaction object into a hex-string. Note that encode filters out fields with undefined values.
+```js
+> api.encode({
+  LedgerEntryType: 'AccountRoot',
+  Flags: 0,
+  Sequence: 1,
+  PreviousTxnLgrSeq: 7,
+  OwnerCount: 0,
+  PreviousTxnID: 'DF530FB14C5304852F20080B0A8EEF3A6BDD044F41F4EBBD68B8B321145FE4FF',
+  Balance: '10000000000',
+  Account: 'rLs1MzkFWCxTbuAHgjeTZK4fcCDDnf2KRv' 
+})
+'1100612200000000240000000125000000072D0000000055DF530FB14C5304852F20080B0A8EEF3A6BDD044F41F4EBBD68B8B321145FE4FF6240000002540BE4008114D0F5430B66E06498D4CEEC816C7B3337F9982337'
+```
+
+#### X-Address Compatibility 
+  * ripple-binary-codec handles X-addresses by looking for a few specific files (Account/SourceTag, Destination/DestinationTag).
+  * If other fields (in the future) must to support X-addresses with tags, this library will need to be updated.
+  * When decoding rippled binary, the output will always output classic address + tag, with no X-addresses. X-address support only applies when encoding to binary.
+
+#### Encoding Currency Codes
+  * The standard format for currency codes is a three-letter string such as `USD`. This is intended for use with ISO 4217 Currency Codes.
+  * Currency codes must be exactly 3 ASCII characters in length and there are [a few other rules](https://xrpl.org/currency-formats.html#currency-codes).
+  * ripple-binary-codec allows any 3-character ASCII string to be encoded as a currency code, although rippled may enforce tighter restrictions.
+  * When _decoding_, if a currency code is three uppercase letters or numbers (`/^[A-Z0-9]{3}$/`), then it will be decoded into that string. For example,`0000000000000000000000004142430000000000` decodes as `ABC`.
+  * When decoding, if a currency code is does not match the regex, then it is not considered to be an ISO 4217 or pseudo-ISO currency. ripple-binary-codec will return a 160-bit hex-string (40 hex characters). For example, `0000000000000000000000006142430000000000` (`aBC`) decodes as `0000000000000000000000006142430000000000` because it contains a lowercase letter.
+
+### encodeForSigning(json: object): string
+
+Encode the transaction object for signing.
+
+### encodeForSigningClaim(json: object): string
+
+Encode the transaction object for payment channel claim.
+
+### encodeForMultisigning(json: object, signer: string): string
+
+Encode the transaction object for multi-signing.
+
+### encodeQuality(value: string): string
+```js
+> api.encodeQuality('195796912.5171664')
+'5D06F4C3362FE1D0'
+```
+
+### decodeQuality(value: string): string 
+```js
+> api.decodeQuality('5D06F4C3362FE1D0')
+'195796912.5171664'
+```
+
+### decodeLedgerData(binary: string): object
+```js
+> api.decodeLedgerData("01E91435016340767BF1C4A3EACEB081770D8ADE216C85445DD6FB002C6B5A2930F2DECE006DA18150CB18F6DD33F6F0990754C962A7CCE62F332FF9C13939B03B864117F0BDA86B6E9B4F873B5C3E520634D343EF5D9D9A4246643D64DAD278BA95DC0EAC6EB5350CF970D521276CDE21276CE60A00")
+{
+  ledger_index: 32052277,
+  total_coins: '99994494362043555',
+  parent_hash: 'EACEB081770D8ADE216C85445DD6FB002C6B5A2930F2DECE006DA18150CB18F6',
+  transaction_hash: 'DD33F6F0990754C962A7CCE62F332FF9C13939B03B864117F0BDA86B6E9B4F87',
+  account_hash: '3B5C3E520634D343EF5D9D9A4246643D64DAD278BA95DC0EAC6EB5350CF970D5',
+  parent_close_time: 556231902,
+  close_time: 556231910,
+  close_time_resolution: 10,
+  close_flags: 0
+}
+```
+
+## Tests
+
+Run unit tests with:
+
+    npm test
+
+Use `--coverage` to generate and display code coverage information:
+
+    npm test --coverage
+
+This tells jest to output code coverage info in the `./coverage` directory, in addition to showing it on the command line.

packages/ripple-binary-codec/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ripple-binary-codec",
+  "version": "1.2.0",
+  "description": "XRP Ledger binary codec",
+  "files": [
+    "dist/*",
+    "bin/*",
+    "test/*"
+  ],
+  "main": "dist/",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "assert": "^2.0.0",
+    "big-integer": "^1.6.48",
+    "buffer": "5.6.0",
+    "create-hash": "^1.2.0",
+    "decimal.js": "^10.2.0",
+    "ripple-address-codec": "^4.2.0"
+  },
+  "scripts": {
+    "build": "tsc -b && cp ./src/enums/definitions.json ./dist/enums",
+    "clean": "rm -rf ./dist && rm -rf tsconfig.tsbuildinfo",
+    "prepare": "npm run build && npm test",
+    "test": "jest",
+    "lint": "eslint . --ext .ts --ext .test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:XRPLF/xrpl.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/XRPLF/xrpl.js/issues"
+  },
+  "homepage": "https://github.com/XRPLF/xrpl.js/packages/ripple-binary-codec#readme",
+  "license": "ISC",
+  "readmeFilename": "README.md",
+  "prettier": "@xrplf/prettier-config",
+  "engines": {
+    "node": ">=10.22.0",
+    "npm": ">=7.0.0"
+  }
+}

packages/ripple-binary-codec/src/README.md

@@ -0,0 +1,3 @@
+# ripple-binary-codec
+
+Serialize and deserialize transactions according to the XRP Ledger protocol. 

packages/ripple-binary-codec/src/binary.ts

@@ -0,0 +1,154 @@
+/* eslint-disable func-style */
+
+import { coreTypes } from './types'
+import { BinaryParser } from './serdes/binary-parser'
+import { AccountID } from './types/account-id'
+import { HashPrefix } from './hash-prefixes'
+import { BinarySerializer, BytesList } from './serdes/binary-serializer'
+import { sha512Half, transactionID } from './hashes'
+import { FieldInstance } from './enums'
+import { STObject } from './types/st-object'
+import { JsonObject } from './types/serialized-type'
+import { Buffer } from 'buffer/'
+import * as bigInt from 'big-integer'
+
+/**
+ * Construct a BinaryParser
+ *
+ * @param bytes hex-string to construct BinaryParser from
+ * @returns A BinaryParser
+ */
+const makeParser = (bytes: string): BinaryParser => new BinaryParser(bytes)
+
+/**
+ * Parse BinaryParser into JSON
+ *
+ * @param parser BinaryParser object
+ * @returns JSON for the bytes in the BinaryParser
+ */
+const readJSON = (parser: BinaryParser): JsonObject =>
+  (parser.readType(coreTypes.STObject) as STObject).toJSON()
+
+/**
+ * Parse a hex-string into its JSON interpretation
+ *
+ * @param bytes hex-string to parse into JSON
+ * @returns JSON
+ */
+const binaryToJSON = (bytes: string): JsonObject => readJSON(makeParser(bytes))
+
+/**
+ * Interface for passing parameters to SerializeObject
+ *
+ * @field set signingFieldOnly to true if you want to serialize only signing fields
+ */
+interface OptionObject {
+  prefix?: Buffer
+  suffix?: Buffer
+  signingFieldsOnly?: boolean
+}
+
+/**
+ * Function to serialize JSON object representing a transaction
+ *
+ * @param object JSON object to serialize
+ * @param opts options for serializing, including optional prefix, suffix, and signingFieldOnly
+ * @returns A Buffer containing the serialized object
+ */
+function serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {
+  const { prefix, suffix, signingFieldsOnly = false } = opts
+  const bytesList = new BytesList()
+
+  if (prefix) {
+    bytesList.put(prefix)
+  }
+
+  const filter = signingFieldsOnly
+    ? (f: FieldInstance): boolean => f.isSigningField
+    : undefined
+  coreTypes.STObject.from(object, filter).toBytesSink(bytesList)
+
+  if (suffix) {
+    bytesList.put(suffix)
+  }
+
+  return bytesList.toBytes()
+}
+
+/**
+ * Serialize an object for signing
+ *
+ * @param transaction Transaction to serialize
+ * @param prefix Prefix bytes to put before the serialized object
+ * @returns A Buffer with the serialized object
+ */
+function signingData(
+  transaction: JsonObject,
+  prefix: Buffer = HashPrefix.transactionSig,
+): Buffer {
+  return serializeObject(transaction, { prefix, signingFieldsOnly: true })
+}
+
+/**
+ * Interface describing fields required for a Claim
+ */
+interface ClaimObject extends JsonObject {
+  channel: string
+  amount: string | number
+}
+
+/**
+ * Serialize a signingClaim
+ *
+ * @param claim A claim object to serialize
+ * @returns the serialized object with appropriate prefix
+ */
+function signingClaimData(claim: ClaimObject): Buffer {
+  const num = bigInt(String(claim.amount))
+  const prefix = HashPrefix.paymentChannelClaim
+  const channel = coreTypes.Hash256.from(claim.channel).toBytes()
+  const amount = coreTypes.UInt64.from(num).toBytes()
+
+  const bytesList = new BytesList()
+
+  bytesList.put(prefix)
+  bytesList.put(channel)
+  bytesList.put(amount)
+  return bytesList.toBytes()
+}
+
+/**
+ * Serialize a transaction object for multiSigning
+ *
+ * @param transaction transaction to serialize
+ * @param signingAccount Account to sign the transaction with
+ * @returns serialized transaction with appropriate prefix and suffix
+ */
+function multiSigningData(
+  transaction: JsonObject,
+  signingAccount: string | AccountID,
+): Buffer {
+  const prefix = HashPrefix.transactionMultiSig
+  const suffix = coreTypes.AccountID.from(signingAccount).toBytes()
+  return serializeObject(transaction, {
+    prefix,
+    suffix,
+    signingFieldsOnly: true,
+  })
+}
+
+export {
+  BinaryParser,
+  BinarySerializer,
+  BytesList,
+  ClaimObject,
+  makeParser,
+  serializeObject,
+  readJSON,
+  multiSigningData,
+  signingData,
+  signingClaimData,
+  binaryToJSON,
+  sha512Half,
+  transactionID,
+}

packages/ripple-binary-codec/src/coretypes.ts

@@ -0,0 +1,29 @@
+import {
+  Field,
+  TransactionType,
+  LedgerEntryType,
+  Type,
+  TransactionResult,
+} from './enums'
+import * as types from './types'
+import * as binary from './binary'
+import { ShaMap } from './shamap'
+import * as ledgerHashes from './ledger-hashes'
+import * as hashes from './hashes'
+import { quality } from './quality'
+import { HashPrefix } from './hash-prefixes'
+
+export {
+  hashes,
+  binary,
+  ledgerHashes,
+  Field,
+  TransactionType,
+  LedgerEntryType,
+  Type,
+  TransactionResult,
+  quality,
+  HashPrefix,
+  ShaMap,
+  types,
+}

packages/ripple-binary-codec/src/enums/README.md

@@ -0,0 +1,60 @@
+# Definitions
+
+## Types
+
+These are the [types](https://xrpl.org/serialization.html#type-list) associated with a given Serialization Field. Each type has an arbitrary [type_code](https://xrpl.org/serialization.html#type-codes), with lower codes sorting first.
+
+## Ledger Entry Types
+
+Each ledger's state tree contain [ledger objects](https://xrpl.org/ledger-object-types.html), which represent all settings, balances, and relationships in the shared ledger. 
+
+## Fields
+
+These are Serialization Fields (`sf`) [defined in rippled's SField.cpp](https://github.com/ripple/rippled/blob/develop/src/ripple/protocol/impl/SField.cpp). Fields with undefined values are omitted before encoding.
+
+### Key
+
+The key is the string defined in the rippled source code, such as "LedgerEntry", "Transaction", etc.
+
+### nth
+
+`nth` is the sort code, meaning "nth of type." It is is combined with the type code in order to construct the Field ID of this field. The Field ID is only used for sorting the fields. Since there are multiple fields with the same data type, the `nth` is used to deterministically order each field among other fields of the same data type.
+
+Each field has a Field ID, which is used to sort fields that have the same type as one another with lower codes sorting first.
+
+- [Field definitions](https://github.com/ripple/rippled/blob/72e6005f562a8f0818bc94803d222ac9345e1e40/src/ripple/protocol/impl/SField.cpp#L72-L266)
+- [Constructing the `SField` field codes](https://github.com/ripple/rippled/blob/eaff9a0e6aec0ad077f118501791c7684debcfd5/src/ripple/protocol/SField.h#L95-L98)
+
+For example, the `Account` field has sort code (nth) `1`, so it comes before the `Destination` field which has sort code `3`.
+
+Sort code numbers are reused for fields of different types, but different fields of the same type never have the same sort code. When you combine the type code with the sort code, you get the field's unique _Field ID_.
+
+The unique [Field ID](https://xrpl.org/serialization.html#field-ids) is prefixed before the field in the final serialized blob. The size of the Field ID is one to three bytes depending on the type code and the field codes it combines.
+
+### isVLEncoded
+
+If true, the field is Variable Length encoded and [length-prefixed](https://xrpl.org/serialization.html#length-prefixing). The variable-length encoded fields are `STI_VL`/`Blob`, `STI_ACCOUNT`/`AccountID`, and `STI_VECTOR256`/`Vector256`.
+
+### isSerialized
+
+Fields are serialized if they are not [one of these](https://github.com/ripple/rippled/blob/eaff9a0e6aec0ad077f118501791c7684debcfd5/src/ripple/protocol/impl/SField.cpp#L71-L78) or if they are not an SField.
+
+- https://github.com/ripple/ripple-binary-codec/blob/14e76e68ead7e4bcd83c942dbdc9064d5a66869b/src/enums/definitions.json#L832
+- https://github.com/ripple/rippled/search?utf8=%E2%9C%93&q=taker_gets_funded&type=
+
+### isSigningField
+
+True unless the field is [specified with `SField::notSigning`](https://github.com/ripple/rippled/blob/eaff9a0e6aec0ad077f118501791c7684debcfd5/src/ripple/protocol/impl/SField.cpp#L198).
+
+## Transaction Results
+
+See:
+
+- https://github.com/ripple/rippled/blob/develop/src/ripple/protocol/TER.h
+- https://xrpl.org/transaction-results.html
+
+TODO: Write a script to read rippled's source file and generate the necessary mapping.
+
+## Transaction Types
+
+See https://github.com/ripple/rippled/blob/develop/src/ripple/protocol/TxFormats.h

packages/ripple-binary-codec/src/enums/index.ts

@@ -0,0 +1,156 @@
+import * as enums from './definitions.json'
+import { SerializedType } from '../types/serialized-type'
+import { Buffer } from 'buffer/'
+
+const TYPE_WIDTH = 2
+const LEDGER_ENTRY_WIDTH = 2
+const TRANSACTION_TYPE_WIDTH = 2
+const TRANSACTION_RESULT_WIDTH = 1
+
+/*
+ * @brief: Serialize a field based on type_code and Field.nth
+ */
+function fieldHeader(type: number, nth: number): Buffer {
+  const header: Array<number> = []
+  if (type < 16) {
+    if (nth < 16) {
+      header.push((type << 4) | nth)
+    } else {
+      header.push(type << 4, nth)
+    }
+  } else if (nth < 16) {
+    header.push(nth, type)
+  } else {
+    header.push(0, type, nth)
+  }
+  return Buffer.from(header)
+}
+
+/*
+ * @brief: Bytes, name, and ordinal representing one type, ledger_type, transaction type, or result
+ */
+class Bytes {
+  readonly bytes: Uint8Array
+
+  constructor(
+    readonly name: string,
+    readonly ordinal: number,
+    readonly ordinalWidth: number,
+  ) {
+    this.bytes = Buffer.alloc(ordinalWidth)
+    for (let i = 0; i < ordinalWidth; i++) {
+      this.bytes[ordinalWidth - i - 1] = (ordinal >>> (i * 8)) & 0xff
+    }
+  }
+
+  toJSON(): string {
+    return this.name
+  }
+
+  toBytesSink(sink): void {
+    sink.put(this.bytes)
+  }
+
+  toBytes(): Uint8Array {
+    return this.bytes
+  }
+}
+
+/*
+ * @brief: Collection of Bytes objects, mapping bidirectionally
+ */
+class BytesLookup {
+  constructor(types: Record<string, number>, readonly ordinalWidth: number) {
+    Object.entries(types).forEach(([k, v]) => {
+      this[k] = new Bytes(k, v, ordinalWidth)
+      this[v.toString()] = this[k]
+    })
+  }
+
+  from(value: Bytes | string): Bytes {
+    return value instanceof Bytes ? value : (this[value] as Bytes)
+  }
+
+  fromParser(parser): Bytes {
+    return this.from(parser.readUIntN(this.ordinalWidth).toString())
+  }
+}
+
+/*
+ * type FieldInfo is the type of the objects containing information about each field in definitions.json
+ */
+interface FieldInfo {
+  nth: number
+  isVLEncoded: boolean
+  isSerialized: boolean
+  isSigningField: boolean
+  type: string
+}
+
+interface FieldInstance {
+  readonly nth: number
+  readonly isVariableLengthEncoded: boolean
+  readonly isSerialized: boolean
+  readonly isSigningField: boolean
+  readonly type: Bytes
+  readonly ordinal: number
+  readonly name: string
+  readonly header: Buffer
+  readonly associatedType: typeof SerializedType
+}
+
+function buildField([name, info]: [string, FieldInfo]): FieldInstance {
+  const typeOrdinal = enums.TYPES[info.type]
+  const field = fieldHeader(typeOrdinal, info.nth)
+  return {
+    name: name,
+    nth: info.nth,
+    isVariableLengthEncoded: info.isVLEncoded,
+    isSerialized: info.isSerialized,
+    isSigningField: info.isSigningField,
+    ordinal: (typeOrdinal << 16) | info.nth,
+    type: new Bytes(info.type, typeOrdinal, TYPE_WIDTH),
+    header: field,
+    associatedType: SerializedType, // For later assignment in ./types/index.js
+  }
+}
+
+/*
+ * @brief: The collection of all fields as defined in definitions.json
+ */
+class FieldLookup {
+  constructor(fields: Array<[string, FieldInfo]>) {
+    fields.forEach(([k, v]) => {
+      this[k] = buildField([k, v])
+      this[this[k].ordinal.toString()] = this[k]
+    })
+  }
+
+  fromString(value: string): FieldInstance {
+    return this[value] as FieldInstance
+  }
+}
+
+const Type = new BytesLookup(enums.TYPES, TYPE_WIDTH)
+const LedgerEntryType = new BytesLookup(
+  enums.LEDGER_ENTRY_TYPES,
+  LEDGER_ENTRY_WIDTH,
+)
+const TransactionType = new BytesLookup(
+  enums.TRANSACTION_TYPES,
+  TRANSACTION_TYPE_WIDTH,
+)
+const TransactionResult = new BytesLookup(
+  enums.TRANSACTION_RESULTS,
+  TRANSACTION_RESULT_WIDTH,
+)
+const Field = new FieldLookup(enums.FIELDS as Array<[string, FieldInfo]>)
+
+export {
+  Field,
+  FieldInstance,
+  Type,
+  LedgerEntryType,
+  TransactionResult,
+  TransactionType,
+}

packages/ripple-binary-codec/src/enums/utils-renumber.ts

@@ -0,0 +1,134 @@
+/**
+ * Quick script to re-number values
+ */
+
+const input = {
+  temBAD_SEND_XRP_PATHS: -283,
+  temBAD_SEQUENCE: -282,
+  temBAD_SIGNATURE: -281,
+  temBAD_SRC_ACCOUNT: -280,
+  temBAD_TRANSFER_RATE: -279,
+  temDST_IS_SRC: -278,
+  temDST_NEEDED: -277,
+  temINVALID: -276,
+  temINVALID_FLAG: -275,
+  temREDUNDANT: -274,
+  temRIPPLE_EMPTY: -273,
+  temDISABLED: -272,
+  temBAD_SIGNER: -271,
+  temBAD_QUORUM: -270,
+  temBAD_WEIGHT: -269,
+  temBAD_TICK_SIZE: -268,
+  temINVALID_ACCOUNT_ID: -267,
+  temCANNOT_PREAUTH_SELF: -266,
+
+  temUNCERTAIN: -265,
+  temUNKNOWN: -264,
+
+  tefFAILURE: -199,
+  tefALREADY: -198,
+  tefBAD_ADD_AUTH: -197,
+  tefBAD_AUTH: -196,
+  tefBAD_LEDGER: -195,
+  tefCREATED: -194,
+  tefEXCEPTION: -193,
+  tefINTERNAL: -192,
+  tefNO_AUTH_REQUIRED: -191,
+  tefPAST_SEQ: -190,
+  tefWRONG_PRIOR: -189,
+  tefMASTER_DISABLED: -188,
+  tefMAX_LEDGER: -187,
+  tefBAD_SIGNATURE: -186,
+  tefBAD_QUORUM: -185,
+  tefNOT_MULTI_SIGNING: -184,
+  tefBAD_AUTH_MASTER: -183,
+  tefINVARIANT_FAILED: -182,
+  tefTOO_BIG: -181,
+
+  terRETRY: -99,
+  terFUNDS_SPENT: -98,
+  terINSUF_FEE_B: -97,
+  terNO_ACCOUNT: -96,
+  terNO_AUTH: -95,
+  terNO_LINE: -94,
+  terOWNERS: -93,
+  terPRE_SEQ: -92,
+  terLAST: -91,
+  terNO_RIPPLE: -90,
+  terQUEUED: -89,
+
+  tesSUCCESS: 0,
+
+  tecCLAIM: 100,
+  tecPATH_PARTIAL: 101,
+  tecUNFUNDED_ADD: 102,
+  tecUNFUNDED_OFFER: 103,
+  tecUNFUNDED_PAYMENT: 104,
+  tecFAILED_PROCESSING: 105,
+  tecDIR_FULL: 121,
+  tecINSUF_RESERVE_LINE: 122,
+  tecINSUF_RESERVE_OFFER: 123,
+  tecNO_DST: 124,
+  tecNO_DST_INSUF_XRP: 125,
+  tecNO_LINE_INSUF_RESERVE: 126,
+  tecNO_LINE_REDUNDANT: 127,
+  tecPATH_DRY: 128,
+  tecUNFUNDED: 129,
+  tecNO_ALTERNATIVE_KEY: 130,
+  tecNO_REGULAR_KEY: 131,
+  tecOWNERS: 132,
+  tecNO_ISSUER: 133,
+  tecNO_AUTH: 134,
+  tecNO_LINE: 135,
+  tecINSUFF_FEE: 136,
+  tecFROZEN: 137,
+  tecNO_TARGET: 138,
+  tecNO_PERMISSION: 139,
+  tecNO_ENTRY: 140,
+  tecINSUFFICIENT_RESERVE: 141,
+  tecNEED_MASTER_KEY: 142,
+  tecDST_TAG_NEEDED: 143,
+  tecINTERNAL: 144,
+  tecOVERSIZE: 145,
+  tecCRYPTOCONDITION_ERROR: 146,
+  tecINVARIANT_FAILED: 147,
+  tecEXPIRED: 148,
+  tecDUPLICATE: 149,
+  tecKILLED: 150,
+  tecHAS_OBLIGATIONS: 151,
+  tecTOO_SOON: 152,
+}
+
+let startingFromTemBADSENDXRPPATHS = -284
+
+let startingFromTefFAILURE = -199
+
+let startingFromTerRETRY = -99
+
+const tesSUCCESS = 0
+
+let startingFromTecCLAIM = 100
+
+const startingFromTecDIRFULL = 121
+
+let previousKey = 'tem'
+Object.keys(input).forEach((key) => {
+  if (key.substring(0, 3) !== previousKey.substring(0, 3)) {
+    console.log()
+    previousKey = key
+  }
+  if (key.substring(0, 3) === 'tem') {
+    console.log(`    "${key}": ${startingFromTemBADSENDXRPPATHS++},`)
+  } else if (key.substring(0, 3) === 'tef') {
+    console.log(`    "${key}": ${startingFromTefFAILURE++},`)
+  } else if (key.substring(0, 3) === 'ter') {
+    console.log(`    "${key}": ${startingFromTerRETRY++},`)
+  } else if (key.substring(0, 3) === 'tes') {
+    console.log(`    "${key}": ${tesSUCCESS},`)
+  } else if (key.substring(0, 3) === 'tec') {
+    if (key === 'tecDIR_FULL') {
+      startingFromTecCLAIM = startingFromTecDIRFULL
+    }
+    console.log(`    "${key}": ${startingFromTecCLAIM++},`)
+  }
+})

packages/ripple-binary-codec/src/hash-prefixes.ts

@@ -0,0 +1,40 @@
+import { Buffer } from 'buffer/'
+
+/**
+ * Write a 32 bit integer to a Buffer
+ *
+ * @param uint32 32 bit integer to write to buffer
+ * @returns a buffer with the bytes representation of uint32
+ */
+function bytes(uint32: number): Buffer {
+  const result = Buffer.alloc(4)
+  result.writeUInt32BE(uint32, 0)
+  return result
+}
+
+/**
+ * Maps HashPrefix names to their byte representation
+ */
+const HashPrefix: Record<string, Buffer> = {
+  transactionID: bytes(0x54584e00),
+  // transaction plus metadata
+  transaction: bytes(0x534e4400),
+  // account state
+  accountStateEntry: bytes(0x4d4c4e00),
+  // inner node in tree
+  innerNode: bytes(0x4d494e00),
+  // ledger master data for signing
+  ledgerHeader: bytes(0x4c575200),
+  // inner transaction to sign
+  transactionSig: bytes(0x53545800),
+  // inner transaction to sign
+  transactionMultiSig: bytes(0x534d5400),
+  // validation for signing
+  validation: bytes(0x56414c00),
+  // proposal for signing
+  proposal: bytes(0x50525000),
+  // payment channel claim
+  paymentChannelClaim: bytes(0x434c4d00),
+}
+
+export { HashPrefix }

packages/ripple-binary-codec/src/hashes.ts

@@ -0,0 +1,77 @@
+import { HashPrefix } from './hash-prefixes'
+import * as createHash from 'create-hash'
+import { Hash256 } from './types/hash-256'
+import { BytesList } from './serdes/binary-serializer'
+import { Buffer } from 'buffer/'
+
+/**
+ * Class for hashing with SHA512
+ * @extends BytesList So SerializedTypes can write bytes to a Sha512Half
+ */
+class Sha512Half extends BytesList {
+  private hash: createHash = createHash('sha512')
+
+  /**
+   * Construct a new Sha512Hash and write bytes this.hash
+   *
+   * @param bytes bytes to write to this.hash
+   * @returns the new Sha512Hash object
+   */
+  static put(bytes: Buffer): Sha512Half {
+    return new Sha512Half().put(bytes)
+  }
+
+  /**
+   * Write bytes to an existing Sha512Hash
+   *
+   * @param bytes bytes to write to object
+   * @returns the Sha512 object
+   */
+  put(bytes: Buffer): Sha512Half {
+    this.hash.update(bytes)
+    return this
+  }
+
+  /**
+   * Compute SHA512 hash and slice in half
+   *
+   * @returns half of a SHA512 hash
+   */
+  finish256(): Buffer {
+    const bytes: Buffer = this.hash.digest()
+    return bytes.slice(0, 32)
+  }
+
+  /**
+   * Constructs a Hash256 from the Sha512Half object
+   *
+   * @returns a Hash256 object
+   */
+  finish(): Hash256 {
+    return new Hash256(this.finish256())
+  }
+}
+
+/**
+ * compute SHA512 hash of a list of bytes
+ *
+ * @param args zero or more arguments to hash
+ * @returns the sha512half hash of the arguments.
+ */
+function sha512Half(...args: Buffer[]): Buffer {
+  const hash = new Sha512Half()
+  args.forEach((a) => hash.put(a))
+  return hash.finish256()
+}
+
+/**
+ * Construct a transactionID from a Serialized Transaction
+ *
+ * @param serialized bytes to hash
+ * @returns a Hash256 object
+ */
+function transactionID(serialized: Buffer): Hash256 {
+  return new Hash256(sha512Half(HashPrefix.transactionID, serialized))
+}
+
+export { Sha512Half, sha512Half, transactionID }

packages/ripple-binary-codec/src/index.ts

@@ -0,0 +1,112 @@
+import * as assert from 'assert'
+import { quality, binary } from './coretypes'
+import { decodeLedgerData } from './ledger-hashes'
+import { ClaimObject } from './binary'
+import { JsonObject } from './types/serialized-type'
+const {
+  signingData,
+  signingClaimData,
+  multiSigningData,
+  binaryToJSON,
+  serializeObject,
+} = binary
+
+/**
+ * Decode a transaction
+ *
+ * @param binary hex-string of the encoded transaction
+ * @returns the JSON representation of the transaction
+ */
+function decode(binary: string): JsonObject {
+  assert.ok(typeof binary === 'string', 'binary must be a hex string')
+  return binaryToJSON(binary)
+}
+
+/**
+ * Encode a transaction
+ *
+ * @param json The JSON representation of a transaction
+ * @returns A hex-string of the encoded transaction
+ */
+function encode(json: object): string {
+  assert.ok(typeof json === 'object')
+  return serializeObject(json as JsonObject)
+    .toString('hex')
+    .toUpperCase()
+}
+
+/**
+ * Encode a transaction and prepare for signing
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForSigning(json: object): string {
+  assert.ok(typeof json === 'object')
+  return signingData(json as JsonObject)
+    .toString('hex')
+    .toUpperCase()
+}
+
+/**
+ * Encode a transaction and prepare for signing with a claim
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForSigningClaim(json: object): string {
+  assert.ok(typeof json === 'object')
+  return signingClaimData(json as ClaimObject)
+    .toString('hex')
+    .toUpperCase()
+}
+
+/**
+ * Encode a transaction and prepare for multi-signing
+ *
+ * @param json JSON object representing the transaction
+ * @param signer string representing the account to sign the transaction with
+ * @returns a hex string of the encoded transaction
+ */
+function encodeForMultisigning(json: object, signer: string): string {
+  assert.ok(typeof json === 'object')
+  assert.equal(json['SigningPubKey'], '')
+  return multiSigningData(json as JsonObject, signer)
+    .toString('hex')
+    .toUpperCase()
+}
+
+/**
+ * Encode a quality value
+ *
+ * @param value string representation of a number
+ * @returns a hex-string representing the quality
+ */
+function encodeQuality(value: string): string {
+  assert.ok(typeof value === 'string')
+  return quality.encode(value).toString('hex').toUpperCase()
+}
+
+/**
+ * Decode a quality value
+ *
+ * @param value hex-string of a quality
+ * @returns a string representing the quality
+ */
+function decodeQuality(value: string): string {
+  assert.ok(typeof value === 'string')
+  return quality.decode(value).toString()
+}
+
+export = {
+  decode,
+  encode,
+  encodeForSigning,
+  encodeForSigningClaim,
+  encodeForMultisigning,
+  encodeQuality,
+  decodeQuality,
+  decodeLedgerData,
+}

packages/ripple-binary-codec/src/ledger-hashes.ts

@@ -0,0 +1,181 @@
+import * as assert from 'assert'
+import { ShaMap, ShaMapNode, ShaMapLeaf } from './shamap'
+import { HashPrefix } from './hash-prefixes'
+import { Sha512Half } from './hashes'
+import { BinarySerializer, serializeObject } from './binary'
+import { Hash256 } from './types/hash-256'
+import { STObject } from './types/st-object'
+import { UInt64 } from './types/uint-64'
+import { UInt32 } from './types/uint-32'
+import { UInt8 } from './types/uint-8'
+import { BinaryParser } from './serdes/binary-parser'
+import { JsonObject } from './types/serialized-type'
+import * as bigInt from 'big-integer'
+
+/**
+ * Computes the hash of a list of objects
+ *
+ * @param itemizer Converts an item into a format that can be added to SHAMap
+ * @param itemsJson Array of items to add to a SHAMap
+ * @returns the hash of the SHAMap
+ */
+function computeHash(
+  itemizer: (item: JsonObject) => [Hash256?, ShaMapNode?, ShaMapLeaf?],
+  itemsJson: Array<JsonObject>,
+): Hash256 {
+  const map = new ShaMap()
+  itemsJson.forEach((item) => map.addItem(...itemizer(item)))
+  return map.hash()
+}
+
+/**
+ * Interface describing a transaction item
+ */
+interface transactionItemObject extends JsonObject {
+  hash: string
+  metaData: JsonObject
+}
+
+/**
+ * Convert a transaction into an index and an item
+ *
+ * @param json transaction with metadata
+ * @returns a tuple of index and item to be added to SHAMap
+ */
+function transactionItemizer(
+  json: transactionItemObject,
+): [Hash256, ShaMapNode, undefined] {
+  assert.ok(json.hash)
+  const index = Hash256.from(json.hash)
+  const item = {
+    hashPrefix() {
+      return HashPrefix.transaction
+    },
+    toBytesSink(sink) {
+      const serializer = new BinarySerializer(sink)
+      serializer.writeLengthEncoded(STObject.from(json))
+      serializer.writeLengthEncoded(STObject.from(json.metaData))
+    },
+  } as ShaMapNode
+  return [index, item, undefined]
+}
+
+/**
+ * Interface describing an entry item
+ */
+interface entryItemObject extends JsonObject {
+  index: string
+}
+
+/**
+ * Convert an entry to a pair Hash256 and ShaMapNode
+ *
+ * @param json JSON describing a ledger entry item
+ * @returns a tuple of index and item to be added to SHAMap
+ */
+function entryItemizer(
+  json: entryItemObject,
+): [Hash256, ShaMapNode, undefined] {
+  const index = Hash256.from(json.index)
+  const bytes = serializeObject(json)
+  const item = {
+    hashPrefix() {
+      return HashPrefix.accountStateEntry
+    },
+    toBytesSink(sink) {
+      sink.put(bytes)
+    },
+  } as ShaMapNode
+  return [index, item, undefined]
+}
+
+/**
+ * Function computing the hash of a transaction tree
+ *
+ * @param param An array of transaction objects to hash
+ * @returns A Hash256 object
+ */
+function transactionTreeHash(param: Array<JsonObject>): Hash256 {
+  const itemizer = transactionItemizer as (
+    json: JsonObject,
+  ) => [Hash256, ShaMapNode, undefined]
+  return computeHash(itemizer, param)
+}
+
+/**
+ * Function computing the hash of accountState
+ *
+ * @param param A list of accountStates hash
+ * @returns A Hash256 object
+ */
+function accountStateHash(param: Array<JsonObject>): Hash256 {
+  const itemizer = entryItemizer as (
+    json: JsonObject,
+  ) => [Hash256, ShaMapNode, undefined]
+  return computeHash(itemizer, param)
+}
+
+/**
+ * Interface describing a ledger header
+ */
+interface ledgerObject {
+  ledger_index: number
+  total_coins: string | number | bigInt.BigInteger
+  parent_hash: string
+  transaction_hash: string
+  account_hash: string
+  parent_close_time: number
+  close_time: number
+  close_time_resolution: number
+  close_flags: number
+}
+
+/**
+ * Serialize and hash a ledger header
+ *
+ * @param header a ledger header
+ * @returns the hash of header
+ */
+function ledgerHash(header: ledgerObject): Hash256 {
+  const hash = new Sha512Half()
+  hash.put(HashPrefix.ledgerHeader)
+  assert.ok(header.parent_close_time !== undefined)
+  assert.ok(header.close_flags !== undefined)
+
+  UInt32.from<number>(header.ledger_index).toBytesSink(hash)
+  UInt64.from<bigInt.BigInteger>(
+    bigInt(String(header.total_coins)),
+  ).toBytesSink(hash)
+  Hash256.from<string>(header.parent_hash).toBytesSink(hash)
+  Hash256.from<string>(header.transaction_hash).toBytesSink(hash)
+  Hash256.from<string>(header.account_hash).toBytesSink(hash)
+  UInt32.from<number>(header.parent_close_time).toBytesSink(hash)
+  UInt32.from<number>(header.close_time).toBytesSink(hash)
+  UInt8.from<number>(header.close_time_resolution).toBytesSink(hash)
+  UInt8.from<number>(header.close_flags).toBytesSink(hash)
+  return hash.finish()
+}
+
+/**
+ * Decodes a serialized ledger header
+ *
+ * @param binary A serialized ledger header
+ * @returns A JSON object describing a ledger header
+ */
+function decodeLedgerData(binary: string): object {
+  assert.ok(typeof binary === 'string', 'binary must be a hex string')
+  const parser = new BinaryParser(binary)
+  return {
+    ledger_index: parser.readUInt32(),
+    total_coins: parser.readType(UInt64).valueOf().toString(),
+    parent_hash: parser.readType(Hash256).toHex(),
+    transaction_hash: parser.readType(Hash256).toHex(),
+    account_hash: parser.readType(Hash256).toHex(),
+    parent_close_time: parser.readUInt32(),
+    close_time: parser.readUInt32(),
+    close_time_resolution: parser.readUInt8(),
+    close_flags: parser.readUInt8(),
+  }
+}
+
+export { accountStateHash, transactionTreeHash, ledgerHash, decodeLedgerData }

packages/ripple-binary-codec/src/quality.ts

@@ -0,0 +1,39 @@
+import { coreTypes } from './types'
+import { Decimal } from 'decimal.js'
+import * as bigInt from 'big-integer'
+import { Buffer } from 'buffer/'
+
+/**
+ * class for encoding and decoding quality
+ */
+class quality {
+  /**
+   * Encode quality amount
+   *
+   * @param arg string representation of an amount
+   * @returns Serialized quality
+   */
+  static encode(quality: string): Buffer {
+    const decimal = new Decimal(quality)
+    const exponent = decimal.e - 15
+    const qualityString = decimal.times(`1e${-exponent}`).abs().toString()
+    const bytes = coreTypes.UInt64.from(bigInt(qualityString)).toBytes()
+    bytes[0] = exponent + 100
+    return bytes
+  }
+
+  /**
+   * Decode quality amount
+   *
+   * @param arg hex-string denoting serialized quality
+   * @returns deserialized quality
+   */
+  static decode(quality: string): Decimal {
+    const bytes = Buffer.from(quality, 'hex').slice(-8)
+    const exponent = bytes[0] - 100
+    const mantissa = new Decimal(`0x${bytes.slice(1).toString('hex')}`)
+    return mantissa.times(`1e${exponent}`)
+  }
+}
+
+export { quality }

packages/ripple-binary-codec/src/serdes/binary-parser.ts

@@ -0,0 +1,206 @@
+import * as assert from 'assert'
+import { Field, FieldInstance } from '../enums'
+import { SerializedType } from '../types/serialized-type'
+import { Buffer } from 'buffer/'
+
+/**
+ * BinaryParser is used to compute fields and values from a HexString
+ */
+class BinaryParser {
+  private bytes: Buffer
+
+  /**
+   * Initialize bytes to a hex string
+   *
+   * @param hexBytes a hex string
+   */
+  constructor(hexBytes: string) {
+    this.bytes = Buffer.from(hexBytes, 'hex')
+  }
+
+  /**
+   * Peek the first byte of the BinaryParser
+   *
+   * @returns The first byte of the BinaryParser
+   */
+  peek(): number {
+    assert.ok(this.bytes.byteLength !== 0)
+    return this.bytes[0]
+  }
+
+  /**
+   * Consume the first n bytes of the BinaryParser
+   *
+   * @param n the number of bytes to skip
+   */
+  skip(n: number): void {
+    assert.ok(n <= this.bytes.byteLength)
+    this.bytes = this.bytes.slice(n)
+  }
+
+  /**
+   * read the first n bytes from the BinaryParser
+   *
+   * @param n The number of bytes to read
+   * @return The bytes
+   */
+  read(n: number): Buffer {
+    assert.ok(n <= this.bytes.byteLength)
+
+    const slice = this.bytes.slice(0, n)
+    this.skip(n)
+    return slice
+  }
+
+  /**
+   * Read an integer of given size
+   *
+   * @param n The number of bytes to read
+   * @return The number represented by those bytes
+   */
+  readUIntN(n: number): number {
+    assert.ok(0 < n && n <= 4, 'invalid n')
+    return this.read(n).reduce((a, b) => (a << 8) | b) >>> 0
+  }
+
+  readUInt8(): number {
+    return this.readUIntN(1)
+  }
+
+  readUInt16(): number {
+    return this.readUIntN(2)
+  }
+
+  readUInt32(): number {
+    return this.readUIntN(4)
+  }
+
+  size(): number {
+    return this.bytes.byteLength
+  }
+
+  end(customEnd?: number): boolean {
+    const length = this.bytes.byteLength
+    return length === 0 || (customEnd !== undefined && length <= customEnd)
+  }
+
+  /**
+   * Reads variable length encoded bytes
+   *
+   * @return The variable length bytes
+   */
+  readVariableLength(): Buffer {
+    return this.read(this.readVariableLengthLength())
+  }
+
+  /**
+   * Reads the length of the variable length encoded bytes
+   *
+   * @return The length of the variable length encoded bytes
+   */
+  readVariableLengthLength(): number {
+    const b1 = this.readUInt8()
+    if (b1 <= 192) {
+      return b1
+    } else if (b1 <= 240) {
+      const b2 = this.readUInt8()
+      return 193 + (b1 - 193) * 256 + b2
+    } else if (b1 <= 254) {
+      const b2 = this.readUInt8()
+      const b3 = this.readUInt8()
+      return 12481 + (b1 - 241) * 65536 + b2 * 256 + b3
+    }
+    throw new Error('Invalid variable length indicator')
+  }
+
+  /**
+   * Reads the field ordinal from the BinaryParser
+   *
+   * @return Field ordinal
+   */
+  readFieldOrdinal(): number {
+    let type = this.readUInt8()
+    let nth = type & 15
+    type >>= 4
+
+    if (type === 0) {
+      type = this.readUInt8()
+      if (type === 0 || type < 16) {
+        throw new Error('Cannot read FieldOrdinal, type_code out of range')
+      }
+    }
+
+    if (nth === 0) {
+      nth = this.readUInt8()
+      if (nth === 0 || nth < 16) {
+        throw new Error('Cannot read FieldOrdinal, field_code out of range')
+      }
+    }
+
+    return (type << 16) | nth
+  }
+
+  /**
+   * Read the field from the BinaryParser
+   *
+   * @return The field represented by the bytes at the head of the BinaryParser
+   */
+  readField(): FieldInstance {
+    return Field.fromString(this.readFieldOrdinal().toString())
+  }
+
+  /**
+   * Read a given type from the BinaryParser
+   *
+   * @param type The type that you want to read from the BinaryParser
+   * @return The instance of that type read from the BinaryParser
+   */
+  readType(type: typeof SerializedType): SerializedType {
+    return type.fromParser(this)
+  }
+
+  /**
+   * Get the type associated with a given field
+   *
+   * @param field The field that you wan to get the type of
+   * @return The type associated with the given field
+   */
+  typeForField(field: FieldInstance): typeof SerializedType {
+    return field.associatedType
+  }
+
+  /**
+   * Read value of the type specified by field from the BinaryParser
+   *
+   * @param field The field that you want to get the associated value for
+   * @return The value associated with the given field
+   */
+  readFieldValue(field: FieldInstance): SerializedType {
+    const type = this.typeForField(field)
+    if (!type) {
+      throw new Error(`unsupported: (${field.name}, ${field.type.name})`)
+    }
+    const sizeHint = field.isVariableLengthEncoded
+      ? this.readVariableLengthLength()
+      : undefined
+    const value = type.fromParser(this, sizeHint)
+    if (value === undefined) {
+      throw new Error(
+        `fromParser for (${field.name}, ${field.type.name}) -> undefined `,
+      )
+    }
+    return value
+  }
+
+  /**
+   * Get the next field and value from the BinaryParser
+   *
+   * @return The field and value
+   */
+  readFieldAndValue(): [FieldInstance, SerializedType] {
+    const field = this.readField()
+    return [field, this.readFieldValue(field)]
+  }
+}
+
+export { BinaryParser }

packages/ripple-binary-codec/src/serdes/binary-serializer.ts

@@ -0,0 +1,156 @@
+import * as assert from 'assert'
+import { FieldInstance } from '../enums'
+import { SerializedType } from '../types/serialized-type'
+import { Buffer } from 'buffer/'
+
+/**
+ * Bytes list is a collection of buffer objects
+ */
+class BytesList {
+  private bytesArray: Array<Buffer> = []
+
+  /**
+   * Get the total number of bytes in the BytesList
+   *
+   * @return the number of bytes
+   */
+  public getLength(): number {
+    return Buffer.concat(this.bytesArray).byteLength
+  }
+
+  /**
+   * Put bytes in the BytesList
+   *
+   * @param bytesArg A Buffer
+   * @return this BytesList
+   */
+  public put(bytesArg: Buffer): BytesList {
+    const bytes = Buffer.from(bytesArg) // Temporary, to catch instances of Uint8Array being passed in
+    this.bytesArray.push(bytes)
+    return this
+  }
+
+  /**
+   * Write this BytesList to the back of another bytes list
+   *
+   *  @param list The BytesList to write to
+   */
+  public toBytesSink(list: BytesList): void {
+    list.put(this.toBytes())
+  }
+
+  public toBytes(): Buffer {
+    return Buffer.concat(this.bytesArray)
+  }
+
+  toHex(): string {
+    return this.toBytes().toString('hex').toUpperCase()
+  }
+}
+
+/**
+ * BinarySerializer is used to write fields and values to buffers
+ */
+class BinarySerializer {
+  private sink: BytesList = new BytesList()
+
+  constructor(sink: BytesList) {
+    this.sink = sink
+  }
+
+  /**
+   * Write a value to this BinarySerializer
+   *
+   * @param value a SerializedType value
+   */
+  write(value: SerializedType): void {
+    value.toBytesSink(this.sink)
+  }
+
+  /**
+   * Write bytes to this BinarySerializer
+   *
+   * @param bytes the bytes to write
+   */
+  put(bytes: Buffer): void {
+    this.sink.put(bytes)
+  }
+
+  /**
+   * Write a value of a given type to this BinarySerializer
+   *
+   * @param type the type to write
+   * @param value a value of that type
+   */
+  writeType(type: typeof SerializedType, value: SerializedType): void {
+    this.write(type.from(value))
+  }
+
+  /**
+   * Write BytesList to this BinarySerializer
+   *
+   * @param bl BytesList to write to BinarySerializer
+   */
+  writeBytesList(bl: BytesList): void {
+    bl.toBytesSink(this.sink)
+  }
+
+  /**
+   * Calculate the header of Variable Length encoded bytes
+   *
+   * @param length the length of the bytes
+   */
+  private encodeVariableLength(length: number): Buffer {
+    const lenBytes = Buffer.alloc(3)
+    if (length <= 192) {
+      lenBytes[0] = length
+      return lenBytes.slice(0, 1)
+    } else if (length <= 12480) {
+      length -= 193
+      lenBytes[0] = 193 + (length >>> 8)
+      lenBytes[1] = length & 0xff
+      return lenBytes.slice(0, 2)
+    } else if (length <= 918744) {
+      length -= 12481
+      lenBytes[0] = 241 + (length >>> 16)
+      lenBytes[1] = (length >> 8) & 0xff
+      lenBytes[2] = length & 0xff
+      return lenBytes.slice(0, 3)
+    }
+    throw new Error('Overflow error')
+  }
+
+  /**
+   * Write field and value to BinarySerializer
+   *
+   * @param field field to write to BinarySerializer
+   * @param value value to write to BinarySerializer
+   */
+  writeFieldAndValue(field: FieldInstance, value: SerializedType): void {
+    const associatedValue = field.associatedType.from(value)
+    assert.ok(associatedValue.toBytesSink !== undefined)
+    assert.ok(field.name !== undefined)
+
+    this.sink.put(field.header)
+
+    if (field.isVariableLengthEncoded) {
+      this.writeLengthEncoded(associatedValue)
+    } else {
+      associatedValue.toBytesSink(this.sink)
+    }
+  }
+
+  /**
+   * Write a variable length encoded value to the BinarySerializer
+   *
+   * @param value length encoded value to write to BytesList
+   */
+  public writeLengthEncoded(value: SerializedType): void {
+    const bytes = new BytesList()
+    value.toBytesSink(bytes)
+    this.put(this.encodeVariableLength(bytes.getLength()))
+    this.writeBytesList(bytes)
+  }
+}
+
+export { BytesList, BinarySerializer }

packages/ripple-binary-codec/src/shamap.ts

@@ -0,0 +1,182 @@
+import { strict as assert } from 'assert'
+import { coreTypes } from './types'
+import { HashPrefix } from './hash-prefixes'
+import { Sha512Half } from './hashes'
+import { Hash256 } from './types/hash-256'
+import { BytesList } from './serdes/binary-serializer'
+import { Buffer } from 'buffer/'
+
+/**
+ * Abstract class describing a SHAMapNode
+ */
+abstract class ShaMapNode {
+  abstract hashPrefix(): Buffer
+  abstract isLeaf(): boolean
+  abstract isInner(): boolean
+  abstract toBytesSink(list: BytesList): void
+  abstract hash(): Hash256
+}
+
+/**
+ * Class describing a Leaf of SHAMap
+ */
+class ShaMapLeaf extends ShaMapNode {
+  constructor(public index: Hash256, public item?: ShaMapNode) {
+    super()
+  }
+
+  /**
+   * @returns true as ShaMapLeaf is a leaf node
+   */
+  isLeaf(): boolean {
+    return true
+  }
+
+  /**
+   * @returns false as ShaMapLeaf is not an inner node
+   */
+  isInner(): boolean {
+    return false
+  }
+
+  /**
+   * Get the prefix of the this.item
+   *
+   * @returns The hash prefix, unless this.item is undefined, then it returns an empty Buffer
+   */
+  hashPrefix(): Buffer {
+    return this.item === undefined ? Buffer.alloc(0) : this.item.hashPrefix()
+  }
+
+  /**
+   * Hash the bytes representation of this
+   *
+   * @returns hash of this.item concatenated with this.index
+   */
+  hash(): Hash256 {
+    const hash = Sha512Half.put(this.hashPrefix())
+    this.toBytesSink(hash)
+    return hash.finish()
+  }
+
+  /**
+   * Write the bytes representation of this to a BytesList
+   * @param list BytesList to write bytes to
+   */
+  toBytesSink(list: BytesList): void {
+    if (this.item !== undefined) {
+      this.item.toBytesSink(list)
+    }
+    this.index.toBytesSink(list)
+  }
+}
+
+/**
+ * Class defining an Inner Node of a SHAMap
+ */
+class ShaMapInner extends ShaMapNode {
+  private slotBits = 0
+  private branches: Array<ShaMapNode> = Array(16)
+
+  constructor(private depth: number = 0) {
+    super()
+  }
+
+  /**
+   * @returns true as ShaMapInner is an inner node
+   */
+  isInner(): boolean {
+    return true
+  }
+
+  /**
+   * @returns false as ShaMapInner is not a leaf node
+   */
+  isLeaf(): boolean {
+    return false
+  }
+
+  /**
+   * Get the hash prefix for this node
+   *
+   * @returns hash prefix describing an inner node
+   */
+  hashPrefix(): Buffer {
+    return HashPrefix.innerNode
+  }
+
+  /**
+   * Set a branch of this node to be another node
+   *
+   * @param slot Slot to add branch to this.branches
+   * @param branch Branch to add
+   */
+  setBranch(slot: number, branch: ShaMapNode): void {
+    this.slotBits = this.slotBits | (1 << slot)
+    this.branches[slot] = branch
+  }
+
+  /**
+   * @returns true if node is empty
+   */
+  empty(): boolean {
+    return this.slotBits === 0
+  }
+
+  /**
+   * Compute the hash of this node
+   *
+   * @returns The hash of this node
+   */
+  hash(): Hash256 {
+    if (this.empty()) {
+      return coreTypes.Hash256.ZERO_256
+    }
+    const hash = Sha512Half.put(this.hashPrefix())
+    this.toBytesSink(hash)
+    return hash.finish()
+  }
+
+  /**
+   * Writes the bytes representation of this node to a BytesList
+   *
+   * @param list BytesList to write bytes to
+   */
+  toBytesSink(list: BytesList): void {
+    for (let i = 0; i < this.branches.length; i++) {
+      const branch = this.branches[i]
+      const hash = branch ? branch.hash() : coreTypes.Hash256.ZERO_256
+      hash.toBytesSink(list)
+    }
+  }
+
+  /**
+   * Add item to the SHAMap
+   *
+   * @param index Hash of the index of the item being inserted
+   * @param item Item to insert in the map
+   * @param leaf Leaf node to insert when branch doesn't exist
+   */
+  addItem(index?: Hash256, item?: ShaMapNode, leaf?: ShaMapLeaf): void {
+    assert.ok(index !== undefined)
+    const nibble = index.nibblet(this.depth)
+    const existing = this.branches[nibble]
+
+    if (existing === undefined) {
+      this.setBranch(nibble, leaf || new ShaMapLeaf(index, item))
+    } else if (existing instanceof ShaMapLeaf) {
+      const newInner = new ShaMapInner(this.depth + 1)
+      newInner.addItem(existing.index, undefined, existing)
+      newInner.addItem(index, item, leaf)
+      this.setBranch(nibble, newInner)
+    } else if (existing instanceof ShaMapInner) {
+      existing.addItem(index, item, leaf)
+    } else {
+      throw new Error('invalid ShaMap.addItem call')
+    }
+  }
+}
+
+class ShaMap extends ShaMapInner {}
+
+export { ShaMap, ShaMapNode, ShaMapLeaf }

packages/ripple-binary-codec/src/types/account-id.ts

@@ -0,0 +1,86 @@
+import {
+  decodeAccountID,
+  encodeAccountID,
+  isValidXAddress,
+  xAddressToClassicAddress,
+} from 'ripple-address-codec'
+import { Hash160 } from './hash-160'
+import { Buffer } from 'buffer/'
+
+const HEX_REGEX = /^[A-F0-9]{40}$/
+
+/**
+ * Class defining how to encode and decode an AccountID
+ */
+class AccountID extends Hash160 {
+  static readonly defaultAccountID: AccountID = new AccountID(Buffer.alloc(20))
+
+  constructor(bytes?: Buffer) {
+    super(bytes ?? AccountID.defaultAccountID.bytes)
+  }
+
+  /**
+   * Defines how to construct an AccountID
+   *
+   * @param value either an existing AccountID, a hex-string, or a base58 r-Address
+   * @returns an AccountID object
+   */
+  static from<T extends Hash160 | string>(value: T): AccountID {
+    if (value instanceof AccountID) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      if (value === '') {
+        return new AccountID()
+      }
+
+      return HEX_REGEX.test(value)
+        ? new AccountID(Buffer.from(value, 'hex'))
+        : this.fromBase58(value)
+    }
+
+    throw new Error('Cannot construct AccountID from value given')
+  }
+
+  /**
+   * Defines how to build an AccountID from a base58 r-Address
+   *
+   * @param value a base58 r-Address
+   * @returns an AccountID object
+   */
+  static fromBase58(value: string): AccountID {
+    if (isValidXAddress(value)) {
+      const classic = xAddressToClassicAddress(value)
+
+      if (classic.tag !== false)
+        throw new Error('Only allowed to have tag on Account or Destination')
+
+      value = classic.classicAddress
+    }
+
+    return new AccountID(Buffer.from(decodeAccountID(value)))
+  }
+
+  /**
+   * Overload of toJSON
+   *
+   * @returns the base58 string for this AccountID
+   */
+  toJSON(): string {
+    return this.toBase58()
+  }
+
+  /**
+   * Defines how to encode AccountID into a base58 address
+   *
+   * @returns the base58 string defined by this.bytes
+   */
+  toBase58(): string {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    return encodeAccountID(this.bytes as any)
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+  }
+}
+
+export { AccountID }

packages/ripple-binary-codec/src/types/amount.ts

@@ -0,0 +1,256 @@
+import { Decimal } from 'decimal.js'
+
+import { BinaryParser } from '../serdes/binary-parser'
+
+import { AccountID } from './account-id'
+import { Currency } from './currency'
+import { JsonObject, SerializedType } from './serialized-type'
+import * as bigInt from 'big-integer'
+import { Buffer } from 'buffer/'
+
+/**
+ * Constants for validating amounts
+ */
+const MIN_IOU_EXPONENT = -96
+const MAX_IOU_EXPONENT = 80
+const MAX_IOU_PRECISION = 16
+const MAX_DROPS = new Decimal('1e17')
+const MIN_XRP = new Decimal('1e-6')
+const mask = bigInt(0x00000000ffffffff)
+
+/**
+ * decimal.js configuration for Amount IOUs
+ */
+Decimal.config({
+  toExpPos: MAX_IOU_EXPONENT + MAX_IOU_PRECISION,
+  toExpNeg: MIN_IOU_EXPONENT - MAX_IOU_PRECISION,
+})
+
+/**
+ * Interface for JSON objects that represent amounts
+ */
+interface AmountObject extends JsonObject {
+  value: string
+  currency: string
+  issuer: string
+}
+
+/**
+ * Type guard for AmountObject
+ */
+function isAmountObject(arg): arg is AmountObject {
+  const keys = Object.keys(arg).sort()
+  return (
+    keys.length === 3 &&
+    keys[0] === 'currency' &&
+    keys[1] === 'issuer' &&
+    keys[2] === 'value'
+  )
+}
+
+/**
+ * Class for serializing/Deserializing Amounts
+ */
+class Amount extends SerializedType {
+  static defaultAmount: Amount = new Amount(
+    Buffer.from('4000000000000000', 'hex'),
+  )
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? Amount.defaultAmount.bytes)
+  }
+
+  /**
+   * Construct an amount from an IOU or string amount
+   *
+   * @param value An Amount, object representing an IOU, or a string
+   *     representing an integer amount
+   * @returns An Amount object
+   */
+  static from<T extends Amount | AmountObject | string>(value: T): Amount {
+    if (value instanceof Amount) {
+      return value
+    }
+
+    let amount = Buffer.alloc(8)
+    if (typeof value === 'string') {
+      Amount.assertXrpIsValid(value)
+
+      const number = bigInt(value)
+
+      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
+      intBuf[0].writeUInt32BE(Number(number.shiftRight(32)), 0)
+      intBuf[1].writeUInt32BE(Number(number.and(mask)), 0)
+
+      amount = Buffer.concat(intBuf)
+
+      amount[0] |= 0x40
+
+      return new Amount(amount)
+    }
+
+    if (isAmountObject(value)) {
+      const number = new Decimal(value.value)
+      Amount.assertIouIsValid(number)
+
+      if (number.isZero()) {
+        amount[0] |= 0x80
+      } else {
+        const integerNumberString = number
+          .times(`1e${-(number.e - 15)}`)
+          .abs()
+          .toString()
+
+        const num = bigInt(integerNumberString)
+        const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
+        intBuf[0].writeUInt32BE(Number(num.shiftRight(32)), 0)
+        intBuf[1].writeUInt32BE(Number(num.and(mask)), 0)
+
+        amount = Buffer.concat(intBuf)
+
+        amount[0] |= 0x80
+
+        if (number.gt(new Decimal(0))) {
+          amount[0] |= 0x40
+        }
+
+        const exponent = number.e - 15
+        const exponentByte = 97 + exponent
+        amount[0] |= exponentByte >>> 2
+        amount[1] |= (exponentByte & 0x03) << 6
+      }
+
+      const currency = Currency.from(value.currency).toBytes()
+      const issuer = AccountID.from(value.issuer).toBytes()
+      return new Amount(Buffer.concat([amount, currency, issuer]))
+    }
+
+    throw new Error('Invalid type to construct an Amount')
+  }
+
+  /**
+   * Read an amount from a BinaryParser
+   *
+   * @param parser BinaryParser to read the Amount from
+   * @returns An Amount object
+   */
+  static fromParser(parser: BinaryParser): Amount {
+    const isXRP = parser.peek() & 0x80
+    const numBytes = isXRP ? 48 : 8
+    return new Amount(parser.read(numBytes))
+  }
+
+  /**
+   * Get the JSON representation of this Amount
+   *
+   * @returns the JSON interpretation of this.bytes
+   */
+  toJSON(): AmountObject | string {
+    if (this.isNative()) {
+      const bytes = this.bytes
+      const isPositive = bytes[0] & 0x40
+      const sign = isPositive ? '' : '-'
+      bytes[0] &= 0x3f
+
+      const msb = bigInt(bytes.slice(0, 4).readUInt32BE(0))
+      const lsb = bigInt(bytes.slice(4).readUInt32BE(0))
+      const num = msb.shiftLeft(32).or(lsb)
+
+      return `${sign}${num.toString()}`
+    } else {
+      const parser = new BinaryParser(this.toString())
+      const mantissa = parser.read(8)
+      const currency = Currency.fromParser(parser) as Currency
+      const issuer = AccountID.fromParser(parser) as AccountID
+
+      const b1 = mantissa[0]
+      const b2 = mantissa[1]
+
+      const isPositive = b1 & 0x40
+      const sign = isPositive ? '' : '-'
+      const exponent = ((b1 & 0x3f) << 2) + ((b2 & 0xff) >> 6) - 97
+
+      mantissa[0] = 0
+      mantissa[1] &= 0x3f
+      const value = new Decimal(`${sign}0x${mantissa.toString('hex')}`).times(
+        `1e${exponent}`,
+      )
+      Amount.assertIouIsValid(value)
+
+      return {
+        value: value.toString(),
+        currency: currency.toJSON(),
+        issuer: issuer.toJSON(),
+      }
+    }
+  }
+
+  /**
+   * Validate XRP amount
+   *
+   * @param amount String representing XRP amount
+   * @returns void, but will throw if invalid amount
+   */
+  private static assertXrpIsValid(amount: string): void {
+    if (amount.indexOf('.') !== -1) {
+      throw new Error(`${amount.toString()} is an illegal amount`)
+    }
+
+    const decimal = new Decimal(amount)
+    if (!decimal.isZero()) {
+      if (decimal.lt(MIN_XRP) || decimal.gt(MAX_DROPS)) {
+        throw new Error(`${amount.toString()} is an illegal amount`)
+      }
+    }
+  }
+
+  /**
+   * Validate IOU.value amount
+   *
+   * @param decimal Decimal.js object representing IOU.value
+   * @returns void, but will throw if invalid amount
+   */
+  private static assertIouIsValid(decimal: Decimal): void {
+    if (!decimal.isZero()) {
+      const p = decimal.precision()
+      const e = decimal.e - 15
+      if (
+        p > MAX_IOU_PRECISION ||
+        e > MAX_IOU_EXPONENT ||
+        e < MIN_IOU_EXPONENT
+      ) {
+        throw new Error('Decimal precision out of range')
+      }
+      this.verifyNoDecimal(decimal)
+    }
+  }
+
+  /**
+   * Ensure that the value after being multiplied by the exponent does not
+   * contain a decimal.
+   *
+   * @param decimal a Decimal object
+   * @returns a string of the object without a decimal
+   */
+  private static verifyNoDecimal(decimal: Decimal): void {
+    const integerNumberString = decimal
+      .times(`1e${-(decimal.e - 15)}`)
+      .abs()
+      .toString()
+
+    if (integerNumberString.indexOf('.') !== -1) {
+      throw new Error('Decimal place found in integerNumberString')
+    }
+  }
+
+  /**
+   * Test if this amount is in units of Native Currency(XRP)
+   *
+   * @returns true if Native (XRP)
+   */
+  private isNative(): boolean {
+    return (this.bytes[0] & 0x80) === 0
+  }
+}
+
+export { Amount, AmountObject }

packages/ripple-binary-codec/src/types/blob.ts

@@ -0,0 +1,43 @@
+import { SerializedType } from './serialized-type'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+/**
+ * Variable length encoded type
+ */
+class Blob extends SerializedType {
+  constructor(bytes: Buffer) {
+    super(bytes)
+  }
+
+  /**
+   * Defines how to read a Blob from a BinaryParser
+   *
+   * @param parser The binary parser to read the Blob from
+   * @param hint The length of the blob, computed by readVariableLengthLength() and passed in
+   * @returns A Blob object
+   */
+  static fromParser(parser: BinaryParser, hint: number): Blob {
+    return new Blob(parser.read(hint))
+  }
+
+  /**
+   * Create a Blob object from a hex-string
+   *
+   * @param value existing Blob object or a hex-string
+   * @returns A Blob object
+   */
+  static from<T extends Blob | string>(value: T): Blob {
+    if (value instanceof Blob) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      return new Blob(Buffer.from(value, 'hex'))
+    }
+
+    throw new Error('Cannot construct Blob from value given')
+  }
+}
+
+export { Blob }

packages/ripple-binary-codec/src/types/currency.ts

@@ -0,0 +1,139 @@
+import { Hash160 } from './hash-160'
+import { Buffer } from 'buffer/'
+
+const ISO_REGEX = /^[A-Z0-9]{3}$/
+const HEX_REGEX = /^[A-F0-9]{40}$/
+
+/**
+ * Convert an ISO code to a currency bytes representation
+ */
+function isoToBytes(iso: string): Buffer {
+  const bytes = Buffer.alloc(20)
+  if (iso !== 'XRP') {
+    const isoBytes = iso.split('').map((c) => c.charCodeAt(0))
+    bytes.set(isoBytes, 12)
+  }
+  return bytes
+}
+
+/**
+ * Tests if ISO is a valid iso code
+ */
+function isIsoCode(iso: string): boolean {
+  return ISO_REGEX.test(iso)
+}
+
+function isoCodeFromHex(code: Buffer): string | null {
+  const iso = code.toString()
+  if (iso === 'XRP') {
+    throw new Error(
+      'Disallowed currency code: to indicate the currency XRP you must use 20 bytes of 0s',
+    )
+  }
+  if (isIsoCode(iso)) {
+    return iso
+  }
+  return null
+}
+
+/**
+ * Tests if hex is a valid hex-string
+ */
+function isHex(hex: string): boolean {
+  return HEX_REGEX.test(hex)
+}
+
+/**
+ * Tests if a string is a valid representation of a currency
+ */
+function isStringRepresentation(input: string): boolean {
+  return input.length === 3 || isHex(input)
+}
+
+/**
+ * Tests if a Buffer is a valid representation of a currency
+ */
+function isBytesArray(bytes: Buffer): boolean {
+  return bytes.byteLength === 20
+}
+
+/**
+ * Ensures that a value is a valid representation of a currency
+ */
+function isValidRepresentation(input: Buffer | string): boolean {
+  return input instanceof Buffer
+    ? isBytesArray(input)
+    : isStringRepresentation(input)
+}
+
+/**
+ * Generate bytes from a string or buffer representation of a currency
+ */
+function bytesFromRepresentation(input: string): Buffer {
+  if (!isValidRepresentation(input)) {
+    throw new Error(`Unsupported Currency representation: ${input}`)
+  }
+  return input.length === 3 ? isoToBytes(input) : Buffer.from(input, 'hex')
+}
+
+/**
+ * Class defining how to encode and decode Currencies
+ */
+class Currency extends Hash160 {
+  static readonly XRP = new Currency(Buffer.alloc(20))
+  private readonly _iso: string | null
+
+  constructor(byteBuf: Buffer) {
+    super(byteBuf ?? Currency.XRP.bytes)
+    const code = this.bytes.slice(12, 15)
+
+    if (this.bytes[0] !== 0) {
+      this._iso = null
+    } else if (code.toString('hex') === '000000') {
+      this._iso = 'XRP'
+    } else {
+      this._iso = isoCodeFromHex(code)
+    }
+  }
+
+  /**
+   * Return the ISO code of this currency
+   *
+   * @returns ISO code if it exists, else null
+   */
+  iso(): string | null {
+    return this._iso
+  }
+
+  /**
+   * Constructs a Currency object
+   *
+   * @param val Currency object or a string representation of a currency
+   */
+  static from<T extends Hash160 | string>(value: T): Currency {
+    if (value instanceof Currency) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      return new Currency(bytesFromRepresentation(value))
+    }
+
+    throw new Error('Cannot construct Currency from value given')
+  }
+
+  /**
+   * Gets the JSON representation of a currency
+   *
+   * @returns JSON representation
+   */
+  toJSON(): string {
+    const iso = this.iso()
+    if (iso !== null) {
+      return iso
+    }
+    return this.bytes.toString('hex').toUpperCase()
+  }
+}
+
+export { Currency }

packages/ripple-binary-codec/src/types/hash-128.ts

@@ -0,0 +1,16 @@
+import { Hash } from './hash'
+import { Buffer } from 'buffer/'
+
+/**
+ * Hash with a width of 128 bits
+ */
+class Hash128 extends Hash {
+  static readonly width = 16
+  static readonly ZERO_128: Hash128 = new Hash128(Buffer.alloc(Hash128.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? Hash128.ZERO_128.bytes)
+  }
+}
+
+export { Hash128 }

packages/ripple-binary-codec/src/types/hash-160.ts

@@ -0,0 +1,20 @@
+import { Hash } from './hash'
+import { Buffer } from 'buffer/'
+
+/**
+ * Hash with a width of 160 bits
+ */
+class Hash160 extends Hash {
+  static readonly width = 20
+  static readonly ZERO_160: Hash160 = new Hash160(Buffer.alloc(Hash160.width))
+
+  constructor(bytes?: Buffer) {
+    if (bytes && bytes.byteLength === 0) {
+      bytes = Hash160.ZERO_160.bytes
+    }
+
+    super(bytes ?? Hash160.ZERO_160.bytes)
+  }
+}
+
+export { Hash160 }

packages/ripple-binary-codec/src/types/hash-256.ts

@@ -0,0 +1,16 @@
+import { Hash } from './hash'
+import { Buffer } from 'buffer/'
+
+/**
+ * Hash with a width of 256 bits
+ */
+class Hash256 extends Hash {
+  static readonly width = 32
+  static readonly ZERO_256 = new Hash256(Buffer.alloc(Hash256.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? Hash256.ZERO_256.bytes)
+  }
+}
+
+export { Hash256 }

packages/ripple-binary-codec/src/types/hash.ts

@@ -0,0 +1,81 @@
+import { Comparable } from './serialized-type'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+/**
+ * Base class defining how to encode and decode hashes
+ */
+class Hash extends Comparable {
+  static readonly width: number
+
+  constructor(bytes: Buffer) {
+    super(bytes)
+    if (this.bytes.byteLength !== (this.constructor as typeof Hash).width) {
+      throw new Error(`Invalid Hash length ${this.bytes.byteLength}`)
+    }
+  }
+
+  /**
+   * Construct a Hash object from an existing Hash object or a hex-string
+   *
+   * @param value A hash object or hex-string of a hash
+   */
+  static from<T extends Hash | string>(value: T): Hash {
+    if (value instanceof this) {
+      return value
+    }
+
+    if (typeof value === 'string') {
+      return new this(Buffer.from(value, 'hex'))
+    }
+
+    throw new Error('Cannot construct Hash from given value')
+  }
+
+  /**
+   * Read a Hash object from a BinaryParser
+   *
+   * @param parser BinaryParser to read the hash from
+   * @param hint length of the bytes to read, optional
+   */
+  static fromParser(parser: BinaryParser, hint?: number): Hash {
+    return new this(parser.read(hint ?? this.width))
+  }
+
+  /**
+   * Overloaded operator for comparing two hash objects
+   *
+   * @param other The Hash to compare this to
+   */
+  compareTo(other: Hash): number {
+    return this.bytes.compare(
+      (this.constructor as typeof Hash).from(other).bytes,
+    )
+  }
+
+  /**
+   * @returns the hex-string representation of this Hash
+   */
+  toString(): string {
+    return this.toHex()
+  }
+
+  /**
+   * Returns four bits at the specified depth within a hash
+   *
+   * @param depth The depth of the four bits
+   * @returns The number represented by the four bits
+   */
+  nibblet(depth: number): number {
+    const byteIx = depth > 0 ? (depth / 2) | 0 : 0
+    let b = this.bytes[byteIx]
+    if (depth % 2 === 0) {
+      b = (b & 0xf0) >>> 4
+    } else {
+      b = b & 0x0f
+    }
+    return b
+  }
+}
+
+export { Hash }

packages/ripple-binary-codec/src/types/index.ts

@@ -0,0 +1,49 @@
+import {
+  Field,
+  TransactionResult,
+  TransactionType,
+  LedgerEntryType,
+} from '../enums'
+import { AccountID } from './account-id'
+import { Amount } from './amount'
+import { Blob } from './blob'
+import { Currency } from './currency'
+import { Hash128 } from './hash-128'
+import { Hash160 } from './hash-160'
+import { Hash256 } from './hash-256'
+import { PathSet } from './path-set'
+import { STArray } from './st-array'
+import { STObject } from './st-object'
+import { UInt16 } from './uint-16'
+import { UInt32 } from './uint-32'
+import { UInt64 } from './uint-64'
+import { UInt8 } from './uint-8'
+import { Vector256 } from './vector-256'
+
+const coreTypes = {
+  AccountID,
+  Amount,
+  Blob,
+  Currency,
+  Hash128,
+  Hash160,
+  Hash256,
+  PathSet,
+  STArray,
+  STObject,
+  UInt8,
+  UInt16,
+  UInt32,
+  UInt64,
+  Vector256,
+}
+
+Object.values(Field).forEach((field) => {
+  field.associatedType = coreTypes[field.type.name]
+})
+
+Field['TransactionType'].associatedType = TransactionType
+Field['TransactionResult'].associatedType = TransactionResult
+Field['LedgerEntryType'].associatedType = LedgerEntryType
+
+export { coreTypes }

packages/ripple-binary-codec/src/types/path-set.ts

@@ -0,0 +1,290 @@
+import { AccountID } from './account-id'
+import { Currency } from './currency'
+import { BinaryParser } from '../serdes/binary-parser'
+import { SerializedType, JsonObject } from './serialized-type'
+import { Buffer } from 'buffer/'
+
+/**
+ * Constants for separating Paths in a PathSet
+ */
+const PATHSET_END_BYTE = 0x00
+const PATH_SEPARATOR_BYTE = 0xff
+
+/**
+ * Constant for masking types of a Hop
+ */
+const TYPE_ACCOUNT = 0x01
+const TYPE_CURRENCY = 0x10
+const TYPE_ISSUER = 0x20
+
+/**
+ * The object representation of a Hop, an issuer AccountID, an account AccountID, and a Currency
+ */
+interface HopObject extends JsonObject {
+  issuer?: string
+  account?: string
+  currency?: string
+}
+
+/**
+ * TypeGuard for HopObject
+ */
+function isHopObject(arg): arg is HopObject {
+  return (
+    arg.issuer !== undefined ||
+    arg.account !== undefined ||
+    arg.currency !== undefined
+  )
+}
+
+/**
+ * TypeGuard for PathSet
+ */
+function isPathSet(arg): arg is Array<Array<HopObject>> {
+  return (
+    (Array.isArray(arg) && arg.length === 0) ||
+    (Array.isArray(arg) && Array.isArray(arg[0]) && arg[0].length === 0) ||
+    (Array.isArray(arg) && Array.isArray(arg[0]) && isHopObject(arg[0][0]))
+  )
+}
+
+/**
+ * Serialize and Deserialize a Hop
+ */
+class Hop extends SerializedType {
+  /**
+   * Create a Hop from a HopObject
+   *
+   * @param value Either a hop or HopObject to create a hop with
+   * @returns a Hop
+   */
+  static from(value: Hop | HopObject): Hop {
+    if (value instanceof Hop) {
+      return value
+    }
+
+    const bytes: Array<Buffer> = [Buffer.from([0])]
+
+    if (value.account) {
+      bytes.push(AccountID.from(value.account).toBytes())
+      bytes[0][0] |= TYPE_ACCOUNT
+    }
+
+    if (value.currency) {
+      bytes.push(Currency.from(value.currency).toBytes())
+      bytes[0][0] |= TYPE_CURRENCY
+    }
+
+    if (value.issuer) {
+      bytes.push(AccountID.from(value.issuer).toBytes())
+      bytes[0][0] |= TYPE_ISSUER
+    }
+
+    return new Hop(Buffer.concat(bytes))
+  }
+
+  /**
+   * Construct a Hop from a BinaryParser
+   *
+   * @param parser BinaryParser to read the Hop from
+   * @returns a Hop
+   */
+  static fromParser(parser: BinaryParser): Hop {
+    const type = parser.readUInt8()
+    const bytes: Array<Buffer> = [Buffer.from([type])]
+
+    if (type & TYPE_ACCOUNT) {
+      bytes.push(parser.read(AccountID.width))
+    }
+
+    if (type & TYPE_CURRENCY) {
+      bytes.push(parser.read(Currency.width))
+    }
+
+    if (type & TYPE_ISSUER) {
+      bytes.push(parser.read(AccountID.width))
+    }
+
+    return new Hop(Buffer.concat(bytes))
+  }
+
+  /**
+   * Get the JSON interpretation of this hop
+   *
+   * @returns a HopObject, an JS object with optional account, issuer, and currency
+   */
+  toJSON(): HopObject {
+    const hopParser = new BinaryParser(this.bytes.toString('hex'))
+    const type = hopParser.readUInt8()
+
+    let account, currency, issuer
+    if (type & TYPE_ACCOUNT) {
+      account = (AccountID.fromParser(hopParser) as AccountID).toJSON()
+    }
+
+    if (type & TYPE_CURRENCY) {
+      currency = (Currency.fromParser(hopParser) as Currency).toJSON()
+    }
+
+    if (type & TYPE_ISSUER) {
+      issuer = (AccountID.fromParser(hopParser) as AccountID).toJSON()
+    }
+
+    const result: HopObject = {}
+    if (account) {
+      result.account = account
+    }
+
+    if (issuer) {
+      result.issuer = issuer
+    }
+
+    if (currency) {
+      result.currency = currency
+    }
+
+    return result
+  }
+
+  /**
+   * get a number representing the type of this hop
+   *
+   * @returns a number to be bitwise and-ed with TYPE_ constants to describe the types in the hop
+   */
+  type(): number {
+    return this.bytes[0]
+  }
+}
+
+/**
+ * Class for serializing/deserializing Paths
+ */
+class Path extends SerializedType {
+  /**
+   * construct a Path from an array of Hops
+   *
+   * @param value Path or array of HopObjects to construct a Path
+   * @returns the Path
+   */
+  static from(value: Path | Array<HopObject>): Path {
+    if (value instanceof Path) {
+      return value
+    }
+
+    const bytes: Array<Buffer> = []
+    value.forEach((hop: HopObject) => {
+      bytes.push(Hop.from(hop).toBytes())
+    })
+
+    return new Path(Buffer.concat(bytes))
+  }
+
+  /**
+   * Read a Path from a BinaryParser
+   *
+   * @param parser BinaryParser to read Path from
+   * @returns the Path represented by the bytes read from the BinaryParser
+   */
+  static fromParser(parser: BinaryParser): Path {
+    const bytes: Array<Buffer> = []
+    while (!parser.end()) {
+      bytes.push(Hop.fromParser(parser).toBytes())
+
+      if (
+        parser.peek() === PATHSET_END_BYTE ||
+        parser.peek() === PATH_SEPARATOR_BYTE
+      ) {
+        break
+      }
+    }
+    return new Path(Buffer.concat(bytes))
+  }
+
+  /**
+   * Get the JSON representation of this Path
+   *
+   * @returns an Array of HopObject constructed from this.bytes
+   */
+  toJSON(): Array<HopObject> {
+    const json: Array<HopObject> = []
+    const pathParser = new BinaryParser(this.toString())
+
+    while (!pathParser.end()) {
+      json.push(Hop.fromParser(pathParser).toJSON())
+    }
+
+    return json
+  }
+}
+
+/**
+ * Deserialize and Serialize the PathSet type
+ */
+class PathSet extends SerializedType {
+  /**
+   * Construct a PathSet from an Array of Arrays representing paths
+   *
+   * @param value A PathSet or Array of Array of HopObjects
+   * @returns the PathSet constructed from value
+   */
+  static from<T extends PathSet | Array<Array<HopObject>>>(value: T): PathSet {
+    if (value instanceof PathSet) {
+      return value
+    }
+
+    if (isPathSet(value)) {
+      const bytes: Array<Buffer> = []
+
+      value.forEach((path: Array<HopObject>) => {
+        bytes.push(Path.from(path).toBytes())
+        bytes.push(Buffer.from([PATH_SEPARATOR_BYTE]))
+      })
+
+      bytes[bytes.length - 1] = Buffer.from([PATHSET_END_BYTE])
+
+      return new PathSet(Buffer.concat(bytes))
+    }
+
+    throw new Error('Cannot construct PathSet from given value')
+  }
+
+  /**
+   * Construct a PathSet from a BinaryParser
+   *
+   * @param parser A BinaryParser to read PathSet from
+   * @returns the PathSet read from parser
+   */
+  static fromParser(parser: BinaryParser): PathSet {
+    const bytes: Array<Buffer> = []
+
+    while (!parser.end()) {
+      bytes.push(Path.fromParser(parser).toBytes())
+      bytes.push(parser.read(1))
+
+      if (bytes[bytes.length - 1][0] == PATHSET_END_BYTE) {
+        break
+      }
+    }
+
+    return new PathSet(Buffer.concat(bytes))
+  }
+
+  /**
+   * Get the JSON representation of this PathSet
+   *
+   * @returns an Array of Array of HopObjects, representing this PathSet
+   */
+  toJSON(): Array<Array<HopObject>> {
+    const json: Array<Array<HopObject>> = []
+    const pathParser = new BinaryParser(this.toString())
+
+    while (!pathParser.end()) {
+      json.push(Path.fromParser(pathParser).toJSON())
+      pathParser.skip(1)
+    }
+
+    return json
+  }
+}
+
+export { PathSet }

packages/ripple-binary-codec/src/types/serialized-type.ts

@@ -0,0 +1,116 @@
+import { BytesList } from '../serdes/binary-serializer'
+import { BinaryParser } from '../serdes/binary-parser'
+import * as bigInt from 'big-integer'
+import { Buffer } from 'buffer/'
+
+type JSON = string | number | boolean | null | undefined | JSON[] | JsonObject
+
+type JsonObject = { [key: string]: JSON }
+
+/**
+ * The base class for all binary-codec types
+ */
+class SerializedType {
+  protected readonly bytes: Buffer = Buffer.alloc(0)
+
+  constructor(bytes: Buffer) {
+    this.bytes = bytes ?? Buffer.alloc(0)
+  }
+
+  static fromParser(parser: BinaryParser, hint?: number): SerializedType {
+    throw new Error('fromParser not implemented')
+    return this.fromParser(parser, hint)
+  }
+
+  static from(
+    value: SerializedType | JSON | bigInt.BigInteger,
+  ): SerializedType {
+    throw new Error('from not implemented')
+    return this.from(value)
+  }
+
+  /**
+   * Write the bytes representation of a SerializedType to a BytesList
+   *
+   * @param list The BytesList to write SerializedType bytes to
+   */
+  toBytesSink(list: BytesList): void {
+    list.put(this.bytes)
+  }
+
+  /**
+   * Get the hex representation of a SerializedType's bytes
+   *
+   * @returns hex String of this.bytes
+   */
+  toHex(): string {
+    return this.toBytes().toString('hex').toUpperCase()
+  }
+
+  /**
+   * Get the bytes representation of a SerializedType
+   *
+   * @returns A buffer of the bytes
+   */
+  toBytes(): Buffer {
+    if (this.bytes) {
+      return this.bytes
+    }
+    const bytes = new BytesList()
+    this.toBytesSink(bytes)
+    return bytes.toBytes()
+  }
+
+  /**
+   * Return the JSON representation of a SerializedType
+   *
+   * @returns any type, if not overloaded returns hexString representation of bytes
+   */
+  toJSON(): JSON {
+    return this.toHex()
+  }
+
+  /**
+   * @returns hexString representation of this.bytes
+   */
+  toString(): string {
+    return this.toHex()
+  }
+}
+
+/**
+ * Base class for SerializedTypes that are comparable
+ */
+class Comparable extends SerializedType {
+  lt(other: Comparable): boolean {
+    return this.compareTo(other) < 0
+  }
+
+  eq(other: Comparable): boolean {
+    return this.compareTo(other) === 0
+  }
+
+  gt(other: Comparable): boolean {
+    return this.compareTo(other) > 0
+  }
+
+  gte(other: Comparable): boolean {
+    return this.compareTo(other) > -1
+  }
+
+  lte(other: Comparable): boolean {
+    return this.compareTo(other) < 1
+  }
+
+  /**
+   * Overload this method to define how two Comparable SerializedTypes are compared
+   *
+   * @param other The comparable object to compare this to
+   * @returns A number denoting the relationship of this and other
+   */
+  compareTo(other: Comparable): number {
+    throw new Error(`cannot compare ${this.toString()} and ${other.toString()}`)
+  }
+}
+
+export { SerializedType, Comparable, JSON, JsonObject }

packages/ripple-binary-codec/src/types/st-array.ts

@@ -0,0 +1,99 @@
+import { SerializedType, JsonObject } from './serialized-type'
+import { STObject } from './st-object'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+const ARRAY_END_MARKER = Buffer.from([0xf1])
+const ARRAY_END_MARKER_NAME = 'ArrayEndMarker'
+
+const OBJECT_END_MARKER = Buffer.from([0xe1])
+
+/**
+ * TypeGuard for Array<JsonObject>
+ */
+function isObjects(args): args is Array<JsonObject> {
+  return (
+    Array.isArray(args) && (args.length === 0 || typeof args[0] === 'object')
+  )
+}
+
+/**
+ * Class for serializing and deserializing Arrays of Objects
+ */
+class STArray extends SerializedType {
+  /**
+   * Construct an STArray from a BinaryParser
+   *
+   * @param parser BinaryParser to parse an STArray from
+   * @returns An STArray Object
+   */
+  static fromParser(parser: BinaryParser): STArray {
+    const bytes: Array<Buffer> = []
+
+    while (!parser.end()) {
+      const field = parser.readField()
+      if (field.name === ARRAY_END_MARKER_NAME) {
+        break
+      }
+
+      bytes.push(
+        field.header,
+        parser.readFieldValue(field).toBytes(),
+        OBJECT_END_MARKER,
+      )
+    }
+
+    bytes.push(ARRAY_END_MARKER)
+    return new STArray(Buffer.concat(bytes))
+  }
+
+  /**
+   * Construct an STArray from an Array of JSON Objects
+   *
+   * @param value STArray or Array of Objects to parse into an STArray
+   * @returns An STArray object
+   */
+  static from<T extends STArray | Array<JsonObject>>(value: T): STArray {
+    if (value instanceof STArray) {
+      return value
+    }
+
+    if (isObjects(value)) {
+      const bytes: Array<Buffer> = []
+      value.forEach((obj) => {
+        bytes.push(STObject.from(obj).toBytes())
+      })
+
+      bytes.push(ARRAY_END_MARKER)
+      return new STArray(Buffer.concat(bytes))
+    }
+
+    throw new Error('Cannot construct STArray from value given')
+  }
+
+  /**
+   * Return the JSON representation of this.bytes
+   *
+   * @returns An Array of JSON objects
+   */
+  toJSON(): Array<JsonObject> {
+    const result: Array<JsonObject> = []
+
+    const arrayParser = new BinaryParser(this.toString())
+
+    while (!arrayParser.end()) {
+      const field = arrayParser.readField()
+      if (field.name === ARRAY_END_MARKER_NAME) {
+        break
+      }
+
+      const outer = {}
+      outer[field.name] = STObject.fromParser(arrayParser).toJSON()
+      result.push(outer)
+    }
+
+    return result
+  }
+}
+
+export { STArray }

packages/ripple-binary-codec/src/types/st-object.ts

@@ -0,0 +1,159 @@
+import { Field, FieldInstance } from '../enums'
+import { SerializedType, JsonObject } from './serialized-type'
+import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'
+import { BinaryParser } from '../serdes/binary-parser'
+import { BinarySerializer, BytesList } from '../serdes/binary-serializer'
+import { Buffer } from 'buffer/'
+
+const OBJECT_END_MARKER_BYTE = Buffer.from([0xe1])
+const OBJECT_END_MARKER = 'ObjectEndMarker'
+const ST_OBJECT = 'STObject'
+const DESTINATION = 'Destination'
+const ACCOUNT = 'Account'
+const SOURCE_TAG = 'SourceTag'
+const DEST_TAG = 'DestinationTag'
+
+/**
+ * Break down an X-Address into an account and a tag
+ *
+ * @param field Name of field
+ * @param xAddress X-Address corresponding to the field
+ */
+function handleXAddress(field: string, xAddress: string): JsonObject {
+  const decoded = xAddressToClassicAddress(xAddress)
+
+  let tagName
+  if (field === DESTINATION) tagName = DEST_TAG
+  else if (field === ACCOUNT) tagName = SOURCE_TAG
+  else if (decoded.tag !== false)
+    throw new Error(`${field} cannot have an associated tag`)
+
+  return decoded.tag !== false
+    ? { [field]: decoded.classicAddress, [tagName]: decoded.tag }
+    : { [field]: decoded.classicAddress }
+}
+
+/**
+ * Validate that two objects don't both have the same tag fields
+ *
+ * @param obj1 First object to check for tags
+ * @param obj2 Second object to check for tags
+ * @throws When both objects have SourceTag or DestinationTag
+ */
+function checkForDuplicateTags(obj1: JsonObject, obj2: JsonObject): void {
+  if (!(obj1[SOURCE_TAG] === undefined || obj2[SOURCE_TAG] === undefined))
+    throw new Error('Cannot have Account X-Address and SourceTag')
+  if (!(obj1[DEST_TAG] === undefined || obj2[DEST_TAG] === undefined))
+    throw new Error('Cannot have Destination X-Address and DestinationTag')
+}
+
+/**
+ * Class for Serializing/Deserializing objects
+ */
+class STObject extends SerializedType {
+  /**
+   * Construct a STObject from a BinaryParser
+   *
+   * @param parser BinaryParser to read STObject from
+   * @returns A STObject object
+   */
+  static fromParser(parser: BinaryParser): STObject {
+    const list: BytesList = new BytesList()
+    const bytes: BinarySerializer = new BinarySerializer(list)
+
+    while (!parser.end()) {
+      const field = parser.readField()
+      if (field.name === OBJECT_END_MARKER) {
+        break
+      }
+
+      const associatedValue = parser.readFieldValue(field)
+
+      bytes.writeFieldAndValue(field, associatedValue)
+      if (field.type.name === ST_OBJECT) {
+        bytes.put(OBJECT_END_MARKER_BYTE)
+      }
+    }
+
+    return new STObject(list.toBytes())
+  }
+
+  /**
+   * Construct a STObject from a JSON object
+   *
+   * @param value An object to include
+   * @param filter optional, denote which field to include in serialized object
+   * @returns a STObject object
+   */
+  static from<T extends STObject | JsonObject>(
+    value: T,
+    filter?: (...any) => boolean,
+  ): STObject {
+    if (value instanceof STObject) {
+      return value
+    }
+
+    const list: BytesList = new BytesList()
+    const bytes: BinarySerializer = new BinarySerializer(list)
+
+    const xAddressDecoded = Object.entries(value).reduce((acc, [key, val]) => {
+      let handled: JsonObject | undefined = undefined
+      if (val && isValidXAddress(val.toString())) {
+        handled = handleXAddress(key, val.toString())
+        checkForDuplicateTags(handled, value)
+      }
+      return Object.assign(acc, handled ?? { [key]: val })
+    }, {})
+
+    let sorted = Object.keys(xAddressDecoded)
+      .map((f: string): FieldInstance => Field[f] as FieldInstance)
+      .filter(
+        (f: FieldInstance): boolean =>
+          f !== undefined &&
+          xAddressDecoded[f.name] !== undefined &&
+          f.isSerialized,
+      )
+      .sort((a, b) => {
+        return a.ordinal - b.ordinal
+      })
+
+    if (filter !== undefined) {
+      sorted = sorted.filter(filter)
+    }
+
+    sorted.forEach((field) => {
+      const associatedValue = field.associatedType.from(
+        xAddressDecoded[field.name],
+      )
+
+      bytes.writeFieldAndValue(field, associatedValue)
+      if (field.type.name === ST_OBJECT) {
+        bytes.put(OBJECT_END_MARKER_BYTE)
+      }
+    })
+
+    return new STObject(list.toBytes())
+  }
+
+  /**
+   * Get the JSON interpretation of this.bytes
+   *
+   * @returns a JSON object
+   */
+  toJSON(): JsonObject {
+    const objectParser = new BinaryParser(this.toString())
+    const accumulator = {}
+
+    while (!objectParser.end()) {
+      const field = objectParser.readField()
+      if (field.name === OBJECT_END_MARKER) {
+        break
+      }
+      accumulator[field.name] = objectParser.readFieldValue(field).toJSON()
+    }
+
+    return accumulator
+  }
+}
+
+export { STObject }

packages/ripple-binary-codec/src/types/uint-16.ts

@@ -0,0 +1,49 @@
+import { UInt } from './uint'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+/**
+ * Derived UInt class for serializing/deserializing 16 bit UInt
+ */
+class UInt16 extends UInt {
+  protected static readonly width: number = 16 / 8 // 2
+  static readonly defaultUInt16: UInt16 = new UInt16(Buffer.alloc(UInt16.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? UInt16.defaultUInt16.bytes)
+  }
+
+  static fromParser(parser: BinaryParser): UInt {
+    return new UInt16(parser.read(UInt16.width))
+  }
+
+  /**
+   * Construct a UInt16 object from a number
+   *
+   * @param val UInt16 object or number
+   */
+  static from<T extends UInt16 | number>(val: T): UInt16 {
+    if (val instanceof UInt16) {
+      return val
+    }
+
+    if (typeof val === 'number') {
+      const buf = Buffer.alloc(UInt16.width)
+      buf.writeUInt16BE(val, 0)
+      return new UInt16(buf)
+    }
+
+    throw new Error('Can not construct UInt16 with given value')
+  }
+
+  /**
+   * get the value of a UInt16 object
+   *
+   * @returns the number represented by this.bytes
+   */
+  valueOf(): number {
+    return this.bytes.readUInt16BE(0)
+  }
+}
+
+export { UInt16 }

packages/ripple-binary-codec/src/types/uint-32.ts

@@ -0,0 +1,56 @@
+import { UInt } from './uint'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+/**
+ * Derived UInt class for serializing/deserializing 32 bit UInt
+ */
+class UInt32 extends UInt {
+  protected static readonly width: number = 32 / 8 // 4
+  static readonly defaultUInt32: UInt32 = new UInt32(Buffer.alloc(UInt32.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? UInt32.defaultUInt32.bytes)
+  }
+
+  static fromParser(parser: BinaryParser): UInt {
+    return new UInt32(parser.read(UInt32.width))
+  }
+
+  /**
+   * Construct a UInt32 object from a number
+   *
+   * @param val UInt32 object or number
+   */
+  static from<T extends UInt32 | number | string>(val: T): UInt32 {
+    if (val instanceof UInt32) {
+      return val
+    }
+
+    const buf = Buffer.alloc(UInt32.width)
+
+    if (typeof val === 'string') {
+      const num = Number.parseInt(val)
+      buf.writeUInt32BE(num, 0)
+      return new UInt32(buf)
+    }
+
+    if (typeof val === 'number') {
+      buf.writeUInt32BE(val, 0)
+      return new UInt32(buf)
+    }
+
+    throw new Error('Cannot construct UInt32 from given value')
+  }
+
+  /**
+   * get the value of a UInt32 object
+   *
+   * @returns the number represented by this.bytes
+   */
+  valueOf(): number {
+    return this.bytes.readUInt32BE(0)
+  }
+}
+
+export { UInt32 }

packages/ripple-binary-codec/src/types/uint-64.ts

@@ -0,0 +1,105 @@
+import { UInt } from './uint'
+import { BinaryParser } from '../serdes/binary-parser'
+import * as bigInt from 'big-integer'
+import { isInstance } from 'big-integer'
+import { Buffer } from 'buffer/'
+
+const HEX_REGEX = /^[a-fA-F0-9]{1,16}$/
+const mask = bigInt(0x00000000ffffffff)
+
+/**
+ * Derived UInt class for serializing/deserializing 64 bit UInt
+ */
+class UInt64 extends UInt {
+  protected static readonly width: number = 64 / 8 // 8
+  static readonly defaultUInt64: UInt64 = new UInt64(Buffer.alloc(UInt64.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? UInt64.defaultUInt64.bytes)
+  }
+
+  static fromParser(parser: BinaryParser): UInt {
+    return new UInt64(parser.read(UInt64.width))
+  }
+
+  /**
+   * Construct a UInt64 object
+   *
+   * @param val A UInt64, hex-string, bigInt, or number
+   * @returns A UInt64 object
+   */
+  static from<T extends UInt64 | string | bigInt.BigInteger | number>(
+    val: T,
+  ): UInt64 {
+    if (val instanceof UInt64) {
+      return val
+    }
+
+    let buf = Buffer.alloc(UInt64.width)
+
+    if (typeof val === 'number') {
+      if (val < 0) {
+        throw new Error('value must be an unsigned integer')
+      }
+
+      const number = bigInt(val)
+
+      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
+      intBuf[0].writeUInt32BE(Number(number.shiftRight(32)), 0)
+      intBuf[1].writeUInt32BE(Number(number.and(mask)), 0)
+
+      return new UInt64(Buffer.concat(intBuf))
+    }
+
+    if (typeof val === 'string') {
+      if (!HEX_REGEX.test(val)) {
+        throw new Error(`${val} is not a valid hex-string`)
+      }
+
+      const strBuf = val.padStart(16, '0')
+      buf = Buffer.from(strBuf, 'hex')
+      return new UInt64(buf)
+    }
+
+    if (isInstance(val)) {
+      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
+      intBuf[0].writeUInt32BE(Number(val.shiftRight(bigInt(32))), 0)
+      intBuf[1].writeUInt32BE(Number(val.and(mask)), 0)
+
+      return new UInt64(Buffer.concat(intBuf))
+    }
+
+    throw new Error('Cannot construct UInt64 from given value')
+  }
+
+  /**
+   * The JSON representation of a UInt64 object
+   *
+   * @returns a hex-string
+   */
+  toJSON(): string {
+    return this.bytes.toString('hex').toUpperCase()
+  }
+
+  /**
+   * Get the value of the UInt64
+   *
+   * @returns the number represented buy this.bytes
+   */
+  valueOf(): bigInt.BigInteger {
+    const msb = bigInt(this.bytes.slice(0, 4).readUInt32BE(0))
+    const lsb = bigInt(this.bytes.slice(4).readUInt32BE(0))
+    return msb.shiftLeft(bigInt(32)).or(lsb)
+  }
+
+  /**
+   * Get the bytes representation of the UInt64 object
+   *
+   * @returns 8 bytes representing the UInt64
+   */
+  toBytes(): Buffer {
+    return this.bytes
+  }
+}
+
+export { UInt64 }

packages/ripple-binary-codec/src/types/uint-8.ts

@@ -0,0 +1,49 @@
+import { UInt } from './uint'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Buffer } from 'buffer/'
+
+/**
+ * Derived UInt class for serializing/deserializing 8 bit UInt
+ */
+class UInt8 extends UInt {
+  protected static readonly width: number = 8 / 8 // 1
+  static readonly defaultUInt8: UInt8 = new UInt8(Buffer.alloc(UInt8.width))
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? UInt8.defaultUInt8.bytes)
+  }
+
+  static fromParser(parser: BinaryParser): UInt {
+    return new UInt8(parser.read(UInt8.width))
+  }
+
+  /**
+   * Construct a UInt8 object from a number
+   *
+   * @param val UInt8 object or number
+   */
+  static from<T extends UInt8 | number>(val: T): UInt8 {
+    if (val instanceof UInt8) {
+      return val
+    }
+
+    if (typeof val === 'number') {
+      const buf = Buffer.alloc(UInt8.width)
+      buf.writeUInt8(val, 0)
+      return new UInt8(buf)
+    }
+
+    throw new Error('Cannot construct UInt8 from given value')
+  }
+
+  /**
+   * get the value of a UInt8 object
+   *
+   * @returns the number represented by this.bytes
+   */
+  valueOf(): number {
+    return this.bytes.readUInt8(0)
+  }
+}
+
+export { UInt8 }

packages/ripple-binary-codec/src/types/uint.ts

@@ -0,0 +1,57 @@
+import * as bigInt from 'big-integer'
+import { Comparable } from './serialized-type'
+import { Buffer } from 'buffer/'
+
+/**
+ * Compare numbers and bigInts n1 and n2
+ *
+ * @param n1 First object to compare
+ * @param n2 Second object to compare
+ * @returns -1, 0, or 1, depending on how the two objects compare
+ */
+function compare(
+  n1: number | bigInt.BigInteger,
+  n2: number | bigInt.BigInteger,
+): number {
+  return n1 < n2 ? -1 : n1 == n2 ? 0 : 1
+}
+
+/**
+ * Base class for serializing and deserializing unsigned integers.
+ */
+abstract class UInt extends Comparable {
+  protected static width: number
+
+  constructor(bytes: Buffer) {
+    super(bytes)
+  }
+
+  /**
+   * Overload of compareTo for Comparable
+   *
+   * @param other other UInt to compare this to
+   * @returns -1, 0, or 1 depending on how the objects relate to each other
+   */
+  compareTo(other: UInt): number {
+    return compare(this.valueOf(), other.valueOf())
+  }
+
+  /**
+   * Convert a UInt object to JSON
+   *
+   * @returns number or string represented by this.bytes
+   */
+  toJSON(): number | string {
+    const val = this.valueOf()
+    return typeof val === 'number' ? val : val.toString()
+  }
+
+  /**
+   * Get the value of the UInt represented by this.bytes
+   *
+   * @returns the value
+   */
+  abstract valueOf(): number | bigInt.BigInteger
+}
+
+export { UInt }

packages/ripple-binary-codec/src/types/vector-256.ts

@@ -0,0 +1,84 @@
+import { SerializedType } from './serialized-type'
+import { BinaryParser } from '../serdes/binary-parser'
+import { Hash256 } from './hash-256'
+import { BytesList } from '../serdes/binary-serializer'
+import { Buffer } from 'buffer/'
+
+/**
+ * TypeGuard for Array<string>
+ */
+function isStrings(arg): arg is Array<string> {
+  return Array.isArray(arg) && (arg.length === 0 || typeof arg[0] === 'string')
+}
+
+/**
+ * Class for serializing and deserializing vectors of Hash256
+ */
+class Vector256 extends SerializedType {
+  constructor(bytes: Buffer) {
+    super(bytes)
+  }
+
+  /**
+   * Construct a Vector256 from a BinaryParser
+   *
+   * @param parser BinaryParser to
+   * @param hint length of the vector, in bytes, optional
+   * @returns a Vector256 object
+   */
+  static fromParser(parser: BinaryParser, hint?: number): Vector256 {
+    const bytesList = new BytesList()
+    const bytes = hint ?? parser.size()
+    const hashes = bytes / 32
+    for (let i = 0; i < hashes; i++) {
+      Hash256.fromParser(parser).toBytesSink(bytesList)
+    }
+    return new Vector256(bytesList.toBytes())
+  }
+
+  /**
+   * Construct a Vector256 object from an array of hashes
+   *
+   * @param value A Vector256 object or array of hex-strings representing Hash256's
+   * @returns a Vector256 object
+   */
+  static from<T extends Vector256 | Array<string>>(value: T): Vector256 {
+    if (value instanceof Vector256) {
+      return value
+    }
+
+    if (isStrings(value)) {
+      const bytesList = new BytesList()
+      value.forEach((hash) => {
+        Hash256.from(hash).toBytesSink(bytesList)
+      })
+      return new Vector256(bytesList.toBytes())
+    }
+
+    throw new Error('Cannot construct Vector256 from given value')
+  }
+
+  /**
+   * Return an Array of hex-strings represented by this.bytes
+   *
+   * @returns An Array of strings representing the Hash256 objects
+   */
+  toJSON(): Array<string> {
+    if (this.bytes.byteLength % 32 !== 0) {
+      throw new Error('Invalid bytes for Vector256')
+    }
+
+    const result: Array<string> = []
+    for (let i = 0; i < this.bytes.byteLength; i += 32) {
+      result.push(
+        this.bytes
+          .slice(i, i + 32)
+          .toString('hex')
+          .toUpperCase(),
+      )
+    }
+    return result
+  }
+}
+
+export { Vector256 }

packages/ripple-binary-codec/test/amount.test.js

@@ -0,0 +1,43 @@
+const { loadFixture } = require('./utils')
+const { coreTypes } = require('../dist/types')
+const { Amount } = coreTypes
+const fixtures = loadFixture('data-driven-tests.json')
+
+function amountErrorTests() {
+  fixtures.values_tests
+    .filter((obj) => obj.type === 'Amount')
+    .forEach((f) => {
+      // We only want these with errors
+      if (!f.error) {
+        return
+      }
+      const testName =
+        `${JSON.stringify(f.test_json)}\n\tis invalid ` + `because: ${f.error}`
+      it(testName, () => {
+        expect(() => {
+          Amount.from(f.test_json)
+          JSON.stringify(f.test_json)
+        }).toThrow()
+      })
+    })
+}
+
+describe('Amount', function () {
+  it('can be parsed from', function () {
+    expect(Amount.from('1000000') instanceof Amount).toBe(true)
+    expect(Amount.from('1000000').toJSON()).toEqual('1000000')
+    const fixture = {
+      value: '1',
+      issuer: '0000000000000000000000000000000000000000',
+      currency: 'USD',
+    }
+    const amt = Amount.from(fixture)
+    const rewritten = {
+      value: '1',
+      issuer: 'rrrrrrrrrrrrrrrrrrrrrhoLvTp',
+      currency: 'USD',
+    }
+    expect(amt.toJSON()).toEqual(rewritten)
+  })
+  amountErrorTests()
+})

packages/ripple-binary-codec/test/binary-json.test.js

@@ -0,0 +1,45 @@
+const fixtures = require('./fixtures/codec-fixtures.json')
+const { decode, encode, decodeLedgerData } = require('../dist')
+
+function json(object) {
+  return JSON.stringify(object)
+}
+
+function truncateForDisplay(longStr) {
+  return `${longStr.slice(0, 10)} ... ${longStr.slice(-10)}`
+}
+
+describe('ripple-binary-codec', function () {
+  function makeSuite(name, entries) {
+    describe(name, function () {
+      entries.forEach((t, testN) => {
+        test(`${name}[${testN}] can encode ${truncateForDisplay(
+          json(t.json),
+        )} to ${truncateForDisplay(t.binary)}`, () => {
+          expect(encode(t.json)).toEqual(t.binary)
+        })
+        test(`${name}[${testN}] can decode ${truncateForDisplay(
+          t.binary,
+        )} to ${truncateForDisplay(json(t.json))}`, () => {
+          const decoded = decode(t.binary)
+          expect(decoded).toEqual(t.json)
+        })
+      })
+    })
+  }
+  makeSuite('transactions', fixtures.transactions)
+  makeSuite('accountState', fixtures.accountState)
+
+  describe('ledgerData', function () {
+    if (fixtures.ledgerData) {
+      fixtures.ledgerData.forEach((t, testN) => {
+        test(`ledgerData[${testN}] can decode ${t.binary} to ${json(
+          t.json,
+        )}`, () => {
+          const decoded = decodeLedgerData(t.binary)
+          expect(t.json).toEqual(decoded)
+        })
+      })
+    }
+  })
+})

packages/ripple-binary-codec/test/binary-parser.test.js

@@ -0,0 +1,396 @@
+const { coreTypes } = require('../dist/types')
+const Decimal = require('decimal.js')
+
+const { encodeAccountID } = require('ripple-address-codec')
+const { binary } = require('../dist/coretypes')
+const { Amount, Hash160 } = coreTypes
+const { makeParser, readJSON } = binary
+const { Field, TransactionType } = require('./../dist/enums')
+const { parseHexOnly, hexOnly, loadFixture } = require('./utils')
+const fixtures = loadFixture('data-driven-tests.json')
+const { BytesList } = require('../dist/serdes/binary-serializer')
+const { Buffer } = require('buffer/')
+
+const __ = hexOnly
+function toJSON(v) {
+  return v.toJSON ? v.toJSON() : v
+}
+
+function assertEqualAmountJSON(actual, expected) {
+  expect(typeof actual === typeof expected).toBe(true)
+  if (typeof actual === 'string') {
+    expect(actual).toEqual(expected)
+    return
+  }
+  expect(actual.currency).toEqual(expected.currency)
+  expect(actual.issuer).toEqual(expected.issuer)
+  expect(
+    actual.value === expected.value ||
+      new Decimal(actual.value).equals(new Decimal(expected.value)),
+  ).toBe(true)
+}
+
+function basicApiTests() {
+  const bytes = parseHexOnly('00,01020304,0506', Uint8Array)
+  test('can read slices of bytes', () => {
+    const parser = makeParser(bytes)
+    expect(parser.bytes instanceof Buffer).toBe(true)
+    const read1 = parser.read(1)
+    expect(read1 instanceof Buffer).toBe(true)
+    expect(read1).toEqual(Buffer.from([0]))
+    expect(parser.read(4)).toEqual(Buffer.from([1, 2, 3, 4]))
+    expect(parser.read(2)).toEqual(Buffer.from([5, 6]))
+    expect(() => parser.read(1)).toThrow()
+  })
+  test('can read a Uint32 at full', () => {
+    const parser = makeParser('FFFFFFFF')
+    expect(parser.readUInt32()).toEqual(0xffffffff)
+  })
+}
+
+function transactionParsingTests() {
+  const transaction = {
+    json: {
+      Account: 'raD5qJMAShLeHZXf9wjUmo6vRK4arj9cF3',
+      Fee: '10',
+      Flags: 0,
+      Sequence: 103929,
+      SigningPubKey:
+        '028472865AF4CB32AA285834B57576B7290AA8C31B459047DB27E16F418D6A7166',
+      TakerGets: {
+        currency: 'ILS',
+        issuer: 'rNPRNzBB92BVpAhhZr4iXDTveCgV5Pofm9',
+        value: '1694.768',
+      },
+      TakerPays: '98957503520',
+      TransactionType: 'OfferCreate',
+      TxnSignature: __(`
+          304502202ABE08D5E78D1E74A4C18F2714F64E87B8BD57444AF
+          A5733109EB3C077077520022100DB335EE97386E4C0591CAC02
+          4D50E9230D8F171EEB901B5E5E4BD6D1E0AEF98C`),
+    },
+    binary: __(`
+      120007220000000024000195F964400000170A53AC2065D5460561E
+      C9DE000000000000000000000000000494C53000000000092D70596
+      8936C419CE614BF264B5EEB1CEA47FF468400000000000000A73210
+      28472865AF4CB32AA285834B57576B7290AA8C31B459047DB27E16F
+      418D6A71667447304502202ABE08D5E78D1E74A4C18F2714F64E87B
+      8BD57444AFA5733109EB3C077077520022100DB335EE97386E4C059
+      1CAC024D50E9230D8F171EEB901B5E5E4BD6D1E0AEF98C811439408
+      A69F0895E62149CFCC006FB89FA7D1E6E5D`),
+  }
+
+  const tx_json = transaction.json
+  // These tests are basically development logs
+
+  test('can be done with low level apis', () => {
+    const parser = makeParser(transaction.binary)
+
+    expect(parser.readField()).toEqual(Field.TransactionType)
+    expect(parser.readUInt16()).toEqual(7)
+    expect(parser.readField()).toEqual(Field.Flags)
+    expect(parser.readUInt32()).toEqual(0)
+    expect(parser.readField()).toEqual(Field.Sequence)
+    expect(parser.readUInt32()).toEqual(103929)
+    expect(parser.readField()).toEqual(Field.TakerPays)
+    parser.read(8)
+    expect(parser.readField()).toEqual(Field.TakerGets)
+    // amount value
+    expect(parser.read(8)).not.toBe([])
+    // amount currency
+    expect(Hash160.fromParser(parser)).not.toBe([])
+    expect(encodeAccountID(parser.read(20))).toEqual(tx_json.TakerGets.issuer)
+    expect(parser.readField()).toEqual(Field.Fee)
+    expect(parser.read(8)).not.toEqual([])
+    expect(parser.readField()).toEqual(Field.SigningPubKey)
+    expect(parser.readVariableLengthLength()).toBe(33)
+    expect(parser.read(33).toString('hex').toUpperCase()).toEqual(
+      tx_json.SigningPubKey,
+    )
+    expect(parser.readField()).toEqual(Field.TxnSignature)
+    expect(parser.readVariableLength().toString('hex').toUpperCase()).toEqual(
+      tx_json.TxnSignature,
+    )
+    expect(parser.readField()).toEqual(Field.Account)
+    expect(encodeAccountID(parser.readVariableLength())).toEqual(
+      tx_json.Account,
+    )
+    expect(parser.end()).toBe(true)
+  })
+
+  test('can be done with high level apis', () => {
+    const parser = makeParser(transaction.binary)
+    function readField() {
+      return parser.readFieldAndValue()
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.TransactionType)
+      expect(value).toEqual(TransactionType.OfferCreate)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.Flags)
+      expect(value.valueOf()).toEqual(0)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.Sequence)
+      expect(value.valueOf()).toEqual(103929)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.TakerPays)
+      expect(value.isNative()).toEqual(true)
+      expect(value.toJSON()).toEqual('98957503520')
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.TakerGets)
+      expect(value.isNative()).toEqual(false)
+      expect(value.toJSON().issuer).toEqual(tx_json.TakerGets.issuer)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.Fee)
+      expect(value.isNative()).toEqual(true)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.SigningPubKey)
+      expect(value.toJSON()).toEqual(tx_json.SigningPubKey)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.TxnSignature)
+      expect(value.toJSON()).toEqual(tx_json.TxnSignature)
+    }
+    {
+      const [field, value] = readField()
+      expect(field).toEqual(Field.Account)
+      expect(value.toJSON()).toEqual(tx_json.Account)
+    }
+    expect(parser.end()).toBe(true)
+  })
+
+  test('can be done with higher level apis', () => {
+    const parser = makeParser(transaction.binary)
+    const jsonFromBinary = readJSON(parser)
+    expect(jsonFromBinary).toEqual(tx_json)
+  })
+
+  test('readJSON (binary.decode) does not return STObject ', () => {
+    const parser = makeParser(transaction.binary)
+    const jsonFromBinary = readJSON(parser)
+    expect(jsonFromBinary instanceof coreTypes.STObject).toBe(false)
+    expect(jsonFromBinary instanceof Object).toBe(true)
+    expect(jsonFromBinary.prototype).toBe(undefined)
+  })
+}
+
+function amountParsingTests() {
+  fixtures.values_tests
+    .filter((obj) => obj.type === 'Amount')
+    .forEach((f, i) => {
+      if (f.error) {
+        return
+      }
+      const parser = makeParser(f.expected_hex)
+      const testName = `values_tests[${i}] parses ${f.expected_hex.slice(
+        0,
+        16,
+      )}...
+          as ${JSON.stringify(f.test_json)}`
+      test(testName, () => {
+        const value = parser.readType(Amount)
+        // May not actually be in canonical form. The fixtures are to be used
+        // also for json -> binary;
+        const json = toJSON(value)
+        assertEqualAmountJSON(json, f.test_json)
+        if (f.exponent) {
+          const exponent = new Decimal(json.value)
+          expect(exponent.e - 15).toEqual(f.exponent)
+        }
+      })
+    })
+}
+
+function fieldParsingTests() {
+  fixtures.fields_tests.forEach((f, i) => {
+    const parser = makeParser(f.expected_hex)
+    test(`fields[${i}]: parses ${f.expected_hex} as ${f.name}`, () => {
+      const field = parser.readField()
+      expect(field.name).toEqual(f.name)
+      expect(field.type.name).toEqual(f.type_name)
+    })
+  })
+  test('Field throws when type code out of range', () => {
+    const parser = makeParser('0101')
+    expect(() => parser.readField()).toThrow(
+      new Error('Cannot read FieldOrdinal, type_code out of range'),
+    )
+  })
+  test('Field throws when field code out of range', () => {
+    const parser = makeParser('1001')
+    expect(() => parser.readFieldOrdinal()).toThrowError(
+      new Error('Cannot read FieldOrdinal, field_code out of range'),
+    )
+  })
+  test('Field throws when both type and field code out of range', () => {
+    const parser = makeParser('000101')
+    expect(() => parser.readFieldOrdinal()).toThrowError(
+      new Error('Cannot read FieldOrdinal, type_code out of range'),
+    )
+  })
+}
+
+function assertRecyclable(json, forField) {
+  const Type = forField.associatedType
+  const recycled = Type.from(json).toJSON()
+  expect(recycled).toEqual(json)
+  const sink = new BytesList()
+  Type.from(recycled).toBytesSink(sink)
+  const recycledAgain = makeParser(sink.toHex()).readType(Type).toJSON()
+  expect(recycledAgain).toEqual(json)
+}
+
+function nestedObjectTests() {
+  fixtures.whole_objects.forEach((f, i) => {
+    test(`whole_objects[${i}]: can parse blob into
+          ${JSON.stringify(
+            f.tx_json,
+          )}`, /*                                              */ () => {
+      const parser = makeParser(f.blob_with_no_signing)
+      let ix = 0
+      while (!parser.end()) {
+        const [field, value] = parser.readFieldAndValue()
+        const expected = f.fields[ix]
+        const expectedJSON = expected[1].json
+        const expectedField = expected[0]
+        const actual = toJSON(value)
+
+        try {
+          expect(actual).toEqual(expectedJSON)
+        } catch (e) {
+          throw new Error(`${e} ${field} a: ${actual} e: ${expectedJSON}`)
+        }
+        expect(field.name).toEqual(expectedField)
+        assertRecyclable(actual, field)
+        ix++
+      }
+    })
+  })
+}
+
+function pathSetBinaryTests() {
+  const bytes = __(
+    `1200002200000000240000002E2E00004BF161D4C71AFD498D00000000000000
+     0000000000000055534400000000000A20B3C85F482532A9578DBB3950B85CA0
+     6594D168400000000000000A69D446F8038585E9400000000000000000000000
+     00425443000000000078CA21A6014541AB7B26C3929B9E0CD8C284D61C732103
+     A4665B1F0B7AE2BCA12E2DB80A192125BBEA660F80E9CEE137BA444C1B0769EC
+     7447304502205A964536805E35785C659D1F9670D057749AE39668175D6AA75D
+     25B218FE682E0221009252C0E5DDD5F2712A48F211669DE17B54113918E0D2C2
+     66F818095E9339D7D3811478CA21A6014541AB7B26C3929B9E0CD8C284D61C83
+     140A20B3C85F482532A9578DBB3950B85CA06594D1011231585E1F3BD02A15D6
+     185F8BB9B57CC60DEDDB37C10000000000000000000000004254430000000000
+     585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C131E4FE687C90257D3D2D694C
+     8531CDEECBE84F33670000000000000000000000004254430000000000E4FE68
+     7C90257D3D2D694C8531CDEECBE84F3367310A20B3C85F482532A9578DBB3950
+     B85CA06594D100000000000000000000000042544300000000000A20B3C85F48
+     2532A9578DBB3950B85CA06594D1300000000000000000000000005553440000
+     0000000A20B3C85F482532A9578DBB3950B85CA06594D1FF31585E1F3BD02A15
+     D6185F8BB9B57CC60DEDDB37C100000000000000000000000042544300000000
+     00585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C131E4FE687C90257D3D2D69
+     4C8531CDEECBE84F33670000000000000000000000004254430000000000E4FE
+     687C90257D3D2D694C8531CDEECBE84F33673115036E2D3F5437A83E5AC3CAEE
+     34FF2C21DEB618000000000000000000000000425443000000000015036E2D3F
+     5437A83E5AC3CAEE34FF2C21DEB6183000000000000000000000000055534400
+     000000000A20B3C85F482532A9578DBB3950B85CA06594D1FF31585E1F3BD02A
+     15D6185F8BB9B57CC60DEDDB37C1000000000000000000000000425443000000
+     0000585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C13157180C769B66D942EE
+     69E6DCC940CA48D82337AD000000000000000000000000425443000000000057
+     180C769B66D942EE69E6DCC940CA48D82337AD10000000000000000000000000
+     00000000000000003000000000000000000000000055534400000000000A20B3
+     C85F482532A9578DBB3950B85CA06594D100`,
+  )
+
+  const expectedJSON = [
+    [
+      {
+        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+        currency: 'BTC',
+        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+      },
+      {
+        account: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
+        currency: 'BTC',
+        issuer: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
+      },
+      {
+        account: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+        currency: 'BTC',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      },
+      {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      },
+    ],
+    [
+      {
+        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+        currency: 'BTC',
+        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+      },
+      {
+        account: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
+        currency: 'BTC',
+        issuer: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
+      },
+      {
+        account: 'rpvfJ4mR6QQAeogpXEKnuyGBx8mYCSnYZi',
+        currency: 'BTC',
+        issuer: 'rpvfJ4mR6QQAeogpXEKnuyGBx8mYCSnYZi',
+      },
+      {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      },
+    ],
+    [
+      {
+        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+        currency: 'BTC',
+        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
+      },
+      {
+        account: 'r3AWbdp2jQLXLywJypdoNwVSvr81xs3uhn',
+        currency: 'BTC',
+        issuer: 'r3AWbdp2jQLXLywJypdoNwVSvr81xs3uhn',
+      },
+      { currency: 'XRP' },
+      {
+        currency: 'USD',
+        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
+      },
+    ],
+  ]
+
+  test('works with long paths', () => {
+    const parser = makeParser(bytes)
+    const txn = readJSON(parser)
+    expect(txn.Paths).toEqual(expectedJSON)
+    // TODO: this should go elsewhere
+    expect(coreTypes.PathSet.from(txn.Paths).toJSON()).toEqual(expectedJSON)
+  })
+}
+
+describe('Binary Parser', function () {
+  describe('pathSetBinaryTests', () => pathSetBinaryTests())
+  describe('nestedObjectTests', () => nestedObjectTests())
+  describe('fieldParsingTests', () => fieldParsingTests())
+  describe('amountParsingTests', () => amountParsingTests())
+  describe('transactionParsingTests', () => transactionParsingTests())
+  describe('basicApiTests', () => basicApiTests())
+})

packages/ripple-binary-codec/test/binary-serializer.test.js

@@ -0,0 +1,289 @@
+const { binary } = require('../dist/coretypes')
+const { encode, decode } = require('../dist')
+const { makeParser, BytesList, BinarySerializer } = binary
+const { coreTypes } = require('../dist/types')
+const { UInt8, UInt16, UInt32, UInt64, STObject } = coreTypes
+const bigInt = require('big-integer')
+const { Buffer } = require('buffer/')
+
+const { loadFixture } = require('./utils')
+const fixtures = loadFixture('data-driven-tests.json')
+const deliverMinTx = require('./fixtures/delivermin-tx.json')
+const deliverMinTxBinary = require('./fixtures/delivermin-tx-binary.json')
+const SignerListSet = {
+  tx: require('./fixtures/signerlistset-tx.json'),
+  binary: require('./fixtures/signerlistset-tx-binary.json'),
+  meta: require('./fixtures/signerlistset-tx-meta-binary.json'),
+}
+const DepositPreauth = {
+  tx: require('./fixtures/deposit-preauth-tx.json'),
+  binary: require('./fixtures/deposit-preauth-tx-binary.json'),
+  meta: require('./fixtures/deposit-preauth-tx-meta-binary.json'),
+}
+const Escrow = {
+  create: {
+    tx: require('./fixtures/escrow-create-tx.json'),
+    binary: require('./fixtures/escrow-create-binary.json'),
+  },
+  finish: {
+    tx: require('./fixtures/escrow-finish-tx.json'),
+    binary: require('./fixtures/escrow-finish-binary.json'),
+    meta: require('./fixtures/escrow-finish-meta-binary.json'),
+  },
+  cancel: {
+    tx: require('./fixtures/escrow-cancel-tx.json'),
+    binary: require('./fixtures/escrow-cancel-binary.json'),
+  },
+}
+const PaymentChannel = {
+  create: {
+    tx: require('./fixtures/payment-channel-create-tx.json'),
+    binary: require('./fixtures/payment-channel-create-binary.json'),
+  },
+  fund: {
+    tx: require('./fixtures/payment-channel-fund-tx.json'),
+    binary: require('./fixtures/payment-channel-fund-binary.json'),
+  },
+  claim: {
+    tx: require('./fixtures/payment-channel-claim-tx.json'),
+    binary: require('./fixtures/payment-channel-claim-binary.json'),
+  },
+}
+
+const Ticket = {
+  create: {
+    tx: require('./fixtures/ticket-create-tx.json'),
+    binary: require('./fixtures/ticket-create-binary.json'),
+  },
+}
+
+let json_undefined = {
+  TakerPays: '223174650',
+  Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
+  TransactionType: 'OfferCreate',
+  Memos: [
+    {
+      Memo: {
+        MemoType: '584D4D2076616C7565',
+        MemoData: '322E3230393635',
+        MemoFormat: undefined,
+      },
+    },
+  ],
+  Fee: '15',
+  OfferSequence: undefined,
+  TakerGets: {
+    currency: 'XMM',
+    value: '100',
+    issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
+  },
+  Flags: 524288,
+  Sequence: undefined,
+  LastLedgerSequence: 6220135,
+}
+
+let json_omitted = {
+  TakerPays: '223174650',
+  Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
+  TransactionType: 'OfferCreate',
+  Memos: [
+    {
+      Memo: {
+        MemoType: '584D4D2076616C7565',
+        MemoData: '322E3230393635',
+      },
+    },
+  ],
+  Fee: '15',
+  TakerGets: {
+    currency: 'XMM',
+    value: '100',
+    issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
+  },
+  Flags: 524288,
+  LastLedgerSequence: 6220135,
+}
+
+const NegativeUNL = require('./fixtures/negative-unl.json')
+
+function bytesListTest() {
+  const list = new BytesList()
+    .put(Buffer.from([0]))
+    .put(Buffer.from([2, 3]))
+    .put(Buffer.from([4, 5]))
+  test('is an Array<Buffer>', function () {
+    expect(Array.isArray(list.bytesArray)).toBe(true)
+    expect(list.bytesArray[0] instanceof Buffer).toBe(true)
+  })
+  test('keeps track of the length itself', function () {
+    expect(list.getLength()).toBe(5)
+  })
+  test('can join all arrays into one via toBytes', function () {
+    const joined = list.toBytes()
+    expect(joined).toHaveLength(5)
+    expect(joined).toEqual(Buffer.from([0, 2, 3, 4, 5]))
+  })
+}
+
+function assertRecycles(blob) {
+  const parser = makeParser(blob)
+  const so = parser.readType(STObject)
+  const out = new BytesList()
+  so.toBytesSink(out)
+  const hex = out.toHex()
+  expect(hex).toEqual(blob)
+  expect(hex + ':').not.toEqual(blob)
+}
+
+function nestedObjectTests() {
+  fixtures.whole_objects.forEach((f, i) => {
+    test(`whole_objects[${i}]: can parse blob and dump out same blob`, () => {
+      assertRecycles(f.blob_with_no_signing)
+    })
+  })
+}
+
+function check(type, n, expected) {
+  test(`Uint${type.width * 8} serializes ${n} as ${expected}`, function () {
+    const bl = new BytesList()
+    const serializer = new BinarySerializer(bl)
+    if (expected === 'throws') {
+      expect(() => serializer.writeType(type, n)).toThrow()
+      return
+    }
+    serializer.writeType(type, n)
+    expect(bl.toBytes()).toEqual(Buffer.from(expected))
+  })
+}
+
+check(UInt8, 5, [5])
+check(UInt16, 5, [0, 5])
+check(UInt32, 5, [0, 0, 0, 5])
+check(UInt32, 0xffffffff, [255, 255, 255, 255])
+check(UInt8, 0xfeffffff, 'throws')
+check(UInt16, 0xfeffffff, 'throws')
+check(UInt16, 0xfeffffff, 'throws')
+check(UInt64, 0xfeffffff, [0, 0, 0, 0, 254, 255, 255, 255])
+check(UInt64, -1, 'throws')
+check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0])
+check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1])
+check(UInt64, bigInt(1), [0, 0, 0, 0, 0, 0, 0, 1])
+
+function deliverMinTest() {
+  test('can serialize DeliverMin', () => {
+    expect(encode(deliverMinTx)).toEqual(deliverMinTxBinary)
+  })
+}
+
+function SignerListSetTest() {
+  test('can serialize SignerListSet', () => {
+    expect(encode(SignerListSet.tx)).toEqual(SignerListSet.binary)
+  })
+  test('can serialize SignerListSet metadata', () => {
+    expect(encode(SignerListSet.tx.meta)).toEqual(SignerListSet.meta)
+  })
+}
+
+function DepositPreauthTest() {
+  test('can serialize DepositPreauth', () => {
+    expect(encode(DepositPreauth.tx)).toEqual(DepositPreauth.binary)
+  })
+  test('can serialize DepositPreauth metadata', () => {
+    expect(encode(DepositPreauth.tx.meta)).toEqual(DepositPreauth.meta)
+  })
+}
+
+function EscrowTest() {
+  test('can serialize EscrowCreate', () => {
+    expect(encode(Escrow.create.tx)).toEqual(Escrow.create.binary)
+  })
+  test('can serialize EscrowFinish', () => {
+    expect(encode(Escrow.finish.tx)).toEqual(Escrow.finish.binary)
+    expect(encode(Escrow.finish.tx.meta)).toEqual(Escrow.finish.meta)
+  })
+  test('can serialize EscrowCancel', () => {
+    expect(encode(Escrow.cancel.tx)).toEqual(Escrow.cancel.binary)
+  })
+}
+
+function PaymentChannelTest() {
+  test('can serialize PaymentChannelCreate', () => {
+    expect(encode(PaymentChannel.create.tx)).toEqual(
+      PaymentChannel.create.binary,
+    )
+  })
+  test('can serialize PaymentChannelFund', () => {
+    expect(encode(PaymentChannel.fund.tx)).toEqual(PaymentChannel.fund.binary)
+  })
+  test('can serialize PaymentChannelClaim', () => {
+    expect(encode(PaymentChannel.claim.tx)).toEqual(PaymentChannel.claim.binary)
+  })
+}
+
+function NegativeUNLTest() {
+  test('can serialize NegativeUNL', () => {
+    expect(encode(NegativeUNL.tx)).toEqual(NegativeUNL.binary)
+  })
+  test('can deserialize NegativeUNL', () => {
+    expect(decode(NegativeUNL.binary)).toEqual(NegativeUNL.tx)
+  })
+}
+
+function omitUndefinedTest() {
+  test('omits fields with undefined value', () => {
+    let encodedOmitted = encode(json_omitted)
+    let encodedUndefined = encode(json_undefined)
+    expect(encodedOmitted).toEqual(encodedUndefined)
+    expect(decode(encodedOmitted)).toEqual(decode(encodedUndefined))
+  })
+}
+
+function ticketTest() {
+  test('can serialize TicketCreate', () => {
+    expect(encode(Ticket.create.tx)).toEqual(Ticket.create.binary)
+  })
+}
+
+function nfTokenTest() {
+  const fixtures = require('./fixtures/nf-token.json')
+
+  for (const txName of Object.keys(fixtures)) {
+    test(`can serialize transaction ${txName}`, () => {
+      expect(encode(fixtures[txName].tx.json)).toEqual(
+        fixtures[txName].tx.binary,
+      )
+    })
+
+    test(`can deserialize transaction ${txName}`, () => {
+      expect(decode(fixtures[txName].tx.binary)).toEqual(
+        fixtures[txName].tx.json,
+      )
+    })
+
+    test(`can serialize meta ${txName}`, () => {
+      expect(encode(fixtures[txName].meta.json)).toEqual(
+        fixtures[txName].meta.binary,
+      )
+    })
+
+    test(`can deserialize meta ${txName}`, () => {
+      expect(decode(fixtures[txName].meta.binary)).toEqual(
+        fixtures[txName].meta.json,
+      )
+    })
+  }
+}
+
+describe('Binary Serialization', function () {
+  describe('nestedObjectTests', nestedObjectTests)
+  describe('BytesList', bytesListTest)
+  describe('DeliverMin', deliverMinTest)
+  describe('DepositPreauth', DepositPreauthTest)
+  describe('SignerListSet', SignerListSetTest)
+  describe('Escrow', EscrowTest)
+  describe('PaymentChannel', PaymentChannelTest)
+  describe('NegativeUNLTest', NegativeUNLTest)
+  describe('OmitUndefined', omitUndefinedTest)
+  describe('TicketTest', ticketTest)
+  describe('NFToken', nfTokenTest)
+})

packages/ripple-binary-codec/test/fixtures/delivermin-tx-binary.json

@@ -0,0 +1 @@
+"1200002280020000240000689E201B010BF0E361D4950EA99C657EF800000000000000000000000055534400000000000A20B3C85F482532A9578DBB3950B85CA06594D1684000000000002AF8694000000000003A986AD40485B690F28E8000000000000000000000000055534400000000000A20B3C85F482532A9578DBB3950B85CA06594D173210254D771E2A30552D1F347F5B88EC87513843F8BC1A408E70A4175B2E3C325FD3C7446304402202A4965FCF0571B7308971956864B1949C2BD924B5A41B5E8DAF00C91C64F964502207FD3BEB7C165BD1F10E6E7C443742BD686F8E102A89B502A4A495F4C29EC5C488114EAAA52373B59DCFBFD3476049AA6408AA22EAA898314EAAA52373B59DCFBFD3476049AA6408AA22EAA8901123000000000000000000000000055534400000000000A20B3C85F482532A9578DBB3950B85CA06594D1FF01FDF050193BEDEAA9074764B961405D31E66AC0E9300000000000000000000000005553440000000000FDF050193BEDEAA9074764B961405D31E66AC0E901FDF050193BEDEAA9074764B961405D31E66AC0E9FF300000000000000000000000005553440000000000DD39C650A96EDA48334E70CC4A85B8B2E8502CD301DD39C650A96EDA48334E70CC4A85B8B2E8502CD3017C44F934D7A5FEEBD1530570CDB83D1D8EF1F37E00"

packages/ripple-binary-codec/test/fixtures/delivermin-tx.json

@@ -0,0 +1,98 @@
+{
+  "Account": "r4PowrZ7KZw83oWDYxzY82ht2kgDmFUpB7",
+  "Amount": {
+    "currency": "USD",
+    "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
+    "value": "5.927096147083"
+  },
+  "DeliverMin": {
+    "currency": "USD",
+    "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
+    "value": "0.012729190692"
+  },
+  "Destination": "r4PowrZ7KZw83oWDYxzY82ht2kgDmFUpB7",
+  "Fee": "11000",
+  "Flags": 2147614720,
+  "LastLedgerSequence": 17559779,
+  "Paths": [
+    [
+      {
+        "currency": "USD",
+        "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
+        "type": 48,
+        "type_hex": "0000000000000030"
+      }
+    ],
+    [
+      {
+        "account": "rQ96qm46YsRX2F7SSCQxToR2ybRuUYsZ4R",
+        "type": 1,
+        "type_hex": "0000000000000001"
+      },
+      {
+        "currency": "USD",
+        "issuer": "rQ96qm46YsRX2F7SSCQxToR2ybRuUYsZ4R",
+        "type": 48,
+        "type_hex": "0000000000000030"
+      },
+      {
+        "account": "rQ96qm46YsRX2F7SSCQxToR2ybRuUYsZ4R",
+        "type": 1,
+        "type_hex": "0000000000000001"
+      }
+    ],
+    [
+      {
+        "currency": "USD",
+        "issuer": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
+        "type": 48,
+        "type_hex": "0000000000000030"
+      },
+      {
+        "account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
+        "type": 1,
+        "type_hex": "0000000000000001"
+      },
+      {
+        "account": "rULnR9YhAkj9HrcxAcudzBhaXRSqT7zJkq",
+        "type": 1,
+        "type_hex": "0000000000000001"
+      }
+    ]
+  ],
+  "SendMax": "15000",
+  "Sequence": 26782,
+  "SigningPubKey": "0254D771E2A30552D1F347F5B88EC87513843F8BC1A408E70A4175B2E3C325FD3C",
+  "TransactionType": "Payment",
+  "TxnSignature": "304402202A4965FCF0571B7308971956864B1949C2BD924B5A41B5E8DAF00C91C64F964502207FD3BEB7C165BD1F10E6E7C443742BD686F8E102A89B502A4A495F4C29EC5C48",
+  "date": 502912010,
+  "hash": "0FB10DF664F33840ABC68A8BBE78178359C55AC1AFC83DB468CE69C4A86E3EAC",
+  "inLedger": 17559773,
+  "ledger_index": 17559773,
+  "meta": {
+    "AffectedNodes": [
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Account": "r4PowrZ7KZw83oWDYxzY82ht2kgDmFUpB7",
+            "Balance": "1064773000",
+            "Flags": 65536,
+            "OwnerCount": 9,
+            "Sequence": 26783
+          },
+          "LedgerEntryType": "AccountRoot",
+          "LedgerIndex": "0D7F8ADAA3269E9C8B2AA9CDE31BC57E2E52133F36516D3DF576DBCE6E405BDC",
+          "PreviousFields": {
+            "Balance": "1064784000",
+            "Sequence": 26782
+          },
+          "PreviousTxnID": "E028797D6C7AE9B84C6930452D427D5E40CE23E199E8DF0534DAAE5277A76CC1",
+          "PreviousTxnLgrSeq": 17537115
+        }
+      }
+    ],
+    "TransactionIndex": 12,
+    "TransactionResult": "tecPATH_PARTIAL"
+  },
+  "validated": true
+}

packages/ripple-binary-codec/test/fixtures/deposit-preauth-tx-binary.json

@@ -0,0 +1 @@
+"1200132280000000240000004168400000000000000A732103EB1E2603E7571D6144684996C10DA75063D6E2F3B3FDABE38B857C1BE9578A5574473045022100B0A5672E3E09FA3AF8CF1DCC1D8C881F58B39212D6FDC42CCF30E5400D0EFD9F02202DDD9517D9409D1D9A529B8AEA7DE13AE4CDF96BB6D18FA0D9732DBFC887348D81148A928D14A643F388AC0D26BAF9755B07EB0A2B44851486FFE2A17E861BA0FE9A3ED8352F895D80E789E0"

packages/ripple-binary-codec/test/fixtures/deposit-preauth-tx-meta-binary.json

@@ -0,0 +1 @@
+"201C00000000F8E51100612500AE5F59558107CEE99D556326ACD4662CA10A24550240D9F933E55435A0C0DB3B06DD343E56146AAAF7A266D8A92DFFEAB1A71B6523534F27820873F4E213014B23398867D2E624000000412D00000007624000000249CB5DD0E1E7220000000024000000422D00000008624000000249CB5DC681148A928D14A643F388AC0D26BAF9755B07EB0A2B44E1E1E311007056C2D0317AD266B93CB3B36AEB0ABB673B0AFFAB134809CCACFD7158F539603C3AE881148A928D14A643F388AC0D26BAF9755B07EB0A2B44851486FFE2A17E861BA0FE9A3ED8352F895D80E789E0E1E1E511006456CD08416851CA53E9649408118A4908E01E43436ED950886D1B1E66F4B68B82ECE7220000000058CD08416851CA53E9649408118A4908E01E43436ED950886D1B1E66F4B68B82EC82148A928D14A643F388AC0D26BAF9755B07EB0A2B44E1E1F1031000"

packages/ripple-binary-codec/test/fixtures/deposit-preauth-tx.json

@@ -0,0 +1,58 @@
+{
+  "Account": "rDd6FpNbeY2CrQajSmP178BmNGusmQiYMM",
+  "Authorize": "rDJFnv5sEfp42LMFiX3mVQKczpFTdxYDzM",
+  "Fee": "10",
+  "Flags": 2147483648,
+  "Sequence": 65,
+  "SigningPubKey": "03EB1E2603E7571D6144684996C10DA75063D6E2F3B3FDABE38B857C1BE9578A55",
+  "TransactionType": "DepositPreauth",
+  "TxnSignature": "3045022100B0A5672E3E09FA3AF8CF1DCC1D8C881F58B39212D6FDC42CCF30E5400D0EFD9F02202DDD9517D9409D1D9A529B8AEA7DE13AE4CDF96BB6D18FA0D9732DBFC887348D",
+  "hash": "B5D94C027C846171B2F5D4C2D126E88580BF369986A155C1890352F5BC4D7AF9",
+  "meta": {
+    "AffectedNodes": [
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Account": "rDd6FpNbeY2CrQajSmP178BmNGusmQiYMM",
+            "Balance": "9827999174",
+            "Flags": 0,
+            "OwnerCount": 8,
+            "Sequence": 66
+          },
+          "LedgerEntryType": "AccountRoot",
+          "LedgerIndex": "146AAAF7A266D8A92DFFEAB1A71B6523534F27820873F4E213014B23398867D2",
+          "PreviousFields": {
+            "Balance": "9827999184",
+            "OwnerCount": 7,
+            "Sequence": 65
+          },
+          "PreviousTxnID": "8107CEE99D556326ACD4662CA10A24550240D9F933E55435A0C0DB3B06DD343E",
+          "PreviousTxnLgrSeq": 11427673
+        }
+      },
+      {
+        "CreatedNode": {
+          "LedgerEntryType": "DepositPreauth",
+          "LedgerIndex": "C2D0317AD266B93CB3B36AEB0ABB673B0AFFAB134809CCACFD7158F539603C3A",
+          "NewFields": {
+            "Account": "rDd6FpNbeY2CrQajSmP178BmNGusmQiYMM",
+            "Authorize": "rDJFnv5sEfp42LMFiX3mVQKczpFTdxYDzM"
+          }
+        }
+      },
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Flags": 0,
+            "Owner": "rDd6FpNbeY2CrQajSmP178BmNGusmQiYMM",
+            "RootIndex": "CD08416851CA53E9649408118A4908E01E43436ED950886D1B1E66F4B68B82EC"
+          },
+          "LedgerEntryType": "DirectoryNode",
+          "LedgerIndex": "CD08416851CA53E9649408118A4908E01E43436ED950886D1B1E66F4B68B82EC"
+        }
+      }
+    ],
+    "TransactionIndex": 0,
+    "TransactionResult": "tesSUCCESS"
+  }
+}

packages/ripple-binary-codec/test/fixtures/escrow-cancel-binary.json

@@ -0,0 +1 @@
+"1200042019000000198114EE5F7CF61504C7CF7E0C22562EB19CC7ACB0FCBA8214EE5F7CF61504C7CF7E0C22562EB19CC7ACB0FCBA"

packages/ripple-binary-codec/test/fixtures/escrow-cancel-tx.json

@@ -0,0 +1,6 @@
+{
+   "Account" : "r4jQDHCUvgcBAa5EzcB1D8BHGcjYP9eBC2",
+   "OfferSequence" : 25,
+   "Owner" : "r4jQDHCUvgcBAa5EzcB1D8BHGcjYP9eBC2",
+   "TransactionType" : "EscrowCancel"
+}

packages/ripple-binary-codec/test/fixtures/escrow-create-binary.json

@@ -0,0 +1 @@
+"1200012E00005BB82024258D09812025258D0980614000000000000064701127A0258020E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B8558101008114EE5F7CF61504C7CF7E0C22562EB19CC7ACB0FCBA8314B5F762798A53D543A014CAF8B297CFF8F2F937E8"

packages/ripple-binary-codec/test/fixtures/escrow-create-tx.json

@@ -0,0 +1,10 @@
+{
+  "Account" : "r4jQDHCUvgcBAa5EzcB1D8BHGcjYP9eBC2",
+  "Amount" : "100",
+  "CancelAfter" : 630000001,
+  "Condition" : "A0258020E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855810100",
+  "Destination" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+  "DestinationTag" : 23480,
+  "FinishAfter" : 630000000,
+  "TransactionType": "EscrowCreate"
+}

packages/ripple-binary-codec/test/fixtures/escrow-finish-binary.json

@@ -0,0 +1 @@
+"1200022280000000240000000320190000000268400000000000000A7321028DB04DA8B702272B2A29FAF3DBCF40D01386208E6A9541DB497BE962FEF96A9C74473045022100E3C860D54E88AFA8584FBED99AA38BCB512AB1D69D87F3F71EF38ACB6EA4B7A202204CC1BB34DAA221416DB8946B583D4F33C7E22C130F9FA49353FB6ADB2DF6C69D8114E151CA3207BAB5B91D2F0E4D35ECDFD4551C69A18214E151CA3207BAB5B91D2F0E4D35ECDFD4551C69A1"

packages/ripple-binary-codec/test/fixtures/escrow-finish-meta-binary.json

@@ -0,0 +1 @@
+"201C0000000BF8E511006125020B814F55F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F95644A462A2806A513D7480CA71059D3D33637B65458017A8828A8F95AF17272501E6624000000010DC67D0E1E7220000000024000000052D00000000624000000013C074F08114DC0BCC71D87BB4E684B35721DC12F2C4E1ABABA4E1E1E4110075569766AE124E5053BCFDE253F6E3DDBAC13858CC0700DDECDCD57FF2FA777BEF7DE7220000000025020B814F202521A0C1B834000000000000000039000000000000000055F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F9614000000002E40D208114E151CA3207BAB5B91D2F0E4D35ECDFD4551C69A18314DC0BCC71D87BB4E684B35721DC12F2C4E1ABABA4E1E1E511006456BA4B47767C25E21CCDA3553BD45BE3699B34B508B459FE0472C70C51660058E0E7220000000058BA4B47767C25E21CCDA3553BD45BE3699B34B508B459FE0472C70C51660058E08214E151CA3207BAB5B91D2F0E4D35ECDFD4551C69A1E1E1E511006125020B814F55F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F956E4DA2A510F0C7FFD0474FAA4C7308A83828E0B3DD09EAA9CFDFFC067E3719D2EE624000000032D00000001624000000002FAF06CE1E7220000000024000000042D00000000624000000002FAF0628114E151CA3207BAB5B91D2F0E4D35ECDFD4551C69A1E1E1E511006456ECE79D27042E87B02DF3A263DB6BB6FCD96E69E20E0955F84D47D164C37546A1E7220000000058ECE79D27042E87B02DF3A263DB6BB6FCD96E69E20E0955F84D47D164C37546A18214DC0BCC71D87BB4E684B35721DC12F2C4E1ABABA4E1E1F1031000"

packages/ripple-binary-codec/test/fixtures/escrow-finish-tx.json

@@ -0,0 +1,95 @@
+{
+  "Account": "rMYPppnVNQ7crMizv8D6wF45kYuSupygyr",
+  "Fee": "10",
+  "Flags": 2147483648,
+  "OfferSequence": 2,
+  "Owner": "rMYPppnVNQ7crMizv8D6wF45kYuSupygyr",
+  "Sequence": 3,
+  "SigningPubKey": "028DB04DA8B702272B2A29FAF3DBCF40D01386208E6A9541DB497BE962FEF96A9C",
+  "TransactionType": "EscrowFinish",
+  "TxnSignature": "3045022100E3C860D54E88AFA8584FBED99AA38BCB512AB1D69D87F3F71EF38ACB6EA4B7A202204CC1BB34DAA221416DB8946B583D4F33C7E22C130F9FA49353FB6ADB2DF6C69D",
+  "hash": "1A76D4BA47A53A66B539D4BD4C30826A5E51C78D0B7344758EACAC77A6753C3C",
+  "meta": {
+    "AffectedNodes": [
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Account": "rMhV8zfKJRqEspcayRfqa4FuzQg8kW5LdB",
+            "Balance": "331379952",
+            "Flags": 0,
+            "OwnerCount": 0,
+            "Sequence": 5
+          },
+          "LedgerEntryType": "AccountRoot",
+          "LedgerIndex": "44A462A2806A513D7480CA71059D3D33637B65458017A8828A8F95AF17272501",
+          "PreviousFields": {
+            "Balance": "282879952"
+          },
+          "PreviousTxnID": "F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F9",
+          "PreviousTxnLgrSeq": 34308431
+        }
+      },
+      {
+        "DeletedNode": {
+          "FinalFields": {
+            "Account": "rMYPppnVNQ7crMizv8D6wF45kYuSupygyr",
+            "Amount": "48500000",
+            "Destination": "rMhV8zfKJRqEspcayRfqa4FuzQg8kW5LdB",
+            "DestinationNode": "0000000000000000",
+            "FinishAfter": 564183480,
+            "Flags": 0,
+            "OwnerNode": "0000000000000000",
+            "PreviousTxnID": "F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F9",
+            "PreviousTxnLgrSeq": 34308431
+          },
+          "LedgerEntryType": "Escrow",
+          "LedgerIndex": "9766AE124E5053BCFDE253F6E3DDBAC13858CC0700DDECDCD57FF2FA777BEF7D"
+        }
+      },
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Flags": 0,
+            "Owner": "rMYPppnVNQ7crMizv8D6wF45kYuSupygyr",
+            "RootIndex": "BA4B47767C25E21CCDA3553BD45BE3699B34B508B459FE0472C70C51660058E0"
+          },
+          "LedgerEntryType": "DirectoryNode",
+          "LedgerIndex": "BA4B47767C25E21CCDA3553BD45BE3699B34B508B459FE0472C70C51660058E0"
+        }
+      },
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Account": "rMYPppnVNQ7crMizv8D6wF45kYuSupygyr",
+            "Balance": "49999970",
+            "Flags": 0,
+            "OwnerCount": 0,
+            "Sequence": 4
+          },
+          "LedgerEntryType": "AccountRoot",
+          "LedgerIndex": "E4DA2A510F0C7FFD0474FAA4C7308A83828E0B3DD09EAA9CFDFFC067E3719D2E",
+          "PreviousFields": {
+            "Balance": "49999980",
+            "OwnerCount": 1,
+            "Sequence": 3
+          },
+          "PreviousTxnID": "F72706F8C7B9C07D83332BE330D77B5CE6A246FE4FA04DD47EBC88719A35B5F9",
+          "PreviousTxnLgrSeq": 34308431
+        }
+      },
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Flags": 0,
+            "Owner": "rMhV8zfKJRqEspcayRfqa4FuzQg8kW5LdB",
+            "RootIndex": "ECE79D27042E87B02DF3A263DB6BB6FCD96E69E20E0955F84D47D164C37546A1"
+          },
+          "LedgerEntryType": "DirectoryNode",
+          "LedgerIndex": "ECE79D27042E87B02DF3A263DB6BB6FCD96E69E20E0955F84D47D164C37546A1"
+        }
+      }
+    ],
+    "TransactionIndex": 11,
+    "TransactionResult": "tesSUCCESS"
+  }
+}

packages/ripple-binary-codec/test/fixtures/negative-unl.json

@@ -0,0 +1,12 @@
+{
+    "binary": "120066240000000026000003006840000000000000007300701321ED9D593004CC501CACD261BD8E31E863F2B3F6CA69505E7FD54DA8F5690BEFB7AE8114000000000000000000000000000000000000000000101101",
+    "tx": {
+        "UNLModifyDisabling": 1,
+        "LedgerSequence": 768,
+        "UNLModifyValidator": "ED9D593004CC501CACD261BD8E31E863F2B3F6CA69505E7FD54DA8F5690BEFB7AE",
+        "TransactionType": "UNLModify",
+        "Account": "rrrrrrrrrrrrrrrrrrrrrhoLvTp",
+        "Sequence": 0,
+        "Fee": "0",
+        "SigningPubKey": ""}
+}

packages/ripple-binary-codec/test/fixtures/nf-token.json

@@ -0,0 +1,547 @@
+{
+  "NFTokenMint": {
+    "tx": {
+      "json": {
+        "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+        "Fee": "12",
+        "Flags": 9,
+        "LastLedgerSequence": 22,
+        "Sequence": 5,
+        "SigningPubKey": "0330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020",
+        "TokenTaxon": 0,
+        "TransactionType": "NFTokenMint",
+        "TransferFee": 50,
+        "TxnSignature": "3045022100DAB7343B26035702FF7E0736E04A092AC9512964E41C3CA64926CDFBE777946602202F295A3BB1282E0AF98F9F5978D4037D75EDEB0EC642519D966D7B9B5826E61B",
+        "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+      },
+      "binary": "12001914003222000000092400000005201B00000016202A0000000068400000000000000C73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD02074473045022100DAB7343B26035702FF7E0736E04A092AC9512964E41C3CA64926CDFBE777946602202F295A3BB1282E0AF98F9F5978D4037D75EDEB0EC642519D966D7B9B5826E61B751868747470733A2F2F677265677765697362726F642E636F6D8114B5F762798A53D543A014CAF8B297CFF8F2F937E8"
+    },
+    "meta": {
+      "json": {
+        "AffectedNodes": [
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "Balance": "99999999999999940",
+                "Flags": 0,
+                "MintedTokens": 5,
+                "OwnerCount": 1,
+                "Sequence": 6
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
+              "PreviousFields": {
+                "Balance": "99999999999999952",
+                "MintedTokens": 4,
+                "Sequence": 5
+              },
+              "PreviousTxnID": "E9BFEE7C403F74445B59B8FA8E972ABD642A360E1FBC15C53BAA717573BEC462",
+              "PreviousTxnLgrSeq": 3
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Flags": 0,
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F00000004",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "LedgerEntryType": "NFTokenPage",
+              "LedgerIndex": "B5F762798A53D543A014CAF8B297CFF8F2F937E8FFFFFFFFFFFFFFFFFFFFFFFF",
+              "PreviousFields": {
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "PreviousTxnID": "E9BFEE7C403F74445B59B8FA8E972ABD642A360E1FBC15C53BAA717573BEC462",
+              "PreviousTxnLgrSeq": 3
+            }
+          }
+        ],
+        "TransactionIndex": 4,
+        "TransactionResult": "tesSUCCESS"
+      },
+      "binary": "201C00000004F8E5110061250000000355E9BFEE7C403F74445B59B8FA8E972ABD642A360E1FBC15C53BAA717573BEC462562B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8E62400000005202B0000000462416345785D89FFD0E1E7220000000024000000062D00000001202B0000000562416345785D89FFC48114B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1E5110050250000000355E9BFEE7C403F74445B59B8FA8E972ABD642A360E1FBC15C53BAA717573BEC46256B5F762798A53D543A014CAF8B297CFF8F2F937E8FFFFFFFFFFFFFFFFFFFFFFFFE6FAEC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003751868747470733A2F2F677265677765697362726F642E636F6DE1F1E1E72200000000FAEC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F00000004751868747470733A2F2F677265677765697362726F642E636F6DE1F1E1E1F1031000"
+    }
+  },
+  "NFTokenBurn": {
+    "tx": {
+      "json": {
+        "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+        "Fee": "12",
+        "Flags": 0,
+        "LastLedgerSequence": 23,
+        "Sequence": 6,
+        "SigningPubKey": "0330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020",
+        "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F00000004",
+        "TransactionType": "NFTokenBurn",
+        "TxnSignature": "3045022100D614E1F0A1C41A05652B8998FC2C4DC8658B95BFD89F4A0DEBE3FFDCB75CE1D8022027DF89138FC442C803DC2BEC07636CEB8D0EC6297E23262A729B83D32F93FD3D"
+      },
+      "binary": "12001A22000000002400000006201B000000175A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F0000000468400000000000000C73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD02074473045022100D614E1F0A1C41A05652B8998FC2C4DC8658B95BFD89F4A0DEBE3FFDCB75CE1D8022027DF89138FC442C803DC2BEC07636CEB8D0EC6297E23262A729B83D32F93FD3D8114B5F762798A53D543A014CAF8B297CFF8F2F937E8"
+    },
+    "meta": {
+      "json": {
+        "AffectedNodes": [
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "Balance": "99999999999999928",
+                "BurnedTokens": 1,
+                "Flags": 0,
+                "MintedTokens": 5,
+                "OwnerCount": 1,
+                "Sequence": 7
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
+              "PreviousFields": {
+                "Balance": "99999999999999940",
+                "Sequence": 6
+              },
+              "PreviousTxnID": "5F0E3A19F1D5B028A31B8A0FDE8533B0FD185E4AE306F79CFF51D18E68985231",
+              "PreviousTxnLgrSeq": 3
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Flags": 0,
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "LedgerEntryType": "NFTokenPage",
+              "LedgerIndex": "B5F762798A53D543A014CAF8B297CFF8F2F937E8FFFFFFFFFFFFFFFFFFFFFFFF",
+              "PreviousFields": {
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F00000004",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "PreviousTxnID": "5F0E3A19F1D5B028A31B8A0FDE8533B0FD185E4AE306F79CFF51D18E68985231",
+              "PreviousTxnLgrSeq": 3
+            }
+          }
+        ],
+        "TransactionIndex": 0,
+        "TransactionResult": "tesSUCCESS"
+      },
+      "binary": "201C00000000F8E51100612500000003555F0E3A19F1D5B028A31B8A0FDE8533B0FD185E4AE306F79CFF51D18E68985231562B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8E6240000000662416345785D89FFC4E1E7220000000024000000072D00000001202B00000005202C0000000162416345785D89FFB88114B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1E51100502500000003555F0E3A19F1D5B028A31B8A0FDE8533B0FD185E4AE306F79CFF51D18E6898523156B5F762798A53D543A014CAF8B297CFF8F2F937E8FFFFFFFFFFFFFFFFFFFFFFFFE6FAEC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E85B974D9F00000004751868747470733A2F2F677265677765697362726F642E636F6DE1F1E1E72200000000FAEC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002751868747470733A2F2F677265677765697362726F642E636F6DE1EC5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003751868747470733A2F2F677265677765697362726F642E636F6DE1F1E1E1F1031000"
+    }
+  },
+  "NFTokenCreateOffer": {
+    "tx": {
+      "json": {
+        "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+        "Amount": "100",
+        "Destination": "rV3WAvwwXgvPrYiUgSoytn9w3mejtPgLo",
+        "Expiration": 999999999,
+        "Fee": "12",
+        "Flags": 1,
+        "LastLedgerSequence": 26,
+        "Sequence": 9,
+        "SigningPubKey": "0330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020",
+        "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+        "TransactionType": "NFTokenCreateOffer",
+        "TxnSignature": "3045022100BCEEEF98B9DB3A2ACA7CE80AB91B9398E3429B93F660BB8A063F134AA798AE970220667C560D16E555DF5EF30536804C082DAEC7A446DF2C7533ADB1E2437AF2CCB0"
+      },
+      "binary": "12001B220000000124000000092A3B9AC9FF201B0000001A5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B0000000061400000000000006468400000000000000C73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD02074473045022100BCEEEF98B9DB3A2ACA7CE80AB91B9398E3429B93F660BB8A063F134AA798AE970220667C560D16E555DF5EF30536804C082DAEC7A446DF2C7533ADB1E2437AF2CCB08114B5F762798A53D543A014CAF8B297CFF8F2F937E883140551EBD684BF2ADE0EF093A92B6E2C55D15BD9AE"
+    },
+    "meta": {
+      "json": {
+        "AffectedNodes": [
+          {
+            "CreatedNode": {
+              "LedgerEntryType": "NFTokenOffer",
+              "LedgerIndex": "1DEF39A07F364CB73BF5F8306BE22628D0AE517A2CB0AE5341269B1E671F2052",
+              "NewFields": {
+                "Amount": "100",
+                "Expiration": 999999999,
+                "Flags": 1,
+                "Owner": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000"
+              }
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "Balance": "99999999999999892",
+                "BurnedTokens": 1,
+                "Flags": 0,
+                "MintedTokens": 5,
+                "OwnerCount": 2,
+                "Sequence": 10
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
+              "PreviousFields": {
+                "Balance": "99999999999999904",
+                "OwnerCount": 1,
+                "Sequence": 9
+              },
+              "PreviousTxnID": "D73C0ACEA1D4C9186A4AF1EAE2A4BD0A719A78AF6CE897C289AB297D371BEF53",
+              "PreviousTxnLgrSeq": 6
+            }
+          },
+          {
+            "CreatedNode": {
+              "LedgerEntryType": "DirectoryNode",
+              "LedgerIndex": "86992C19DA69763CAA9A4FC1697508140A995F15173EB00892C8EE23D5FD8FC3",
+              "NewFields": {
+                "Flags": 2,
+                "RootIndex": "86992C19DA69763CAA9A4FC1697508140A995F15173EB00892C8EE23D5FD8FC3",
+                "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000"
+              }
+            }
+          },
+          {
+            "CreatedNode": {
+              "LedgerEntryType": "DirectoryNode",
+              "LedgerIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204",
+              "NewFields": {
+                "Owner": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "RootIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204"
+              }
+            }
+          }
+        ],
+        "TransactionIndex": 0,
+        "TransactionResult": "tesSUCCESS"
+      },
+      "binary": "201C00000000F8E3110037561DEF39A07F364CB73BF5F8306BE22628D0AE517A2CB0AE5341269B1E671F2052E822000000012A3B9AC9FF5A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B000000006140000000000000648214B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1E5110061250000000655D73C0ACEA1D4C9186A4AF1EAE2A4BD0A719A78AF6CE897C289AB297D371BEF53562B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8E624000000092D0000000162416345785D89FFA0E1E72200000000240000000A2D00000002202B00000005202C0000000162416345785D89FF948114B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1E31100645686992C19DA69763CAA9A4FC1697508140A995F15173EB00892C8EE23D5FD8FC3E822000000025886992C19DA69763CAA9A4FC1697508140A995F15173EB00892C8EE23D5FD8FC35A00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000E1E1E311006456D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204E858D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA6352048214B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1F1031000"
+    }
+  },
+  "NFTokenCancelOffer": {
+    "tx": {
+      "json": {
+        "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+        "Fee": "12",
+        "Flags": 0,
+        "LastLedgerSequence": 27,
+        "Sequence": 10,
+        "SigningPubKey": "0330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020",
+        "TokenIDs": [
+          "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000"
+        ],
+        "TransactionType": "NFTokenCancelOffer",
+        "TxnSignature": "3044022075EAF267D19A626B3D970A96C363380FC7CCFB81178D75F723C5F097309B9FBC022027A896B759E882BFCB810C8AB5B3D819AEBFCAD6E0AF17F909BB3AFA9085EBEE"
+      },
+      "binary": "12001C2200000000240000000A201B0000001B68400000000000000C73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD02074463044022075EAF267D19A626B3D970A96C363380FC7CCFB81178D75F723C5F097309B9FBC022027A896B759E882BFCB810C8AB5B3D819AEBFCAD6E0AF17F909BB3AFA9085EBEE8114B5F762798A53D543A014CAF8B297CFF8F2F937E804132000090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000"
+    },
+    "meta": {
+      "json": {
+        "AffectedNodes": [
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "Balance": "99999999999999880",
+                "BurnedTokens": 1,
+                "Flags": 0,
+                "MintedTokens": 5,
+                "OwnerCount": 2,
+                "Sequence": 11
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
+              "PreviousFields": {
+                "Balance": "99999999999999892",
+                "Sequence": 10
+              },
+              "PreviousTxnID": "4D43E602582E492DC685408C36B18CFB326FBC06C03DA46580F03356F91D590D",
+              "PreviousTxnLgrSeq": 7
+            }
+          }
+        ],
+        "TransactionIndex": 0,
+        "TransactionResult": "tesSUCCESS"
+      },
+      "binary": "201C00000000F8E51100612500000007554D43E602582E492DC685408C36B18CFB326FBC06C03DA46580F03356F91D590D562B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8E6240000000A62416345785D89FF94E1E72200000000240000000B2D00000002202B00000005202C0000000162416345785D89FF888114B5F762798A53D543A014CAF8B297CFF8F2F937E8E1E1F1031000"
+    }
+  },
+  "NFTokenAcceptOffer": {
+    "tx": {
+      "json": {
+        "Account": "rKBmBAi3cWzuj6iZYx6K7F3xF1LSs3br3o",
+        "Fee": "12",
+        "Flags": 0,
+        "LastLedgerSequence": 37,
+        "SellOffer": "AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AF",
+        "Sequence": 9,
+        "SigningPubKey": "ED3C94824B6696F16CA54F0E3085A5ED8867D19DC4BA572086E03DCAB30B094D79",
+        "TransactionType": "NFTokenAcceptOffer",
+        "TxnSignature": "D6653C5BDA53E29CFF05905BE4EA36A913D28D8730EAAB339FFC57D0484230349E195303A301490DDF5DC3BC01AD22047D9A0BBC37983D96ED06DBBFE43F9A08"
+      },
+      "binary": "12001D22000000002400000009201B00000025501DAED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AF68400000000000000C7321ED3C94824B6696F16CA54F0E3085A5ED8867D19DC4BA572086E03DCAB30B094D797440D6653C5BDA53E29CFF05905BE4EA36A913D28D8730EAAB339FFC57D0484230349E195303A301490DDF5DC3BC01AD22047D9A0BBC37983D96ED06DBBFE43F9A088114C77B4F8423139A8F0939DDEB9EB076CC74F4A3B3"
+    },
+    "meta": {
+      "json": {
+        "AffectedNodes": [
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "Balance": "99997999999999932",
+                "BurnedTokens": 1,
+                "Flags": 0,
+                "MintedTokens": 5,
+                "OwnerCount": 3,
+                "Sequence": 15
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
+              "PreviousFields": {
+                "Balance": "99997999999999832",
+                "OwnerCount": 4
+              },
+              "PreviousTxnID": "BB2608749900A1762B2C7E60AFB437091F56810B39E85545E9541A5F33FD2785",
+              "PreviousTxnLgrSeq": 16
+            }
+          },
+          {
+            "DeletedNode": {
+              "FinalFields": {
+                "Flags": 2,
+                "RootIndex": "45D3F54AACBCD7F8A5FB0737DA561BE9F0EA924276B2FDB0B8EA8D7FE4319632",
+                "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003"
+              },
+              "LedgerEntryType": "DirectoryNode",
+              "LedgerIndex": "45D3F54AACBCD7F8A5FB0737DA561BE9F0EA924276B2FDB0B8EA8D7FE4319632"
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Account": "rKBmBAi3cWzuj6iZYx6K7F3xF1LSs3br3o",
+                "Balance": "1999999999888",
+                "Flags": 0,
+                "OwnerCount": 1,
+                "Sequence": 10
+              },
+              "LedgerEntryType": "AccountRoot",
+              "LedgerIndex": "4BDDA92DDF4C9702E2952261A181E7E1EFF37E9C2AC9D390D0E81AF34FC8A325",
+              "PreviousFields": {
+                "Balance": "2000000000000",
+                "OwnerCount": 0,
+                "Sequence": 9
+              },
+              "PreviousTxnID": "2B07B79F67C41680E07ED8EDCA5BC20827F1694D51207EFD800F5174FE76ADB3",
+              "PreviousTxnLgrSeq": 13
+            }
+          },
+          {
+            "DeletedNode": {
+              "FinalFields": {
+                "Amount": "100",
+                "Flags": 1,
+                "OfferNode": "0000000000000000",
+                "Owner": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "OwnerNode": "0000000000000000",
+                "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003"
+              },
+              "LedgerEntryType": "NFTokenOffer",
+              "LedgerIndex": "AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AF"
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Flags": 0,
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "LedgerEntryType": "NFTokenPage",
+              "LedgerIndex": "B5F762798A53D543A014CAF8B297CFF8F2F937E8FFFFFFFFFFFFFFFFFFFFFFFF",
+              "PreviousFields": {
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E80000099B00000000",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E816E5DA9C00000001",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E82DCBAB9D00000002",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  },
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              },
+              "PreviousTxnID": "EF14A0EB3B1E7E928A07F4B6A659EEA4FB0F839499397B224E19DE61CAA884C7",
+              "PreviousTxnLgrSeq": 4
+            }
+          },
+          {
+            "CreatedNode": {
+              "LedgerEntryType": "NFTokenPage",
+              "LedgerIndex": "C77B4F8423139A8F0939DDEB9EB076CC74F4A3B3FFFFFFFFFFFFFFFFFFFFFFFF",
+              "NewFields": {
+                "NonFungibleTokens": [
+                  {
+                    "NonFungibleToken": {
+                      "TokenID": "00090032B5F762798A53D543A014CAF8B297CFF8F2F937E844B17C9E00000003",
+                      "URI": "68747470733A2F2F677265677765697362726F642E636F6D"
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          {
+            "ModifiedNode": {
+              "FinalFields": {
+                "Flags": 0,
+                "Owner": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                "RootIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204"
+              },
+              "LedgerEntryType": "DirectoryNode",
+              "LedgerIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204"
+            }
+          }
+        ],
+        "TransactionIndex": 0,
+        "TransactionResult": "tesSUCCESS"
+      },
+      "binary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
+    }
+  }
+}

packages/ripple-binary-codec/test/fixtures/payment-channel-claim-binary.json

@@ -0,0 +1 @@
+"12000F5016C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B9E5992CA61986140000000000F42406240000000000F4240712132D2471DB72B27E3310F355BB33E339BF26F8392D5A93D3BC0FC3B566612DA0F0A764630440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1E721B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80ECA3CD7B9B"

packages/ripple-binary-codec/test/fixtures/payment-channel-claim-tx.json

@@ -0,0 +1,8 @@
+{
+  "TransactionType": "PaymentChannelClaim",
+  "Channel": "C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B9E5992CA6198",
+  "Balance": "1000000",
+  "Amount": "1000000",
+  "Signature": "30440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1E721B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80ECA3CD7B9B",
+  "PublicKey": "32D2471DB72B27E3310F355BB33E339BF26F8392D5A93D3BC0FC3B566612DA0F0A"
+}

packages/ripple-binary-codec/test/fixtures/payment-channel-create-binary.json

@@ -0,0 +1 @@
+"12000D2300002DE32E00005BB820241FC78D66202700015180614000000000002710712132D2471DB72B27E3310F355BB33E339BF26F8392D5A93D3BC0FC3B566612DA0F0A81144B4E9C06F24296074F7BC48F92A97916C6DC5EA98314204288D2E47F8EF6C99BCC457966320D12409711"

packages/ripple-binary-codec/test/fixtures/payment-channel-create-tx.json

@@ -0,0 +1,11 @@
+{
+  "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+  "TransactionType": "PaymentChannelCreate",
+  "Amount": "10000",
+  "Destination": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
+  "SettleDelay": 86400,
+  "PublicKey": "32D2471DB72B27E3310F355BB33E339BF26F8392D5A93D3BC0FC3B566612DA0F0A",
+  "CancelAfter": 533171558,
+  "DestinationTag": 23480,
+  "SourceTag": 11747
+}

packages/ripple-binary-codec/test/fixtures/payment-channel-fund-binary.json

@@ -0,0 +1 @@
+"12000E2A206023E65016C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B9E5992CA6198614000000000030D4081144B4E9C06F24296074F7BC48F92A97916C6DC5EA9"

packages/ripple-binary-codec/test/fixtures/payment-channel-fund-tx.json

@@ -0,0 +1,7 @@
+{
+  "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+  "TransactionType": "PaymentChannelFund",
+  "Channel": "C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B9E5992CA6198",
+  "Amount": "200000",
+  "Expiration": 543171558
+}

packages/ripple-binary-codec/test/fixtures/signerlistset-tx-binary.json

@@ -0,0 +1 @@
+"12000C22800000002400003B49201B01724E3520230000000368400000000000000B73210315B15964B3704B171E860DE1FC914D283395EE825C8546AEEBF0D24A5802BBC574463044022069FC98D0BC32F510D4F94ECC726613E957D290050E428DD86EDA2C2515A1732D02207064EF085437B3F12A744AC6528D9E0C59FAA5A9FE903DF3639D2F09B522175F81144901F90028CEAD8AF389AC6FA0F83643DB67E95BF4EB1300018114EA97C2F7C88AE5735A59811F6F89E825B478982FE1EB1300018114B4AC72AF6C0EE5A1B8C94A3C20BE09599BBB57EEE1EB1300018114FA7420343B9EA7C9B294C3AF802AE80103F0B11BE1F1"

packages/ripple-binary-codec/test/fixtures/signerlistset-tx-meta-binary.json

@@ -0,0 +1 @@
+"201C00000008F8E51100612501724363554CD30C2526418A76ABED74713DF144B19F1B29BD8F7BC9EADCF16D33D7EC83D8560DAF42BEE40F0EEFCFD8D54E81ECACD9371D281CDD9B77384FCDAF0E16560A44E62400003B4962400000010F99515AE1E722000000002400003B4A2D0000001962400000010F99514F81144901F90028CEAD8AF389AC6FA0F83643DB67E95B8814CAA26A38FC8F4E5D6D142432B0D7D94A2880DDDFE1E1E51100535616F6AEEC6B85C9658B4BF604671677B7A7B2FAAFDB2FA5A0B72CBB49CAE80924E72200000000202300000003202600000000340000000000000000F4EB1300018114B4AC72AF6C0EE5A1B8C94A3C20BE09599BBB57EEE1EB1300018114EA97C2F7C88AE5735A59811F6F89E825B478982FE1EB1300018114FA7420343B9EA7C9B294C3AF802AE80103F0B11BE1F1E1E1F1031000"

packages/ripple-binary-codec/test/fixtures/signerlistset-tx.json

@@ -0,0 +1,94 @@
+{
+  "Account": "rfCp6hiUS4qqN1i4hTyX4ogA49MEbXgCau",
+  "Fee": "11",
+  "Flags": 2147483648,
+  "LastLedgerSequence": 24268341,
+  "Sequence": 15177,
+  "SignerEntries": [
+    {
+      "SignerEntry": {
+        "Account": "r4PQv7BCpp4SAJx3isNpQM8T2BuGrMQs5U",
+        "SignerWeight": 1
+      }
+    },
+    {
+      "SignerEntry": {
+        "Account": "rH7KDR67MZR7LDV7gesmEMXtaqU3FaK7Lr",
+        "SignerWeight": 1
+      }
+    },
+    {
+      "SignerEntry": {
+        "Account": "rPqHsX34XApKSfE4UxKbqVXb3WRmmgMY2u",
+        "SignerWeight": 1
+      }
+    }
+  ],
+  "SignerQuorum": 3,
+  "SigningPubKey": "0315B15964B3704B171E860DE1FC914D283395EE825C8546AEEBF0D24A5802BBC5",
+  "TransactionType": "SignerListSet",
+  "TxnSignature": "3044022069FC98D0BC32F510D4F94ECC726613E957D290050E428DD86EDA2C2515A1732D02207064EF085437B3F12A744AC6528D9E0C59FAA5A9FE903DF3639D2F09B522175F",
+  "date": 527847001,
+  "hash": "98C33CABFAE9F830CE842C260E34C25B0F987EE691941C0C9225AD476871B73D",
+  "inLedger": 24268339,
+  "ledger_index": 24268339,
+  "meta": {
+    "AffectedNodes": [
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Account": "rfCp6hiUS4qqN1i4hTyX4ogA49MEbXgCau",
+            "Balance": "4556673359",
+            "Flags": 0,
+            "OwnerCount": 25,
+            "RegularKey": "rK7ShY9CeDMBHLNFSMtTrSAUd9uzwcymcL",
+            "Sequence": 15178
+          },
+          "LedgerEntryType": "AccountRoot",
+          "LedgerIndex": "0DAF42BEE40F0EEFCFD8D54E81ECACD9371D281CDD9B77384FCDAF0E16560A44",
+          "PreviousFields": {
+            "Balance": "4556673370",
+            "Sequence": 15177
+          },
+          "PreviousTxnID": "4CD30C2526418A76ABED74713DF144B19F1B29BD8F7BC9EADCF16D33D7EC83D8",
+          "PreviousTxnLgrSeq": 24265571
+        }
+      },
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "Flags": 0,
+            "OwnerNode": "0000000000000000",
+            "SignerEntries": [
+              {
+                "SignerEntry": {
+                  "Account": "rH7KDR67MZR7LDV7gesmEMXtaqU3FaK7Lr",
+                  "SignerWeight": 1
+                }
+              },
+              {
+                "SignerEntry": {
+                  "Account": "r4PQv7BCpp4SAJx3isNpQM8T2BuGrMQs5U",
+                  "SignerWeight": 1
+                }
+              },
+              {
+                "SignerEntry": {
+                  "Account": "rPqHsX34XApKSfE4UxKbqVXb3WRmmgMY2u",
+                  "SignerWeight": 1
+                }
+              }
+            ],
+            "SignerListID": 0,
+            "SignerQuorum": 3
+          },
+          "LedgerEntryType": "SignerList",
+          "LedgerIndex": "16F6AEEC6B85C9658B4BF604671677B7A7B2FAAFDB2FA5A0B72CBB49CAE80924"
+        }
+      }
+    ],
+    "TransactionIndex": 8,
+    "TransactionResult": "tesSUCCESS"
+  },
+  "validated": true
+}