Publish

- @transia/ripple-binary-codec@1.4.6-alpha.9
 - @transia/xrpl@2.7.3-alpha.26

.github/workflows/codeql-analysis.yml

@@ -39,7 +39,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +50,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v2
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -64,4 +64,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2

.vscode/settings.json

@@ -29,7 +29,7 @@
         "enable": true
     },
     "editor.codeActionsOnSave": {
-        "source.fixAll.eslint": true
+        "source.fixAll.eslint": "explicit"
     },
     "files.insertFinalNewline": true,
     "files.trimFinalNewlines": true,

CONTRIBUTING.md

@@ -169,48 +169,86 @@ npm install abbrev -w ripple-keypairs
 npm uninstall abbrev -w xrpl
 ```
 
-## Release process
+## Release process + checklist
 
-### Release
+## PR process
 
-1. Ensure that all tests passed on the last CI that ran on `main`.
+- [ ] Your changes should be on a branch.
+- [ ] Your changes should have unit tests.
+- [ ] Lint the code with `npm lint`
+- [ ] Build your code with `npm build`
+- [ ] Run the unit tests with `npm test`
+- [ ] Get a full code review.
+- [ ] Merge your branch into `main` and push to github.
+- [ ] Ensure that all tests passed on the last CI that ran on `main`.
 
-NOW WE ARE READY TO PUBLISH! No new code changes happen manually now.
+## Release
 
-2. Checkout `main` (or your beta branch) and `git pull`.
-3. Create a new branch (`git checkout -b <BRANCH_NAME>`) to capture updates that take place during this process.
-4. Update `HISTORY.md` to reflect release changes.
-5. Run `npm run docgen` if the docs were modified in this release to update them (skip this step for a beta).
-6. Run `npm run build` to triple check the build still works
-7. Run `npx lerna version --no-git-tag-version` - This creates a draft PR and bumps the versions of the packages.
-  * For each changed package, pick what the new version should be. Lerna will bump the versions, commit version bumps to `main`, and create a new git tag for each published package.
-  * If publishing a beta, make sure that the versions are all of the form `a.b.c-beta.d`, where `a`, `b`, and `c` are identical to the last normal release except for one, which has been incremented by 1.
-8. Run `npm i` to update the package-lock with the updated versions
-9. Create a new PR from this branch into `main` and merge it (you can directly merge into the beta branch for a beta).
-10. Checkout `main` and `git pull` (you can skip this step for a beta since you already have the latest version of the beta branch).
-11. Run `npx lerna publish from-package --yes` - This will actually publish the packages.
-  * NOTE: if you're releasing a beta, run `npx lerna publish from-package --dist-tag beta --yes` instead.
-  * If it asks for it, enter your [npmjs.com](https://npmjs.com) OTP (one-time password) to complete publication.
-12. Create a new branch (`git checkout -b <BRANCH_NAME>`)to capture the updated packages from the release. Merge those changes into `main`. (You can skip this step on a beta release).
+1. Checkout `main` (or your beta branch) and `git pull`.
+1. Create a new branch (`git checkout -b <BRANCH_NAME>`) to capture updates that take place during this process.
+1. Update `HISTORY.md` to reflect release changes.
 
-NOW YOU HAVE PUBLISHED! But you're not done; we have to notify people!
+   - [ ] Update the version number and release date, and ensure it lists the changes since the previous release.
 
-13. Pull the most recent changes to main locally.
-14. Run `git tag <tagname> -m <tagname>`, where `<tagname>` is the new package and version (e.g. `xrpl@2.1.1`), for each version released.
-15. Run `git push --follow-tags`, to push the tags to Github.
-16. On Github, click the "releases" link on the right-hand side of the page.
-17. Click "Draft a new release"
-18. Click "Choose a tag", and choose a tag that you just created.
-19. Edit the name of the release to match the tag (IE \<package\>@\<version\>) and edit the description as you see fit.
-20. Repeat steps 17-19 for each release.
-21. Send an email to [xrpl-announce](https://groups.google.com/g/xrpl-announce).
+1. Run `npm run docgen` if the docs were modified in this release to update them (skip this step for a beta).
+1. Run `npm run build` to triple check the build still works
+1. Run `npx lerna version --no-git-tag-version` - This creates a draft PR and bumps the versions of the packages.
+
+   - For each changed package, pick what the new version should be. Lerna will bump the versions, commit version bumps to `main`, and create a new git tag for each published package.
+   - If publishing a beta, make sure that the versions are all of the form `a.b.c-beta.d`, where `a`, `b`, and `c` are identical to the last normal release except for one, which has been incremented by 1.
+
+1. Run `npm i` to update the package-lock with the updated versions.
+1. Create a new PR from this branch into `main` and merge it (you can directly merge into the beta branch for a beta).
+1. Checkout `main` and `git pull` (you can skip this step for a beta since you already have the latest version of the beta branch).
+1. Actually publish the packages with one of the following:
+
+   - Stable release: Run `npx lerna publish from-package --yes`
+   - Beta release: Run `npx lerna publish from-package --dist-tag beta --yes`  
+     Notice this allows developers to install the package with `npm add xrpl@beta`
+
+1. If requested, enter your [npmjs.com](https://npmjs.com) OTP (one-time password) to complete publication.
+1. If not a beta release: Create a new branch (`git checkout -b <BRANCH_NAME>`) to capture the updated packages from the release. Merge those changes into `main`.
+
+   NOW YOU HAVE PUBLISHED! But you're not done; we have to notify people!
+
+1. Pull the most recent changes to `main` locally.
+1. Run `git tag <tagname> -m <tagname>`, where `<tagname>` is the new package and version (e.g. `xrpl@2.1.1`), for each version released.
+1. Run `git push --follow-tags`, to push the tags to Github.
+1. On GitHub, click the "Releases" link on the right-hand side of the page.
+
+1. Repeat for each release:
+
+   1. Click "Draft a new release"
+   1. Click "Choose a tag", and choose a tag that you just created.
+   1. Edit the name of the release to match the tag (IE \<package\>@\<version\>) and edit the description as you see fit.
+
+1. Lastly, send an email to [xrpl-announce](https://groups.google.com/g/xrpl-announce).
+
+# ripple-lib 1.x releases
+
+- [ ] Publish the release to npm.
+
+  - [ ] If you are publishing a 1.x release to the `xrpl` package, use:
+
+        npm publish --tag ripple-lib
+
+    This prevents the release from taking the `latest` tag.
+
+For ripple-lib:
+
+ - Have one of the ripple-lib package maintainers push to `ripple-lib` (npm package name). You can contact [@intelliot](https://github.com/intelliot) to request the npm publish.
+- For ripple-lib releases, cross-publish the package to `xrpl` with `--tag ripple-lib`
+  - [Here's why](https://blog.greenkeeper.io/one-simple-trick-for-javascript-package-maintainers-to-avoid-breaking-their-user-s-software-and-to-6edf06dc5617).
+
+- https://www.npmjs.com/package/ripple-lib
+- https://www.npmjs.com/package/xrpl
 
 ## Mailing Lists
 
 We have a low-traffic mailing list for announcements of new `xrpl.js` releases. (About 1 email every couple of weeks)
 
-+ [Subscribe to xrpl-announce](https://groups.google.com/g/xrpl-announce)
+- [Subscribe to xrpl-announce](https://groups.google.com/g/xrpl-announce)
 
 If you're using the XRP Ledger in production, you should run a [rippled server](https://github.com/ripple/rippled) and subscribe to the ripple-server mailing list as well.
 
-+ [Subscribe to ripple-server](https://groups.google.com/g/ripple-server)
+- [Subscribe to ripple-server](https://groups.google.com/g/ripple-server)

README.md

@@ -32,19 +32,19 @@ All of which works in Node.js (tested for v14+) & web browsers (tested for Chrom
 In an existing project (with package.json), install xrpl.js with:
 
 ```
-$ npm install --save xrpl
+$ npm install --save @transia/xrpl
 ```
 
 Or with `yarn`:
 
 ```
-$ yarn add xrpl
+$ yarn add @transia/xrpl
 ```
 
 Example usage:
 
 ```js
-const xrpl = require("xrpl");
+const xrpl = require("@transia/xrpl");
 async function main() {
   const client = new xrpl.Client("wss://s.altnet.rippletest.net:51233");
   await client.connect();

package.json

@@ -13,10 +13,10 @@
     "update:confirm": "npx npm-check-updates --configFileName .ncurc.json -u"
   },
   "dependencies": {
-    "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"
+    "@transia/ripple-address-codec": "file:packages/ripple-address-codec",
+    "@transia/ripple-binary-codec": "file:packages/ripple-binary-codec",
+    "@transia/ripple-keypairs": "file:packages/ripple-keypairs",
+    "@transia/xrpl": "file:packages/xrpl"
   },
   "devDependencies": {
     "@types/brorand": "^1.0.30",

packages/ripple-address-codec/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ripple-address-codec",
-  "version": "4.2.5",
+  "version": "4.2.8-alpha.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "ripple-address-codec",
-      "version": "4.2.4",
+      "version": "4.2.8-alpha.0",
       "license": "ISC",
       "dependencies": {
         "base-x": "^3.0.9",

packages/ripple-address-codec/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "ripple-address-codec",
-  "version": "4.2.5",
+  "name": "@transia/ripple-address-codec",
+  "version": "4.2.8-alpha.0",
   "description": "encodes/decodes base58 encoded XRP Ledger identifiers",
   "files": [
     "dist/*",
@@ -15,7 +15,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:XRPLF/xrpl.js.git"
+    "url": "git@github.com/Transia-RnD/xrpl.js/tree/beta"
   },
   "prepublish": "tsc -b",
   "prepublishOnly": "tslint -b ./ && jest",

packages/ripple-binary-codec/HISTORY.md

@@ -1,6 +1,8 @@
 # ripple-binary-codec Release History
 
 ## Unreleased
+### Added
+- Allow custom type definitions to be used for encoding/decoding transactions at runtime (e.g. for sidechains/new amendments)
 
 ## 1.5.0 (2023-03-08)
 ### Changed

packages/ripple-binary-codec/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "ripple-binary-codec",
-  "version": "1.4.3",
+  "name": "@transia/ripple-binary-codec",
+  "version": "1.4.6-alpha.9",
   "description": "XRP Ledger binary codec",
   "files": [
     "dist/*",
@@ -12,12 +12,12 @@
     "test": "test"
   },
   "dependencies": {
+    "@transia/ripple-address-codec": "^4.2.8-alpha.0",
     "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.5"
+    "decimal.js": "^10.2.0"
   },
   "scripts": {
     "build": "tsc -b && copyfiles ./src/enums/definitions.json ./dist/enums/",
@@ -28,7 +28,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:XRPLF/xrpl.js.git"
+    "url": "git@github.com/Transia-RnD/xrpl.js/tree/beta"
   },
   "bugs": {
     "url": "https://github.com/XRPLF/xrpl.js/issues"

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

@@ -6,36 +6,56 @@ 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 {
+  type XrplDefinitionsBase,
+  DEFAULT_DEFINITIONS,
+  type FieldInstance,
+} from './enums'
 import { STObject } from './types/st-object'
 import { JsonObject } from './types/serialized-type'
 import { Buffer } from 'buffer/'
 import bigInt = require('big-integer')
+import { AmountObject } from './types/amount'
 
 /**
  * Construct a BinaryParser
  *
  * @param bytes hex-string to construct BinaryParser from
+ * @param definitions rippled definitions used to parse the values of transaction types and such.
+ *                          Can be customized for sidechains and amendments.
  * @returns A BinaryParser
  */
-const makeParser = (bytes: string): BinaryParser => new BinaryParser(bytes)
+const makeParser = (
+  bytes: string,
+  definitions?: XrplDefinitionsBase,
+): BinaryParser => new BinaryParser(bytes, definitions)
 
 /**
  * Parse BinaryParser into JSON
  *
  * @param parser BinaryParser object
+ * @param definitions rippled definitions used to parse the values of transaction types and such.
+ *                          Can be customized for sidechains and amendments.
  * @returns JSON for the bytes in the BinaryParser
  */
-const readJSON = (parser: BinaryParser): JsonObject =>
-  (parser.readType(coreTypes.STObject) as STObject).toJSON()
+const readJSON = (
+  parser: BinaryParser,
+  definitions: XrplDefinitionsBase = DEFAULT_DEFINITIONS,
+): JsonObject =>
+  (parser.readType(coreTypes.STObject) as STObject).toJSON(definitions)
 
 /**
  * Parse a hex-string into its JSON interpretation
  *
  * @param bytes hex-string to parse into JSON
+ * @param definitions rippled definitions used to parse the values of transaction types and such.
+ *                          Can be customized for sidechains and amendments.
  * @returns JSON
  */
-const binaryToJSON = (bytes: string): JsonObject => readJSON(makeParser(bytes))
+const binaryToJSON = (
+  bytes: string,
+  definitions?: XrplDefinitionsBase,
+): JsonObject => readJSON(makeParser(bytes, definitions), definitions)
 
 /**
  * Interface for passing parameters to SerializeObject
@@ -46,17 +66,18 @@ interface OptionObject {
   prefix?: Buffer
   suffix?: Buffer
   signingFieldsOnly?: boolean
+  definitions?: XrplDefinitionsBase
 }
 
 /**
  * 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
+ * @param opts options for serializing, including optional prefix, suffix, signingFieldOnly, and definitions
  * @returns A Buffer containing the serialized object
  */
 function serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {
-  const { prefix, suffix, signingFieldsOnly = false } = opts
+  const { prefix, suffix, signingFieldsOnly = false, definitions } = opts
   const bytesList = new BytesList()
 
   if (prefix) {
@@ -66,8 +87,9 @@ function serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {
   const filter = signingFieldsOnly
     ? (f: FieldInstance): boolean => f.isSigningField
     : undefined
-
-  coreTypes.STObject.from(object, filter).toBytesSink(bytesList)
+  ;(coreTypes.STObject as typeof STObject)
+    .from(object, filter, definitions)
+    .toBytesSink(bytesList)
 
   if (suffix) {
     bytesList.put(suffix)
@@ -81,13 +103,19 @@ function serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {
  *
  * @param transaction Transaction to serialize
  * @param prefix Prefix bytes to put before the serialized object
+ * @param opts.definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns A Buffer with the serialized object
  */
 function signingData(
   transaction: JsonObject,
   prefix: Buffer = HashPrefix.transactionSig,
+  opts: { definitions?: XrplDefinitionsBase } = {},
 ): Buffer {
-  return serializeObject(transaction, { prefix, signingFieldsOnly: true })
+  return serializeObject(transaction, {
+    prefix,
+    signingFieldsOnly: true,
+    definitions: opts.definitions,
+  })
 }
 
 /**
@@ -95,26 +123,30 @@ function signingData(
  */
 interface ClaimObject extends JsonObject {
   channel: string
-  amount: string | number
+  amount: AmountObject
 }
 
 /**
  * Serialize a signingClaim
  *
  * @param claim A claim object to serialize
+ * @param opts.definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @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)
+  if (typeof claim.amount === 'string') {
+    const num = bigInt(String(claim.amount))
+    const amount = coreTypes.UInt64.from(num).toBytes()
+    bytesList.put(amount)
+  } else {
+    const amount = coreTypes.Amount.from(claim.amount).toBytes()
+    bytesList.put(amount)
+  }
   return bytesList.toBytes()
 }
 
@@ -123,11 +155,15 @@ function signingClaimData(claim: ClaimObject): Buffer {
  *
  * @param transaction transaction to serialize
  * @param signingAccount Account to sign the transaction with
+ * @param opts.definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns serialized transaction with appropriate prefix and suffix
  */
 function multiSigningData(
   transaction: JsonObject,
   signingAccount: string | AccountID,
+  opts: { definitions: XrplDefinitionsBase } = {
+    definitions: DEFAULT_DEFINITIONS,
+  },
 ): Buffer {
   const prefix = HashPrefix.transactionMultiSig
   const suffix = coreTypes.AccountID.from(signingAccount).toBytes()
@@ -135,6 +171,7 @@ function multiSigningData(
     prefix,
     suffix,
     signingFieldsOnly: true,
+    definitions: opts.definitions,
   })
 }
 

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

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_DEFINITIONS,
   Field,
   TransactionType,
   LedgerEntryType,
@@ -17,6 +18,7 @@ export {
   hashes,
   binary,
   ledgerHashes,
+  DEFAULT_DEFINITIONS,
   Field,
   TransactionType,
   LedgerEntryType,

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

@@ -1,12 +1,16 @@
 # Definitions
 
+This file is used to serialize/deserialize transactions and ledger objects for the XRPL. It's broken into 5 sections laid out below.
+
+At the bottom of this README you can find instructions and examples for how to define your own types in a definitions file in order to work on a custom sidechain or develop new amendments.
+
 ## 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. 
+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
 
@@ -53,8 +57,88 @@ 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.
+To generate a new definitions file from rippled source code, use this tool: https://github.com/RichardAH/xrpl-codec-gen
 
 ## Transaction Types
 
 See https://github.com/ripple/rippled/blob/develop/src/ripple/protocol/TxFormats.h
+
+# Defining Your Own Definitions
+
+If you're building your own sidechain or writing an amendment for the XRPL, you may need to create new XRPL definitions.
+
+To do that there are a couple things you need to do:
+
+1. Generate your own `definitions.json` file from rippled source code using [this tool](https://github.com/RichardAH/xrpl-codec-gen) (The default `definitions.json` for mainnet can be found [here](https://github.com/XRPLF/xrpl.js/blob/main/packages/ripple-binary-codec/src/enums/definitions.json))
+2. Create new SerializedType classes for any new Types (So that encode/decode behavior is defined). The SerializedType classes correspond to "ST..." classes in Rippled. Note: This is very rarely required.
+
+- For examples of how to implement that you can look at objects in the [`types` folder](../types/), such as `Amount`, `UInt8`, or `STArray`.
+
+3. Import your `definitions.json` file to construct your own `XrplDefinitions` object.
+4. Pass the `XrplDefinitions` object whenever you `encode` or `decode` a transaction.
+5. If you added any new transaction types, you should create an `interface` for the transaction that extends `BaseTransaction` from the `xrpl` repo to use it with the functions on `Client` (See the below example of adding a new transaction type)
+
+## Example of adding a new Transaction type
+
+```
+// newDefinitionsJson is where you can import your custom defined definitions.json file
+const newDefinitionsJson = require('./new-transaction-type-definitions.json')
+const { XrplDefinitions, Client } = require('xrpl')
+
+const newDefs = new XrplDefinitions(newDefinitionsJson)
+
+// Change to point at the server you care about
+const serverAddress = 'wss://s.devnet.rippletest.net:51233'
+const client = new Client(serverAddress)
+const wallet1 = await client.fundWallet()
+
+// Extending BaseTransaction allows typescript to recognize this as a transaction type
+interface NewTx extends BaseTransaction {
+    Amount: Amount
+}
+
+const tx: NewTx = {
+    // The TransactionType here needs to match what you added in your newDefinitionsJson file
+    TransactionType: 'NewTx',
+    Account: wallet1.address,
+    Amount: '100',
+}
+
+// By passing in your newDefs, your new transaction should be serializable.
+// Rippled will still throw an error though if it's not a supported transaction type.
+const result = await client.submitAndWait(tx, {
+    wallet: wallet1,
+    definitions: newDefs,
+})
+```
+
+## Example of adding a new serializable Type
+
+```
+const { XrplDefinitions } = require('../dist/coretypes')
+
+// newDefinitionsJson is where you can import your custom defined definitions.json file
+const newDefinitionsJson = require('./fixtures/new-definitions.json')
+
+
+// For any new Types you create, you'll need to make a class with the same name which extends a SerializedType object
+// In order to define how to serialize/deserialize that field. Here we simply make our NewType act like a UInt32.
+
+const { UInt32 } = require('../dist/types/uint-32')
+class NewType extends UInt32 {
+  // Should be the same as UInt32
+}
+
+const extendedCoreTypes = { NewType }
+
+const newDefs = new XrplDefinitions(newDefinitionsJson, extendedCoreTypes)
+
+// From this point on, we should be able to serialize / deserialize Transactions with fields that have 'NewType' as their Type.
+
+const encoded = encode(my_tx, newDefs)
+const decoded = decode(encoded, newDefs)
+```
+
+## Other examples
+
+You can find other examples of how to modify `definitions.json` in `definition.test.js` which contains tests for this feature, and uses various example modified `definition` files. You can find the tests and the corresponding example `definition` files in [this folder of test cases](https://github.com/XRPLF/xrpl.js/tree/main/packages/ripple-binary-codec/test)

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

@@ -0,0 +1,75 @@
+import { BytesList, BinaryParser } from '../binary'
+import { Buffer } from 'buffer/'
+
+/*
+ * @brief: Bytes, name, and ordinal representing one type, ledger_type, transaction type, or result
+ */
+export class Bytes {
+  readonly bytes: Buffer
+
+  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: BytesList): void {
+    sink.put(this.bytes)
+  }
+
+  toBytes(): Uint8Array {
+    return this.bytes
+  }
+}
+
+/*
+ * @brief: Collection of Bytes objects, mapping bidirectionally
+ */
+export class BytesLookup {
+  constructor(types: Record<string, number>, readonly ordinalWidth: number) {
+    Object.entries(types).forEach(([k, v]) => {
+      this.add(k, v)
+    })
+  }
+
+  /**
+   * Add a new name value pair to the BytesLookup.
+   *
+   * @param name - A human readable name for the field.
+   * @param value - The numeric value for the field.
+   * @throws if the name or value already exist in the lookup because it's unclear how to decode.
+   */
+  add(name: string, value: number): void {
+    if (this[name]) {
+      throw new SyntaxError(
+        `Attempted to add a value with a duplicate name "${name}". This is not allowed because it is unclear how to decode.`,
+      )
+    }
+    if (this[value.toString()]) {
+      throw new SyntaxError(
+        `Attempted to add a duplicate value under a different name (Given name: "${name}" and previous name: "${
+          this[value.toString()]
+        }. This is not allowed because it is unclear how to decode.\nGiven value: ${value.toString()}`,
+      )
+    }
+    this[name] = new Bytes(name, value, this.ordinalWidth)
+    this[value.toString()] = this[name]
+  }
+
+  from(value: Bytes | string): Bytes {
+    return value instanceof Bytes ? value : (this[value] as Bytes)
+  }
+
+  fromParser(parser: BinaryParser): Bytes {
+    return this.from(parser.readUIntN(this.ordinalWidth).toString())
+  }
+}

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

@@ -0,0 +1,4 @@
+export const TYPE_WIDTH = 2
+export const LEDGER_ENTRY_WIDTH = 2
+export const TRANSACTION_TYPE_WIDTH = 2
+export const TRANSACTION_RESULT_WIDTH = 1

packages/ripple-binary-codec/src/enums/definitions.json

@@ -37,6 +37,7 @@
     "LedgerHashes": 104,
     "Amendments": 102,
     "FeeSettings": 115,
+    "ImportVLSequence": 73,
     "Escrow": 117,
     "PayChannel": 120,
     "Check": 67,
@@ -44,11 +45,17 @@
     "NegativeUNL": 78,
     "NFTokenPage": 80,
     "NFTokenOffer": 55,
+    "URIToken": 85,
+    "UNLReport": 82,
     "Any": -3,
     "Child": -2,
     "Nickname": 110,
     "Contract": 99,
-    "GeneratorMap": 103
+    "GeneratorMap": 103,
+    "Hook": 72,
+    "HookState": 118,
+    "HookDefinition": 68,
+    "EmittedTxn": 69
   },
   "FIELDS": [
     [
@@ -134,40 +141,40 @@
     [
       "LedgerEntry",
       {
-        "nth": 1,
+        "nth": 257,
         "isVLEncoded": false,
         "isSerialized": false,
-        "isSigningField": true,
+        "isSigningField": false,
         "type": "LedgerEntry"
       }
     ],
     [
       "Transaction",
       {
-        "nth": 1,
+        "nth": 257,
         "isVLEncoded": false,
         "isSerialized": false,
-        "isSigningField": true,
+        "isSigningField": false,
         "type": "Transaction"
       }
     ],
     [
       "Validation",
       {
-        "nth": 1,
+        "nth": 257,
         "isVLEncoded": false,
         "isSerialized": false,
-        "isSigningField": true,
+        "isSigningField": false,
         "type": "Validation"
       }
     ],
     [
       "Metadata",
       {
-        "nth": 1,
+        "nth": 257,
         "isVLEncoded": false,
-        "isSerialized": true,
-        "isSigningField": true,
+        "isSerialized": false,
+        "isSigningField": false,
         "type": "Metadata"
       }
     ],
@@ -321,6 +328,16 @@
         "type": "UInt16"
       }
     ],
+    [
+      "NetworkID",
+      {
+        "nth": 1,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
     [
       "Flags",
       {
@@ -761,6 +778,76 @@
         "type": "UInt32"
       }
     ],
+    [
+      "LockCount",
+      {
+        "nth": 49,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "FirstNFTokenSequence",
+      {
+        "nth": 50,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "XahauActivationLgrSeq",
+      {
+        "nth": 96,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "ImportSequence",
+      {
+        "nth": 97,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "RewardTime",
+      {
+        "nth": 98,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "RewardLgrFirst",
+      {
+        "nth": 99,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
+    [
+      "RewardLgrLast",
+      {
+        "nth": 100,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt32"
+      }
+    ],
     [
       "IndexNext",
       {
@@ -891,16 +978,6 @@
         "type": "UInt64"
       }
     ],
-    [
-      "HookOn",
-      {
-        "nth": 16,
-        "isVLEncoded": false,
-        "isSerialized": true,
-        "isSigningField": true,
-        "type": "UInt64"
-      }
-    ],
     [
       "HookInstructionCount",
       {
@@ -931,6 +1008,36 @@
         "type": "UInt64"
       }
     ],
+    [
+      "AccountIndex",
+      {
+        "nth": 98,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt64"
+      }
+    ],
+    [
+      "AccountCount",
+      {
+        "nth": 99,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt64"
+      }
+    ],
+    [
+      "RewardAccumulator",
+      {
+        "nth": 100,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "UInt64"
+      }
+    ],
     [
       "EmailHash",
       {
@@ -1151,6 +1258,16 @@
         "type": "Hash256"
       }
     ],
+    [
+      "HookOn",
+      {
+        "nth": 20,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
     [
       "Digest",
       {
@@ -1281,6 +1398,66 @@
         "type": "Hash256"
       }
     ],
+    [
+      "OfferID",
+      {
+        "nth": 34,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
+    [
+      "EscrowID",
+      {
+        "nth": 35,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
+    [
+      "URITokenID",
+      {
+        "nth": 36,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
+    [
+      "GovernanceFlags",
+      {
+        "nth": 99,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
+    [
+      "GovernanceMarks",
+      {
+        "nth": 98,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
+    [
+      "EmittedTxnID",
+      {
+        "nth": 97,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Hash256"
+      }
+    ],
     [
       "Amount",
       {
@@ -1421,6 +1598,56 @@
         "type": "Amount"
       }
     ],
+    [
+      "HookCallbackFee",
+      {
+        "nth": 20,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Amount"
+      }
+    ],
+    [
+      "LockedBalance",
+      {
+        "nth": 21,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Amount"
+      }
+    ],
+    [
+      "BaseFeeDrops",
+      {
+        "nth": 22,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Amount"
+      }
+    ],
+    [
+      "ReserveBaseDrops",
+      {
+        "nth": 23,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Amount"
+      }
+    ],
+    [
+      "ReserveIncrementDrops",
+      {
+        "nth": 24,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Amount"
+      }
+    ],
     [
       "PublicKey",
       {
@@ -1661,6 +1888,16 @@
         "type": "Blob"
       }
     ],
+    [
+      "Blob",
+      {
+        "nth": 26,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Blob"
+      }
+    ],
     [
       "Account",
       {
@@ -1761,6 +1998,16 @@
         "type": "AccountID"
       }
     ],
+    [
+      "Inform",
+      {
+        "nth": 99,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "AccountID"
+      }
+    ],
     [
       "Indexes",
       {
@@ -1801,6 +2048,26 @@
         "type": "Vector256"
       }
     ],
+    [
+      "HookNamespaces",
+      {
+        "nth": 5,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Vector256"
+      }
+    ],
+    [
+      "URITokenIDs",
+      {
+        "nth": 99,
+        "isVLEncoded": true,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "Vector256"
+      }
+    ],
     [
       "Paths",
       {
@@ -2021,6 +2288,66 @@
         "type": "STObject"
       }
     ],
+    [
+      "GenesisMint",
+      {
+        "nth": 96,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "ActiveValidator",
+      {
+        "nth": 95,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "ImportVLKey",
+      {
+        "nth": 94,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "HookEmission",
+      {
+        "nth": 93,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "MintURIToken",
+      {
+        "nth": 92,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
+    [
+      "AmountEntry",
+      {
+        "nth": 91,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STObject"
+      }
+    ],
     [
       "Signers",
       {
@@ -2160,6 +2487,56 @@
         "isSigningField": true,
         "type": "STArray"
       }
+    ],
+    [
+      "GenesisMints",
+      {
+        "nth": 96,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
+    ],
+    [
+      "ActiveValidators",
+      {
+        "nth": 95,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
+    ],
+    [
+      "ImportVLKeys",
+      {
+        "nth": 94,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
+    ],
+    [
+      "HookEmissions",
+      {
+        "nth": 93,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
+    ],
+    [
+      "Amounts",
+      {
+        "nth": 92,
+        "isVLEncoded": false,
+        "isSerialized": true,
+        "isSigningField": true,
+        "type": "STArray"
+      }
     ]
   ],
   "TRANSACTION_RESULTS": {
@@ -2176,6 +2553,12 @@
     "telCAN_NOT_QUEUE_BLOCKED": -389,
     "telCAN_NOT_QUEUE_FEE": -388,
     "telCAN_NOT_QUEUE_FULL": -387,
+    "telWRONG_NETWORK": -386,
+    "telREQUIRES_NETWORK_ID": -385,
+    "telNETWORK_ID_MAKES_TX_NON_CANONICAL": -384,
+    "telNON_LOCAL_EMITTED_TXN": -383,
+    "telIMPORT_VL_KEY_NOT_RECOGNISED": -382,
+    "telCAN_NOT_QUEUE_IMPORT": -381,
 
     "temMALFORMED": -299,
     "temBAD_AMOUNT": -298,
@@ -2188,11 +2571,11 @@
     "temBAD_PATH": -291,
     "temBAD_PATH_LOOP": -290,
     "temBAD_REGKEY": -289,
-    "temBAD_SEND_XRP_LIMIT": -288,
-    "temBAD_SEND_XRP_MAX": -287,
-    "temBAD_SEND_XRP_NO_DIRECT": -286,
-    "temBAD_SEND_XRP_PARTIAL": -285,
-    "temBAD_SEND_XRP_PATHS": -284,
+    "temBAD_SEND_NATIVE_LIMIT": -288,
+    "temBAD_SEND_NATIVE_MAX": -287,
+    "temBAD_SEND_NATIVE_NO_DIRECT": -286,
+    "temBAD_SEND_NATIVE_PARTIAL": -285,
+    "temBAD_SEND_NATIVE_PATHS": -284,
     "temBAD_SEQUENCE": -283,
     "temBAD_SIGNATURE": -282,
     "temBAD_SRC_ACCOUNT": -281,
@@ -2215,6 +2598,15 @@
     "temUNKNOWN": -264,
     "temSEQ_AND_TICKET": -263,
     "temBAD_NFTOKEN_TRANSFER_FEE": -262,
+    "temAMM_BAD_TOKENS": -261,
+    "temXCHAIN_EQUAL_DOOR_ACCOUNTS": -260,
+    "temXCHAIN_BAD_PROOF": -259,
+    "temXCHAIN_BRIDGE_BAD_ISSUES": -258,
+    "temXCHAIN_BRIDGE_NONDOOR_OWNER": -257,
+    "temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT": -256,
+    "temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT": -255,
+    "temXCHAIN_TOO_MANY_ATTESTATIONS": -254,
+    "temHOOK_DATA_TOO_LARGE": -253,
 
     "tefFAILURE": -199,
     "tefALREADY": -198,
@@ -2237,6 +2629,9 @@
     "tefTOO_BIG": -181,
     "tefNO_TICKET": -180,
     "tefNFTOKEN_IS_NOT_TRANSFERABLE": -179,
+    "tefPAST_IMPORT_SEQ": -178,
+    "tefPAST_IMPORT_VL_SEQ": -177,
+    "tefNONDIR_EMIT": -176,
 
     "terRETRY": -99,
     "terFUNDS_SPENT": -98,
@@ -2250,6 +2645,8 @@
     "terNO_RIPPLE": -90,
     "terQUEUED": -89,
     "terPRE_TICKET": -88,
+    "terNO_AMM": -87,
+    "terNO_HOOK": -86,
 
     "tesSUCCESS": 0,
 
@@ -2263,7 +2660,7 @@
     "tecINSUF_RESERVE_LINE": 122,
     "tecINSUF_RESERVE_OFFER": 123,
     "tecNO_DST": 124,
-    "tecNO_DST_INSUF_XRP": 125,
+    "tecNO_DST_INSUF_NATIVE": 125,
     "tecNO_LINE_INSUF_RESERVE": 126,
     "tecNO_LINE_REDUNDANT": 127,
     "tecPATH_DRY": 128,
@@ -2291,6 +2688,7 @@
     "tecKILLED": 150,
     "tecHAS_OBLIGATIONS": 151,
     "tecTOO_SOON": 152,
+    "tecHOOK_REJECTED": 153,
     "tecMAX_SEQUENCE_REACHED": 154,
     "tecNO_SUITABLE_NFTOKEN_PAGE": 155,
     "tecNFTOKEN_BUY_SELL_MISMATCH": 156,
@@ -2298,7 +2696,34 @@
     "tecCANT_ACCEPT_OWN_NFTOKEN_OFFER": 158,
     "tecINSUFFICIENT_FUNDS": 159,
     "tecOBJECT_NOT_FOUND": 160,
-    "tecINSUFFICIENT_PAYMENT": 161
+    "tecINSUFFICIENT_PAYMENT": 161,
+    "tecAMM_UNFUNDED": 162,
+    "tecAMM_BALANCE": 163,
+    "tecAMM_FAILED_DEPOSIT": 164,
+    "tecAMM_FAILED_WITHDRAW": 165,
+    "tecAMM_INVALID_TOKENS": 166,
+    "tecAMM_FAILED_BID": 167,
+    "tecAMM_FAILED_VOTE": 168,
+    "tecREQUIRES_FLAG": 169,
+    "tecPRECISION_LOSS": 170,
+    "tecBAD_XCHAIN_TRANSFER_ISSUE": 171,
+    "tecXCHAIN_NO_CLAIM_ID": 172,
+    "tecXCHAIN_BAD_CLAIM_ID": 173,
+    "tecXCHAIN_CLAIM_NO_QUORUM": 174,
+    "tecXCHAIN_PROOF_UNKNOWN_KEY": 175,
+    "tecXCHAIN_CREATE_ACCOUNT_NONXRP_ISSUE": 176,
+    "tecXCHAIN_WRONG_CHAIN": 177,
+    "tecXCHAIN_REWARD_MISMATCH": 178,
+    "tecXCHAIN_NO_SIGNERS_LIST": 179,
+    "tecXCHAIN_SENDING_ACCOUNT_MISMATCH": 180,
+    "tecXCHAIN_INSUFF_CREATE_AMOUNT": 181,
+    "tecXCHAIN_ACCOUNT_CREATE_PAST": 182,
+    "tecXCHAIN_ACCOUNT_CREATE_TOO_MANY": 183,
+    "tecXCHAIN_PAYMENT_FAILED": 184,
+    "tecXCHAIN_SELF_COMMIT": 185,
+    "tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR": 186,
+    "tecINSUF_RESERVE_SELLER": 187,
+    "tecLAST_POSSIBLE_ENTRY": 255
   },
   "TRANSACTION_TYPES": {
     "Invalid": -1,
@@ -2330,8 +2755,20 @@
     "NFTokenCreateOffer": 27,
     "NFTokenCancelOffer": 28,
     "NFTokenAcceptOffer": 29,
+    "URITokenMint": 45,
+    "URITokenBurn": 46,
+    "URITokenBuy": 47,
+    "URITokenCreateSellOffer": 48,
+    "URITokenCancelSellOffer": 49,
+    "Remit": 95,
+    "GenesisMint": 96,
+    "Import": 97,
+    "ClaimReward": 98,
+    "Invoke": 99,
     "EnableAmendment": 100,
     "SetFee": 101,
-    "UNLModify": 102
+    "UNLModify": 102,
+    "EmitFailure": 103,
+    "UNLReport": 104
   }
 }

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

@@ -0,0 +1,85 @@
+import { Bytes } from './bytes'
+import { SerializedType } from '../types/serialized-type'
+import { TYPE_WIDTH } from './constants'
+import { Buffer } from 'buffer/'
+
+/**
+ * Encoding information for a rippled field, often used in transactions.
+ * See the enums [README.md](https://github.com/XRPLF/xrpl.js/tree/main/packages/ripple-binary-codec/src/enums) for more details on what each means.
+ */
+export interface FieldInfo {
+  nth: number
+  isVLEncoded: boolean
+  isSerialized: boolean
+  isSigningField: boolean
+  type: string
+}
+
+export 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
+}
+
+/*
+ * @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)
+}
+
+function buildField(
+  [name, info]: [string, FieldInfo],
+  typeOrdinal: number,
+): FieldInstance {
+  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 or Definitions.updateAll(...)
+  }
+}
+
+/*
+ * @brief: The collection of all fields as defined in definitions.json
+ */
+export class FieldLookup {
+  constructor(
+    fields: Array<[string, FieldInfo]>,
+    types: Record<string, number>,
+  ) {
+    fields.forEach(([name, field_info]) => {
+      const typeOrdinal = types[field_info.type]
+      this[name] = buildField([name, field_info], typeOrdinal)
+      this[this[name].ordinal.toString()] = this[name]
+    })
+  }
+
+  fromString(value: string): FieldInstance {
+    return this[value] as FieldInstance
+  }
+}

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

@@ -1,164 +1,36 @@
 import * as enums from './definitions.json'
-import { SerializedType } from '../types/serialized-type'
-import { Buffer } from 'buffer/'
-import { BytesList } from '../binary'
+import {
+  XrplDefinitionsBase,
+  FieldInstance,
+  Bytes,
+} from './xrpl-definitions-base'
+/**
+ * By default, coreTypes from the `types` folder is where known type definitions are initialized to avoid import cycles.
+ */
+const DEFAULT_DEFINITIONS = new XrplDefinitionsBase(enums, {})
+
+const Type = DEFAULT_DEFINITIONS.type
+const LedgerEntryType = DEFAULT_DEFINITIONS.ledgerEntryType
+const TransactionType = DEFAULT_DEFINITIONS.transactionType
+const TransactionResult = DEFAULT_DEFINITIONS.transactionResult
+const Field = DEFAULT_DEFINITIONS.field
 
 /*
  * @brief: All valid transaction types
  */
-export const TRANSACTION_TYPES = Object.entries(enums.TRANSACTION_TYPES)
-  .filter(([_key, value]) => value >= 0)
-  .map(([key, _value]) => key)
-
-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
- */
-export class Bytes {
-  readonly bytes: Buffer
-
-  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: BytesList): 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]>)
+const TRANSACTION_TYPES = DEFAULT_DEFINITIONS.transactionNames
+const TRANSACTION_TYPE_MAP = DEFAULT_DEFINITIONS.transactionMap
 
 export {
+  Bytes,
+  XrplDefinitionsBase,
+  DEFAULT_DEFINITIONS,
   Field,
   FieldInstance,
   Type,
   LedgerEntryType,
   TransactionResult,
   TransactionType,
+  TRANSACTION_TYPES,
+  TRANSACTION_TYPE_MAP,
 }

packages/ripple-binary-codec/src/enums/xrpl-definitions-base.ts

@@ -0,0 +1,123 @@
+import { SerializedType } from '../types/serialized-type'
+import { Bytes, BytesLookup } from './bytes'
+import { FieldInfo, FieldLookup, FieldInstance } from './field'
+import {
+  TYPE_WIDTH,
+  LEDGER_ENTRY_WIDTH,
+  TRANSACTION_TYPE_WIDTH,
+  TRANSACTION_RESULT_WIDTH,
+} from './constants'
+
+interface DefinitionsData {
+  TYPES: Record<string, number>
+  LEDGER_ENTRY_TYPES: Record<string, number>
+  FIELDS: (string | FieldInfo)[][]
+  TRANSACTION_RESULTS: Record<string, number>
+  TRANSACTION_TYPES: Record<string, number>
+}
+
+/**
+ * Stores the various types and fields for rippled to be used to encode/decode information later on.
+ * XrplDefinitions should be instantiated instead of this class.
+ */
+class XrplDefinitionsBase {
+  // A collection of fields that can be included in transactions
+  field: FieldLookup
+  // A collection of ids corresponding to types of ledger objects
+  ledgerEntryType: BytesLookup
+  // A collection of type flags used to determine how to serialize a field's data
+  type: BytesLookup
+  // Errors and result codes for transactions
+  transactionResult: BytesLookup
+  // Defined transactions that can be submitted to the ledger
+  transactionType: BytesLookup
+  // Valid transaction names
+  transactionNames: string[]
+  // Valid transaction names
+  transactionMap: Record<string, number>
+  // Maps serializable types to their TypeScript class implementation
+  dataTypes: Record<string, typeof SerializedType>
+
+  /**
+   * Present rippled types in a typed and updatable format.
+   * For an example of the input format see `definitions.json`
+   * To generate a new definitions file from rippled source code, use this tool: https://github.com/RichardAH/xrpl-codec-gen
+   *
+   * See the definitions.test.js file for examples of how to create your own updated definitions.json.
+   *
+   * @param enums - A json encoding of the core types, transaction types, transaction results, transaction names, and fields.
+   * @param types - A list of type objects with the same name as the fields defined.
+   *              You can use the coreTypes object if you are not adding new types.
+   */
+  constructor(
+    enums: DefinitionsData,
+    types: Record<string, typeof SerializedType>,
+  ) {
+    this.type = new BytesLookup(enums.TYPES, TYPE_WIDTH)
+    this.ledgerEntryType = new BytesLookup(
+      enums.LEDGER_ENTRY_TYPES,
+      LEDGER_ENTRY_WIDTH,
+    )
+    this.transactionType = new BytesLookup(
+      enums.TRANSACTION_TYPES,
+      TRANSACTION_TYPE_WIDTH,
+    )
+    this.transactionResult = new BytesLookup(
+      enums.TRANSACTION_RESULTS,
+      TRANSACTION_RESULT_WIDTH,
+    )
+    this.field = new FieldLookup(
+      enums.FIELDS as Array<[string, FieldInfo]>,
+      enums.TYPES,
+    )
+
+    this.transactionNames = Object.entries(enums.TRANSACTION_TYPES)
+      .filter(([_key, value]) => value >= 0)
+      .map(([key, _value]) => key)
+
+    const ignoreList = ['EnableAmendment', 'SetFee', 'UNLModify', 'EmitFailure']
+    this.transactionMap = Object.assign(
+      {},
+      ...Object.entries(enums.TRANSACTION_TYPES)
+
+        .filter(([_key, _value]) => _value >= 0 || ignoreList.includes(_key))
+        .map(([key, value]) => ({ [key]: value })),
+    )
+
+    this.dataTypes = {} // Filled in via associateTypes
+    this.associateTypes(types)
+  }
+
+  /**
+   * Associates each Field to a corresponding class that TypeScript can recognize.
+   *
+   * @param types a list of type objects with the same name as the fields defined.
+   *              Defaults to xrpl.js's core type definitions.
+   */
+  public associateTypes(types: Record<string, typeof SerializedType>): void {
+    // Overwrite any existing type definitions with the given types
+    this.dataTypes = Object.assign({}, this.dataTypes, types)
+
+    Object.values(this.field).forEach((field) => {
+      field.associatedType = this.dataTypes[field.type.name]
+    })
+
+    this.field['TransactionType'].associatedType = this.transactionType
+    this.field['TransactionResult'].associatedType = this.transactionResult
+    this.field['LedgerEntryType'].associatedType = this.ledgerEntryType
+  }
+
+  public getAssociatedTypes(): Record<string, typeof SerializedType> {
+    return this.dataTypes
+  }
+}
+
+export {
+  DefinitionsData,
+  XrplDefinitionsBase,
+  FieldLookup,
+  FieldInfo,
+  FieldInstance,
+  Bytes,
+  BytesLookup,
+}

packages/ripple-binary-codec/src/enums/xrpl-definitions.ts

@@ -0,0 +1,32 @@
+import {
+  type DefinitionsData,
+  XrplDefinitionsBase,
+} from './xrpl-definitions-base'
+import { coreTypes } from '../types'
+import { SerializedType } from '../types/serialized-type'
+
+/**
+ * Stores the various types and fields for rippled to be used to encode/decode information later on.
+ * Should be used instead of XrplDefinitionsBase since this defines default `types` for serializing/deserializing
+ * ledger data.
+ */
+export class XrplDefinitions extends XrplDefinitionsBase {
+  /**
+   * Present rippled types in a typed and updatable format.
+   * For an example of the input format see `definitions.json`
+   * To generate a new definitions file from rippled source code, use this tool: https://github.com/RichardAH/xrpl-codec-gen
+   *
+   * See the definitions.test.js file for examples of how to create your own updated definitions.json.
+   *
+   * @param enums - A json encoding of the core types, transaction types, transaction results, transaction names, and fields.
+   * @param additionalTypes - A list of SerializedType objects with the same name as the fields defined.
+   *              These types will be included in addition to the coreTypes used on mainnet.
+   */
+  constructor(
+    enums: DefinitionsData,
+    additionalTypes?: Record<string, typeof SerializedType>,
+  ) {
+    const types = Object.assign({}, coreTypes, additionalTypes)
+    super(enums, types)
+  }
+}

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

@@ -1,9 +1,16 @@
 import * as assert from 'assert'
-import { quality, binary } from './coretypes'
+import { quality, binary, HashPrefix } from './coretypes'
 import { decodeLedgerData } from './ledger-hashes'
 import { ClaimObject } from './binary'
 import { JsonObject } from './types/serialized-type'
-import { TRANSACTION_TYPES } from './enums'
+import {
+  XrplDefinitionsBase,
+  TRANSACTION_TYPES,
+  TRANSACTION_TYPE_MAP,
+  DEFAULT_DEFINITIONS,
+} from './enums'
+import { XrplDefinitions } from './enums/xrpl-definitions'
+import { coreTypes } from './types'
 
 const {
   signingData,
@@ -17,22 +24,25 @@ const {
  * Decode a transaction
  *
  * @param binary hex-string of the encoded transaction
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns the JSON representation of the transaction
  */
-function decode(binary: string): JsonObject {
+function decode(binary: string, definitions?: XrplDefinitionsBase): JsonObject {
   assert.ok(typeof binary === 'string', 'binary must be a hex string')
-  return binaryToJSON(binary)
+  return binaryToJSON(binary, definitions)
 }
 
 /**
  * Encode a transaction
  *
  * @param json The JSON representation of a transaction
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
+ *
  * @returns A hex-string of the encoded transaction
  */
-function encode(json: object): string {
+function encode(json: object, definitions?: XrplDefinitionsBase): string {
   assert.ok(typeof json === 'object')
-  return serializeObject(json as JsonObject)
+  return serializeObject(json as JsonObject, { definitions })
     .toString('hex')
     .toUpperCase()
 }
@@ -42,11 +52,17 @@ function encode(json: object): string {
  *
  * @param json JSON object representing the transaction
  * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns a hex string of the encoded transaction
  */
-function encodeForSigning(json: object): string {
+function encodeForSigning(
+  json: object,
+  definitions?: XrplDefinitionsBase,
+): string {
   assert.ok(typeof json === 'object')
-  return signingData(json as JsonObject)
+  return signingData(json as JsonObject, HashPrefix.transactionSig, {
+    definitions,
+  })
     .toString('hex')
     .toUpperCase()
 }
@@ -56,6 +72,7 @@ function encodeForSigning(json: object): string {
  *
  * @param json JSON object representing the transaction
  * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns a hex string of the encoded transaction
  */
 function encodeForSigningClaim(json: object): string {
@@ -70,12 +87,18 @@ function encodeForSigningClaim(json: object): string {
  *
  * @param json JSON object representing the transaction
  * @param signer string representing the account to sign the transaction with
+ * @param definitions Custom rippled types to use instead of the default. Used for sidechains and amendments.
  * @returns a hex string of the encoded transaction
  */
-function encodeForMultisigning(json: object, signer: string): string {
+function encodeForMultisigning(
+  json: object,
+  signer: string,
+  definitions?: XrplDefinitionsBase,
+): string {
   assert.ok(typeof json === 'object')
   assert.equal(json['SigningPubKey'], '')
-  return multiSigningData(json as JsonObject, signer)
+  const definitionsOpt = definitions ? { definitions } : undefined
+  return multiSigningData(json as JsonObject, signer, definitionsOpt)
     .toString('hex')
     .toUpperCase()
 }
@@ -112,4 +135,9 @@ export {
   decodeQuality,
   decodeLedgerData,
   TRANSACTION_TYPES,
+  TRANSACTION_TYPE_MAP,
+  XrplDefinitions,
+  XrplDefinitionsBase,
+  DEFAULT_DEFINITIONS,
+  coreTypes,
 }

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

@@ -11,6 +11,7 @@ import { UInt8 } from './types/uint-8'
 import { BinaryParser } from './serdes/binary-parser'
 import { JsonObject } from './types/serialized-type'
 import bigInt = require('big-integer')
+import { XrplDefinitionsBase } from './enums'
 
 /**
  * Computes the hash of a list of objects
@@ -160,11 +161,16 @@ function ledgerHash(header: ledgerObject): Hash256 {
  * Decodes a serialized ledger header
  *
  * @param binary A serialized ledger header
+ * @param definitions Type definitions to parse the ledger objects.
+ *      Used if there are non-default ledger objects to decode.
  * @returns A JSON object describing a ledger header
  */
-function decodeLedgerData(binary: string): object {
+function decodeLedgerData(
+  binary: string,
+  definitions?: XrplDefinitionsBase,
+): object {
   assert.ok(typeof binary === 'string', 'binary must be a hex string')
-  const parser = new BinaryParser(binary)
+  const parser = new BinaryParser(binary, definitions)
   return {
     ledger_index: parser.readUInt32(),
     total_coins: parser.readType(UInt64).valueOf().toString(),

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

@@ -1,6 +1,10 @@
 import * as assert from 'assert'
-import { Field, FieldInstance } from '../enums'
-import { SerializedType } from '../types/serialized-type'
+import {
+  XrplDefinitionsBase,
+  DEFAULT_DEFINITIONS,
+  FieldInstance,
+} from '../enums'
+import { type SerializedType } from '../types/serialized-type'
 import { Buffer } from 'buffer/'
 
 /**
@@ -8,14 +12,21 @@ import { Buffer } from 'buffer/'
  */
 class BinaryParser {
   private bytes: Buffer
+  definitions: XrplDefinitionsBase
 
   /**
    * Initialize bytes to a hex string
    *
    * @param hexBytes a hex string
+   * @param definitions Rippled definitions used to parse the values of transaction types and such.
+   *                          Can be customized for sidechains and amendments.
    */
-  constructor(hexBytes: string) {
+  constructor(
+    hexBytes: string,
+    definitions: XrplDefinitionsBase = DEFAULT_DEFINITIONS,
+  ) {
     this.bytes = Buffer.from(hexBytes, 'hex')
+    this.definitions = definitions
   }
 
   /**
@@ -146,7 +157,7 @@ class BinaryParser {
    * @return The field represented by the bytes at the head of the BinaryParser
    */
   readField(): FieldInstance {
-    return Field.fromString(this.readFieldOrdinal().toString())
+    return this.definitions.field.fromString(this.readFieldOrdinal().toString())
   }
 
   /**

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

@@ -1,6 +1,6 @@
 import * as assert from 'assert'
 import { FieldInstance } from '../enums'
-import { SerializedType } from '../types/serialized-type'
+import { type SerializedType } from '../types/serialized-type'
 import { Buffer } from 'buffer/'
 
 /**

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

@@ -130,7 +130,7 @@ class ShaMapInner extends ShaMapNode {
    */
   hash(): Hash256 {
     if (this.empty()) {
-      return coreTypes.Hash256.ZERO_256
+      return (coreTypes.Hash256 as typeof Hash256).ZERO_256
     }
     const hash = Sha512Half.put(this.hashPrefix())
     this.toBytesSink(hash)
@@ -145,7 +145,9 @@ class ShaMapInner extends ShaMapNode {
   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
+      const hash = branch
+        ? branch.hash()
+        : (coreTypes.Hash256 as typeof Hash256).ZERO_256
       hash.toBytesSink(list)
     }
   }

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

@@ -3,7 +3,7 @@ import {
   encodeAccountID,
   isValidXAddress,
   xAddressToClassicAddress,
-} from 'ripple-address-codec'
+} from '@transia/ripple-address-codec'
 import { Hash160 } from './hash-160'
 import { Buffer } from 'buffer/'
 

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

@@ -12,7 +12,7 @@ const STANDARD_FORMAT_HEX_REGEX = /^0{24}[\x00-\x7F]{6}0{10}$/
  */
 function isoToBytes(iso: string): Buffer {
   const bytes = Buffer.alloc(20)
-  if (iso !== 'XRP') {
+  if (iso !== 'XAH') {
     const isoBytes = iso.split('').map((c) => c.charCodeAt(0))
     bytes.set(isoBytes, 12)
   }
@@ -28,7 +28,7 @@ function isIsoCode(iso: string): boolean {
 
 function isoCodeFromHex(code: Buffer): string | null {
   const iso = code.toString()
-  if (iso === 'XRP') {
+  if (iso === 'XAH') {
     return null
   }
   if (isIsoCode(iso)) {
@@ -89,7 +89,7 @@ class Currency extends Hash160 {
     const hex = this.bytes.toString('hex')
 
     if (XRP_HEX_REGEX.test(hex)) {
-      this._iso = 'XRP'
+      this._iso = 'XAH'
     } else if (STANDARD_FORMAT_HEX_REGEX.test(hex)) {
       this._iso = isoCodeFromHex(this.bytes.slice(12, 15))
     } else {

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

@@ -1,9 +1,3 @@
-import {
-  Field,
-  TransactionResult,
-  TransactionType,
-  LedgerEntryType,
-} from '../enums'
 import { AccountID } from './account-id'
 import { Amount } from './amount'
 import { Blob } from './blob'
@@ -19,8 +13,10 @@ import { UInt32 } from './uint-32'
 import { UInt64 } from './uint-64'
 import { UInt8 } from './uint-8'
 import { Vector256 } from './vector-256'
+import { type SerializedType } from './serialized-type'
+import { DEFAULT_DEFINITIONS } from '../enums'
 
-const coreTypes = {
+const coreTypes: Record<string, typeof SerializedType> = {
   AccountID,
   Amount,
   Blob,
@@ -38,12 +34,26 @@ const coreTypes = {
   Vector256,
 }
 
-Object.values(Field).forEach((field) => {
-  field.associatedType = coreTypes[field.type.name]
-})
+// Ensures that the DEFAULT_DEFINITIONS object connects these types to fields for serializing/deserializing
+// This is done here instead of in enums/index.ts to avoid a circular dependency
+// because some of the above types depend on BinarySerailizer which depends on enums/index.ts.
+DEFAULT_DEFINITIONS.associateTypes(coreTypes)
 
-Field['TransactionType'].associatedType = TransactionType
-Field['TransactionResult'].associatedType = TransactionResult
-Field['LedgerEntryType'].associatedType = LedgerEntryType
-
-export { coreTypes }
+export {
+  coreTypes,
+  AccountID,
+  Amount,
+  Blob,
+  Currency,
+  Hash128,
+  Hash160,
+  Hash256,
+  PathSet,
+  STArray,
+  STObject,
+  UInt8,
+  UInt16,
+  UInt32,
+  UInt64,
+  Vector256,
+}

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

@@ -1,6 +1,14 @@
-import { Field, FieldInstance, Bytes } from '../enums'
+import {
+  DEFAULT_DEFINITIONS,
+  FieldInstance,
+  Bytes,
+  XrplDefinitionsBase,
+} from '../enums'
 import { SerializedType, JsonObject } from './serialized-type'
-import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'
+import {
+  xAddressToClassicAddress,
+  isValidXAddress,
+} from '@transia/ripple-address-codec'
 import { BinaryParser } from '../serdes/binary-parser'
 import { BinarySerializer, BytesList } from '../serdes/binary-serializer'
 import { Buffer } from 'buffer/'
@@ -83,11 +91,13 @@ class STObject extends SerializedType {
    *
    * @param value An object to include
    * @param filter optional, denote which field to include in serialized object
+   * @param definitions optional, types and values to use to encode/decode a transaction
    * @returns a STObject object
    */
   static from<T extends STObject | JsonObject>(
     value: T,
     filter?: (...any) => boolean,
+    definitions: XrplDefinitionsBase = DEFAULT_DEFINITIONS,
   ): STObject {
     if (value instanceof STObject) {
       return value
@@ -108,7 +118,7 @@ class STObject extends SerializedType {
     }, {})
 
     let sorted = Object.keys(xAddressDecoded)
-      .map((f: string): FieldInstance => Field[f] as FieldInstance)
+      .map((f: string): FieldInstance => definitions.field[f] as FieldInstance)
       .filter(
         (f: FieldInstance): boolean =>
           f !== undefined &&
@@ -155,11 +165,12 @@ class STObject extends SerializedType {
 
   /**
    * Get the JSON interpretation of this.bytes
-   *
+   * @param definitions rippled definitions used to parse the values of transaction types and such.
+   *                          Can be customized for sidechains and amendments.
    * @returns a JSON object
    */
-  toJSON(): JsonObject {
-    const objectParser = new BinaryParser(this.toString())
+  toJSON(definitions?: XrplDefinitionsBase): JsonObject {
+    const objectParser = new BinaryParser(this.toString(), definitions)
     const accumulator = {}
 
     while (!objectParser.end()) {

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

@@ -1,7 +1,7 @@
 const { coreTypes } = require('../src/types')
 const Decimal = require('decimal.js')
 
-const { encodeAccountID } = require('ripple-address-codec')
+const { encodeAccountID } = require('@transia/ripple-address-codec')
 const { binary } = require('../src/coretypes')
 const { Amount, Hash160 } = coreTypes
 const { makeParser, readJSON } = binary
@@ -369,7 +369,7 @@ function pathSetBinaryTests() {
         currency: 'BTC',
         issuer: 'r3AWbdp2jQLXLywJypdoNwVSvr81xs3uhn',
       },
-      { currency: 'XRP' },
+      { currency: 'XAH' },
       {
         currency: 'USD',
         issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',

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

@@ -105,6 +105,16 @@ let json_omitted = {
 }
 
 const NegativeUNL = require('./fixtures/negative-unl.json')
+const UNLReport = {
+  tx: require('./fixtures/unl-report.json'),
+  binary: require('./fixtures/unl-report-binary.json'),
+  meta: require('./fixtures/unl-report-meta-binary.json'),
+}
+
+const Remit = {
+  tx: require('./fixtures/remit-tx.json'),
+  binary: require('./fixtures/remit-binary.json'),
+}
 
 function bytesListTest() {
   const list = new BytesList()
@@ -229,6 +239,18 @@ function NegativeUNLTest() {
   })
 }
 
+function UNLReportTest() {
+  test('can serialize UNLReport', () => {
+    expect(encode(UNLReport.tx)).toEqual(UNLReport.binary)
+  })
+  test('can serialize UNLReport metadata', () => {
+    expect(encode(UNLReport.tx.meta)).toEqual(UNLReport.meta)
+  })
+  test('can deserialize UNLReport metadata', () => {
+    expect(decode(UNLReport.meta)).toEqual(UNLReport.tx.meta)
+  })
+}
+
 function omitUndefinedTest() {
   test('omits fields with undefined value', () => {
     let encodedOmitted = encode(json_omitted)
@@ -274,6 +296,12 @@ function nfTokenTest() {
   }
 }
 
+function RemitTest() {
+  test('can serialize Remit', () => {
+    expect(encode(Remit.tx)).toEqual(Remit.binary)
+  })
+}
+
 describe('Binary Serialization', function () {
   describe('nestedObjectTests', nestedObjectTests)
   describe('BytesList', bytesListTest)
@@ -286,4 +314,6 @@ describe('Binary Serialization', function () {
   describe('OmitUndefined', omitUndefinedTest)
   describe('TicketTest', ticketTest)
   describe('NFToken', nfTokenTest)
+  describe('UNLReport', UNLReportTest)
+  describe('Remit', RemitTest)
 })

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

@@ -0,0 +1,100 @@
+const { encode, decode, XrplDefinitions } = require('../src')
+const normalDefinitionsJson = require('../src/enums/definitions.json')
+const { UInt32 } = require('../dist/types/uint-32')
+
+const txJson = {
+  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
+  Amount: '1000',
+  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
+  Fee: '10',
+  Flags: 0,
+  Sequence: 1,
+  TransactionType: 'Payment',
+}
+
+describe('encode and decode using new types as a parameter', function () {
+  test('can encode and decode a new TransactionType', function () {
+    const tx = { ...txJson, TransactionType: 'NewTestTransaction' }
+    // Before updating the types, this should not be encodable
+    expect(() => encode(tx)).toThrow()
+
+    // Normally this would be generated directly from rippled with something like `server_definitions`.
+    // Added here to make it easier to see what is actually changing in the definitions.json file.
+    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
+    definitions.TRANSACTION_TYPES['NewTestTransaction'] = 30
+
+    const newDefs = new XrplDefinitions(definitions)
+
+    const encoded = encode(tx, newDefs)
+    expect(() => decode(encoded)).toThrow()
+    const decoded = decode(encoded, newDefs)
+    expect(decoded).toStrictEqual(tx)
+  })
+
+  test('can encode and decode a new Field', function () {
+    const tx = { ...txJson, NewFieldDefinition: 10 }
+
+    // Before updating the types, undefined fields will be ignored on encode
+    expect(decode(encode(tx))).not.toStrictEqual(tx)
+
+    // Normally this would be generated directly from rippled with something like `server_definitions`.
+    // Added here to make it easier to see what is actually changing in the definitions.json file.
+    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
+
+    definitions.FIELDS.push([
+      'NewFieldDefinition',
+      {
+        nth: 101,
+        isVLEncoded: false,
+        isSerialized: true,
+        isSigningField: true,
+        type: 'UInt32',
+      },
+    ])
+
+    const newDefs = new XrplDefinitions(definitions)
+
+    const encoded = encode(tx, newDefs)
+    expect(() => decode(encoded)).toThrow()
+    const decoded = decode(encoded, newDefs)
+    expect(decoded).toStrictEqual(tx)
+  })
+
+  test('can encode and decode a new Type', function () {
+    const tx = {
+      ...txJson,
+      TestField: 10, // Should work the same as a UInt32
+    }
+
+    // Normally this would be generated directly from rippled with something like `server_definitions`.
+    // Added here to make it easier to see what is actually changing in the definitions.json file.
+    const definitions = JSON.parse(JSON.stringify(normalDefinitionsJson))
+    definitions.TYPES.NewType = 24
+    definitions.FIELDS.push([
+      'TestField',
+      {
+        nth: 100,
+        isVLEncoded: true,
+        isSerialized: true,
+        isSigningField: true,
+        type: 'NewType',
+      },
+    ])
+
+    // Test that before updating the types this tx fails to decode correctly. Note that undefined fields are ignored on encode.
+    expect(decode(encode(tx))).not.toStrictEqual(tx)
+
+    class NewType extends UInt32 {
+      // Should be the same as UInt32
+    }
+
+    const extendedCoreTypes = { NewType }
+
+    const newDefs = new XrplDefinitions(definitions, extendedCoreTypes)
+
+    const encoded = encode(tx, newDefs)
+    expect(() => decode(encoded)).toThrow()
+    const decoded = decode(encoded, newDefs)
+    expect(decoded).toStrictEqual(tx)
+  })
+})

packages/ripple-binary-codec/test/fixtures/data-driven-tests.json

@@ -2904,7 +2904,7 @@
             "type_id": 6,
             "is_native": true,
             "type": "Amount",
-            "error": "1000000000000 absolute XRP is bigger than max native value 100000000000.0",
+            "error": "1000000000000 absolute XAH is bigger than max native value 100000000000.0",
             "is_negative": false
         },
         {
@@ -2912,7 +2912,7 @@
             "type_id": 6,
             "is_native": true,
             "type": "Amount",
-            "error": "10000000000000000000 absolute XRP is bigger than max native value 100000000000.0",
+            "error": "10000000000000000000 absolute XAH is bigger than max native value 100000000000.0",
             "is_negative": true
         }
     ]

packages/ripple-binary-codec/test/fixtures/remit-binary.json

@@ -0,0 +1 @@
+"12005F22000000002403EDEB4A2E00000001201B03EE5D3150116F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B68400000000000000C732102F9E33F16DF9507705EC954E3F94EB5F10D1FC4A354606DBE6297DBB1096FE65474473045022100E3FAE0EDEC3D6A8FF6D81BC9CF8288A61B7EEDE8071E90FF9314CB4621058D10022043545CF631706D700CEE65A1DB83EFDD185413808292D9D90F14D87D3DC2D8CB701A04DEADBEEF81147990EC5D1D8DF69E070A968D4B186986FDF06ED0831449FF0C73CA6AF9733DA805F76CA2C37776B7C46B806314757C4A9ED08284D61F3D8807280795F858BAB61DE05C220000000150156F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B7504DEADBEEFE1F05CE05B6140000000000003E8E1E05B61D4838D7EA4C68000000000000000000000000000555344000000000006B80F0F1D98AEDA846ED981F741C398FB2C4FD1E1F100136320AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE"

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

@@ -0,0 +1,39 @@
+{
+  "TransactionType": "Remit",
+  "Account": "rUn84CUYbNjRoTQ6mSW7BVJPSVJNLb1QLo",
+  "Destination": "rfkE1aSy9G8Upk4JssnwBxhEv5p4mn2KTy",
+  "DestinationTag": 1,
+  "Fee": "12",
+  "Flags": 0,
+  "LastLedgerSequence": 65953073,
+  "Sequence": 65923914,
+  "SigningPubKey": "02F9E33F16DF9507705EC954E3F94EB5F10D1FC4A354606DBE6297DBB1096FE654",
+  "TxnSignature": "3045022100E3FAE0EDEC3D6A8FF6D81BC9CF8288A61B7EEDE8071E90FF9314CB4621058D10022043545CF631706D700CEE65A1DB83EFDD185413808292D9D90F14D87D3DC2D8CB",
+  "Amounts": [
+    {
+      "AmountEntry": {
+        "Amount": "1000"
+      }
+    },
+    {
+      "AmountEntry": {
+        "Amount": {
+          "currency": "USD",
+          "issuer": "rcXY84C4g14iFp6taFXjjQGVeHqSCh9RX",
+          "value": "1"
+        }
+      }
+    }
+  ],
+  "MintURIToken": {
+    "URI": "DEADBEEF",
+    "Digest": "6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B",
+    "Flags": 1
+  },
+  "URITokenIDs": [
+    "AED08CC1F50DD5F23A1948AF86153A3F3B7593E5EC77D65A02BB1B29E05AB6AE"
+  ],
+  "InvoiceID": "6F1DFD1D0FE8A32E40E1F2C05CF1C15545BAB56B617F9C6C2D63A6B704BEF59B",
+  "Blob": "DEADBEEF",
+  "Inform": "rB5Ux4Lv2nRx6eeoAAsZmtctnBQ2LiACnk"
+}

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

@@ -0,0 +1 @@
+"120068240000000026006D2E00684000000000000000730081140000000000000000000000000000000000000000E05F7121ED93B2BE467CAD2F9F56FB3A82BDFF17F84B09E34232DDE8FAF2FC72382F142655E1"

packages/ripple-binary-codec/test/fixtures/unl-report-meta-binary.json

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

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

@@ -0,0 +1,89 @@
+{
+  "Account": "",
+  "ActiveValidator": {
+    "PublicKey": "ED93B2BE467CAD2F9F56FB3A82BDFF17F84B09E34232DDE8FAF2FC72382F142655"
+  },
+  "Fee": "0",
+  "LedgerSequence": 7155200,
+  "Sequence": 0,
+  "SigningPubKey": "",
+  "TransactionType": "UNLReport",
+  "hash": "0878863F758F74A5CBD35691CDAB625A3BCD35B21B440E20545C4757DDB0CA43",
+  "meta": {
+    "AffectedNodes": [
+      {
+        "ModifiedNode": {
+          "FinalFields": {
+            "ActiveValidators": [
+              {
+                "ActiveValidator": {
+                  "Account": "roUo3ygV92bdhfE1v9LGpPETXvJv2kQv5",
+                  "PublicKey": "ED93B2BE467CAD2F9F56FB3A82BDFF17F84B09E34232DDE8FAF2FC72382F142655"
+                }
+              }
+            ],
+            "Flags": 0,
+            "ImportVLKeys": [
+              {
+                "ImportVLKey": {
+                  "Account": "rBxZvQBY551DJ21g9AC1Qc9ASQowqcskbF",
+                  "PublicKey": "ED264807102805220DA0F312E71FC2C69E1552C9C5790F6C25E3729DEB573D5860"
+                }
+              }
+            ]
+          },
+          "LedgerEntryType": "UNLReport",
+          "LedgerIndex": "61E32E7A24A238F1C619D5F9DDCC41A94B33B66C0163F7EFCC8A19C9FD6F28DC",
+          "PreviousFields": {
+            "ActiveValidators": [
+              {
+                "ActiveValidator": {
+                  "Account": "rGhk2uLd8ShzX2Zrcgn8sQk1LWBG4jjEwf",
+                  "PublicKey": "ED3ABC6740983BFB13FFD9728EBCC365A2877877D368FC28990819522300C92A69"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "rnr4kwS1VkJhvjVRuq2fbWZtEdN2HbpVVu",
+                  "PublicKey": "ED49F82B2FFD537F224A1E0A10DEEFC3C25CE3882979E6B327C9F18603D21F0A22"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "rJupFrPPYgUNFBdoSqhMEJ22hiHKiZSHXQ",
+                  "PublicKey": "ED79EB0F6A9F01A039235E536D19F812B55ACF540C9E22CF62C271E0D42BFF5174"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "roUo3ygV92bdhfE1v9LGpPETXvJv2kQv5",
+                  "PublicKey": "ED93B2BE467CAD2F9F56FB3A82BDFF17F84B09E34232DDE8FAF2FC72382F142655"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "rGsa7f4arJ8JE9ok9LCht6jCu5xBKUKVMq",
+                  "PublicKey": "ED96F581FED430E8CBE1F08B37408857001D4118D49FBB594B0BE007C2DBFFD367"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "r3htgPchiR2r8kMGzPK3Wfv3WTrpaRKjtU",
+                  "PublicKey": "EDCF31B8F683345E1C49B4A1D85BF2731E55E7D6781F3D4BF45EE7ADF2D2FB3402"
+                }
+              },
+              {
+                "ActiveValidator": {
+                  "Account": "rfQtB8m51sdbWgcmddRX2mMjMpSxzX1AGr",
+                  "PublicKey": "EDDF197FC59A7FAA09EB1AD60A4638BA6201DD51497B5C08A1745115098E229E0E"
+                }
+              }
+            ]
+          }
+        }
+      }
+    ],
+    "TransactionIndex": 0,
+    "TransactionResult": "tesSUCCESS"
+  }
+}

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

@@ -77,7 +77,7 @@ describe('Hash256', function () {
 
 describe('Currency', function () {
   test('Decoding allows dodgy XRP without throwing', function () {
-    const currencyCode = '0000000000000000000000005852500000000000'
+    const currencyCode = '0000000000000000000000005841480000000000'
     expect(Currency.from(currencyCode).toJSON()).toBe(currencyCode)
   })
   test('Currency code with lowercase letters decodes to ISO code', () => {
@@ -113,7 +113,7 @@ describe('Currency', function () {
 
   test('can be constructed from a Buffer', function () {
     const xrp = new Currency(Buffer.alloc(20))
-    expect(xrp.iso()).toBe('XRP')
+    expect(xrp.iso()).toBe('XAH')
   })
   test('Can handle non-standard currency codes', () => {
     const currency = '015841551A748AD2C1F76FF6ECB0CCCD00000000'

packages/ripple-binary-codec/test/signing-data-encoding.test.js

@@ -4,6 +4,9 @@ const {
   encodeForSigningClaim,
   encodeForMultisigning,
 } = require('../src')
+const { XrplDefinitions } = require('../src/enums/xrpl-definitions')
+
+const normalDefinitions = require('../src/enums/definitions.json')
 
 const tx_json = {
   Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
@@ -67,6 +70,53 @@ describe('Signing data', function () {
     )
   })
 
+  test('can create single signing blobs with modified type', function () {
+    const customPaymentDefinitions = JSON.parse(
+      JSON.stringify(normalDefinitions),
+    )
+    customPaymentDefinitions.TRANSACTION_TYPES.Payment = 31
+
+    const newDefs = new XrplDefinitions(customPaymentDefinitions)
+    const actual = encodeForSigning(tx_json, newDefs)
+    expect(actual).toBe(
+      [
+        '53545800', // signingPrefix
+        // TransactionType
+        '12',
+        '001F',
+        // Flags
+        '22',
+        '80000000',
+        // Sequence
+        '24',
+        '00000001',
+        // Amount
+        '61',
+        // native amount
+        '40000000000003E8',
+        // Fee
+        '68',
+        // native amount
+        '400000000000000A',
+        // SigningPubKey
+        '73',
+        // VLLength
+        '21',
+        'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A',
+        // Account
+        '81',
+        // VLLength
+        '14',
+        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
+        // Destination
+        '83',
+        // VLLength
+        '14',
+        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
+      ].join(''),
+    )
+  })
+
   test('can fail gracefully for invalid TransactionType', function () {
     const invalidTransactionType = {
       ...tx_json,
@@ -78,7 +128,7 @@ describe('Signing data', function () {
 
   test('can create multi signing blobs', function () {
     const signingAccount = 'rJZdUusLDtY9NEsGea7ijqhVrXv98rYBYN'
-    const signingJson = Object.assign({}, tx_json, { SigningPubKey: '' })
+    const signingJson = { ...tx_json, SigningPubKey: '' }
     const actual = encodeForMultisigning(signingJson, signingAccount)
     expect(actual).toBe(
       [
@@ -120,7 +170,7 @@ describe('Signing data', function () {
       ].join(''),
     )
   })
-  test('can create claim blob', function () {
+  test('can create native claim blob', function () {
     const channel =
       '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1'
     const amount = '1000'
@@ -137,4 +187,27 @@ describe('Signing data', function () {
       ].join(''),
     )
   })
+  test('can create ic claim blob', function () {
+    const channel =
+      '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1'
+    const amount = {
+      issuer: 'rJZdUusLDtY9NEsGea7ijqhVrXv98rYBYN',
+      currency: 'USD',
+      value: '10',
+    }
+    const json = { channel, amount }
+    const actual = encodeForSigningClaim(json)
+    expect(actual).toBe(
+      [
+        // hash prefix
+        '434C4D00',
+        // channel ID
+        '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1',
+        // amount as a uint64
+        'D4C38D7EA4C680000000000000000000000000005553440000000000C0A5ABEF',
+        // amount as a uint64
+        '242802EFED4B041E8F2D4A8CC86AE3D1',
+      ].join(''),
+    )
+  })
 })

packages/ripple-binary-codec/test/tx-encode-decode.test.js

@@ -58,7 +58,7 @@ describe('encoding and decoding tx_json', function () {
       Sequence: 19,
       LimitAmount: {
         value: '200',
-        currency: '0000000000000000000000005852500000000000',
+        currency: '0000000000000000000000005841480000000000',
         issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
       },
       Fee: '10',

packages/ripple-keypairs/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "ripple-keypairs",
-  "version": "1.1.5",
+  "name": "@transia/ripple-keypairs",
+  "version": "1.1.8-alpha.0",
   "description": "Cryptographic key pairs for the XRP Ledger",
   "scripts": {
     "build": "tsc -b",
@@ -17,15 +17,15 @@
     "test": "test"
   },
   "dependencies": {
+    "@transia/ripple-address-codec": "^4.2.8-alpha.0",
     "bn.js": "^5.1.1",
     "brorand": "^1.0.5",
     "elliptic": "^6.5.4",
-    "hash.js": "^1.0.3",
-    "ripple-address-codec": "^4.2.5"
+    "hash.js": "^1.0.3"
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:XRPLF/xrpl.js.git"
+    "url": "git@github.com/Transia-RnD/xrpl.js/tree/beta"
   },
   "license": "ISC",
   "prettier": "@xrplf/prettier-config",

packages/ripple-keypairs/src/index.ts

@@ -3,7 +3,7 @@ import brorand = require('brorand')
 import * as hashjs from 'hash.js'
 import * as elliptic from 'elliptic'
 
-import * as addressCodec from 'ripple-address-codec'
+import * as addressCodec from '@transia/ripple-address-codec'
 import { derivePrivateKey, accountPublicFromPublicGenerator } from './secp256k1'
 import * as utils from './utils'
 

packages/ripple-keypairs/test/codec.test.ts

@@ -1,5 +1,5 @@
 import assert from 'assert'
-import * as api from 'ripple-address-codec'
+import * as api from '@transia/ripple-address-codec'
 
 function toHex(bytes) {
   return Buffer.from(bytes).toString('hex').toUpperCase()

packages/ripple-keypairs/test/xrp-codec.test.ts

@@ -1,5 +1,5 @@
 import assert from 'assert'
-import * as api from 'ripple-address-codec'
+import * as api from '@transia/ripple-address-codec'
 
 function toHex(bytes: Buffer) {
   return Buffer.from(bytes).toString('hex').toUpperCase()

packages/xrpl/HISTORY.md

@@ -3,6 +3,12 @@
 Subscribe to [the **xrpl-announce** mailing list](https://groups.google.com/g/xrpl-announce) for release announcements. We recommend that xrpl.js (ripple-lib) users stay up-to-date with the latest stable release.
 ## Unreleased
 
+### Added
+* Null and undefined values in transactions are now treated as though the field was not passed in.
+
+### Fixed
+* Added `destination_amount` to `PathOption` which is returned as part of a `path_find` request
+
 ## 2.7.0 (2023-03-08)
 
 ### Fixed
@@ -1692,7 +1698,7 @@ __OTHER CHANGES__
         parseBinary: false
       }
     ```
-+ Added full currency name support, e.g. `Currency.from_json('XRP').to_human({full_name:'Ripples'})` will return `XRP - Ripples`
++ Added full currency name support, e.g. `Currency.from_json('XAH').to_human({full_name:'Ripples'})` will return `XAH - Ripples`
 + Improved interest bearing currency support, e.g. `Currency.from_human('USD - US Dollar (2.5%pa)')`
 + Improve test coverage
 + Added blob vault client.  The vault client facilitates interaction with ripple's namespace and blob vault or 3rd party blob vaults using ripple's blob vault software (https://github.com/ripple/ripple-blobvault). A list of the available functions can be found at [docs/VAULTCLIENT.md](docs/VAULTCLIENT.md)

packages/xrpl/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "xrpl",
-  "version": "2.7.0",
+  "name": "@transia/xrpl",
+  "version": "2.7.3-alpha.26",
   "license": "ISC",
   "description": "A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser",
   "files": [
@@ -22,14 +22,14 @@
     "https-proxy-agent": false
   },
   "dependencies": {
+    "@transia/ripple-address-codec": "^4.2.8-alpha.0",
+    "@transia/ripple-binary-codec": "^1.4.6-alpha.9",
+    "@transia/ripple-keypairs": "^1.1.8-alpha.0",
     "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.2.5",
-    "ripple-binary-codec": "^1.4.3",
-    "ripple-keypairs": "^1.1.5",
     "ws": "^8.2.2"
   },
   "devDependencies": {
@@ -75,10 +75,11 @@
   "prettier": "@xrplf/prettier-config",
   "repository": {
     "type": "git",
-    "url": "git@github.com:XRPLF/xrpl.js.git"
+    "url": "git@github.com/Transia-RnD/xrpl.js/tree/beta"
   },
   "readmeFilename": "README.md",
   "engines": {
     "node": ">=10.13.0"
-  }
+  },
+  "gitHead": "3b234ec8ec1c677e0f3f534fd2985c985871c87e"
 }

packages/xrpl/snippets/src/paths.ts

@@ -18,7 +18,7 @@ async function createTxWithPaths(): Promise<void> {
     source_account: wallet.classicAddress,
     source_currencies: [
       {
-        currency: 'XRP',
+        currency: 'XAH',
       },
     ],
     destination_account,

packages/xrpl/src/Wallet/fundWallet.ts

@@ -1,7 +1,7 @@
 import { IncomingMessage } from 'http'
 import { request as httpsRequest, RequestOptions } from 'https'
 
-import { isValidClassicAddress } from 'ripple-address-codec'
+import { isValidClassicAddress } from '@transia/ripple-address-codec'
 
 import type { Client } from '../client'
 import { RippledError, XRPLFaucetError } from '../errors'

packages/xrpl/src/Wallet/index.ts

@@ -1,32 +1,33 @@
 /* eslint-disable max-lines -- There are lots of equivalent constructors which make sense to have here. */
-import BigNumber from 'bignumber.js'
-import { fromSeed } from 'bip32'
-import { mnemonicToSeedSync, validateMnemonic } from 'bip39'
-import isEqual from 'lodash/isEqual'
 import {
   classicAddressToXAddress,
   isValidXAddress,
   xAddressToClassicAddress,
   encodeSeed,
-} from 'ripple-address-codec'
+} from '@transia/ripple-address-codec'
 import {
   decode,
   encodeForSigning,
   encodeForMultisigning,
   encode,
-} from 'ripple-binary-codec'
+} from '@transia/ripple-binary-codec'
 import {
   deriveAddress,
   deriveKeypair,
   generateSeed,
   verify,
   sign,
-} from 'ripple-keypairs'
+} from '@transia/ripple-keypairs'
+import BigNumber from 'bignumber.js'
+import { fromSeed } from 'bip32'
+import { mnemonicToSeedSync, validateMnemonic } from 'bip39'
+import isEqual from 'lodash/isEqual'
+import omitBy from 'lodash/omitBy'
 
 import ECDSA from '../ECDSA'
 import { ValidationError, XrplError } from '../errors'
 import { IssuedCurrencyAmount } from '../models/common'
-import { Transaction } from '../models/transactions'
+import { Transaction, validate } from '../models/transactions'
 import { isIssuedCurrency } from '../models/transactions/common'
 import { isHex } from '../models/utils'
 import { ensureClassicAddress } from '../sugar/utils'
@@ -323,7 +324,12 @@ class Wallet {
       multisignAddress = this.classicAddress
     }
 
-    const tx = { ...transaction }
+    // clean null & undefined valued tx properties
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- ensure Transaction flows through
+    const tx = omitBy(
+      { ...transaction },
+      (value) => value == null,
+    ) as unknown as Transaction
 
     if (tx.TxnSignature || tx.Signers) {
       throw new ValidationError(
@@ -333,6 +339,12 @@ class Wallet {
 
     removeTrailingZeros(tx)
 
+    /*
+     * This will throw a more clear error for JS users if the supplied transaction has incorrect formatting
+     */
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validate does not accept Transaction type
+    validate(tx as unknown as Record<string, unknown>)
+
     const txToSignAndEncode = { ...tx }
 
     txToSignAndEncode.SigningPubKey = multisignAddress ? '' : this.publicKey
@@ -460,9 +472,6 @@ class Wallet {
     })
 
     if (txCopy.TransactionType === 'NFTokenMint' && txCopy.URI) {
-      if (!isHex(txCopy.URI)) {
-        throw new ValidationError('URI must be a hex value')
-      }
       txCopy.URI = txCopy.URI.toUpperCase()
     }
 
@@ -476,10 +485,10 @@ class Wallet {
 
         if (
           txCurrency.length === standard_currency_code_len &&
-          txCurrency.toUpperCase() === 'XRP'
+          txCurrency.toUpperCase() === 'XAH'
         ) {
           throw new XrplError(
-            `Trying to sign an issued currency with a similar standard code to XRP (received '${txCurrency}'). XRP is not an issued currency.`,
+            `Trying to sign an issued currency with a similar standard code to XAH (received '${txCurrency}'). XAH is not an issued currency.`,
           )
         }
 
@@ -566,7 +575,7 @@ function removeTrailingZeros(tx: Transaction): void {
 /* eslint-disable @typescript-eslint/no-magic-numbers -- Magic numbers are from rippleds of currency code encoding */
 function isoToHex(iso: string): string {
   const bytes = Buffer.alloc(20)
-  if (iso !== 'XRP') {
+  if (iso !== 'XAH') {
     const isoBytes = iso.split('').map((chr) => chr.charCodeAt(0))
     bytes.set(isoBytes, 12)
   }

packages/xrpl/src/Wallet/signer.ts

@@ -1,13 +1,13 @@
-import { BigNumber } from 'bignumber.js'
-import { flatMap } from 'lodash'
-import { decodeAccountID } from 'ripple-address-codec'
+import { decodeAccountID } from '@transia/ripple-address-codec'
 import {
   decode,
   encode,
   encodeForSigning,
   encodeForSigningClaim,
-} from 'ripple-binary-codec'
-import { sign as signWithKeypair, verify } from 'ripple-keypairs'
+} from '@transia/ripple-binary-codec'
+import { sign as signWithKeypair, verify } from '@transia/ripple-keypairs'
+import { BigNumber } from 'bignumber.js'
+import { flatMap } from 'lodash'
 
 import { ValidationError } from '../errors'
 import { Signer } from '../models/common'

packages/xrpl/src/client/index.ts

@@ -101,6 +101,7 @@ import {
   getXrpBalance,
   submit,
   submitAndWait,
+  getNetworkID,
 } from '../sugar'
 import fundWallet from '../Wallet/fundWallet'
 
@@ -200,6 +201,13 @@ class Client extends EventEmitter {
    */
   public readonly maxFeeXRP: string
 
+  /**
+   * Network ID of the server this sdk is connected to
+   *
+   * @category Fee
+   */
+  public networkID: number
+
   /**
    * Creates a new Client with a websocket connection to a rippled server.
    *
@@ -218,6 +226,7 @@ class Client extends EventEmitter {
 
     this.feeCushion = options.feeCushion ?? DEFAULT_FEE_CUSHION
     this.maxFeeXRP = options.maxFeeXRP ?? DEFAULT_MAX_FEE_XRP
+    this.networkID = 1
 
     this.connection = new Connection(server, options)
 
@@ -634,6 +643,11 @@ class Client extends EventEmitter {
    */
   public getLedgerIndex = getLedgerIndex
 
+  /**
+   * @category Abstraction
+   */
+  public getNetworkID = getNetworkID
+
   /**
    * @category Faucet
    */

packages/xrpl/src/client/partialPayment.ts

@@ -1,5 +1,5 @@
+import { decode } from '@transia/ripple-binary-codec'
 import BigNumber from 'bignumber.js'
-import { decode } from 'ripple-binary-codec'
 
 import type {
   AccountTxResponse,

packages/xrpl/src/models/common/index.ts

@@ -1,7 +1,7 @@
 export type LedgerIndex = number | ('validated' | 'closed' | 'current')
 
 interface XRP {
-  currency: 'XRP'
+  currency: 'XAH'
 }
 
 interface IssuedCurrency {
@@ -17,6 +17,8 @@ export interface IssuedCurrencyAmount extends IssuedCurrency {
 
 export type Amount = IssuedCurrencyAmount | string
 
+export type AmountEntry = Amount
+
 export interface Signer {
   Signer: {
     Account: string
@@ -51,6 +53,84 @@ interface PathStep {
 
 export type Path = PathStep[]
 
+/**
+ * The object that describes the grant in HookGrants.
+ */
+export interface HookGrant {
+  /**
+   * The object that describes the grant in HookGrants.
+   */
+  HookGrant: {
+    /**
+     * The hook hash of the grant.
+     */
+    HookHash: string
+    /**
+     * The account authorized on the grant.
+     */
+    Authorize?: string
+  }
+}
+
+/**
+ * The object that describes the parameter in HookParameters.
+ */
+export interface HookParameter {
+  /**
+   * The object that describes the parameter in HookParameters.
+   */
+  HookParameter: {
+    /**
+     * The name of the parameter.
+     */
+    HookParameterName: string
+    /**
+     * The value of the parameter.
+     */
+    HookParameterValue: string
+  }
+}
+
+/**
+ * The object that describes the hook in Hooks.
+ */
+export interface Hook {
+  /**
+   * The object that describes the hook in Hooks.
+   */
+  Hook: {
+    HookHash?: string
+    /**
+     * The code that is executed when the hook is triggered.
+     */
+    CreateCode?: string
+    /**
+     * The flags that are set on the hook.
+     */
+    Flags?: number
+    /**
+     * The transactions that triggers the hook. Represented as a 256Hash
+     */
+    HookOn?: string
+    /**
+     * The namespace of the hook.
+     */
+    HookNamespace?: string
+    /**
+     * The API version of the hook.
+     */
+    HookApiVersion?: number
+    /**
+     * The parameters of the hook.
+     */
+    HookParameters?: HookParameter[]
+    /**
+     * The grants of the hook.
+     */
+    HookGrants?: HookGrant[]
+  }
+}
+
 /**
  * The object that describes the signer in SignerEntries.
  */
@@ -117,3 +197,31 @@ export interface NFTOffer {
   destination?: string
   expiration?: number
 }
+
+/**
+ * This information is added to emitted Transactions.
+ */
+export interface EmitDetails {
+  EmitBurden: number
+  EmitGeneration: number
+  EmitHookHash: string
+  EmitParentTxnID: string
+}
+
+/**
+ * The object that describes the uritoken in MintURIToken.
+ */
+export interface MintURIToken {
+  /**
+   *
+   */
+  URI: string
+  /**
+   *
+   */
+  Digest?: string
+  /**
+   * The flags that are set on the uritoken.
+   */
+  Flags?: number
+}

packages/xrpl/src/models/ledger/AccountRoot.ts

@@ -72,6 +72,10 @@ export default interface AccountRoot extends BaseLedgerEntry {
    * account to each other.
    */
   TransferRate?: number
+  ImportSequence?: string
+  GovernanceFlags?: string
+  GovernanceMarks?: string
+  AccountIndex?: number
 }
 
 /**

packages/xrpl/src/models/ledger/EmittedTxn.ts

@@ -0,0 +1,20 @@
+import { Transaction } from '../transactions'
+
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ * The EmittedTxn object type contains the
+ *
+ * @category Ledger Entries
+ */
+export default interface EmittedTxn extends BaseLedgerEntry {
+  LedgerEntryType: 'EmittedTxn'
+
+  EmittedTxn: Transaction
+
+  /**
+   * A hint indicating which page of the sender's owner directory links to this
+   * object, in case the directory consists of multiple pages.
+   */
+  OwnerNode: string
+}

packages/xrpl/src/models/ledger/Escrow.ts

@@ -1,7 +1,9 @@
+import { Amount } from '../common'
+
 import BaseLedgerEntry from './BaseLedgerEntry'
 
 /**
- * The Escrow object type represents a held payment of XRP waiting to be
+ * The Escrow object type represents a held payment waiting to be
  * executed or canceled.
  *
  * @category Ledger Entries
@@ -10,17 +12,17 @@ export default interface Escrow extends BaseLedgerEntry {
   LedgerEntryType: 'Escrow'
   /**
    * The address of the owner (sender) of this held payment. This is the
-   * account that provided the XRP, and gets it back if the held payment is
+   * account that provided the amounts, and gets it back if the held payment is
    * canceled.
    */
   Account: string
   /**
-   * The destination address where the XRP is paid if the held payment is
+   * The destination address where the amounts are paid if the held payment is
    * successful.
    */
   Destination: string
-  /** The amount of XRP, in drops, to be delivered by the held payment. */
-  Amount: string
+  /** The amount to be delivered by the held payment. */
+  Amount: Amount
   /**
    * A PREIMAGE-SHA-256 crypto-condition, as hexadecimal. If present, the
    * EscrowFinish transaction must contain a fulfillment that satisfies this
@@ -71,4 +73,9 @@ export default interface Escrow extends BaseLedgerEntry {
    * modified this object.
    */
   PreviousTxnLgrSeq: number
+  /**
+   * The fee to charge when users finish an escrow, initially set on the
+   * creation of an escrow contract, and updated on subsequent finish transactions
+   */
+  TransferRate?: number
 }

packages/xrpl/src/models/ledger/FeeSettings.ts

@@ -24,4 +24,6 @@ export default interface FeeSettings extends BaseLedgerEntry {
    * type.
    */
   Flags: number
+  XahauActivationLgrSeq?: number
+  AccountCount?: number
 }

packages/xrpl/src/models/ledger/Hook.ts

@@ -0,0 +1,27 @@
+import { Hook as WHook } from '../common'
+
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ * The Hook object type contains the
+ *
+ * @category Ledger Entries
+ */
+export default interface Hook extends BaseLedgerEntry {
+  LedgerEntryType: 'Hook'
+
+  /** The identifying (classic) address of this account. */
+  Account: string
+
+  /**
+   * A hint indicating which page of the sender's owner directory links to this
+   * object, in case the directory consists of multiple pages.
+   */
+  OwnerNode: string
+
+  PreviousTxnID: string
+
+  PreviousTxnLgrSeq: number
+
+  Hooks: WHook[]
+}

packages/xrpl/src/models/ledger/HookDefinition.ts

@@ -0,0 +1,67 @@
+import { HookParameter } from '../common'
+
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ * The HookDefintion object type contains the
+ *
+ * @category Ledger Entries
+ */
+export default interface HookDefintion extends BaseLedgerEntry {
+  LedgerEntryType: 'HookDefintion'
+
+  /**
+   * The flags that are set on the hook.
+   */
+  Flags: number
+
+  /**
+   * This field contains a string that is used to uniquely identify the hook.
+   */
+  HookHash: string
+
+  /**
+   * The transactions that triggers the hook. Represented as a 256Hash
+   */
+  HookOn?: string
+
+  /**
+   * The namespace of the hook.
+   */
+  HookNamespace?: string
+
+  /**
+   * The API version of the hook.
+   */
+  HookApiVersion?: string
+
+  /**
+   * The parameters of the hook.
+   */
+  HookParameters?: HookParameter[]
+
+  /**
+   * The code that is executed when the hook is triggered.
+   */
+  CreateCode?: string
+
+  /**
+   * This is an optional field that contains the transaction ID of the hook set.
+   */
+  HookSetTxnID?: string
+
+  /**
+   * This is an optional field that contains the number of references to this hook.
+   */
+  ReferenceCount?: number
+
+  /**
+   * This is an optional field that contains the fee associated with the hook.
+   */
+  Fee?: string
+
+  /**
+   * This is an optional field that contains the callback fee associated with the hook.
+   */
+  HookCallbackFee?: number
+}

packages/xrpl/src/models/ledger/HookState.ts

@@ -0,0 +1,29 @@
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ * The HookState object type contains the
+ *
+ * @category Ledger Entries
+ */
+export default interface HookState extends BaseLedgerEntry {
+  LedgerEntryType: 'HookState'
+
+  /**
+   * A hint indicating which page of the sender's owner directory links to this
+   * object, in case the directory consists of multiple pages.
+   */
+  OwnerNode: string
+
+  /**
+   * The HookStateKey property contains the key associated with this hook state,
+   * and the HookStateData property contains the data associated with this hook state.
+   */
+  HookStateKey: string
+
+  /**
+   * The `HookStateData` property contains the data associated with this hook state.
+   * It is typically a string containing the data associated with this hook state,
+   * such as an identifier or other information.
+   */
+  HookStateData: string
+}

packages/xrpl/src/models/ledger/ImportVLSequence.ts

@@ -0,0 +1,19 @@
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ *
+ *
+ *
+ * @category Ledger Entries
+ */
+export default interface ImportVLSequence extends BaseLedgerEntry {
+  LedgerEntryType: 'ImportVLSequence'
+  /**
+   *
+   */
+  PublicKey: string
+  /**
+   *
+   */
+  ImportSequence: string
+}

packages/xrpl/src/models/ledger/LedgerEntry.ts

@@ -3,8 +3,13 @@ import Amendments from './Amendments'
 import Check from './Check'
 import DepositPreauth from './DepositPreauth'
 import DirectoryNode from './DirectoryNode'
+import EmittedTxn from './EmittedTxn'
 import Escrow from './Escrow'
 import FeeSettings from './FeeSettings'
+import Hook from './Hook'
+import HookDefinition from './HookDefinition'
+import HookState from './HookState'
+import ImportVLSequence from './ImportVLSequence'
 import LedgerHashes from './LedgerHashes'
 import NegativeUNL from './NegativeUNL'
 import Offer from './Offer'
@@ -12,6 +17,8 @@ import PayChannel from './PayChannel'
 import RippleState from './RippleState'
 import SignerList from './SignerList'
 import Ticket from './Ticket'
+import UNLReport from './UNLReport'
+import URIToken from './URIToken'
 
 type LedgerEntry =
   | AccountRoot
@@ -19,8 +26,13 @@ type LedgerEntry =
   | Check
   | DepositPreauth
   | DirectoryNode
+  | EmittedTxn
   | Escrow
   | FeeSettings
+  | Hook
+  | HookDefinition
+  | HookState
+  | ImportVLSequence
   | LedgerHashes
   | NegativeUNL
   | Offer
@@ -28,5 +40,7 @@ type LedgerEntry =
   | RippleState
   | SignerList
   | Ticket
+  | UNLReport
+  | URIToken
 
 export default LedgerEntry

packages/xrpl/src/models/ledger/PayChannel.ts

@@ -1,9 +1,11 @@
+import { Amount } from '../common'
+
 import BaseLedgerEntry from './BaseLedgerEntry'
 
 /**
  * The PayChannel object type represents a payment channel. Payment channels
- * enable small, rapid off-ledger payments of XRP that can be later reconciled
- * with the consensus ledger. A payment channel holds a balance of XRP that can
+ * enable small, rapid off-ledger payments that can be later reconciled
+ * with the consensus ledger. A payment channel holds a balance that can
  * only be paid out to a specific destination address until the channel is
  * closed.
  *
@@ -18,37 +20,37 @@ export default interface PayChannel extends BaseLedgerEntry {
   Account: string
   /**
    * The destination address for this payment channel. While the payment
-   * channel is open, this address is the only one that can receive XRP from the
+   * channel is open, this address is the only one that can receive amounts from the
    * channel. This comes from the Destination field of the transaction that
    * created the channel.
    */
   Destination: string
   /**
-   * Total XRP, in drops, that has been allocated to this channel. This
-   * includes XRP that has been paid to the destination address. This is
-   * initially set by the transaction that created the channel and can be
-   * increased if the source address sends a PaymentChannelFund transaction.
+   * Total amount that has been allocated to this channel. This includes amounts
+   * that have been paid to the destination address. This is initially set by the
+   * transaction that created the channel and can be increased if the source
+   * address sends a PaymentChannelFund transaction.
    */
-  Amount: string
+  Amount: Amount
   /**
-   * Total XRP, in drops, already paid out by the channel. The difference
-   * between this value and the Amount field is how much XRP can still be paid
-   * to the destination address with PaymentChannelClaim transactions. If the
-   * channel closes, the remaining difference is returned to the source address.
+   * Total amount already paid out by the channel. The difference between this value
+   * and the Amount field is how much can still be paid to the destination address
+   * with PaymentChannelClaim transactions. If the channel closes, the remaining
+   * difference is returned to the source address.
    */
-  Balance: string
+  Balance: Amount
   /**
    * Public key, in hexadecimal, of the key pair that can be used to sign
    * claims against this channel. This can be any valid secp256k1 or Ed25519
    * public key. This is set by the transaction that created the channel and
    * must match the public key used in claims against the channel. The channel
-   * source address can also send XRP from this channel to the destination
+   * source address can also send amounts from this channel to the destination
    * without signed claims.
    */
   PublicKey: string
   /**
    * Number of seconds the source address must wait to close the channel if
-   * it still has any XRP in it. Smaller values mean that the destination
+   * it still has any amount in it. Smaller values mean that the destination
    * address has less time to redeem any outstanding claims after the source
    * address requests to close the channel. Can be any value that fits in a
    * 32-bit unsigned integer (0 to 2^32-1). This is set by the transaction that
@@ -104,4 +106,10 @@ export default interface PayChannel extends BaseLedgerEntry {
    * this object, in case the directory consists of multiple pages.
    */
   DestinationNode?: string
+  /**
+   * The fee to charge when users make claims on a payment channel, initially
+   * set on the creation of a payment channel and updated on subsequent funding
+   * or claim transactions.
+   */
+  TransferRate?: number
 }

packages/xrpl/src/models/ledger/UNLReport.ts

@@ -0,0 +1,42 @@
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+interface ImportVLKey {
+  ImportVLKey: {
+    PublicKey: string
+    Account?: string
+  }
+}
+interface ActiveValidator {
+  ActiveValidator: {
+    PublicKey: string
+    Account?: string
+  }
+}
+
+/**
+ *
+ *
+ *
+ * @category Ledger Entries
+ */
+export default interface UNLReport extends BaseLedgerEntry {
+  LedgerEntryType: 'UNLReport'
+  /**
+   *
+   */
+  ImportVLKeys?: ImportVLKey[]
+  /**
+   *
+   */
+  ActiveValidators?: ActiveValidator[]
+  /**
+   * The identifying hash of the transaction that most recently modified this
+   * object.
+   */
+  PreviousTxnID: string
+  /**
+   * The index of the ledger that contains the transaction that most recently
+   * modified this object.
+   */
+  PreviousTxnLgrSeq: number
+}

packages/xrpl/src/models/ledger/URIToken.ts

@@ -0,0 +1,53 @@
+import { Amount } from '../common'
+
+import BaseLedgerEntry from './BaseLedgerEntry'
+
+/**
+ * The URIToken object type contains the
+ *
+ * @category Ledger Entries
+ */
+export default interface URIToken extends BaseLedgerEntry {
+  LedgerEntryType: 'URIToken'
+
+  /**
+   */
+  Owner: string
+
+  /**
+   * A hint indicating which page of the sender's owner directory links to this
+   * object, in case the directory consists of multiple pages.
+   */
+  OwnerNode: string
+
+  /**
+   */
+  Issuer: string
+
+  /**
+   */
+  URI: string
+
+  /**
+   */
+  Digest: string
+
+  /**
+   */
+  Amount: Amount
+
+  /**
+   */
+  Destination: string
+
+  /**
+   * The identifying hash of the transaction that most recently modified this
+   * object.
+   */
+  PreviousTxnID: string
+  /**
+   * The index of the ledger that contains the transaction that most recently
+   * modified this object.
+   */
+  PreviousTxnLgrSeq: number
+}

packages/xrpl/src/models/ledger/index.ts

@@ -6,8 +6,13 @@ import Amendments from './Amendments'
 import Check from './Check'
 import DepositPreauth from './DepositPreauth'
 import DirectoryNode from './DirectoryNode'
+import EmittedTxn from './EmittedTxn'
 import Escrow from './Escrow'
 import FeeSettings from './FeeSettings'
+import Hook from './Hook'
+import HookDefinition from './HookDefinition'
+import HookState from './HookState'
+import ImportVLSequence from './ImportVLSequence'
 import Ledger from './Ledger'
 import LedgerEntry from './LedgerEntry'
 import LedgerHashes from './LedgerHashes'
@@ -17,6 +22,8 @@ import PayChannel from './PayChannel'
 import RippleState, { RippleStateFlags } from './RippleState'
 import SignerList, { SignerListFlags } from './SignerList'
 import Ticket from './Ticket'
+import UNLReport from './UNLReport'
+import URIToken from './URIToken'
 
 export {
   AccountRoot,
@@ -26,8 +33,13 @@ export {
   Check,
   DepositPreauth,
   DirectoryNode,
+  EmittedTxn,
   Escrow,
   FeeSettings,
+  Hook,
+  HookDefinition,
+  HookState,
+  ImportVLSequence,
   Ledger,
   LedgerEntry,
   LedgerHashes,
@@ -40,4 +52,6 @@ export {
   SignerList,
   SignerListFlags,
   Ticket,
+  UNLReport,
+  URIToken,
 }

packages/xrpl/src/models/methods/accountChannels.ts

@@ -1,10 +1,10 @@
-import { LedgerIndex } from '../common'
+import { Amount, LedgerIndex } from '../common'
 
 import { BaseRequest, BaseResponse } from './baseMethod'
 
 interface Channel {
   account: string
-  amount: string
+  amount: Amount
   balance: string
   channel_id: string
   destination_account: string
@@ -15,6 +15,7 @@ interface Channel {
   cancel_after?: number
   source_tab?: number
   destination_tag?: number
+  transfer_rate?: number
 }
 
 /**

packages/xrpl/src/models/methods/accountLines.ts

@@ -1,4 +1,4 @@
-import { LedgerIndex } from '../common'
+import { Amount, LedgerIndex } from '../common'
 
 import { BaseRequest, BaseResponse } from './baseMethod'
 
@@ -64,6 +64,14 @@ export interface Trustline {
    * false.
    */
   freeze_peer?: boolean
+  /**
+   * The total amount of FT, in drops/Amount locked in payment channels or escrow.
+   */
+  locked_balance?: Amount
+  /**
+   * The total number of lock balances on a RippleState ledger object.
+   */
+  lock_count?: number
 }
 
 /**

packages/xrpl/src/models/methods/accountNamespace.ts

@@ -0,0 +1,46 @@
+import { HookState } from '../ledger'
+
+import { BaseRequest, BaseResponse } from './baseMethod'
+
+/**
+ * The `account_namespace` command retrieves the account namespace. All information retrieved is relative to a
+ * particular version of the ledger. Returns an {@link AccountNamespaceResponse}.
+ *
+ * @category Requests
+ */
+export interface AccountNamespaceRequest extends BaseRequest {
+  command: 'account_namespace'
+  /** A unique identifier for the account, most commonly the account's address. */
+  account: string
+  /** The hex namespace. */
+  namespace_id?: string
+}
+
+/**
+ * Response expected from an {@link AccountNamespaceRequest}.
+ *
+ * @category Responses
+ */
+export interface AccountNamespaceResponse extends BaseResponse {
+  result: {
+    /**
+     * The account requested.
+     */
+    account: string
+    /**
+     * The namespace_id requested.
+     */
+    namespace_id: string
+    /**
+     * A list of HookStates for the specified account namespace_id.
+     */
+    namespace_entries: HookState[]
+    /**
+     * The ledger index of the current open ledger, which was used when
+     * retrieving this information.
+     */
+    ledger_current_index: number
+    /** If true, this data comes from a validated ledger. */
+    validated: boolean
+  }
+}

packages/xrpl/src/models/methods/accountObjects.ts

@@ -3,11 +3,13 @@ import {
   Check,
   DepositPreauth,
   Escrow,
+  Hook,
   Offer,
   PayChannel,
   RippleState,
   SignerList,
   Ticket,
+  URIToken,
 } from '../ledger'
 
 import { BaseRequest, BaseResponse } from './baseMethod'
@@ -16,12 +18,14 @@ type AccountObjectType =
   | 'check'
   | 'deposit_preauth'
   | 'escrow'
+  | 'hook'
   | 'nft_offer'
   | 'offer'
   | 'payment_channel'
   | 'signer_list'
   | 'state'
   | 'ticket'
+  | 'uritoken'
 
 /**
  * The account_objects command returns the raw ledger format for all objects
@@ -73,11 +77,13 @@ type AccountObject =
   | Check
   | DepositPreauth
   | Escrow
+  | Hook
   | Offer
   | PayChannel
   | SignerList
   | RippleState
   | Ticket
+  | URIToken
 
 /**
  * Response expected from an {@link AccountObjectsRequest}.

packages/xrpl/src/models/methods/channelVerify.ts

@@ -9,7 +9,7 @@ import { BaseRequest, BaseResponse } from './baseMethod'
  */
 export interface ChannelVerifyRequest extends BaseRequest {
   command: 'channel_verify'
-  /** The amount of XRP, in drops, the provided signature authorizes. */
+  /** The amount the provided signature authorizes. */
   amount: string
   /**
    * The Channel ID of the channel that provides the XRP. This is a

packages/xrpl/src/models/methods/index.ts

@@ -8,6 +8,10 @@ import {
 } from './accountCurrencies'
 import { AccountInfoRequest, AccountInfoResponse } from './accountInfo'
 import { AccountLinesRequest, AccountLinesResponse } from './accountLines'
+import {
+  AccountNamespaceRequest,
+  AccountNamespaceResponse,
+} from './accountNamespace'
 import { AccountNFTsRequest, AccountNFTsResponse } from './accountNFTs'
 import { AccountObjectsRequest, AccountObjectsResponse } from './accountObjects'
 import {
@@ -83,6 +87,7 @@ type Request =
   | AccountCurrenciesRequest
   | AccountInfoRequest
   | AccountLinesRequest
+  | AccountNamespaceRequest
   | AccountNFTsRequest
   | AccountObjectsRequest
   | AccountOffersRequest
@@ -133,6 +138,7 @@ type Response =
   | AccountCurrenciesResponse
   | AccountInfoResponse
   | AccountLinesResponse
+  | AccountNamespaceResponse
   | AccountNFTsResponse
   | AccountObjectsResponse
   | AccountOffersResponse

packages/xrpl/src/models/methods/ledgerEntry.ts

@@ -79,6 +79,11 @@ export interface LedgerEntryRequest extends BaseRequest {
       }
     | string
 
+  /**
+   * The object ID of a transaction emitted by the ledger entry.
+   */
+  emitted_txn?: string
+
   /**
    * The Escrow object to retrieve. If a string, must be the object ID of the
    * escrow, as hexadecimal. If an object, requires owner and seq sub-fields.
@@ -92,6 +97,47 @@ export interface LedgerEntryRequest extends BaseRequest {
       }
     | string
 
+  /**
+   * The hash of the Hook object to retrieve.
+   */
+  hook_definition?: string
+
+  /**
+   * The Hook object to retrieve. If a string, must be the object ID of the Hook.
+   * If an object, requires `account` sub-field.
+   */
+  hook?:
+    | {
+        /** The account of the Hook object. */
+        account: string
+      }
+    | string
+
+  /**
+   * Object specifying the HookState object to retrieve. Requires the sub-fields
+   * `account`, `key`, and `namespace_id` to uniquely specify the HookState entry
+   * to retrieve.
+   */
+  hook_state?: {
+    /** The account of the Hook object. */
+    account: string
+    /** The key of the state. */
+    key: string
+    /** The namespace of the state. */
+    namespace_id: string
+  }
+
+  /**
+   * The Import VL Sequence object to retrieve. If a string, must be the object ID of the VLSequence.
+   * If an object, requires `public_key` sub-field.
+   */
+  import_vlseq?:
+    | {
+        /** The public_key of the Import VL Sequence object. */
+        public_key: string
+      }
+    | string
+
   /**
    * The Offer object to retrieve. If a string, interpret as the unique object
    * ID to the Offer. If an object, requires the sub-fields `account` and `seq`
@@ -137,6 +183,20 @@ export interface LedgerEntryRequest extends BaseRequest {
         ticket_sequence: number
       }
     | string
+
+  /**
+   * The URIToken object to retrieve. If a string, must be the object ID of the
+   * URIToken, as hexadecimal. If an object, the `issuer` and `uri`
+   * sub-fields are required to uniquely specify the URIToken entry.
+   */
+  uri_token?:
+    | {
+        /** The issuer of the URIToken object. */
+        issuer: string
+        /** The URIToken uri string (ascii). */
+        uri: string
+      }
+    | string
 }
 
 /**

packages/xrpl/src/models/methods/pathFind.ts

@@ -63,6 +63,11 @@ interface PathOption {
    * Destination to receive the desired amount.
    */
   source_amount: Amount
+  /**
+   * Destination Amount that the destination would receive along this path.
+   * If the `send_max` field is set, this field will be set.
+   */
+  destination_amount?: Amount
 }
 
 /**
@@ -80,7 +85,7 @@ export interface PathFindResponse extends BaseResponse {
     alternatives: PathOption[]
     /** Unique address of the account that would receive a transaction. */
     destination_account: string
-    /** Currency amount that the destination would receive in a transaction. */
+    /** Currency amount provided in the WebSocket request. */
     destination_amount: Amount
     /** Unique address that would send a transaction. */
     source_account: string

packages/xrpl/src/models/methods/serverInfo.ts

@@ -136,6 +136,10 @@ export interface ServerInfoResponse extends BaseResponse {
        * overall network's load factor.
        */
       load_factor?: number
+      /**
+       * The network id of the server.
+       */
+      network_id?: number
       /**
        * Current multiplier to the transaction cost based on
        * load to this server.

packages/xrpl/src/models/transactions/NFTokenMint.ts

@@ -86,8 +86,11 @@ export interface NFTokenMint extends BaseTransaction {
    *
    * This field must be hex-encoded. You can use `convertStringToHex` to
    * convert this field to the proper encoding.
+   *
+   * This field must not be an empty string. Omit it from the transaction or
+   * set to `undefined` value if you do not use it.
    */
-  URI?: string
+  URI?: string | null
   Flags?: number | NFTokenMintFlagsInterface
 }
 
@@ -106,6 +109,10 @@ export function validateNFTokenMint(tx: Record<string, unknown>): void {
     )
   }
 
+  if (typeof tx.URI === 'string' && tx.URI === '') {
+    throw new ValidationError('NFTokenMint: URI must not be empty string')
+  }
+
   if (typeof tx.URI === 'string' && !isHex(tx.URI)) {
     throw new ValidationError('NFTokenMint: URI must be in hex format')
   }

packages/xrpl/src/models/transactions/accountSet.ts

@@ -1,6 +1,6 @@
 /* eslint-disable complexity -- Necessary for validateAccountSet */
 
-import { isValidClassicAddress } from 'ripple-address-codec'
+import { isValidClassicAddress } from '@transia/ripple-address-codec'
 
 import { ValidationError } from '../../errors'
 
@@ -48,6 +48,7 @@ export enum AccountSetAsfFlags {
    */
   asfAuthorizedNFTokenMinter = 10,
   /** asf 11 is reserved for Hooks amendment */
+  asfTshCollect = 11,
   /** Disallow other accounts from creating incoming NFTOffers */
   asfDisallowIncomingNFTokenOffer = 12,
   /** Disallow other accounts from creating incoming Checks */

packages/xrpl/src/models/transactions/claimReward.ts

@@ -0,0 +1,28 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ * ClaimReward is a transaction model that allows an account to claim rewards.
+ *
+ * @category Transaction Models
+ */
+export interface ClaimReward extends BaseTransaction {
+  TransactionType: 'ClaimReward'
+  /** The unique address of the issuer where the reward.c hook is installed. */
+  Issuer?: string
+}
+
+/**
+ * Verify the form and type of an ClaimReward at runtime.
+ *
+ * @param tx - An ClaimReward Transaction.
+ * @throws When the ClaimReward is Malformed.
+ */
+export function validateClaimReward(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Issuer !== undefined && typeof tx.Issuer !== 'string') {
+    throw new ValidationError('ClaimReward: invalid Issuer')
+  }
+}

packages/xrpl/src/models/transactions/common.ts

@@ -1,10 +1,17 @@
 /* eslint-disable max-lines-per-function -- Necessary for validateBaseTransaction */
 /* eslint-disable complexity -- Necessary for validateBaseTransaction */
 /* eslint-disable max-statements -- Necessary for validateBaseTransaction */
-import { TRANSACTION_TYPES } from 'ripple-binary-codec'
+import { TRANSACTION_TYPES } from '@transia/ripple-binary-codec'
 
 import { ValidationError } from '../../errors'
-import { Amount, IssuedCurrencyAmount, Memo, Signer } from '../common'
+import {
+  Amount,
+  HookParameter,
+  IssuedCurrencyAmount,
+  Memo,
+  Signer,
+  EmitDetails,
+} from '../common'
 import { onlyHasFields } from '../utils'
 
 const MEMO_SIZE = 3
@@ -159,6 +166,18 @@ export interface BaseTransaction {
    * account it says it is from.
    */
   TxnSignature?: string
+  /**
+   * The network id of the transaction.
+   */
+  NetworkID?: number
+  /**
+   * The hook parameters of the transaction.
+   */
+  HookParameters?: HookParameter[]
+  /**
+   * The hook parameters of the transaction.
+   */
+  EmitDetails?: EmitDetails
 }
 
 /**
@@ -252,6 +271,9 @@ export function validateBaseTransaction(common: Record<string, unknown>): void {
   ) {
     throw new ValidationError('BaseTransaction: invalid TxnSignature')
   }
+  if (common.NetworkID !== undefined && typeof common.NetworkID !== 'number') {
+    throw new ValidationError('BaseTransaction: invalid NetworkID')
+  }
 }
 
 /**

packages/xrpl/src/models/transactions/escrowCancel.ts

@@ -3,7 +3,7 @@ import { ValidationError } from '../../errors'
 import { BaseTransaction, validateBaseTransaction } from './common'
 
 /**
- * Return escrowed XRP to the sender.
+ * Return escrowed amount to the sender.
  *
  * @category Transaction Models
  */
@@ -15,7 +15,12 @@ export interface EscrowCancel extends BaseTransaction {
    * Transaction sequence (or Ticket  number) of EscrowCreate transaction that.
    * created the escrow to cancel.
    */
-  OfferSequence: number
+  OfferSequence?: number
+  /**
+   * The ID of the Escrow ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  EscrowID?: string
 }
 
 /**
@@ -35,11 +40,17 @@ export function validateEscrowCancel(tx: Record<string, unknown>): void {
     throw new ValidationError('EscrowCancel: Owner must be a string')
   }
 
-  if (tx.OfferSequence === undefined) {
-    throw new ValidationError('EscrowCancel: missing OfferSequence')
+  if (tx.OfferSequence === undefined && tx.EscrowID === undefined) {
+    throw new ValidationError(
+      'EscrowCancel: must include OfferSequence or EscrowID',
+    )
   }
 
-  if (typeof tx.OfferSequence !== 'number') {
-    throw new ValidationError('EscrowCancel: OfferSequence must be a number')
+  if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
+    throw new ValidationError('EscrowCancel: invalid OfferSequence')
+  }
+
+  if (tx.EscrowID !== undefined && typeof tx.EscrowID !== 'string') {
+    throw new ValidationError('EscrowCancel: invalid EscrowID')
   }
 }

packages/xrpl/src/models/transactions/escrowCreate.ts

@@ -1,22 +1,23 @@
 /* eslint-disable complexity -- Necessary for validateEscrowCreate */
 import { ValidationError } from '../../errors'
+import { Amount } from '../common'
 
-import { BaseTransaction, validateBaseTransaction } from './common'
+import { BaseTransaction, isAmount, validateBaseTransaction } from './common'
 
 /**
- * Sequester XRP until the escrow process either finishes or is canceled.
+ * Sequester amount until the escrow process either finishes or is canceled.
  *
  * @category Transaction Models
  */
 export interface EscrowCreate extends BaseTransaction {
   TransactionType: 'EscrowCreate'
   /**
-   * Amount of XRP, in drops, to deduct from the sender's balance and escrow.
-   * Once escrowed, the XRP can either go to the Destination address (after the.
-   * FinishAfter time) or returned to the sender (after the CancelAfter time).
+   * Amount to deduct from the sender's balance and escrow. Once escrowed, the
+   * amount can either go to the Destination address (after the FinishAfter time)
+   * or returned to the sender (after the CancelAfter time).
    */
-  Amount: string
-  /** Address to receive escrowed XRP. */
+  Amount: Amount
+  /** Address to receive escrowed amount. */
   Destination: string
   /**
    * The time, in seconds since the Ripple Epoch, when this escrow expires.
@@ -25,7 +26,7 @@ export interface EscrowCreate extends BaseTransaction {
    */
   CancelAfter?: number
   /**
-   * The time, in seconds since the Ripple Epoch, when the escrowed XRP can be
+   * The time, in seconds since the Ripple Epoch, when the escrowed amount can be
    * released to the recipient. This value is immutable; the funds cannot move.
    * until this time is reached.
    */
@@ -55,8 +56,8 @@ export function validateEscrowCreate(tx: Record<string, unknown>): void {
     throw new ValidationError('EscrowCreate: missing field Amount')
   }
 
-  if (typeof tx.Amount !== 'string') {
-    throw new ValidationError('EscrowCreate: Amount must be a string')
+  if (typeof tx.Amount !== 'string' && !isAmount(tx.Amount)) {
+    throw new ValidationError('EscrowCreate: Amount must be an Amount')
   }
 
   if (tx.Destination === undefined) {

packages/xrpl/src/models/transactions/escrowFinish.ts

@@ -3,7 +3,7 @@ import { ValidationError } from '../../errors'
 import { BaseTransaction, validateBaseTransaction } from './common'
 
 /**
- * Deliver XRP from a held payment to the recipient.
+ * Deliver amount from a held payment to the recipient.
  *
  * @category Transaction Models
  */

packages/xrpl/src/models/transactions/import.ts

@@ -0,0 +1,38 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ *
+ *
+ * @category Transaction Models
+ */
+export interface Import extends BaseTransaction {
+  TransactionType: 'Import'
+  /**
+   *
+   */
+  Issuer?: string
+  /**
+   * Hex value representing a VL Blob.
+   */
+  Blob?: string
+}
+
+/**
+ * Verify the form and type of an Import at runtime.
+ *
+ * @param tx - An Import Transaction.
+ * @throws When the Import is Malformed.
+ */
+export function validateImport(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Issuer !== undefined && typeof tx.Issuer !== 'string') {
+    throw new ValidationError('Import: Issuer must be a string')
+  }
+
+  if (tx.Account === tx.Issuer) {
+    throw new ValidationError('Import: Issuer and Account must not be equal')
+  }
+}

packages/xrpl/src/models/transactions/index.ts

@@ -10,10 +10,13 @@ export { AccountDelete } from './accountDelete'
 export { CheckCancel } from './checkCancel'
 export { CheckCash } from './checkCash'
 export { CheckCreate } from './checkCreate'
+export { ClaimReward } from './claimReward'
 export { DepositPreauth } from './depositPreauth'
 export { EscrowCancel } from './escrowCancel'
 export { EscrowCreate } from './escrowCreate'
 export { EscrowFinish } from './escrowFinish'
+export { Import } from './import'
+export { Invoke } from './invoke'
 export { NFTokenAcceptOffer } from './NFTokenAcceptOffer'
 export { NFTokenBurn } from './NFTokenBurn'
 export { NFTokenCancelOffer } from './NFTokenCancelOffer'
@@ -41,7 +44,18 @@ export {
 } from './paymentChannelClaim'
 export { PaymentChannelCreate } from './paymentChannelCreate'
 export { PaymentChannelFund } from './paymentChannelFund'
+export { Remit } from './remit'
+export { SetHookFlagsInterface, SetHookFlags, SetHook } from './setHook'
 export { SetRegularKey } from './setRegularKey'
 export { SignerListSet } from './signerListSet'
 export { TicketCreate } from './ticketCreate'
 export { TrustSetFlagsInterface, TrustSetFlags, TrustSet } from './trustSet'
+export {
+  URITokenMintFlagsInterface,
+  URITokenMintFlags,
+  URITokenMint,
+} from './uriTokenMint'
+export { URITokenBurn } from './uriTokenBurn'
+export { URITokenCreateSellOffer } from './uriTokenCreateSellOffer'
+export { URITokenBuy } from './uriTokenBuy'
+export { URITokenCancelSellOffer } from './uriTokenCancelSellOffer'

packages/xrpl/src/models/transactions/invoke.ts

@@ -0,0 +1,36 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ *
+ *
+ * @category Transaction Models
+ */
+export interface Invoke extends BaseTransaction {
+  TransactionType: 'Invoke'
+  /**
+   * If present, invokes the Hook on the Destination account.
+   */
+  Destination?: string
+  /**
+   * Hex value representing a VL Blob.
+   */
+  Blob?: string
+}
+
+/**
+ * Verify the form and type of an Invoke at runtime.
+ *
+ * @param tx - An Invoke Transaction.
+ * @throws When the Invoke is Malformed.
+ */
+export function validateInvoke(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Account === tx.Destination) {
+    throw new ValidationError(
+      'Invoke: Destination and Account must not be equal',
+    )
+  }
+}

packages/xrpl/src/models/transactions/metadata.ts

@@ -1,5 +1,29 @@
 import { Amount } from '../common'
 
+export interface HookExecution {
+  HookExecution: {
+    HookAccount: string
+    HookEmitCount: number
+    HookExecutionIndex: number
+    HookHash: string
+    HookInstructionCount: string
+    HookResult: number
+    HookReturnCode: string
+    HookReturnString: string
+    HookStateChangeCount: number
+    Flags: number
+  }
+}
+
+export interface HookEmission {
+  HookEmission: {
+    EmittedTxnID: string
+    HookAccount: string
+    HookHash: string
+    EmitNonce: string
+  }
+}
+
 export interface CreatedNode {
   CreatedNode: {
     LedgerEntryType: string
@@ -60,6 +84,8 @@ export function isDeletedNode(node: Node): node is DeletedNode {
 }
 
 export interface TransactionMetadata {
+  HookExecutions?: HookExecution[]
+  HookEmissions?: HookEmission[]
   AffectedNodes: Node[]
   DeliveredAmount?: Amount
   // "unavailable" possible for transactions before 2014-01-20

packages/xrpl/src/models/transactions/offerCancel.ts

@@ -15,7 +15,12 @@ export interface OfferCancel extends BaseTransaction {
    * created by that transaction. It is not considered an error if the offer.
    * specified does not exist.
    */
-  OfferSequence: number
+  OfferSequence?: number
+  /**
+   * The ID of the Escrow ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  OfferID?: string
 }
 
 /**
@@ -27,11 +32,17 @@ export interface OfferCancel extends BaseTransaction {
 export function validateOfferCancel(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
-  if (tx.OfferSequence === undefined) {
-    throw new ValidationError('OfferCancel: missing field OfferSequence')
+  if (tx.OfferSequence === undefined && tx.OfferID === undefined) {
+    throw new ValidationError(
+      'OfferCancel: must include OfferSequence or OfferID',
+    )
   }
 
-  if (typeof tx.OfferSequence !== 'number') {
-    throw new ValidationError('OfferCancel: OfferSequence must be a number')
+  if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
+    throw new ValidationError('OfferCancel: invalid OfferSequence')
+  }
+
+  if (tx.OfferID !== undefined && typeof tx.OfferID !== 'string') {
+    throw new ValidationError('OfferCancel: invalid OfferID')
   }
 }

packages/xrpl/src/models/transactions/offerCreate.ts

@@ -103,6 +103,11 @@ export interface OfferCreate extends BaseTransaction {
   Expiration?: number
   /** An offer to delete first, specified in the same way as OfferCancel. */
   OfferSequence?: number
+  /**
+   * The ID of the Offer ledger object to cancel as a 64-character hexadecimal
+   * string.
+   */
+  OfferID?: string
   /** The amount and type of currency being provided by the offer creator. */
   TakerGets: Amount
   /** The amount and type of currency being requested by the offer creator. */
@@ -141,4 +146,8 @@ export function validateOfferCreate(tx: Record<string, unknown>): void {
   if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {
     throw new ValidationError('OfferCreate: invalid OfferSequence')
   }
+
+  if (tx.OfferID !== undefined && typeof tx.OfferID !== 'string') {
+    throw new ValidationError('OfferCreate: invalid OfferID')
+  }
 }

packages/xrpl/src/models/transactions/paymentChannelClaim.ts

@@ -1,7 +1,13 @@
 /* eslint-disable complexity -- Necessary for validatePaymentChannelClaim */
 import { ValidationError } from '../../errors'
+import { Amount } from '../common'
 
-import { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'
+import {
+  BaseTransaction,
+  GlobalFlags,
+  validateBaseTransaction,
+  isAmount,
+} from './common'
 
 /**
  * Enum representing values for PaymentChannelClaim transaction flags.
@@ -18,15 +24,15 @@ export enum PaymentChannelClaimFlags {
   /**
    * Request to close the channel. Only the channel source and destination
    * addresses can use this flag. This flag closes the channel immediately if it
-   * has no more XRP allocated to it after processing the current claim, or if
+   * has no more funds allocated to it after processing the current claim, or if
    * the destination address uses it. If the source address uses this flag when
-   * the channel still holds XRP, this schedules the channel to close after
+   * the channel still holds an amount, this schedules the channel to close after
    * SettleDelay seconds have passed. (Specifically, this sets the Expiration of
    * the channel to the close time of the previous ledger plus the channel's
    * SettleDelay time, unless the channel already has an earlier Expiration
    * time.) If the destination address uses this flag when the channel still
-   * holds XRP, any XRP that remains after processing the claim is returned to
-   * the source address.
+   * holds an amount, any amount that remains after processing the claim is
+   * returned to the source address.
    */
   tfClose = 0x00020000,
 }
@@ -78,21 +84,21 @@ export interface PaymentChannelClaimFlagsInterface extends GlobalFlags {
   /**
    * Request to close the channel. Only the channel source and destination
    * addresses can use this flag. This flag closes the channel immediately if it
-   * has no more XRP allocated to it after processing the current claim, or if
+   * has no more funds allocated to it after processing the current claim, or if
    * the destination address uses it. If the source address uses this flag when
-   * the channel still holds XRP, this schedules the channel to close after
+   * the channel still holds an amount, this schedules the channel to close after
    * SettleDelay seconds have passed. (Specifically, this sets the Expiration of
    * the channel to the close time of the previous ledger plus the channel's
    * SettleDelay time, unless the channel already has an earlier Expiration
    * time.) If the destination address uses this flag when the channel still
-   * holds XRP, any XRP that remains after processing the claim is returned to
-   * the source address.
+   * holds an amount, any amount that remains after processing the claim is
+   * returned to the source address.
    */
   tfClose?: boolean
 }
 
 /**
- * Claim XRP from a payment channel, adjust the payment channel's expiration,
+ * Claim amount from a payment channel, adjust the payment channel's expiration,
  * or both.
  *
  * @category Transaction Models
@@ -103,18 +109,18 @@ export interface PaymentChannelClaim extends BaseTransaction {
   /** The unique ID of the channel as a 64-character hexadecimal string. */
   Channel: string
   /**
-   * Total amount of XRP, in drops, delivered by this channel after processing
-   * this claim. Required to deliver XRP. Must be more than the total amount
-   * delivered by the channel so far, but not greater than the Amount of the
-   * signed claim. Must be provided except when closing the channel.
+   * Total amount delivered by this channel after processing this claim. Required
+   * to deliver amount. Must be more than the total amount delivered by the channel
+   * so far, but not greater than the Amount of the signed claim. Must be provided
+   * except when closing the channel.
    */
-  Balance?: string
+  Balance?: Amount
   /**
-   * The amount of XRP, in drops, authorized by the Signature. This must match
-   * the amount in the signed message. This is the cumulative amount of XRP that
-   * can be dispensed by the channel, including XRP previously redeemed.
+   * The amount authorized by the Signature. This must match the amount in the
+   * signed message. This is the cumulative amount that can be dispensed by the
+   * channel, including amounts previously redeemed. Required unless closing the channel.
    */
-  Amount?: string
+  Amount?: Amount
   /**
    * The signature of this claim, as hexadecimal. The signed message contains
    * the channel ID and the amount of the claim. Required unless the sender of
@@ -147,12 +153,12 @@ export function validatePaymentChannelClaim(tx: Record<string, unknown>): void {
     throw new ValidationError('PaymentChannelClaim: Channel must be a string')
   }
 
-  if (tx.Balance !== undefined && typeof tx.Balance !== 'string') {
-    throw new ValidationError('PaymentChannelClaim: Balance must be a string')
+  if (tx.Balance !== undefined && !isAmount(tx.Balance)) {
+    throw new ValidationError('PaymentChannelClaim: Balance must be an Amount')
   }
 
-  if (tx.Amount !== undefined && typeof tx.Amount !== 'string') {
-    throw new ValidationError('PaymentChannelClaim: Amount must be a string')
+  if (tx.Amount !== undefined && !isAmount(tx.Amount)) {
+    throw new ValidationError('PaymentChannelClaim: Amount must be an Amount')
   }
 
   if (tx.Signature !== undefined && typeof tx.Signature !== 'string') {

packages/xrpl/src/models/transactions/paymentChannelCreate.ts

@@ -1,10 +1,11 @@
 /* eslint-disable complexity -- Necessary for validatePaymentChannelCreate */
 import { ValidationError } from '../../errors'
+import { Amount } from '../common'
 
-import { BaseTransaction, validateBaseTransaction } from './common'
+import { BaseTransaction, validateBaseTransaction, isAmount } from './common'
 
 /**
- * Create a unidirectional channel and fund it with XRP. The address sending
+ * Create a unidirectional channel and fund it. The address sending
  * this transaction becomes the "source address" of the payment channel.
  *
  * @category Transaction Models
@@ -12,20 +13,20 @@ import { BaseTransaction, validateBaseTransaction } from './common'
 export interface PaymentChannelCreate extends BaseTransaction {
   TransactionType: 'PaymentChannelCreate'
   /**
-   * Amount of XRP, in drops, to deduct from the sender's balance and set aside
-   * in this channel. While the channel is open, the XRP can only go to the
-   * Destination address. When the channel closes, any unclaimed XRP is returned
-   * to the source address's balance.
+   * Amount to deduct from the sender's balance and set aside in this channel.
+   * While the channel is open, the amount can only go to the Destination
+   * address. When the channel closes, any unclaimed amount is returned to
+   * the source address's balance.
    */
-  Amount: string
+  Amount: Amount
   /**
-   * Address to receive XRP claims against this channel. This is also known as
+   * Address to receive claims against this channel. This is also known as
    * the "destination address" for the channel.
    */
   Destination: string
   /**
    * Amount of time the source address must wait before closing the channel if
-   * it has unclaimed XRP.
+   * it has unclaimed amount.
    */
   SettleDelay: number
   /**
@@ -65,8 +66,8 @@ export function validatePaymentChannelCreate(
     throw new ValidationError('PaymentChannelCreate: missing Amount')
   }
 
-  if (typeof tx.Amount !== 'string') {
-    throw new ValidationError('PaymentChannelCreate: Amount must be a string')
+  if (typeof tx.Amount !== 'string' && !isAmount(tx.Amount)) {
+    throw new ValidationError('PaymentChannelCreate: Amount must be an Amount')
   }
 
   if (tx.Destination === undefined) {

packages/xrpl/src/models/transactions/paymentChannelFund.ts

@@ -1,9 +1,10 @@
 import { ValidationError } from '../../errors'
+import { Amount } from '../common'
 
-import { BaseTransaction, validateBaseTransaction } from './common'
+import { BaseTransaction, validateBaseTransaction, isAmount } from './common'
 
 /**
- * Add additional XRP to an open payment channel, and optionally update the
+ * Add additional amount to an open payment channel, and optionally update the
  * expiration time of the channel. Only the source address of the channel can
  * use this transaction.
  *
@@ -17,16 +18,15 @@ export interface PaymentChannelFund extends BaseTransaction {
    */
   Channel: string
   /**
-   * Amount of XRP in drops to add to the channel. Must be a positive amount
-   * of XRP.
+   * Amount to add to the channel. Must be a positive amount
    */
-  Amount: string
+  Amount: Amount
   /**
    * New Expiration time to set for the channel in seconds since the Ripple
    * Epoch. This must be later than either the current time plus the SettleDelay
    * of the channel, or the existing Expiration of the channel. After the
    * Expiration time, any transaction that would access the channel closes the
-   * channel without taking its normal action. Any unspent XRP is returned to
+   * channel without taking its normal action. Any unspent amount is returned to
    * the source address when the channel closes. (Expiration is separate from
    * the channel's immutable CancelAfter time.) For more information, see the
    * PayChannel ledger object type.
@@ -55,8 +55,8 @@ export function validatePaymentChannelFund(tx: Record<string, unknown>): void {
     throw new ValidationError('PaymentChannelFund: missing Amount')
   }
 
-  if (typeof tx.Amount !== 'string') {
-    throw new ValidationError('PaymentChannelFund: Amount must be a string')
+  if (typeof tx.Amount !== 'string' && !isAmount(tx.Amount)) {
+    throw new ValidationError('PaymentChannelFund: Amount must be an Amount')
   }
 
   if (tx.Expiration !== undefined && typeof tx.Expiration !== 'number') {

packages/xrpl/src/models/transactions/remit.ts

@@ -0,0 +1,200 @@
+import { ValidationError } from '../../errors'
+import { AmountEntry, MintURIToken } from '../common'
+import { isHex } from '../utils'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+const MAX_URI_LENGTH = 256
+const DIGEST_LENGTH = 64
+const MAX_ARRAY_LENGTH = 32
+const MAX_BLOB_LENGTH = 1024
+
+/**
+ * A Remit transaction represents a transfer of value from one account to
+ * another.
+ *
+ * @category Transaction Models
+ */
+export interface Remit extends BaseTransaction {
+  TransactionType: 'Remit'
+  /** The unique address of the account receiving the payment. */
+  Destination: string
+  /**
+   * Arbitrary tag that identifies the reason for the payment to the
+   * destination, or a hosted recipient to pay.
+   */
+  DestinationTag?: number
+  /**
+   *
+   */
+  Amounts?: AmountEntry[]
+  /**
+   *
+   */
+  MintURIToken?: MintURIToken
+  /**
+   * Arbitrary 256-bit hash representing a specific reason or identifier for
+   * this payment.
+   */
+  InvoiceID?: string
+  /**
+   * Hex value representing a VL Blob.
+   */
+  Blob?: string
+  /** The unique address of the account to inform */
+  Inform?: string
+}
+
+/**
+ * Verify the form and type of a Remit at runtime.
+ *
+ * @param tx - A Remit Transaction.
+ * @throws When the Remit is malformed.
+ */
+// eslint-disable-next-line complexity -- ignore
+export function validateRemit(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Amounts !== undefined) {
+    checkAmounts(tx)
+  }
+  if (tx.URITokenIDs !== undefined) {
+    checkURITokenIDs(tx)
+  }
+  if (tx.Destination === tx.Account) {
+    throw new ValidationError(
+      'Remit: Destination must not be equal to the account',
+    )
+  }
+  if (tx.DestinationTag != null && typeof tx.DestinationTag !== 'number') {
+    throw new ValidationError('Remit: DestinationTag must be a number')
+  }
+  if (tx.Inform === tx.Account || tx.inform === tx.Destination) {
+    throw new ValidationError(
+      'Remit: Inform must not be equal to the account or destination',
+    )
+  }
+
+  if (tx.MintURIToken !== undefined) {
+    checkMintURIToken(tx)
+  }
+
+  if (tx.Blob !== undefined && typeof tx.Blob !== 'string') {
+    throw new ValidationError('Remit: Blob must be a string')
+  }
+
+  if (tx.Blob !== undefined && typeof tx.Blob === 'string') {
+    if (!isHex(tx.Blob)) {
+      throw new ValidationError('Remit: Blob must be a hex string')
+    }
+    if (tx.Blob.length > MAX_BLOB_LENGTH) {
+      throw new ValidationError('Remit: max size Blob')
+    }
+  }
+}
+
+function checkAmounts(tx: Record<string, unknown>): void {
+  if (!Array.isArray(tx.Amounts)) {
+    throw new ValidationError('Remit: Amounts must be an array')
+  }
+  if (tx.Amounts.length < 1) {
+    throw new ValidationError('Remit: empty field Amounts')
+  }
+  if (tx.Amounts.length > MAX_ARRAY_LENGTH) {
+    throw new ValidationError('Remit: max field Amounts')
+  }
+  const seen = new Set<string>()
+  let seenXrp = false
+  for (const amount of tx.Amounts) {
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+      amount.AmountEntry === undefined ||
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+      typeof amount.AmountEntry !== 'object'
+    ) {
+      throw new ValidationError('Remit: invalid Amounts.AmountEntry')
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- ignore
+    if (typeof amount.AmountEntry.Amount === 'string') {
+      // eslint-disable-next-line max-depth -- ignore
+      if (seenXrp) {
+        throw new ValidationError(
+          'Remit: Duplicate Native amounts are not allowed',
+        )
+      }
+      seenXrp = true
+    } else {
+      // eslint-disable-next-line max-len -- ignore
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-member-access -- ignore
+      const amountKey = `${amount.AmountEntry.Amount.currency}:${amount.AmountEntry.Amount.issuer}`
+      // eslint-disable-next-line max-depth -- ingore
+      if (seen.has(amountKey)) {
+        throw new ValidationError('Remit: Duplicate amounts are not allowed')
+      }
+      seen.add(amountKey)
+    }
+  }
+}
+
+function checkURITokenIDs(tx: Record<string, unknown>): void {
+  if (!Array.isArray(tx.URITokenIDs)) {
+    throw new ValidationError('Remit: invalid field URITokenIDs')
+  }
+  if (tx.URITokenIDs.length < 1) {
+    throw new ValidationError('Remit: empty field URITokenIDs')
+  }
+  if (tx.URITokenIDs.length > MAX_ARRAY_LENGTH) {
+    throw new ValidationError('Remit: max field URITokenIDs')
+  }
+  const seen = new Set<string>()
+  for (const token of tx.URITokenIDs) {
+    if (typeof token !== 'string' || !isHex(token)) {
+      throw new ValidationError('Remit: URITokenID must be a hex string')
+    }
+    if (token.length !== DIGEST_LENGTH) {
+      throw new ValidationError(
+        `Remit: URITokenID must be exactly ${DIGEST_LENGTH} characters`,
+      )
+    }
+    if (seen.has(token)) {
+      throw new ValidationError('Remit: Duplicate URITokens are not allowed')
+    }
+    seen.add(token)
+  }
+}
+
+// eslint-disable-next-line complexity -- ignore
+function checkMintURIToken(tx: Record<string, unknown>): void {
+  function isRecord(value: unknown): value is Record<string, unknown> {
+    return value !== null && typeof value === 'object'
+  }
+  if (!isRecord(tx.MintURIToken)) {
+    throw new ValidationError('Remit: invalid MintURIToken')
+  }
+  if (tx.MintURIToken.URI === undefined) {
+    throw new ValidationError('Remit: missing field MintURIToken.URI')
+  }
+  if (typeof tx.MintURIToken.URI !== 'string' || !isHex(tx.MintURIToken.URI)) {
+    throw new ValidationError('Remit: MintURIToken.URI must be a hex string')
+  }
+  if (tx.MintURIToken.URI.length > MAX_URI_LENGTH) {
+    throw new ValidationError(
+      `Remit: URI must be less than ${MAX_URI_LENGTH} characters`,
+    )
+  }
+  if (
+    tx.MintURIToken.Digest !== undefined &&
+    typeof tx.MintURIToken.Digest !== 'string'
+  ) {
+    throw new ValidationError(`Remit: MintURIToken.Digest must be a string`)
+  }
+  if (
+    tx.MintURIToken.Digest !== undefined &&
+    !isHex(tx.MintURIToken.Digest) &&
+    tx.MintURIToken.Digest.length !== DIGEST_LENGTH
+  ) {
+    throw new ValidationError(
+      `Remit: Digest must be exactly ${DIGEST_LENGTH} characters`,
+    )
+  }
+}

packages/xrpl/src/models/transactions/setHook.ts

@@ -0,0 +1,81 @@
+import { ValidationError } from '../../errors'
+import { Hook } from '../common'
+
+import { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'
+
+/**
+ * Enum representing values for Set Hook Transaction Flags.
+ *
+ * @category Transaction Flags
+ */
+export enum SetHookFlags {
+  /**
+   */
+  hsfOverride = 0x00000001,
+  /**
+   */
+  hsfNSDelete = 0x0000002,
+  /**
+   */
+  hsfCollect = 0x00000004,
+}
+
+export interface SetHookFlagsInterface extends GlobalFlags {
+  hsfOverride?: boolean
+  hsfNSDelete?: boolean
+  hsfCollect?: boolean
+}
+
+/**
+ *
+ *
+ * @category Transaction Models
+ */
+export interface SetHook extends BaseTransaction {
+  TransactionType: 'SetHook'
+  /**
+   *
+   */
+  Hooks: Hook[]
+
+  Flags?: number | SetHookFlagsInterface
+}
+
+const MAX_HOOKS = 10
+const HEX_REGEX = /^[0-9A-Fa-f]{64}$/u
+
+/**
+ * Verify the form and type of an SetHook at runtime.
+ *
+ * @param tx - An SetHook Transaction.
+ * @throws When the SetHook is Malformed.
+ */
+export function validateSetHook(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (!Array.isArray(tx.Hooks)) {
+    throw new ValidationError('SetHook: invalid Hooks')
+  }
+
+  if (tx.Hooks.length > MAX_HOOKS) {
+    throw new ValidationError(
+      `SetHook: maximum of ${MAX_HOOKS} hooks allowed in Hooks`,
+    )
+  }
+
+  for (const hook of tx.Hooks) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be a Hook
+    const hookObject = hook as Hook
+    const { HookOn, HookNamespace } = hookObject.Hook
+    if (HookOn !== undefined && !HEX_REGEX.test(HookOn)) {
+      throw new ValidationError(
+        `SetHook: HookOn in Hook must be a 256-bit (32-byte) hexadecimal value`,
+      )
+    }
+    if (HookNamespace !== undefined && !HEX_REGEX.test(HookNamespace)) {
+      throw new ValidationError(
+        `SetHook: HookNamespace in Hook must be a 256-bit (32-byte) hexadecimal value`,
+      )
+    }
+  }
+}

packages/xrpl/src/models/transactions/signerListSet.ts

@@ -23,7 +23,7 @@ export interface SignerListSet extends BaseTransaction {
    * more than 32 members. No address may appear more than once in the list, nor
    * may the Account submitting the transaction appear in the list.
    */
-  SignerEntries: SignerEntry[]
+  SignerEntries?: SignerEntry[]
 }
 
 const MAX_SIGNERS = 32
@@ -36,6 +36,7 @@ const HEX_WALLET_LOCATOR_REGEX = /^[0-9A-Fa-f]{64}$/u
  * @param tx - An SignerListSet Transaction.
  * @throws When the SignerListSet is Malformed.
  */
+// eslint-disable-next-line complexity -- validation can be complex
 export function validateSignerListSet(tx: Record<string, unknown>): void {
   validateBaseTransaction(tx)
 
@@ -47,6 +48,10 @@ export function validateSignerListSet(tx: Record<string, unknown>): void {
     throw new ValidationError('SignerListSet: invalid SignerQuorum')
   }
 
+  if (tx.SignerQuorum === 0) {
+    return
+  }
+
   if (tx.SignerEntries === undefined) {
     throw new ValidationError('SignerListSet: missing field SignerEntries')
   }

packages/xrpl/src/models/transactions/transaction.ts

@@ -1,10 +1,6 @@
 /* eslint-disable complexity -- verifies 19 tx types hence a lot of checks needed */
 /* eslint-disable max-lines-per-function -- need to work with a lot of Tx verifications */
 
-import isEqual from 'lodash/isEqual'
-import omitBy from 'lodash/omitBy'
-import { encode, decode } from 'ripple-binary-codec'
-
 import { ValidationError } from '../../errors'
 import { setTransactionFlagsToNumber } from '../utils/flags'
 
@@ -13,10 +9,13 @@ import { AccountSet, validateAccountSet } from './accountSet'
 import { CheckCancel, validateCheckCancel } from './checkCancel'
 import { CheckCash, validateCheckCash } from './checkCash'
 import { CheckCreate, validateCheckCreate } from './checkCreate'
+import { ClaimReward, validateClaimReward } from './claimReward'
 import { DepositPreauth, validateDepositPreauth } from './depositPreauth'
 import { EscrowCancel, validateEscrowCancel } from './escrowCancel'
 import { EscrowCreate, validateEscrowCreate } from './escrowCreate'
 import { EscrowFinish, validateEscrowFinish } from './escrowFinish'
+import { Import, validateImport } from './import'
+import { Invoke, validateInvoke } from './invoke'
 import { TransactionMetadata } from './metadata'
 import {
   NFTokenAcceptOffer,
@@ -47,10 +46,23 @@ import {
   PaymentChannelFund,
   validatePaymentChannelFund,
 } from './paymentChannelFund'
+import { Remit, validateRemit } from './remit'
+import { SetHook, validateSetHook } from './setHook'
 import { SetRegularKey, validateSetRegularKey } from './setRegularKey'
 import { SignerListSet, validateSignerListSet } from './signerListSet'
 import { TicketCreate, validateTicketCreate } from './ticketCreate'
 import { TrustSet, validateTrustSet } from './trustSet'
+import { URITokenBurn, validateURITokenBurn } from './uriTokenBurn'
+import { URITokenBuy, validateURITokenBuy } from './uriTokenBuy'
+import {
+  URITokenCancelSellOffer,
+  validateURITokenCancelSellOffer,
+} from './uriTokenCancelSellOffer'
+import {
+  URITokenCreateSellOffer,
+  validateURITokenCreateSellOffer,
+} from './uriTokenCreateSellOffer'
+import { URITokenMint, validateURITokenMint } from './uriTokenMint'
 
 /**
  * @category Transaction Models
@@ -61,10 +73,13 @@ export type Transaction =
   | CheckCancel
   | CheckCash
   | CheckCreate
+  | ClaimReward
   | DepositPreauth
   | EscrowCancel
   | EscrowCreate
   | EscrowFinish
+  | Import
+  | Invoke
   | NFTokenAcceptOffer
   | NFTokenBurn
   | NFTokenCancelOffer
@@ -76,10 +91,17 @@ export type Transaction =
   | PaymentChannelClaim
   | PaymentChannelCreate
   | PaymentChannelFund
+  | Remit
+  | SetHook
   | SetRegularKey
   | SignerListSet
   | TicketCreate
   | TrustSet
+  | URITokenBurn
+  | URITokenBuy
+  | URITokenCancelSellOffer
+  | URITokenMint
+  | URITokenCreateSellOffer
 
 /**
  * @category Transaction Models
@@ -128,6 +150,10 @@ export function validate(transaction: Record<string, unknown>): void {
       validateCheckCreate(tx)
       break
 
+    case 'ClaimReward':
+      validateClaimReward(tx)
+      break
+
     case 'DepositPreauth':
       validateDepositPreauth(tx)
       break
@@ -144,6 +170,14 @@ export function validate(transaction: Record<string, unknown>): void {
       validateEscrowFinish(tx)
       break
 
+    case 'Import':
+      validateImport(tx)
+      break
+
+    case 'Invoke':
+      validateInvoke(tx)
+      break
+
     case 'NFTokenAcceptOffer':
       validateNFTokenAcceptOffer(tx)
       break
@@ -188,6 +222,14 @@ export function validate(transaction: Record<string, unknown>): void {
       validatePaymentChannelFund(tx)
       break
 
+    case 'Remit':
+      validateRemit(tx)
+      break
+
+    case 'SetHook':
+      validateSetHook(tx)
+      break
+
     case 'SetRegularKey':
       validateSetRegularKey(tx)
       break
@@ -204,18 +246,29 @@ export function validate(transaction: Record<string, unknown>): void {
       validateTrustSet(tx)
       break
 
+    case 'URITokenMint':
+      validateURITokenMint(tx)
+      break
+
+    case 'URITokenBurn':
+      validateURITokenBurn(tx)
+      break
+
+    case 'URITokenCreateSellOffer':
+      validateURITokenCreateSellOffer(tx)
+      break
+
+    case 'URITokenBuy':
+      validateURITokenBuy(tx)
+      break
+
+    case 'URITokenCancelSellOffer':
+      validateURITokenCancelSellOffer(tx)
+      break
+
     default:
       throw new ValidationError(
         `Invalid field TransactionType: ${tx.TransactionType}`,
       )
   }
-
-  if (
-    !isEqual(
-      decode(encode(tx)),
-      omitBy(tx, (value) => value == null),
-    )
-  ) {
-    throw new ValidationError(`Invalid Transaction: ${tx.TransactionType}`)
-  }
 }

packages/xrpl/src/models/transactions/uriTokenBurn.ts

@@ -0,0 +1,60 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ * Map of flags to boolean values representing {@link URITokenBurn} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ *
+ * @example
+ * ```typescript
+ * const tx: URITokenBurn = {
+ * Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * TransactionType: 'URITokenBurn',
+ * }
+ *
+ * // Autofill the tx to see how flags actually look compared to the interface usage.
+ * const autofilledTx = await client.autofill(tx)
+ * console.log(autofilledTx)
+ * // {
+ * // Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * // URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * // TransactionType: 'URITokenBurn',
+ * // Sequence: 21970384,
+ * // Fee: '12',
+ * // LastLedgerSequence: 21970404
+ * // }
+ * ```
+ */
+
+/**
+ * An URITokenBurn transaction is effectively a limit order . It defines an
+ * intent to exchange currencies, and creates an Offer object if not completely.
+ * Fulfilled when placed. Offers can be partially fulfilled.
+ *
+ * @category Transaction Models
+ */
+export interface URITokenBurn extends BaseTransaction {
+  TransactionType: 'URITokenBurn'
+  /**
+   * Identifies the URIToken object to be removed by the transaction.
+   */
+  URITokenID: string
+}
+
+/**
+ * Verify the form and type of an URITokenBurn at runtime.
+ *
+ * @param tx - An URITokenBurn Transaction.
+ * @throws When the URITokenBurn is Malformed.
+ */
+export function validateURITokenBurn(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.URITokenID == null) {
+    throw new ValidationError('NFTokenBurn: missing field URITokenID')
+  }
+}

packages/xrpl/src/models/transactions/uriTokenBuy.ts

@@ -0,0 +1,83 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+
+import { BaseTransaction, isAmount, validateBaseTransaction } from './common'
+
+/**
+ * Map of flags to boolean values representing {@link URITokenBuy} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ *
+ * @example
+ * ```typescript
+ * const tx: URITokenBuy = {
+ * Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * Amount: '1000000',
+ * TransactionType: 'URITokenBuy',
+ * }
+ *
+ * // Autofill the tx to see how flags actually look compared to the interface usage.
+ * const autofilledTx = await client.autofill(tx)
+ * console.log(autofilledTx)
+ * // {
+ * // Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * // URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * // Amount: '1000000',
+ * // TransactionType: 'URITokenBuy',
+ * // Sequence: 21970384,
+ * // Fee: '12',
+ * // LastLedgerSequence: 21970404
+ * // }
+ * ```
+ */
+
+/**
+ * An URITokenBuy transaction is effectively a limit order . It defines an
+ * intent to exchange currencies, and creates an Offer object if not completely.
+ * Fulfilled when placed. Offers can be partially fulfilled.
+ *
+ * @category Transaction Models
+ */
+export interface URITokenBuy extends BaseTransaction {
+  TransactionType: 'URITokenBuy'
+  /**
+   * Identifies the URITokenID of the NFToken object that the
+   * offer references.
+   */
+  URITokenID: string
+  /**
+   * Indicates the amount expected or offered for the Token.
+   *
+   * The amount must be non-zero, except when this is a sell
+   * offer and the asset is XRP. This would indicate that the current
+   * owner of the token is giving it away free, either to anyone at all,
+   * or to the account identified by the Destination field.
+   */
+  Amount: Amount
+}
+
+/**
+ * Verify the form and type of an URITokenBuy at runtime.
+ *
+ * @param tx - An URITokenBuy Transaction.
+ * @throws When the URITokenBuy is Malformed.
+ */
+export function validateURITokenBuy(tx: Record<string, unknown>): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Account === tx.Destination) {
+    throw new ValidationError(
+      'URITokenBuy: Destination and Account must not be equal',
+    )
+  }
+
+  if (tx.URITokenID == null) {
+    throw new ValidationError('URITokenBuy: missing field URITokenID')
+  }
+
+  if (!isAmount(tx.Amount)) {
+    throw new ValidationError('URITokenBuy: invalid Amount')
+  }
+}

packages/xrpl/src/models/transactions/uriTokenCancelSellOffer.ts

@@ -0,0 +1,65 @@
+import { ValidationError } from '../../errors'
+
+import { BaseTransaction, validateBaseTransaction } from './common'
+
+/**
+ * Map of flags to boolean values representing {@link URITokenCancelSellOffer} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ *
+ * @example
+ * ```typescript
+ * const tx: URITokenCancelSellOffer = {
+ * Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * TransactionType: 'URITokenCancelSellOffer',
+ * }
+ *
+ * // Autofill the tx to see how flags actually look compared to the interface usage.
+ * const autofilledTx = await client.autofill(tx)
+ * console.log(autofilledTx)
+ * // {
+ * // Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * // URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * // TransactionType: 'URITokenCancelSellOffer',
+ * // Sequence: 21970384,
+ * // Fee: '12',
+ * // LastLedgerSequence: 21970404
+ * // }
+ * ```
+ */
+
+/**
+ * An URITokenCancelSellOffer transaction is effectively a limit order . It defines an
+ * intent to exchange currencies, and creates an Offer object if not completely.
+ * Fulfilled when placed. Offers can be partially fulfilled.
+ *
+ * @category Transaction Models
+ */
+export interface URITokenCancelSellOffer extends BaseTransaction {
+  TransactionType: 'URITokenCancelSellOffer'
+  /**
+   * Identifies the URITokenID of the NFToken object that the
+   * offer references.
+   */
+  URITokenID: string
+}
+
+/**
+ * Verify the form and type of an URITokenCancelSellOffer at runtime.
+ *
+ * @param tx - An URITokenCancelSellOffer Transaction.
+ * @throws When the URITokenCancelSellOffer is Malformed.
+ */
+export function validateURITokenCancelSellOffer(
+  tx: Record<string, unknown>,
+): void {
+  validateBaseTransaction(tx)
+
+  if (tx.URITokenID == null) {
+    throw new ValidationError(
+      'URITokenCancelSellOffer: missing field URITokenID',
+    )
+  }
+}

packages/xrpl/src/models/transactions/uriTokenCreateSellOffer.ts

@@ -0,0 +1,93 @@
+import { ValidationError } from '../../errors'
+import { Amount } from '../common'
+
+import { BaseTransaction, isAmount, validateBaseTransaction } from './common'
+
+/**
+ * Map of flags to boolean values representing {@link URITokenCreateSellOffer} transaction
+ * flags.
+ *
+ * @category Transaction Flags
+ *
+ * @example
+ * ```typescript
+ * const tx: URITokenCreateSellOffer = {
+ * Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * Amount: '1000000',
+ * TransactionType: 'URITokenCreateSellOffer',
+ * }
+ *
+ * // Autofill the tx to see how flags actually look compared to the interface usage.
+ * const autofilledTx = await client.autofill(tx)
+ * console.log(autofilledTx)
+ * // {
+ * // Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',
+ * // URITokenID: '7AFCE32EBA8BD310CC2D00BE10B76E2183337EA20444D4580E4DBDB396C101FB',
+ * // Amount: '1000000',
+ * // TransactionType: 'URITokenCreateSellOffer',
+ * // Sequence: 21970384,
+ * // Fee: '12',
+ * // LastLedgerSequence: 21970404
+ * // }
+ * ```
+ */
+
+/**
+ * An URITokenCreateSellOffer transaction is effectively a limit order . It defines an
+ * intent to exchange currencies, and creates an Offer object if not completely.
+ * Fulfilled when placed. Offers can be partially fulfilled.
+ *
+ * @category Transaction Models
+ */
+export interface URITokenCreateSellOffer extends BaseTransaction {
+  TransactionType: 'URITokenCreateSellOffer'
+  /**
+   * Identifies the URITokenID of the NFToken object that the
+   * offer references.
+   */
+  URITokenID: string
+  /**
+   * Indicates the amount expected or offered for the Token.
+   *
+   * The amount must be non-zero, except when this is a sell
+   * offer and the asset is XRP. This would indicate that the current
+   * owner of the token is giving it away free, either to anyone at all,
+   * or to the account identified by the Destination field.
+   */
+  Amount: Amount
+  /**
+   * If present, indicates that this offer may only be
+   * accepted by the specified account. Attempts by other
+   * accounts to accept this offer MUST fail.
+   */
+  Destination?: string
+}
+
+/**
+ * Verify the form and type of an URITokenCreateSellOffer at runtime.
+ *
+ * @param tx - An URITokenCreateSellOffer Transaction.
+ * @throws When the URITokenCreateSellOffer is Malformed.
+ */
+export function validateURITokenCreateSellOffer(
+  tx: Record<string, unknown>,
+): void {
+  validateBaseTransaction(tx)
+
+  if (tx.Account === tx.Destination) {
+    throw new ValidationError(
+      'URITokenCreateSellOffer: Destination and Account must not be equal',
+    )
+  }
+
+  if (tx.URITokenID == null) {
+    throw new ValidationError(
+      'URITokenCreateSellOffer: missing field URITokenID',
+    )
+  }
+
+  if (!isAmount(tx.Amount)) {
+    throw new ValidationError('URITokenCreateSellOffer: invalid Amount')
+  }
+}