Support Cron Amendment (#32)

Co-authored-by: Chenna Keshava B S <21219765+ckeshava@users.noreply.github.com>
Co-authored-by: Denis Angell <dangell@transia.co>

.ci-config/getNewAmendments.js

@@ -0,0 +1,56 @@
+const xahau = require("xahau");
+const fs = require("fs");
+const path = require("path");
+
+const filePath = path.resolve(__dirname, "./rippled.cfg");
+const existingConfig = fs.readFileSync(filePath, "utf-8");
+
+const networkToEmulate = "wss://s.devnet.rippletest.net:51233/";
+
+const amendmentsToIgnore = [
+  "86E83A7D2ECE3AD5FA87AB2195AE015C950469ABF0B72EAACED318F74886AE90", // CryptoConditionsSuite is obsolete
+];
+
+async function main() {
+  const client = new xahau.Client(networkToEmulate);
+  await client.connect();
+
+  // Looks up what amendments have been enabled via their hash
+  const request = {
+    command: "ledger_entry",
+    index: "7DB0788C020F02780A673DC74757F23823FA3014C1866E72CC4CD8B226CD6EF4",
+    ledger_index: "validated",
+  };
+  const response = await client.request(request);
+
+  const amendments = response.result.node.Amendments;
+
+  const newAmendments = [];
+  amendments.forEach((amendment) => {
+    if (
+      !existingConfig.includes(amendment) &&
+      !amendmentsToIgnore.includes(amendment)
+    ) {
+      newAmendments.push(amendment);
+    }
+  });
+
+  if (newAmendments.length > 0) {
+    console.log(
+      "New Amendment Hashes - Look up their names on https://xrpl.org/known-amendments.html"
+    );
+    newAmendments.forEach((amendment) => {
+      console.log(amendment);
+    });
+  } else {
+    console.log(
+      `No new amendments to add!
+Looking at network: ${networkToEmulate}.
+Path to config: ${filePath}`
+    );
+  }
+
+  await client.disconnect();
+}
+
+main().catch((error) => console.log(error));

.ci-config/xahaud.cfg

@@ -0,0 +1,169 @@
+[server]
+port_rpc_admin_local
+port_ws_public
+port_ws_admin_local
+
+# port_peer
+# port_ws_admin_local
+# ssl_key = /etc/ssl/private/server.key
+# ssl_cert = /etc/ssl/certs/server.crt
+
+# IPs must be 0.0.0.0 instead of 127.0.0.1 to be accessed outside the docker container
+
+[port_rpc_admin_local]
+port = 5005
+ip = 0.0.0.0
+admin = 0.0.0.0
+protocol = http
+
+[port_ws_public]
+port = 80
+ip = 0.0.0.0
+protocol = ws
+
+# [port_peer]
+# port = 51235
+# ip = 0.0.0.0
+# protocol = peer
+
+[port_ws_admin_local]
+port = 6006
+ip = 0.0.0.0
+admin = 0.0.0.0
+protocol = ws
+
+[node_size]
+small
+
+# tiny
+# small
+# medium
+# large
+# huge
+
+[node_db]
+type=NuDB
+path=/var/lib/rippled/db/nudb
+advisory_delete=0
+
+# How many ledgers do we want to keep (history)?
+# Integer value that defines the number of ledgers
+# between online deletion events
+online_delete=256
+
+[ledger_history]
+# How many ledgers do we want to keep (history)?
+# Integer value (ledger count)
+# or (if you have lots of TB SSD storage): 'full'
+256
+
+[database_path]
+/var/lib/rippled/db
+
+[debug_logfile]
+/var/log/rippled/debug.log
+
+
+[ips]
+r.ripple.com 51235
+
+# [validators_file]
+# validators.txt
+
+[rpc_startup]
+{ "command": "log_level", "severity": "info" }
+
+# severity (order: lots of information .. only errors)
+# debug
+# info
+# warn
+# error
+# fatal
+
+[ssl_verify]
+1
+
+# The [features] stanza does not currently work for standalone mode: https://github.com/XRPLF/xrpl-dev-portal/issues/1762#issuecomment-1441252450
+
+
+# In order to enable an amendment which by default would vote "No", you must include its amendment id and name here.
+# To add amendments specifically from the latest releases of rippled:
+# 1. Go to https://xrpl.org/known-amendments.html
+# 2. Find the first amendment in the latest releases of rippled which are not already in the list below
+# 3. Click on each amendment to get their Amendment ID and name to add to this list manually.
+#    You will likely update the list with all amendments from a new release of rippled all at once.
+
+# To get the list of amendments on a network (e.g. devnet) follow the steps in xahau.js's CONTRIBUTING.md for "Updating the Docker container".
+# https://github.com/Xahau/xahau.js/blob/main/CONTRIBUTING.md
+# (Running the script `getNewAmendments.js` should help you identify any new amendments that should be added.)
+#
+# Note: The version of rippled you use this config with must have an implementation for the amendments you attempt to enable or it will crash.
+# If you need the version of rippled to be more up to date, you may need to make a comment on this repo: https://github.com/WietseWind/docker-rippled
+
+[features]
+# Amendments
+NegativeUNL
+fixRemoveNFTokenAutoTrustLine
+NonFungibleTokensV1
+CheckCashMakesTrustLine
+fixRmSmallIncreasedQOffers
+fixSTAmountCanonicalize
+FlowSortStrands
+TicketBatch
+fixQualityUpperBound
+FlowCross
+HardenedValidations
+DepositPreauth
+MultiSignReserve
+fix1623
+fix1513
+RequireFullyCanonicalSig
+fix1543
+fix1781
+fixCheckThreading
+fix1515
+CryptoConditionsSuite
+fixPayChanRecipientOwnerDir
+fix1578
+fix1571
+fixAmendmentMajorityCalc
+fixTakerDryOfferRemoval
+fixMasterKeyAsRegularKey
+Flow
+DeletableAccounts
+DepositAuth
+Checks
+NonFungibleTokensV1_1
+DisallowIncoming
+fixNonFungibleTokensV1_2
+fixUniversalNumber
+ImmediateOfferKilled
+XRPFees
+ExpandedSignerList
+fixNFTokenRemint
+# Additional Amendments
+BalanceRewards
+Hooks
+HooksUpdate1
+Import
+Remit
+URIToken
+XahauGenesis
+ZeroB2M
+fix240819
+fix240911
+fixFloatDivide
+fixNFTokenDirV1
+fixNFTokenNegOffer
+fixNSDelete
+fixPageCap
+fixReduceImport
+fixXahauV1
+fixXahauV2
+fixXahauV3
+PaychanAndEscrowForTokens
+DeepFreeze
+Clawback
+
+[network_id]
+21337

.coderabbit.yaml

@@ -0,0 +1,28 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+language: "en-US"
+reviews:
+  # Set the profile for reviews. Assertive profile yields more feedback, that may be considered nitpicky.
+  profile: "chill"
+  # Approve the review once CodeRabbit's comments are resolved. Note: In GitLab, all discussions must be resolved.
+  request_changes_workflow: false
+  # Generate a high level summary of the changes in the PR/MR description.
+  high_level_summary: false
+  # Generate a poem in the walkthrough comment.
+  poem: true
+  # Post review details on each review. Additionally, post a review status when a review is skipped in certain cases.
+  review_status: true
+  # Generate walkthrough in a markdown collapsible section.
+  collapse_walkthrough: false
+  # Abort the in-progress review if the pull request is closed or merged.
+  abort_on_close: true
+  auto_review:
+    # Automatic Review | Automatic code review
+    enabled: true
+    # Review draft PRs/MRs.
+    drafts: false
+    # Ignore reviewing if the title of the pull request contains any of these keywords (case-insensitive).
+    ignore_title_keywords:
+      - build(
+chat:
+  # Enable the bot to reply automatically without requiring the user to tag it.
+  auto_reply: true

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: weekly
+    time: "15:00"
+  open-pull-requests-limit: 10

.github/pull_request_template.md

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

.github/workflows/codeql-analysis.yml

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

.github/workflows/nodejs.yml

@@ -0,0 +1,200 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+env:
+  XAHAUD_DOCKER_IMAGE: xahauci/xahaud:2025.2.6
+
+on:
+  push:
+    branches: [main-xahau, 1.x]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-and-lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Setup npm version 9
+        run: |
+          npm i -g npm@9 --registry=https://registry.npmjs.org
+
+      - name: Cache node modules
+        id: cache-nodemodules
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-node-modules
+        with:
+          # caching node_modules
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-deps-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-deps-${{ matrix.node-version }}-
+            ${{ runner.os }}-deps-
+
+      - name: Install Dependencies
+        if: steps.cache-nodemodules.outputs.cache-hit != 'true'
+        run: npm ci
+
+      - run: npm run build
+      - run: npm run lint
+
+  unit:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Setup npm version 9
+        run: |
+          npm i -g npm@9 --registry=https://registry.npmjs.org
+
+      - name: Cache node modules
+        id: cache-nodemodules
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-node-modules
+        with:
+          # caching node_modules
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-deps-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-deps-${{ matrix.node-version }}-
+            ${{ runner.os }}-deps-
+
+      - name: Install Dependencies
+        if: steps.cache-nodemodules.outputs.cache-hit != 'true'
+        run: npm ci
+
+      - run: npm run build
+      - run: npm test
+
+  integration:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Run docker in background
+        run: |
+          docker run --detach --rm --name xahaud-service -p 6006:6006 --volume "${{ github.workspace }}/.ci-config/":"/opt/xahau/etc/" --health-cmd="wget localhost:6006 || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s --env GITHUB_ACTIONS=true --env CI=true ${{ env.XAHAUD_DOCKER_IMAGE }} /opt/xahau/bin/xahaud -a --conf /opt/xahau/etc/xahaud.cfg
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Setup npm version 9
+        run: |
+          npm i -g npm@9 --registry=https://registry.npmjs.org
+
+      - name: Cache node modules
+        id: cache-nodemodules
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-node-modules
+        with:
+          # caching node_modules
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-deps-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-deps-${{ matrix.node-version }}-
+            ${{ runner.os }}-deps-
+
+      - name: Install Dependencies
+        if: steps.cache-nodemodules.outputs.cache-hit != 'true'
+        run: npm ci
+
+      - run: npm run build
+
+      - name: Run integration test
+        run: npm run test:integration
+
+      - name: Stop docker container
+        if: always()
+        run: docker stop xahaud-service
+
+  browser:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Run docker in background
+        run: |
+          docker run --detach --rm --name xahaud-service -p 6006:6006 --volume "${{ github.workspace }}/.ci-config/":"/opt/xahau/etc/" --health-cmd="wget localhost:6006 || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s --env GITHUB_ACTIONS=true --env CI=true ${{ env.XAHAUD_DOCKER_IMAGE }} /opt/xahau/bin/xahaud -a --conf /opt/xahau/etc/xahaud.cfg
+
+      - name: Setup npm version 9
+        run: |
+          npm i -g npm@9 --registry=https://registry.npmjs.org
+
+      - name: Cache node modules
+        id: cache-nodemodules
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-node-modules
+        with:
+          # caching node_modules
+          path: |
+            node_modules
+            */*/node_modules
+          key: ${{ runner.os }}-deps-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-deps-${{ matrix.node-version }}-
+            ${{ runner.os }}-deps-
+
+      - name: Install Dependencies
+        if: steps.cache-nodemodules.outputs.cache-hit != 'true'
+        run: npm ci
+
+      - run: npm run build
+
+      - name: Run integration test
+        run: npm run test:browser
+
+      - name: Stop docker container
+        if: always()
+        run: docker stop xahaud-service

.gitignore

@@ -1,5 +1,9 @@
 # .gitignore
 
+# Ignore package locks other than npm.
+yarn.lock
+npm-shrinkwrap.json
+
 # Ignore vim swap files.
 *.swp
 
@@ -17,7 +21,8 @@
 
 # Ignore object files.
 *.o
-build/*.js
+build/
+coverage/
 tags
 bin/rippled
 Debug/*.*
@@ -25,6 +30,7 @@ Release/*.*
 
 # Ignore locally installed node_modules
 node_modules
+!test/node_modules
 
 # Ignore tmp directory.
 tmp
@@ -34,8 +40,6 @@ db/*.db
 db/*.db-*
 
 # Ignore customized configs
-rippled.cfg
-validators.txt
 test/config.js
 
 # Ignore coverage files
@@ -46,9 +50,27 @@ test/config.js
 
 # Ignore IntelliJ files
 .idea
+*.iml
 
 # Ignore npm-debug
 npm-debug.log
 
-# Ignore dist folder, build for bower
+# Ignore dist folder, built from tsc
 dist/
+
+# TypeScript incremental compilation cache
+*.tsbuildinfo
+
+# Ignore perf test cache
+scripts/cache
+
+.eslintrc
+
+# nyc (istanbul)
+.nyc_output
+
+# browser tests
+testCompiledForWeb
+
+# lerna debug
+lerna-debug.log

.ncurc.json

@@ -0,0 +1,4 @@
+{
+  "reject": [
+  ]
+}

.npmignore

@@ -1,3 +0,0 @@
-deploy
-lib-cov
-coverage.html

.nvmrc

@@ -0,0 +1 @@
+v18

.prettierignore

@@ -0,0 +1 @@
+*.md

.travis.yml

@@ -1,13 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"
-script: npm test --coverage
-after_success:
-- npm run coveralls
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/d1ec4245f90231619d30
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false

.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+      "dbaeumer.vscode-eslint",
+      "esbenp.prettier-vscode"
+    ]
+  }

.vscode/settings.json

@@ -0,0 +1,60 @@
+{
+    "editor.tabSize": 2,
+    "cSpell.words": [
+        "altnet",
+        "Autofills",
+        "Clawback",
+        "hostid",
+        "keypair",
+        "keypairs",
+        "multisign",
+        "multisigned",
+        "multisigning",
+        "preauthorization",
+        "rippletest",
+        "secp256k1",
+        "Setf",
+        "Sidechains",
+        "xchain"
+    ],
+    "[javascript]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.formatOnSave": true
+    },
+    "[javascriptreact]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.formatOnSave": true
+    },
+    "[typescript]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.formatOnSave": true
+    },
+    "[typescriptreact]": {
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.formatOnSave": true
+    },
+    "eslint.alwaysShowStatus": true,
+    "eslint.lintTask.enable": true,
+    "eslint.codeAction.showDocumentation": {
+        "enable": true
+    },
+    "editor.codeActionsOnSave": {
+        "source.fixAll.eslint": "explicit"
+    },
+    "files.insertFinalNewline": true,
+    "files.trimFinalNewlines": true,
+    "files.trimTrailingWhitespace": true,
+    "files.watcherExclude": {
+        "**/.git/objects/**": true,
+        "**/.git/subtree-cache/**": true,
+        "**/.hg/store/**": true
+    },
+    "search.exclude": {
+        "**/.git": true,
+        "**/node_modules": true,
+        "**/tmp": true,
+        "**/docs/**/*.html": true,
+        "**/fixtures/**/*.json": true,
+        "**/docs/assets": true
+    },
+}

CONTRIBUTING.md

@@ -0,0 +1,280 @@
+# Contributing
+
+### High Level Process to Contribute Code
+
+- You should open a PR against `main` and ensure that all CI passes.
+- Your changes should have [unit](#unit-tests) and/or [integration tests](#integration-tests).
+- Your changes should [pass the linter](#run-the-linter).
+- You should get a full code review from two of the maintainers.
+- Then you can merge your changes. (Which will then be included in the next release)
+
+## Set up your dev environment
+
+### Requirements
+
+We use Node v18 for development - that is the version that our linters require.
+You must also use `npm` v7. You can check your `npm` version with:
+
+```bash
+npm -v
+```
+
+If your `npm` version is too old, use this command to update it:
+
+```bash
+npm -g i npm@7
+```
+
+### Set up
+
+1. Clone the repository
+2. `cd` into the repository
+3. Install dependencies with `npm install`
+
+### Build
+
+```bash
+npm run build
+```
+
+## Run the linter
+
+```bash
+npm install
+npm run build
+npm run lint
+```
+
+## Running Tests
+
+For integration and browser tests, we use a `xahaud` node in standalone mode to test xahau.js code against. To set this up, you can either configure and run `xahaud` locally, or set up the Docker container `xahauci/xahaud` by [following these instructions](#integration-tests). The latter will require you to [install Docker](https://docs.docker.com/get-docker/).
+
+### Unit Tests
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+### Integration Tests
+
+From the top-level xahau.js folder (one level above `packages`), run the following commands:
+
+```bash
+npm install
+# sets up the xahaud standalone Docker container - you can skip this step if you already have it set up
+docker run -p 6006:6006 --interactive -t --volume $PWD/.ci-config:/opt/xahau/etc/ --platform linux/amd64 xahauci/xahaud:2025.2.6 /opt/xahau/bin/xahaud -a --conf /opt/xahau/etc/xahaud.cfg
+npm run build
+npm run test:integration
+```
+
+Breaking down the command:
+* `docker run -p 6006:6006` starts a Docker container with an open port for admin WebSocket requests.
+* `--interactive` allows you to interact with the container.
+* `-t` starts a terminal in the container for you to send commands to.
+* `--volume $PWD/.ci-config:/config/` identifies the `xahaud.cfg` and `validators.txt` to import. It must be an absolute path, so we use `$PWD` instead of `./`.
+* `xahauci/xahaud` is an image that is regularly updated with the latest `xahaud` releases
+* `/opt/xahau/bin/xahaud -a --conf /opt/xahau/etc/xahaud.cfg` starts `xahaud` in standalone mode
+
+### Browser Tests
+
+There are two ways to run browser tests.
+
+One is in the browser - run `npm run build:browserTests` and open `test/localIntegrationRunner.html` in your browser.
+
+The other is in the command line (this is what we use for CI) -
+
+This should be run from the `xahau.js` top level folder (one above the `packages` folder).
+
+```bash
+npm run build
+# sets up the xahaud standalone Docker container - you can skip this step if you already have it set up
+docker run -p 6006:6006 --interactive -t --volume $PWD/.ci-config:/opt/xahau/etc/ --platform linux/amd64 xahauci/xahaud:2025.2.6 /opt/xahau/bin/xahaud -a --conf /opt/xahau/etc/xahaud.cfg
+npm run test:browser
+```
+
+## High Level Architecture
+
+This is a monorepo, which means that there are multiple packages in a single GitHub repository using [Lerna](https://lerna.js.org/).
+
+The 4 packages currently here are:
+
+1. xahau.js - The client library for interacting with the ledger.
+2. xahau-binary-codec - A library for serializing and deserializing transactions for the ledger.
+3. xahau-keypairs - A library for generating and using cryptographic keypairs.
+4. xahau-address-codec - A library for encoding and decoding Xahau Ledger addresses and seeds.
+5. isomorphic - A collection of isomorphic implementations of crypto and utility functions.
+6. secret-numbers - Generate XRPL Accounts with a number-based secret: 8 chunks of 6 digits.
+
+Each package has it's own README which dives deeper into what it's main purpose is, and the core functionality it offers.
+They also run tests independently as they were originally in separate repositories.
+
+These are managed in a monorepo because often a change in a lower-level library will also require a change in xahau.js, and so it makes sense to be able to allow for modifications of all packages at once without coordinating versions across multiple repositories.
+
+Let's dive a bit into how xahau.js is structured!
+
+### The File Structure
+
+Within the xrpl package, each folder has a specific purpose:
+
+**Client** - This contains logic for handling the websocket connection to xahaud servers.
+**Models** - These types model LedgerObjects, Requests/Methods, and Transactions in order to give type hints and nice errors for users.
+**Sugar** - This is where handy helper functions end up, like `submit`, `autofill`, and `getXAHBalance` amongst others.
+**Utils** - These are shared functions which are useful for conversions, or internal implementation details within the library.
+**Wallet** - This logic handles managing keys, addresses, and signing within xahau.js
+
+### Writing Tests for xahau.js
+
+For every file in `src`, we try to have a corresponding file in `test` with unit tests.
+
+The goal is to maintain above 80% code coverage, and generally any new feature or bug fix should be accompanied by unit tests, and integration tests if applicable.
+
+For an example of a unit test, check out the [autofill tests here](./packages/xahau/test/client/autofill.ts).
+
+If your code connects to the ledger (ex. Adding a new transaction type) it's handy to write integration tests to ensure that you can successfully interact with the ledger. Integration tests are generally run against a docker instance of xahaud which contains the latest updates. Since standalone mode allows us to manually close ledgers, this allows us to run integration tests at a much faster rate than if we had to wait 4-5 seconds per transaction for the ledger to validate the transaction. [See above](#running-tests) for how to start up the docker container to run integration tests.
+
+All integration tests should be written in the `test/integration` folder, with new `Requests` and `Transactions` tests being in their respective folders.
+
+For an example of how to write an integration test for `xahau.js`, you can look at the [Payment integration test](./packages/xahau/test/integration/transactions/payment.ts).
+
+## Generate reference docs
+
+You can see the complete reference documentation at [`xahau.js` docs](https://js.xrpl.org). You can also generate them locally using `typedoc`:
+
+```bash
+npm run docgen
+```
+
+This updates `docs/` at the top level, where GitHub Pages looks for the docs.
+
+## Update `definitions.json`
+
+Use [this repo](https://github.com/RichardAH/xrpl-codec-gen) to generate a new `definitions.json` file from the xahaud source code. Instructions are available in that README.
+
+## Adding and removing packages
+
+`xahau.js` uses `lerna` and `npm`'s workspaces features to manage a monorepo.
+Adding and removing packages requires a slightly different process than normal
+as a result.
+
+### Adding or removing development dependencies
+
+`xahau.js` strives to use the same development dependencies in all packages.
+You may add and remove dev dependencies like normal:
+
+```bash
+### adding a new dependency
+npm install --save-dev abbrev
+### removing a dependency
+npm uninstall --save-dev abbrev
+```
+
+### Adding or removing runtime dependencies
+
+You need to specify which package is changing using the `-w` flag:
+
+```bash
+### adding a new dependency to `xahau`
+npm install abbrev -w xahau
+### adding a new dependency to `xahau-keypairs`
+npm install abbrev -w xahau-keypairs
+### removing a dependency
+npm uninstall abbrev -w xahau
+```
+
+## Updating the Docker container for CI
+
+In order to test the library, we need to enable the latest amendments in the docker container.
+This requires updating the `/.ci-config/xahaud.cfg` file with the hashes and names of new amendments.
+
+In order to update the list, follow these steps from the top level of the library:
+1. Run `node ./.ci-config/getNewAmendments.js`
+2. If there are any new amendment hashes, add a comment to the end of `/.ci-config/xahaud.cfg` with the date
+   - `Ex. "# Added August 9th, 2023"`
+3. For each hash printed out by the script, add the hash and name to the config file.
+   - Ex. `B2A4DB846F0891BF2C76AB2F2ACC8F5B4EC64437135C6E56F3F859DE5FFD5856 ExpandedSignerList`
+   - You can look up the name by searching for the hash on https://xrpl.org/known-amendments.html
+4. Push your changes
+
+Note: The same updated config can be used to update xahau-py's CI as well.
+
+## Updating `definitions.json`
+
+This should almost always be done using the [`xrpl-codec-gen`](https://github.com/RichardAH/xrpl-codec-gen) script - if the output needs manual intervention afterwards, consider updating the script instead.
+
+1. Clone / pull the latest changes from [xahaud](https://github.com/XRPLF/xahaud) - Specifically the `develop` branch is usually the right one.
+2. Clone / pull the latest changes from [`xrpl-codec-gen`](https://github.com/RichardAH/xrpl-codec-gen)
+3. From the `xrpl-codec-gen` tool, follow the steps in the `README.md` to generate a new `definitions.json` file.
+4. Replace the `definitions.json` file in the `xahau-binary-codec` with the newly generated file.
+5. Verify that the changes make sense by inspection before submitting, as there may be updates required for the `xrpl-codec-gen` tool depending on the latest amendments we're updating to match.
+
+
+## Release process + checklist
+
+## PR process
+
+- [ ] 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`.
+
+## 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.
+
+   - [ ] Update the version number and release date, and ensure it lists the changes since the previous release.
+
+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 bumps the package versions.
+
+   - 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 you do NOT want to update the package number, choose "Custom Version" and set the version to be the same as the existing version. Lerna will not publish any changes in this case.
+   - 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 xahau@beta`
+
+1. If requested, enter your [npmjs.com](https://npmjs.com) OTP (one-time password) to complete publication.
+
+   NOW YOU HAVE PUBLISHED! But you're not done; we have to notify people!
+
+1. Run `git tag <tagname> -m <tagname>`, where `<tagname>` is the new package and version (e.g. `xahau@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. Send an email to [xahau-announce](https://groups.google.com/g/xahau-announce).
+1. Lastly, send a similar message to the Xahau Discord in the [`javascript` channel](https://discord.com/channels/1085202760548499486/1085203623111295068). The message should include:
+   1. The version changes for xahau libraries
+   1. A link to the more detailed changes
+   1. Highlights of important changes
+
+
+## Mailing Lists
+
+We have a low-traffic mailing list for announcements of new `xahau.js` releases. (About 1 email every couple of weeks)
+
+- [Subscribe to xahau-announce](https://groups.google.com/g/xahau-announce)
+
+If you're using the Xahau Ledger in production, you should run a [xahaud server](https://github.com/xahau/xahaud) and subscribe to the xahau-server mailing list as well.
+
+- [Subscribe to xahau-server](https://groups.google.com/g/xahau-server)

Gulpfile.js

@@ -1,163 +0,0 @@
-var gulp = require('gulp');
-var concat = require('gulp-concat');
-var uglify = require('gulp-uglify');
-var rename = require('gulp-rename');
-var webpack = require('webpack');
-var jshint = require('gulp-jshint');
-var map = require('map-stream');
-var bump = require('gulp-bump');
-var argv = require('yargs').argv;
-//var header = require('gulp-header');
-
-var pkg = require('./package.json');
-
-var banner = '/*! <%= pkg.name %> - v<%= pkg.version %> - '
-+ '<%= new Date().toISOString() %>\n'
-+ '<%= pkg.homepage ? "* " + pkg.homepage + "\n" : "" %>'
-+ '* Copyright (c) <%= new Date().getFullYear() %> <%= pkg.author.name %>;'
-+ ' Licensed <%= pkg.license %> */'
-
-var sjclSrc = [
-  'src/js/sjcl/core/sjcl.js',
-  'src/js/sjcl/core/aes.js',
-  'src/js/sjcl/core/bitArray.js',
-  'src/js/sjcl/core/codecString.js',
-  'src/js/sjcl/core/codecHex.js',
-  'src/js/sjcl/core/codecBase64.js',
-  'src/js/sjcl/core/codecBytes.js',
-  'src/js/sjcl/core/sha256.js',
-  'src/js/sjcl/core/sha512.js',
-  'src/js/sjcl/core/sha1.js',
-  'src/js/sjcl/core/ccm.js',
-  // 'src/js/sjcl/core/cbc.js',
-  // 'src/js/sjcl/core/ocb2.js',
-  'src/js/sjcl/core/hmac.js',
-  'src/js/sjcl/core/pbkdf2.js',
-  'src/js/sjcl/core/random.js',
-  'src/js/sjcl/core/convenience.js',
-  'src/js/sjcl/core/bn.js',
-  'src/js/sjcl/core/ecc.js',
-  'src/js/sjcl/core/srp.js',
-  'src/js/sjcl-custom/sjcl-ecc-pointextras.js',
-  'src/js/sjcl-custom/sjcl-secp256k1.js',
-  'src/js/sjcl-custom/sjcl-ripemd160.js',
-  'src/js/sjcl-custom/sjcl-extramath.js',
-  'src/js/sjcl-custom/sjcl-montgomery.js',
-  'src/js/sjcl-custom/sjcl-validecc.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-canonical.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-der.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-recoverablepublickey.js',
-  'src/js/sjcl-custom/sjcl-jacobi.js'
-];
-
-gulp.task('concat-sjcl', function() {
-  return gulp.src(sjclSrc)
-  .pipe(concat('sjcl.js'))
-  .pipe(gulp.dest('./build/'));
-});
-
-gulp.task('build', [ 'concat-sjcl' ], function(callback) {
-  webpack({
-    cache: true,
-    entry: './src/js/ripple/index.js',
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: [ 'ripple-', '.js' ].join(pkg.version)
-    },
-  }, callback);
-});
-
-gulp.task('bower-build', [ 'build' ], function(callback) {
-  return gulp.src([ './build/ripple-', '.js' ].join(pkg.version))
-  .pipe(rename('ripple.js'))
-  .pipe(gulp.dest('./dist/'));
-});
-
-gulp.task('bower-build-min', [ 'build-min' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-min.js' ].join(pkg.version))
-  .pipe(rename('ripple-min.js'))
-  .pipe(gulp.dest('./dist/'));
-});
-
-gulp.task('bower-build-debug', [ 'build-debug' ], function(callback) {
-  return gulp.src([ './build/ripple-', '-debug.js' ].join(pkg.version))
-  .pipe(rename('ripple-debug.js'))
-  .pipe(gulp.dest('./dist/'));
-});
-
-gulp.task('bower-version', function() {
-  gulp.src('./dist/bower.json')
-  .pipe(bump({version: pkg.version}))
-  .pipe(gulp.dest('./dist/'));
-});
-
-gulp.task('version-bump', function() {
-  if (!argv.type) {
-    throw new Error("No type found, pass it in using the --type argument");
-  }
-  gulp.src('./package.json')
-  .pipe(bump({type:argv.type}))
-  .pipe(gulp.dest('./'));
-});
-
-gulp.task('version-beta', function() {
-  gulp.src('./package.json')
-  .pipe(bump({version: pkg.version+'-beta'}))
-  .pipe(gulp.dest('./'));
-});
-
-gulp.task('build-min', [ 'build' ], function(callback) {
-  return gulp.src([ './build/ripple-', '.js' ].join(pkg.version))
-  .pipe(uglify())
-  .pipe(rename([ 'ripple-', '-min.js' ].join(pkg.version)))
-  .pipe(gulp.dest('./build/'));
-});
-
-gulp.task('build-debug', [ 'concat-sjcl' ], function(callback) {
-  webpack({
-    cache: true,
-    entry: './src/js/ripple/index.js',
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: [ 'ripple-', '-debug.js' ].join(pkg.version)
-    },
-    debug: true,
-    devtool: 'eval'
-  }, callback);
-});
-
-gulp.task('lint', function() {
-  gulp.src('src/js/ripple/*.js')
-  .pipe(jshint())
-  .pipe(map(function(file, callback) {
-    if (!file.jshint.success) {
-      console.log('\nIn', file.path);
-
-      file.jshint.results.forEach(function(err) {
-        if (err && err.error) {
-          var col1 = err.error.line + ':' + err.error.character;
-          var col2 = '[' + err.error.reason + ']';
-          var col3 = '(' + err.error.code + ')';
-
-          while (col1.length < 8) {
-            col1 += ' ';
-          }
-
-          console.log('  ' + [ col1, col2, col3 ].join(' '));
-        }
-      });
-    }
-
-    callback(null, file);
-  }));
-});
-
-gulp.task('watch', function() {
-  gulp.watch('src/js/ripple/*', [ 'build-debug' ]);
-});
-
-gulp.task('default', [ 'concat-sjcl', 'build', 'build-debug', 'build-min' ]);
-
-gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug', 'bower-version']);

HISTORY.md

@@ -1,154 +1,12 @@
-##0.9.0
-
-+ Add routes to the vault client for KYC attestations ([ed2da574](https://github.com/ripple/ripple-lib/commit/ed2da57475acf5e9d2cf3373858f4274832bd83f))
-
-+ Configurable maxAttempts for transaction submission ([d107092](https://github.com/ripple/ripple-lib/commit/d10709254061e9e4416d2cb78b5cac1ec0d7ffa5))
-
-+ Fix: change handling of requestLedger options ([57b7030](https://github.com/ripple/ripple-lib/commit/57b70300f5f0c7534ede118ddbb5d8762668a4f8))
-
-+ **Breaking change:** make maxLoops in seed.get_key optional. [Example use in tests](https://github.com/ripple/ripple-lib/blob/develop/test/seed-test.js) ([23e473b](https://github.com/ripple/ripple-lib/commit/23e473b6886c457781949c825b3ff48b3984e51f)) 
-
-##0.8.2
-
-+ Currency: Allow mixed letters and numbers in currencies
-
-+ Deprecate account_tx map/reduce/filter
-
-+ Fix: correct requestLedger arguments
-
-+ Fix: missing subscription on error events for some server methods
-
-+ Fix: orderbook reset on reconnect
-
-+ Fix: ripple-lib crashing. Add potential missing error handlers
-
-
-##0.8.1
-
-+ Wallet: Add Wallet class that generates wallets
-
-+ Make npm test runnable in Windows.
-
-+ Fix several stability issues, see merged PR's for details
-
-+ Fix bug in Amount.to_human_full()
-
-+ Fix undefined fee states when connecting to a rippled that is syncing
-
-
-##0.8.0
-
-+ Orderbook: Added tracking of offer funds for determining when offers are not funded
-
-+ Orderbook: Added tests
-
-+ Orderbook: Update owner funds
-
-+ Transactions: If transaction errs with `tefALREADY`, wait until all possible submissions err with the same before emitting `error`. Fixes a client "Transaction malformed" bug.
-
-+ Transactions: Track submissions, don't bother submitting to unconnected servers
-
-+ Request: `request.request()` now accepts an array of servers as first argument. Servers can be represented with URL, or the server object itself.
-
-+ Request: `request.broadcast()` now returns the number of servers request was sent to
-
-+ Server: Acquire host information from server without additional request
-
-+ Amount: Add a constant for the maximum canonical value that can be expressed as a Ripple value
-
-+ Amount: Make Constants static fields on the class, instead of a seperate export
-
-
-##0.7.39
-
-+ Improvements to multi-server support. Fixed an issue where a server's score was not reset and connections would keep dropping after being connected for a significant amount of time.
-
-+ Improvements in order book support. Added support for currency pairs with interest bearing currencies. You can request an order book with hex, ISO code or full name for the currency.
-
-+ Fix value parsing for amount/currency order pairs, e.g. `Amount.from_human("XAU 12345.6789")`
-
-+ Improved Amount parsing from human readable string given a hex currency, e.g. `Amount.from_human("10 015841551A748AD2C1F76FF6ECB0CCCD00000000")`
-
-+ Improvements to username normalization in the vault client
-
-+ Add 2-factor authentication support for vault client
-
-+ Removed vestiges of Grunt, switched to Gulp
-
-
-##0.7.37
-
-+ **Deprecations**
-
-    1. Removed humanistic amount detection in `transaction.payment`. Passing `1XRP` as the payment amount no longer works.
-    2. `remote.setServer` uses full server URL rather than hostname. Example: `remote.setServer('wss://s`.ripple.com:443')`
-    3. Removed constructors for deprecated transaction types from `transaction.js`.
-    4. Removed `invoiceID` option from `transaction.payment`. Instead, use the `transaction.invoiceID` method.
-    5. Removed `transaction.transactionManager` getter.
-
-+ Improved multi-server support. Servers are now ranked dynamically, and transactions are broadcasted to all connected servers.
-
-+ Automatically ping connected servers. Client configuration now should contain `ping: <seconds>` to specify the ping interval.
-
-+ Added `transaction.lastLedger` to specify `LastLedgerSequence`. Setting it this way also ensures that the sequence is not bumped on subsequent requests.
-
-+ Added optional `remote.accountTx` binary parsing.
-    ```js
-      {
-        binary: true,
-        parseBinary: false
-      }
-    ```
-+ Added full currency name support, e.g. `Currency.from_json('XRP').to_human({full_name:'Ripples'})` will return `XRP - 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)
-
-
-##0.7.35
-
-+ `LastLedgerSequence` is set by default on outgoing transactions. This refers to the last valid ledger index (AKA sequence) for a transaction. By default, this index is set to the current index (at submission time) plus 8. In theory, this allows ripple-lib to deterministically fail a transaction whose submission request timed out, but whose associated server continues to emit ledger_closed events.
-
-+ Transactions that err with `telINSUF_FEE_P` will be automatically resubmitted. This error indicates that the `Fee` supplied in the transaction submission request was inadquate. Ideally, the `Fee` is tracked by ripple-lib in real-time, and the resubmitted transaction will most likely succeed.
-
-+ Added Transaction.iff(function(callback) { }). Callback expects first argument to be an Error or null, second argument is a boolean which indicates whether or not to proceed with the transaction submission. If an `iff` function is specified, it will be executed prior to every submission of the transaction (including resubmissions).
-
-+ Transactions will now emit `presubmit` and `postsubmit` events. They will be emitted before and after a transaction is submitted, respectively.
-
-+ Added Transaction.summary(). Returns a summary of a transaction in semi-human-readable form. JSON-stringifiable.
-
-+ Remote.requestAccountTx() with `binary: true` will automatically parse transactions.
-
-+ Added Remote.requestAccountTx filter, map, and reduce.
-
-```js
-  remote.requestAccountTx({
-    account: 'retc',
-    ledger_index_min: -1,
-    ledger_index_max: -1,
-    limit: 100,
-    binary: true,
-
-    filter: function(transaction) {
-      return transaction.tx.TransactionType === 'Payment';
-    },
-
-    map: function(transaction) {
-      return Number(transaction.tx.Amount);
-    },
-
-    reduce: function(a, b) {
-      return a + b;
-    },
-
-    pluck: 'transactions'
-  }, console.log)
-```
-
-+ Added persistence hooks.
-
-+ General performance improvements, especially for long-running processes.
-
+# Release History (Changelog)
+
+Please see the individual HISTORY.md and XAHAU_HISTORY.md documents in each package for changes:
+
+* [Release History for **xahau.js**](packages/xrpl/HISTORY.md)
+  * The **xahau** package is a TypeScript/JavaScript library for interacting with the [Xahau Ledger](https://docs.xahau.network/).
+* [Release History for **xahau-address-codec**](packages/xahau-address-codec/HISTORY.md)
+  * The **xahau-address-codec** package provides functions for encoding and decoding Xahau Ledger addresses and seeds.
+* [Release History for **xahau-binary-codec**](packages/xahau-binary-codec/HISTORY.md)
+  * The **xahau-binary-codec** package provides functions to encode to, and decode from, the Xahau binary serialization format.
+* [Release History for **xahau-keypairs**](packages/xahau-keypairs/HISTORY.md)
+  * The **xahau-keypairs** package implements Xahau cryptographic keypair and wallet generation, with support for rfc6979 and EdDSA deterministic signatures.

LICENSE

@@ -1,52 +0,0 @@
-Copyright (c) 2012,2013,2014 Ripple Labs Inc.
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
---------------------------------------
-
-Some code from Tom Wu:
-This software is covered under the following copyright:
-
-Copyright (c) 2003-2005  Tom Wu
-All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
-EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
-WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
-
-IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
-INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
-RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
-THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
-OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-In addition, the following condition applies:
-
-All redistributions must retain an intact copy of this copyright notice
-and disclaimer.
-
-Address all questions regarding this license to:
-
-  Tom Wu
-  tjw@cs.Stanford.EDU

README.md

@@ -1,94 +1,99 @@
-#ripple-lib
+# xahau.js
 
-JavaScript client for [rippled](https://github.com/ripple/rippled)
+A JavaScript/TypeScript library for interacting with the Xahau Ledger
 
-[![Build Status](https://travis-ci.org/ripple/ripple-lib.svg?branch=develop)](https://travis-ci.org/ripple/ripple-lib) [![Coverage Status](https://coveralls.io/repos/ripple/ripple-lib/badge.png?branch=develop)](https://coveralls.io/r/ripple/ripple-lib?branch=develop)
+[![NPM](https://nodei.co/npm/xahau.png)](https://www.npmjs.org/package/xahau)
+![npm bundle size](https://img.shields.io/bundlephobia/min/xahau)
 
-[![NPM](https://nodei.co/npm/ripple-lib.png)](https://www.npmjs.org/package/ripple-lib)
+This is the recommended library for integrating a JavaScript/TypeScript app with the Xahau Ledger, especially if you intend to use advanced functionality such as IOUs, payment paths, the decentralized exchange, account settings, payment channels, escrows, multi-signing, and more.
 
-###Features
+<!-- ## [➡️ Reference Documentation](http://js.xahau.org)
 
-+ Connect to a rippled server in JavaScript (Node.js or browser)
-+ Issue [rippled API](https://ripple.com/wiki/JSON_Messages) requests
-+ Listen to events on the Ripple network (transaction, ledger, etc.)
-+ Sign and submit transactions to the Ripple network
+See the full reference documentation for all classes, methods, and utilities.
 
-###In this file
+## Features
 
-1. [Installation](README.md#installation)
-2. [Quickstart](README.md#quickstart)
-3. [Running tests](https://github.com/ripple/ripple-lib#running-tests)
+1. Managing keys & creating test credentials ([`Wallet`](https://js.xahau.org/classes/Wallet.html) && [`Client.fundWallet()`](https://js.xahau.org/classes/Client.html#fundWallet))
+2. Submitting transactions to the Xahau Ledger ([`Client.submit(...)`](https://js.xahau.org/classes/Client.html#submit) & [transaction types](https://xahau.org/transaction-types.html))
+3. Sending requests to observe the ledger ([`Client.request(...)`](https://js.xahau.org/classes/Client.html#request) using [public API methods](https://xahau.org/public-api-methods.html))
+4. Subscribing to changes in the ledger ([Ex. ledger, transactions, & more...](https://xahau.org/subscribe.html))
+5. Parsing ledger data into more convenient formats ([`xrpToDrops`](https://js.xahau.org/functions/xrpToDrops.html) and [`rippleTimeToISOTime`](https://js.xahau.org/functions/rippleTimeToISOTime.html))
 
-###Additional documentation
+All of which works in Node.js (tested for v18+) & web browsers (tested for Chrome). -->
 
-1. [Guides](docs/GUIDES.md)
-2. [API Reference](docs/REFERENCE.md)
-3. [Wiki](https://ripple.com/wiki/Ripple_JavaScript_library)
+# Quickstart
 
-###Also see
+### Requirements
 
-+ [The Ripple wiki](https://ripple.com/wiki)
-+ [ripple.com](https://ripple.com)
++ **[Node.js v18](https://nodejs.org/)** is recommended. We also support v20. Other versions may work but are not frequently tested.
 
-##Installation
+### Installing xahau.js
 
-**Via npm for Node.js**
+In an existing project (with package.json), install xahau.js with:
 
 ```
-  $ npm install ripple-lib
+$ npm install --save xahau
 ```
 
-**Via bower (for browser use)**
+Or with `yarn`:
 
 ```
-  $ bower install ripple
+$ yarn add xahau
 ```
 
-See the [bower-ripple repo](https://github.com/ripple/bower-ripple) for additional bower instructions
-
-
-**Building ripple-lib from github**
-
-```
-  $ git clone https://github.com/ripple/ripple-lib
-  $ npm install
-  $ npm run build
-```
-
-Then use the minified `build/ripple-*-min.js`
-
-##Quickstart
-
-`Remote.js` ([remote.js](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/remote.js)) is the point of entry for interacting with rippled
+Example usage:
 
 ```js
-/* Loading ripple-lib with Node.js */
-var Remote = require('ripple-lib').Remote;
-
-/* Loading ripple-lib in a webpage */
-// var Remote = ripple.Remote;
-
-var remote = new Remote({
-  // see the API Reference for available options
-  servers: [ 'wss://s1.ripple.com:443' ]
-});
-
-remote.connect(function() {
-  /* remote connected */
-  remote.request('server_info', function(err, info) {
+const xahau = require("xahau");
+async function main() {
+  const client = new xahau.Client("wss://xahau-test.net");
+  await client.connect();
 
+  const response = await client.request({
+    command: "account_info",
+    account: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
+    ledger_index: "validated",
   });
-});
+  console.log(response);
+
+  await client.disconnect();
+}
+main();
 ```
 
-##Running tests
+It goes through:
 
-1. Clone the repository
+1. Creating a new test account
+2. Sending a payment transaction
+3. And sending requests to see your account balance!
 
-2. `cd` into the repository and install dependencies with `npm install`
+### Case by Case Setup Steps
 
-3. `npm test` or `node_modules/.bin/mocha test/*-test.js`
+If you're using xahau.js with React or Deno, you'll need to do a couple extra steps to set it up:
 
-**Generating code coverage**
+- [Using xahau.js with a CDN](https://github.com/XRPLF/xahau.js/blob/main/UNIQUE_SETUPS.md#using-xahaujs-from-a-cdn)
+- [Using xahau.js with `create-react-app`](https://github.com/XRPLF/xahau.js/blob/main/UNIQUE_SETUPS.md#using-xahaujs-with-create-react-app)
+- [Using xahau.js with `React Native`](https://github.com/XRPLF/xahau.js/blob/main/UNIQUE_SETUPS.md#using-xahaujs-with-react-native)
+- [Using xahau.js with `Vite React`](https://github.com/XRPLF/xahau.js/blob/main/UNIQUE_SETUPS.md#using-xahaujs-with-vite-react)
+- [Using xahau.js with `Deno`](https://github.com/XRPLF/xahau.js/blob/main/UNIQUE_SETUPS.md#using-xahaujs-with-deno)
 
-ripple-lib uses `istanbul` to generate code coverage. To create a code coverage report, run `npm test --coverage`. The report will be created in `coverage/lcov-report/`.
+## Documentation
+
+As you develop with xahau.js, there's two sites you'll use extensively:
+
+1. [docs.xahau.network](https://docs.xahau.network/technical/protocol-reference) is the primary source for:
+   - How the ledger works ([See Concepts](https://docs.xahau.network/))
+   - What kinds of transactions there are ([Transaction Types](https://docs.xahau.network/technical/protocol-reference/transactions/transaction-types))
+   - Requests you can send ([Public API Methods](https://docs.xahau.network/features/http-websocket-apis))
+
+### Mailing Lists
+
+If you want to hear when we release new versions of xahau.js, you can join our low-traffic mailing list (About 1 email per week):
+
+- [Subscribe to xahau-announce](https://groups.google.com/g/xahau-announce)
+
+If you're using the Xahau Ledger in production, you should run a [xahaud server](https://github.com/Xahau/xahaud) and subscribe to the xahau-server mailing list as well.
+
+- [Subscribe to xahau-server](https://groups.google.com/g/xahau-server)
+
+You are also welcome to create an [issue](https://github.com/Xahau/xahau.js/issues) here and we'll do our best to respond within 3 days.

UNIQUE_SETUPS.md

@@ -0,0 +1,81 @@
+# Unique Setup Steps for Xahau.js
+
+Starting in 3.0 xahau and all the packages in this repo no longer require custom configurations (ex. polyfills) to run.
+
+### Using xahau.js from a CDN
+
+You can avoid setting up your build system to handle `xahau.js` by using a cdn version that is prebuilt for the browser.
+
+- unpkg `<script src="https://unpkg.com/xahau@2.3.0/build/xahau-latest-min.js"></script>`
+- jsdelivr `<script src="https://cdn.jsdelivr.net/npm/xahau@2.3.0/build/xahau-latest-min.js"></script>`
+
+Ensure that the full path is provided so the browser can find the sourcemaps.
+
+### Using xahau.js with `create-react-app`
+
+Starting in 3.0 xahau and its related packages no longer require custom configurations (ex. polyfills) to run.
+
+This online template uses these steps to run xahau.js with React in the browser:
+https://codesandbox.io/s/xahau-intro-pxgdjr?file=/src/App.js
+
+### Using xahau.js with React Native
+
+If you want to use `xahau.js` with React Native you will need to install polyfills for core NodeJS modules.
+
+1. Install dependencies (you can use `yarn` as well):
+
+   ```shell
+   npm install xahau \
+       fast-text-encoding \
+       react-native-get-random-values
+   ```
+
+2. After that, run the following commands:
+
+   ```shell
+   # compile `react-native-get-random-values` pods see https://www.npmjs.com/package/react-native-get-random-values#installation
+   npx pod-install
+   ```
+   
+3. Create `polyfills.js` and add
+
+```javascript
+// Required for TextEncoder/TextDecoder
+import 'fast-text-encoding'
+// Required for `crypto.getRandomValues`
+import 'react-native-get-random-values'
+```
+
+4. Import `polyfills` in index file your project (it must be the first line):
+
+```javascript
+import './polyfills'
+...
+```
+
+### Using xahau.js with Vite React
+
+Starting in 3.0 xahau and all the packages in this repo no longer require custom configurations (ex. polyfills) to run.
+
+### Using xahau.js with Deno
+
+Until official support for [Deno](https://deno.land) is added, you can use the following work-around to use `xahau.js` with Deno:
+
+> [!NOTE]
+> The following is currently broken due to https://github.com/denoland/deno/issues/20516.
+> Once that is fixed there could be other issues as well.
+
+```javascript
+import xahau from 'https://dev.jspm.io/npm:xahau';
+
+(async () => {
+  const api = new (xahau as any).Client('wss://xahau-test.net');
+  const address = 'rH8NxV12EuV...khfJ5uw9kT';
+
+  api.connect().then(() => {
+    api.getBalances(address).then((balances: any) => {
+      console.log(JSON.stringify(balances, null, 2));
+    });
+  });
+})();
+```

bench/modpow.js

@@ -1,44 +0,0 @@
-var Benchmark;
-try {
-  Benchmark = require('benchmark');
-} catch (e) {
-  console.error("Please install Benchmark.js: npm install benchmark");
-  process.exit(1);
-}
-
-var sjcl = require('../build/sjcl');
-var jsbn = require('../src/js/jsbn/jsbn');
-
-var base = "3f70f29d3f3ae354a6d2536ceafba83cfc787cd91e7acd2b6bde05e62beb8295ae18e3f786726f8d034bbc15bf8331df959f59d431736d5f306aaba63dacec279484e39d76db9b527738072af15730e8b9956a64e8e4dbe868f77d1414a8a8b8bf65380a1f008d39c5fabe1a9f8343929342ab7b4f635bdc52532d764701ff3d8072c475c012ff0c59373e8bc423928d99f58c3a6d9f6ab21ee20bc8e8818fc147db09f60c81906f2c6f73dc69725f075853a89f0cd02a30a8dd86b660ccdeffc292f398efb54088c822774445a6afde471f7dd327ef9996296898a5747726ccaeeceeb2e459df98b4128cb5ab8c7cd20c563f960a1aa770f3c81f13f967b6cc";
-var exponent = "322e393f76a1c22b147e7d193c00c023afb7c1500b006ff1bc1cc8d391fc38bd";
-var modulus = "c7f1bc1dfb1be82d244aef01228c1409c198894eca9e21430f1669b4aa3864c9f37f3d51b2b4ba1ab9e80f59d267fda1521e88b05117993175e004543c6e3611242f24432ce8efa3b81f0ff660b4f91c5d52f2511a6f38181a7bf9abeef72db056508bbb4eeb5f65f161dd2d5b439655d2ae7081fcc62fdcb281520911d96700c85cdaf12e7d1f15b55ade867240722425198d4ce39019550c4c8a921fc231d3e94297688c2d77cd68ee8fdeda38b7f9a274701fef23b4eaa6c1a9c15b2d77f37634930386fc20ec291be95aed9956801e1c76601b09c413ad915ff03bfdc0b6b233686ae59e8caf11750b509ab4e57ee09202239baee3d6e392d1640185e1cd";
-var expected = "5b3823974b3eda87286d3f38499de290bd575d8b02f06720acacf3d50950f9ca0ff6b749f3be03913ddca0b291e0b263bdab6c9cb97e4ab47ee9c235ff20931a8ca358726fab93614e2c549594f5c50b1c979b34f840b6d4fc51d6feb2dd072995421d17862cb405e040fc1ed662a3245a1f97bbafa6d1f7f76c7db6a802e3037acdf01ab5053f5da518d6753477193b9c25e1720519dcb9e2f6e70d5786656d356151845a49861dfc40187eff0e85cd18b1f3f3b97c476472edfa090b868b2388edfffecc521c20df8cebb8aacfb3669b020330dd6ea64b2a3067a972b8f249bccc19347eff43893e916f0949bd5789a5cce0f8b7cd87cece909d679345c0d4";
-
-var BigInteger = jsbn.BigInteger;
-var jsbnBase = new BigInteger(base, 16);
-var jsbnExponent = new BigInteger(exponent, 16);
-var jsbnModulus = new BigInteger(modulus, 16);
-
-var bn = sjcl.bn;
-var sjclBase = new bn(base);
-var sjclExponent = new bn(exponent);
-var sjclModulus = new bn(modulus);
-
-var suite = new Benchmark.Suite;
-
-// add tests
-suite.add('jsbn#modPow', function() {
-  jsbnBase.modPow(jsbnExponent, jsbnModulus);
-});
-suite.add('sjcl#powermodMontgomery', function() {
-  sjclBase.powermodMontgomery(sjclExponent, sjclModulus);
-});
-suite.on('cycle', function(event) {
-  console.log(String(event.target));
-});
-suite.on('complete', function() {
-  console.log('Fastest is ' + this.filter('fastest').pluck('name'));
-});
-// run async
-console.log("Running benchmark...");
-suite.run({ 'async': false });

bin/decode_binary.js

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-
-var SerializedObject = require('../src/js/ripple/serializedobject').SerializedObject;
-
-var argv = process.argv.slice(2);
-
-var blob;
-
-blob = argv.shift();
-
-if (blob === '-') {
-  read_input(ready);
-} else {
-  ready();
-}
-
-function read_input(callback) {
-  tx_json = '';
-  process.stdin.on('data', function(data) { tx_json += data; });
-  process.stdin.on('end', callback);
-  process.stdin.resume();
-}
-
-function ready() {
-  var valid_arguments = blob;
-
-  if (!valid_arguments) {
-    console.error('Invalid arguments\n');
-    print_usage();
-  } else {
-      decode();
-    }
-}
-
-function print_usage() {
-  console.log(
-    'Usage: decode_binary.js <hex_blob>\n\n',
-    'Example: decode_binary.js 120000240000000161D6871AFD498D00000000000000000000000000005553440000000000550FC62003E785DC231A1058A05E56E3F09CF4E668400000000000000A732102AE75B908F0A95F740A7BFA96057637E5C2170BC8DAD13B2F7B52AE75FAEBEFCF811450F97A072F1C4357F1AD84566A609479D927C9428314550FC62003E785DC231A1058A05E56E3F09CF4E6'
-  );
-};
-
-function decode() {
-  buffer = new SerializedObject(blob);
-  console.log(buffer.to_json());
-};
-
-// vim:sw=2:sts=2:ts=8:et

bin/rsign.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-var Transaction = require('../src/js/ripple/transaction').Transaction;
-
-var argv = process.argv.slice(2);
-
-var verbose;
-var secret;
-var tx_json;
-
-if (~argv.indexOf('-v')){
-  argv.splice(argv.indexOf('-v'), 1);
-  verbose = true;
-}
-
-secret  = argv.shift();
-tx_json = argv.shift();
-
-if (tx_json === '-') {
-  read_input(ready);
-} else {
-  ready();
-}
-
-function read_input(callback) {
-  tx_json = '';
-  process.stdin.on('data', function(data) { tx_json += data; });
-  process.stdin.on('end', callback);
-  process.stdin.resume();
-}
-
-function ready() {
-  var valid_arguments = secret && tx_json;
-
-  if (!valid_arguments) {
-    console.error('Invalid arguments\n');
-    print_usage();
-  } else {
-    var valid_json = true;
-
-    try {
-      tx_json = JSON.parse(tx_json);
-    } catch(exception) {
-      valid_json = false;
-    }
-
-    if (!valid_json) {
-      console.error('Invalid JSON\n');
-      print_usage();
-    } else {
-      sign_transaction();
-    }
-  }
-}
-
-function print_usage() {
-  console.log(
-    'Usage: rsign.js <secret> <json>\n\n',
-    'Example: rsign.js ssq55ueDob4yV3kPVnNQLHB6icwpC',
-    JSON.stringify({
-      TransactionType: 'Payment',
-      Account: 'r3P9vH81KBayazSTrQj6S25jW6kDb779Gi',
-      Destination: 'r3kmLJN5D28dHuH8vZNUZpMC43pEHpaocV',
-      Amount: '200000000',
-      Fee: '10',
-      Sequence: 1
-    })
-    );
-};
-
-function sign_transaction() {
-  var tx = new Transaction();
-
-  tx.tx_json = tx_json;
-  tx._secret = secret;
-  tx.complete();
-
-  var unsigned_blob = tx.serialize().to_hex();
-  var unsigned_hash = tx.signingHash();
-  tx.sign();
-
-  if (verbose) {
-    var sim = { };
-
-    sim.tx_blob         = tx.serialize().to_hex();
-    sim.tx_json         = tx.tx_json;
-    sim.tx_signing_hash = unsigned_hash;
-    sim.tx_unsigned     = unsigned_blob;
-
-    console.log(JSON.stringify(sim, null, 2));
-  } else {
-    console.log(tx.serialize().to_hex());
-  }
-};
-
-// vim:sw=2:sts=2:ts=8:et

bin/validate_address.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-
-var UInt160 = require('../').UInt160;
-var address = process.argv[2];
-
-if (address === '-') {
-  readInput(validateAddress);
-} else {
-  validateAddress(address);
-}
-
-function readInput(callback) {
-  var result = '';
-  process.stdin.resume();
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', function(data) {
-    result += data;
-  });
-  process.stdin.on('end', function() {
-    callback(result);
-  });
-};
-
-function validateAddress(address) {
-  process.stdout.write((UInt160.is_valid(address.trim()) ? '0' : '1') + '\r\n');
-};

deploy/start rippled.bat

@@ -1,3 +0,0 @@
-start newcoin
-sleep 4
-start index.html

docs/GUIDES.md

@@ -1,206 +0,0 @@
-#Guides
-
-This file provides step-by-step walkthroughs for some of the most common usages of `ripple-lib`.
-
-###In this document
-
-1. [Connecting to the Ripple network with `Remote`](GUIDES.md#connecting-to-the-ripple-network)
-2. [Using `Remote` functions and `Request` objects](GUIDES.md#sending-rippled-API-requests)
-3. [Listening to the network](GUIDES.md#listening-to-the-network)
-4. [Submitting a payment to the network](GUIDES.md#submitting-a-payment-to-the-network)
-   * [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees)
-5. [Submitting a trade offer to the network](GUIDES.md#submitting-a-trade-offer-to-the-network)
-
-###Also see
-
-1. [The ripple-lib README](../README.md)
-2. [The ripple-lib API Reference](REFERENCE.md)
-
-##Generating a new Ripple Wallet
-
-  ```js
-    var Wallet = require('ripple-lib').Wallet;
-
-    var wallet = Wallet.generate();
-    console.log(wallet);
-    // { address: 'rEf4sbVobiiDGExrNj2PkNHGMA8eS6jWh3',
-    //   secret: 'shFh4a38EZpEdZxrLifEnVPAoBRce' }
-  ```
-
-##Connecting to the Ripple network
-
-1. [Get ripple-lib](README.md#getting-ripple-lib)
-2. Load the ripple-lib module into a Node.js file or webpage:
-  ```js
-  /* Loading ripple-lib with Node.js */
-  var Remote = require('ripple-lib').Remote;
-
-  /* Loading ripple-lib in a webpage */
-  // var Remote = ripple.Remote;
-  ```
-3. Create a new `Remote` and connect to the network:
-  ```js
-  var remote = new Remote({options});
-
-  remote.connect(function() {
-    /* remote connected, use some remote functions here */
-  });
-  ```
-  __NOTE:__ See the API Reference for available [`Remote` options](REFERENCE.md#1-remote-options)
-
-4. You're connected! Read on to see what to do now.
-
-
-##Sending rippled API requests
-
-`Remote` contains functions for constructing a `Request` object. 
-
-A `Request` is an `EventEmitter` so you can listen for success or failure events -- or, instead, you can provide a callback.
-
-Here is an example, using [request_server_info](https://ripple.com/wiki/JSON_Messages#server_info).
-
-+ Constructing a `Request` with event listeners
-```js
-var request = remote.request('server_info');
-
-request.on('success', function onSuccess(res) {
-  //handle success
-});
-
-request.on('error', function onError(err) {
-  //handle error
-});
-
-request.request();
-```
-
-+ Using a callback:
-```js
-remote.request('server_info', function(err, res) {
-  if (err) {
-    //handle error
-  } else {
-    //handle success
-  }
-});
-```
-
-__NOTE:__ See the API Reference for available [`Remote` functions](REFERENCE.md#2-remote-functions)
-
-
-##Listening to the network
-
-See the [wiki](https://ripple.com/wiki/JSON_Messages#subscribe) for details on subscription requests.
-
-```js
- /* Loading ripple-lib with Node.js */
-  var Remote = require('ripple-lib').Remote;
-
-  /* Loading ripple-lib in a webpage */
-  // var Remote = ripple.Remote;
-
-  var remote = new Remote({options});
-
-  remote.connect(function() {
-    var request = remote.request('subscribe');
-
-    request.addStream('ledger'); //remote will emit `ledger_closed`
-    request.addStream('transactions'); //remote will emit `transaction`
-
-    request.on('ledger_closed', function onLedgerClosed(ledgerData) {
-	//handle ledger
-    });
-
-    request.on('transaction', function onTransacstion(transaction) {
-	//handle transaction
-    });
-
-    request.request(function(err) {
-      	if (err) {
-        } else {
-        }
-    });
-  });
-```
-* https://ripple.com/wiki/RPC_API#transactions_stream_messages
-* https://ripple.com/wiki/RPC_API#ledger_stream_messages
-
-##Submitting a payment to the network
-
-Submitting a payment transaction to the Ripple network involves connecting to a `Remote`, creating a transaction, signing it with the user's secret, and submitting it to the `rippled` server. Note that the `Amount` module is used to convert human-readable amounts like '1XRP' or '10.50USD' to the type of Amount object used by the Ripple network.
-
-```js
-/* Loading ripple-lib Remote and Amount modules in Node.js */ 
-var Remote = require('ripple-lib').Remote;
-var Amount = require('ripple-lib').Amount;
-
-/* Loading ripple-lib Remote and Amount modules in a webpage */
-// var Remote = ripple.Remote;
-// var Amount = ripple.Amount;
-
-var MY_ADDRESS = 'rrrMyAddress';
-var MY_SECRET  = 'secret';
-var RECIPIENT  = 'rrrRecipient';
-var AMOUNT     = Amount.from_human('1XRP');
-
-var remote = new Remote({ /* Remote options */ });
-
-remote.connect(function() {
-  remote.setSecret(MY_ADDRESS, MY_SECRET);
-
-  var transaction = remote.createTransaction('Payment', {
-    account: MY_ADDRESS, 
-    destination: RECIPIENT, 
-    amount: AMOUNT
-  });
-
-  transaction.submit(function(err, res) {
-    /* handle submission errors / success */
-  });
-});
-```
-
-###A note on transaction fees
-
-A full description of network transaction fees can be found on the [Ripple Wiki](https://ripple.com/wiki/Transaction_Fee).
-
-In short, transaction fees are very small amounts (on the order of ~10) of [XRP drops](https://ripple.com/wiki/Ripple_credits#Notes_on_drops) spent and destroyed with every transaction. They are largely used to account for network load and prevent spam. With `ripple-lib`, transaction fees are calculated locally by default and the fee you are willing to pay is submitted along with your transaction.
-
-Since the fee required for a transaction may change between the time when the original fee was calculated and the time when the transaction is submitted, it is wise to use the [`fee_cushion`](REFERENCE.md#1-remote-options) to ensure that the transaction will go through. For example, suppose the original fee calculated for a transaction was 10 XRP drops but at the instant the transaction is submitted the server is experiencing a higher load and it has raised its minimum fee to 12 XRP drops. Without a `fee_cusion`, this transaction would not be processed by the server, but with a `fee_cusion` of, say, 1.5 it would be processed and you would just pay the 2 extra XRP drops.
-
-The [`max_fee`](REFERENCE.md#1-remote-options) option can be used to avoid submitting a transaction to a server that is charging unreasonably high fees.
-
-
-##4. Submitting a trade offer to the network
-
-Submitting a trade offer to the network is similar to submitting a payment transaction. Here is an example for a trade that expires in 24 hours where you are offering to sell 1 USD in exchange for 100 XRP:
-
-```js
-/* Loading ripple-lib Remote and Amount modules in Node.js */ 
-var Remote = require('ripple-lib').Remote;
-var Amount = require('ripple-lib').Amount;
-
-/* Loading ripple-lib Remote and Amount modules in a webpage */
-// var Remote = ripple.Remote;
-// var Amount = ripple.Amount;
-
-var MY_ADDRESS = 'rrrMyAddress';
-var MY_SECRET  = 'secret';
-var GATEWAY = 'rrrGateWay';
-
-var remote = new Remote({ /* Remote options */ });
-
-remote.connect(function() {
-  remote.setSecret(MY_ADDRESS, MY_SECRET);
-
-  var transaction = remote.createTransaction('OfferCreate', {
-    account: MY_ADDRESS,
-    taker_pays: '1',
-    taker_gets: '1/USD/' + GATEWAY
-  });
-
-  transaction.submit(function(err, res) {
-    /* handle submission errors / success */
-  });
-});
-```

docs/REFERENCE.md

@@ -1,302 +0,0 @@
-#API Reference
-
-__(More examples coming soon!)__
-
-###In this document:
-
-1. [`Remote` options](REFERENCE.md#remote-options)
-2. [`Request` constructors](REFERENCE.md#request-constructor-functions)
-  + [Server requests](REFERENCE.md#server-requests)
-  + [Ledger requests](REFERENCE.md#ledger-requests)
-  + [Transaction requests](REFERENCE.md#transaction-requests)
-  + [Account requests](REFERENCE.md#account-requests)
-  + [Orderbook requests](REFERENCE.md#orderbook-requests)
-  + [Transaction requests](REFERENCE.md#transaction-requests)
-3. [`Transaction` constructors](REFERENCE.md#transaction-constructors)
-  + [Transaction events](REFERENCE.md#transaction-events)
-
-###Also see:
-
-1. [The ripple-lib README](../README.md)
-2. [The ripple-lib GUIDES](GUIDES.md)
-
-#Remote options
-
-```js
-/* Loading ripple-lib with Node.js */
-var Remote = require('ripple-lib').Remote;
-
-/* Loading ripple-lib in a webpage */
-// var Remote = ripple.Remote;
-
-var options = { };
-
-var remote = new Remote(options);
-```
-
-A new `Remote` can be created with the following options:
-
-+ `trace` *boolean default: false* Log all of the events emitted
-+ `max_listeners` *number default: 0* Set maxListeners for servers
-+ `trusted` *boolean default: false*, if remote is trusted (boolean)
-+ `local_signing` *boolean default: true*
-+ `local_fee` *boolean default: true* Set whether the transaction fee range will be set locally, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees))
-+ `fee_cushion` *number default: 1.2* Extra fee multiplier to account for async fee changes, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees))
-+ `max_fee` *number default: Infinity* Maximum acceptable transaction fee, see [A note on transaction fees](GUIDES.md#a-note-on-transaction-fees)
-+ `servers` *array* Array of server objects of the following form:
-
-```js
-{
-  host:    <string>,
-  port:    <number>,
-  secure:  <boolean>
-}
-```
-
-or
-
-```js
- 'wss://host:port'
-```
-
-#Request constructor functions
-
-##Server requests
-
-**[server_info([callback])](https://ripple.com/wiki/JSON_Messages#server_info)**
-
-Returns information about the state of the server. If you are connected to multiple servers and want to select by a particular host, use `request.setServer`. Example:
-
-```js
-var request = remote.request('server_info');
-
-request.setServer('wss://s1.ripple.com');
-
-request.request(function(err, res) {
-
-});
-```
-
-**[unl_list([callback])](https://ripple.com/wiki/JSON_Messages#unl_list)**
-
-**[unl_add(addr, comment, [callback])](https://ripple.com/wiki/JSON_Messages#unl_add)**
-
-**[unl_delete(node, [callback])](https://ripple.com/wiki/JSON_Messages#unl_delete)**
-
-**[requestPeers([callback])](https://ripple.com/wiki/JSON_Messages#peers)**
-
-
-**[connect(ip, port, [callback])](https://ripple.com/wiki/JSON_Messages#connect)**
-
-##Ledger requests
-
-**[ledger(ledger, [opts], [callback])](https://ripple.com/wiki/JSON_Messages#ledger)**
-
-**ledger_header([callback])**
-
-**[ledger_current([callback])](https://ripple.com/wiki/JSON_Messages#ledger_current)**
-
-**[ledger_entry(type, [callback])](https://ripple.com/wiki/JSON_Messages#ledger_entry)**
-
-**[subscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#subscribe)**
-
-Start receiving selected streams from the server.
-
-**[unsubscribe([streams], [callback])](https://ripple.com/wiki/JSON_Messages#unsubscribe)**
-
-Stop receiving selected streams from the server.
-
-##Account requests
-
-**[account_info(account, [callback])](https://ripple.com/wiki/JSON_Messages#account_info)**
-
-Return information about the specified account.
-
-```
-{
-  ledger_current_index: <number>,
-  account_data: {
-    Account:            <string>,
-    Balance:            <number>,
-    Flags:              <number>,
-    LedgerEntryType:    <string>,
-    OwnerCount:         <number>,
-    PreviousTxnID:      <string>,
-    PreviousTxnLgrSeq:  <number>,
-    Sequence:           <number> ,
-    index:              <string>
-  }
-}
-```
-
-**[account_lines(accountID, [account_index], [ledger], [callback])](https://ripple.com/wiki/JSON_Messages#account_lines)**
-
-**[account_offers(accountID, [account_index], [ledger], [callback])](https://ripple.com/wiki/JSON_Messages#account_offers)**
-
-Return the specified account's outstanding offers.
-
-**[account_tx(options, [callback])](https://ripple.com/wiki/JSON_Messages#account_tx)**
-
-Fetch a list of transactions that applied to this account.
-
-Options:
-
-+ `account`
-+ `ledger_index_min`
-+ `ledger_index_max`
-+  `binary` *false*
-+ `count` *false*
-+  `descending` *false*
-+  `offset` *0*
-+  `limit`
-+ `forward` *false*
-+ `fwd_marker`
-+ `rev_marker`
-
-**[wallet_accounts(seed, [callback])](https://ripple.com/wiki/JSON_Messages#wallet_accounts)**
-
-Return a list of accounts for a wallet. *Requires trusted remote*
-
-**account_balance(account, [ledger], [callback])**
-
-Get the balance for an account. Returns an [Amount](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/amount.js) object.
-
-**account_flags(account, [ledger], [callback])**
-
-Return the flags for an account.
-
-**owner_count(account, [ledger], [callback])**
-
-Return the owner count for an account.
-
-**ripple_balance(account, issuer, currency, [ledger], [callback])**
-
-Return a request to get a ripple balance
-
-##Orderbook requests
-
-**[book_offers(options, [callback])](https://ripple.com/wiki/JSON_Messages#book_offers)**
-
-Return the offers for an order book, also called a *snapshot*
-
-```js
-var request = remote.request('book_offers', {
-  taker_gets: {
-    'currency':'XRP'
-  },
-  taker_pays: {
-    'currency':'USD',
-    'issuer': 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B'
-  }
-});
-
-request.request(function(err, offers) {
-  //handle offers
-});
-```
-
-##Transaction requests
-
-**[transaction_entry(hash, [ledger_hash], [callback])](https://ripple.com/wiki/JSON_Messages#transaction_entry)**
-
-Searches a particular ledger for a transaction hash. Default ledger is the open ledger.
-
-**[tx(hash, [callback])](https://ripple.com/wiki/JSON_Messages#tx)**
-
-Searches ledger history for validated transaction hashes.
-
-**[sign(secret, tx_json, [callback])](https://ripple.com/wiki/JSON_Messages#sign)**
-
-Sign a transaction. *Requires trusted remote*
-
-**[submit([callback])](https://ripple.com/wiki/JSON_Messages#submit)**
-
-Submit a transaction to the network. This command is used internally to submit transactions with a greater degree of reliability. See [Submitting a payment to the network](GUIDES.md#3-submitting-a-payment-to-the-network) for details.
-
-**[ripple_path_find(src_account, dst_account, dst_amount, src_currencies, [callback])](https://ripple.com/wiki/JSON_Messages#path_find)**
-
-#Transaction constructors
-
-Use `remote.createTransaction('TransactionType', [options])` to construct a transaction. To submit, use `transaction.submit([callback])`.
-
-**Payment**
-
-```js
-var transaction = remote.createTransaction('Payment', {
-  account: MY_ADDRESS,
-  destination: DEST_ADDRESS,
-  amount: AMOUNT
-});
-```
-
-**AccountSet**
-
-```js
-var transaction = remote.createTransaction('AccountSet', {
-  account: MY_ADDRESS,
-  set: 'RequireDest',
-  clear: 'RequireAuth'
-});
-```
-
-**TrustSet**
-
-```js
-var transaction = remote.createTransaction('TrustSet', {
-  account: MY_ADDRESS,
-  limit: '1/USD/rrrrrrrrrrrrrrrrrrrrBZbvji'
-});
-```
-
-**OfferCreate**
-
-```js
-var transaction = remote.createTransaction('OfferCreate', {
-  account: MY_ADDRESS,
-  taker_pays: '1',
-  taker_gets: '1/USD/rrrrrrrrrrrrrrrrrrrrBZbvji'
-});
-```
-
-##Transaction events
-
-[Transaction](https://github.com/ripple/ripple-lib/blob/develop/src/js/ripple/transaction.js) objects are EventEmitters. They may emit the following events.
-
-+ `final` Transaction has erred or succeeded. This event indicates that the transaction has finished processing.
-+ `error` Transaction has erred. This event is a final state.
-+ `success` Transaction succeeded. This event is a final state.
-+ `presubmit` Immediately before transaction is submitted
-+ `postsubmit` Immediately after transaction is submitted
-+ `submitted` Transaction has been submitted to the network. The submission may result in a remote error or success.
-+ `resubmitted` Transaction is beginning resubmission.
-+ `proposed` Transaction has been submitted *successfully* to the network. The transaction at this point is awaiting validation in a ledger.
-+ `timeout` Transaction submission timed out. The transaction will be resubmitted.
-+ `fee_adjusted` Transaction fee has been adjusted during its pending state. The transaction fee will only be adjusted if the remote is configured for local fees, which it is by default.
-+ `abort` Transaction has been aborted. Transactions are only aborted by manual calls to `#abort`.
-+ `missing` Four ledgers have closed without detecting validated transaction
-+ `lost` Eight ledgers have closed without detecting validated transaction. Consider the transaction lost and err/finalize.
-
-##Complete payment example
-
-```js
-remote.setSecret(MY_ADDRESS, MY_SECRET);
-
-var transaction = remote.createTransaction('Payment', {
-  account: MY_ADDRESS,
-  destination: DEST_ADDRESS,
-  amount: AMOUNT
-});
-
-transaction.on('resubmitted', function() {
-  // initial submission failed, resubmitting
-});
-
-transaction.submit(function(err, res) {
- // submission has finalized with either an error or success.
- // the transaction will not be retried after this point
-});
-```
-
-#Amount objects
-
-Coming Soon

docs/VAULTCLIENT.md

@@ -1,168 +0,0 @@
-ripple-vault-client
-===================
-
-A javascript / http client to interact with Ripple Vault servers.
-
-The purpose of this tool is to enable applications in any javascript
-environment to login with the ripple vault and access the decrypted
-data stored using credentials originally obtained at ripple.com
-     
-        
-## Vault Client Usage
-
-    vaultClient = new ripple.VaultClient(domain);
-    
-    vaultClient.getAuthInfo(username, callback);
-    
-    vaultClient.getRippleName(address, url, callback);
-
-    vaultClient.exists(username, callback);
-    
-        
-
-    vaultClient.login(username, password, callback);
-
-    vaultClient.relogin(id, cryptKey, callback);
-
-    vaultClient.unlock(username, password, encryptSecret, callback);
-
-    vaultClient.loginAndUnlock(username, password, callback);
-    
-    
-    
-    vaultClient.register(options, callback);
-    
-    vaultClient.deleteBlob(options, callback);
-    
-    vaultClient.recoverBlob(options, callback);
-        
-    vaultClient.rename(options, callback);
-    
-    vaultClient.changePassword(options, callback);
-     
-    vaultClient.verify(username, token, callback);
-    
-    vaultClient.resendEmail(options, callback);
-    
-    vaultClient.updateProfile(options, fn);
-    
-
-# Blob Methods
-    
-    blob.encrypt();
-    
-    blob.decrypt(encryptedBlob);
-    
-    blob.encryptSecret(encryptionKey);
-    
-    blob.decryptSecret(encryptionKey, secret);
-    
-    blob.set(pointer, value, callback);
-    
-    blob.unset(pointer, callback);
-    
-    blob.extend(pointer, value, callback);
-    
-    blob.unshift(pointer, value, callback);
-    
-    blob.filter(pointer, field, value, subcommands, callback);
-    
-    
-## Identity Vault
-
-  The identity vault stores identity information inside the encrypted 
-  blob vault.  The identity fields can be additionally encrypted with the 
-  unlock key, that encrypts the secret, for added security. Methods are 
-  accessed from the 'identity' property of the blob object.
-
-
-# Identity fields
-  + name
-  + entityType (individual, corporation, organization)
-  + email
-  + phone
-  + address
-    + contact
-    + line1
-    + line2
-    + city
-    + postalCode
-    + region - state/province/region
-    + country
-  + nationalID
-    + number
-    + type (ssn, taxID, passport, driversLicense, other)
-    + country - issuing country
-  + birthday
-  + birthplace
-  
-  
-# Identity Methods
-
-    blob.identity.set(pointer, key, value, callback);
-    
-    blob.identity.unset(pointer, key, callback);
-    
-    blob.identity.get(pointer, key);
-    
-    blob.identity.getAll(key);
-    
-    blob.identity.getFullAddress(key);  //get text string of full address
-    
-
-## Spec Tests
-
-Run `npm test` to test the high-level behavior specs 
-
-  Ripple Txt
-    ✓ should get the content of a ripple.txt file from a given domain 
-    ✓ should get currencies from a ripple.txt file for a given domain
-    ✓ should get the domain from a given url 
-
-  AuthInfo
-    ✓ should get auth info 
-
-  VaultClient
-    #initialization
-      ✓ should be initialized with a domain 
-      ✓ should default to ripple.com without a domain 
-    #exists
-      ✓ should determine if a username exists on the domain 
-    #login
-      ✓ with username and password should retrive the blob, crypt key, and id
-    #relogin
-      ✓ should retrieve the decrypted blob with blob vault url, id, and crypt key 
-    #unlock
-      ✓ should access the wallet secret using encryption secret, username and password
-    #loginAndUnlock
-      ✓ should get the decrypted blob and decrypted secret given name and password
-    #register
-      ✓ should create a new blob
-    #deleteBlob
-      ✓ should remove an existing blob
-    #updateProfile
-      ✓ should update profile parameters associated with a blob 
-
-  Blob
-    ✓ #set 
-    ✓ #extend 
-    ✓ #unset 
-    ✓ #unshift 
-    ✓ #filter 
-    ✓ #consolidate 
-    #rename
-      ✓ should change the username of a blob
-    #changePassword
-      ✓ should change the password and keys of a blob
-    #recoverBlob
-      ✓ should recover the blob given a username and secret
-    #verifyEmail
-      ✓ should verify an email given a username and token 
-    #resendVerifcationEmail
-      ✓ should resend a verification given options
-    identity
-      ✓ #identity_set 
-      ✓ #identity_get 
-      ✓ #identity_getAll 
-      ✓ #identity_getFullAddress 
-      ✓ #identity_unset 

jest.config.base.js

@@ -0,0 +1,20 @@
+const { TextDecoder, TextEncoder } = require("util");
+
+module.exports = {
+  roots: ["<rootDir>/src"],
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+  collectCoverage: true,
+  verbose: true,
+  testEnvironment: "node",
+  globals: {
+    TextDecoder: TextDecoder,
+    TextEncoder: TextEncoder,
+    error: console.error,
+    warn: console.warn,
+    info: console.info,
+    debug: console.debug,
+  },
+};

jest.config.js

@@ -0,0 +1,8 @@
+const path = require("path");
+const base = require("./jest.config.base.js");
+
+module.exports = {
+  ...base,
+  projects: ["<rootDir>/packages/**/jest.config.js"],
+  coverageDirectory: "<rootDir>/coverage/",
+};

karma.config.js

@@ -0,0 +1,28 @@
+module.exports = function (config) {
+  config.set({
+    plugins: ["karma-webpack", "karma-jasmine", "karma-chrome-launcher"],
+
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ["jasmine"],
+
+    // preprocess matching files before serving them to the browser
+    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+    preprocessors: {
+      // Use webpack to bundle our test files
+      "test/**/*.test.ts": ["webpack"],
+    },
+
+    browsers: ["ChromeHeadless"],
+    // runs only one browser at a time
+    concurrency: 1,
+    // CI mode
+    singleRun: true,
+    client: {
+      jasmine: {
+        // ensures that tests are run in order instead of a random order
+        random: false,
+      },
+    },
+  });
+};

lerna.json

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

package.json

@@ -1,54 +1,70 @@
 {
-  "name": "ripple-lib",
-  "version": "0.9.0-rc1",
-  "description": "Ripple JavaScript client library",
-  "files": [
-    "src/js/*",
-    "bin/*",
-    "build/*",
-    "test/*",
-    "Makefile",
-    "Gulpfile.js"
-  ],
-  "main": "src/js/ripple",
-  "directories": {
-    "test": "test"
+  "name": "xahau.js",
+  "private": true,
+  "scripts": {
+    "analyze": "lerna run analyze --stream",
+    "test": "lerna run test --stream",
+    "test:browser": "lerna run test:browser --stream",
+    "test:integration": "lerna run test:integration --stream",
+    "lint": "lerna run lint --stream",
+    "clean": "lerna run clean --stream",
+    "build": "lerna run build --stream",
+    "docgen": "lerna run docgen --stream",
+    "update:check": "npx npm-check-updates --configFileName .ncurc.json",
+    "update:confirm": "npx npm-check-updates --configFileName .ncurc.json -u"
   },
   "dependencies": {
-    "async": "~0.8.0",
-    "ws": "~0.4.31",
-    "extend": "~1.2.1",
-    "lru-cache": "~2.5.0",
-    "superagent": "^0.18.0",
-    "gulp-bump": "~0.1.10",
-    "ripple-wallet-generator": "1.0.1"
+    "@xrplf/isomorphic": "file:packages/isomorphic",
+    "@xrplf/secret-numbers": "file:packages/secret-numbers",
+    "xahau-address-codec": "file:packages/xahau-address-codec",
+    "xahau-binary-codec": "file:packages/xahau-binary-codec",
+    "xahau-keypairs": "file:packages/xahau-keypairs",
+    "xahau": "file:packages/xahau"
   },
   "devDependencies": {
-    "mocha": "~1.14.0",
-    "gulp": "~3.6.2",
-    "gulp-concat": "~2.2.0",
-    "gulp-jshint": "~1.5.5",
-    "gulp-uglify": "~0.3.0",
-    "gulp-rename": "~1.2.0",
-    "webpack": "~1.1.11",
-    "map-stream": "~0.1.0",
-    "istanbul": "~0.2.10",
-    "coveralls": "~2.10.0",
-    "nock": "^0.34.1",
-    "yargs": "~1.3.1"
+    "@types/chai": "^4.2.21",
+    "@types/jest": "^29.2.2",
+    "@types/lodash": "^4.14.136",
+    "@types/node": "^18.19.29",
+    "@types/ws": "^8.2.0",
+    "@typescript-eslint/eslint-plugin": "^5.28.0",
+    "@typescript-eslint/parser": "^5.28.0",
+    "@xrplf/eslint-config": "^1.9.1",
+    "@xrplf/prettier-config": "^1.9.1",
+    "chai": "^4.3.4",
+    "copyfiles": "^2.4.1",
+    "eslint": "^8.18.0",
+    "eslint-plugin-array-func": "^3.1.7",
+    "eslint-plugin-consistent-default-export-name": "^0.0.15",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsdoc": "^39.3.3",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-tsdoc": "^0.2.16",
+    "expect": "^29.3.1",
+    "jest": "^29.3.1",
+    "jest-mock": "^29.3.1",
+    "lerna": "^4.0.0",
+    "lodash": "^4.17.21",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "process": "^0.11.10",
+    "source-map-loader": "^5.0.0",
+    "source-map-support": "^0.5.16",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.2.5",
+    "ts-node": "^10.2.1",
+    "typescript": "^5.1.6",
+    "webpack": "^5.81.0",
+    "webpack-bundle-analyzer": "^4.1.0",
+    "webpack-cli": "^5.0.1"
   },
-  "scripts": {
-    "build": "node_modules/.bin/gulp",
-    "pretest": "node_modules/.bin/gulp concat-sjcl",
-    "test": "./node_modules/.bin/istanbul test -x build/sjcl.js -x src/js/jsbn/* ./node_modules/mocha/bin/mocha -- --reporter spec test/*-test.js",
-    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/ripple/ripple-lib.git"
-  },
-  "readmeFilename": "README.md",
+  "workspaces": [
+    "./packages/*"
+  ],
   "engines": {
-    "node": ">=0.10.0"
+    "node": ">=18.0.0",
+    "npm": ">=7.10.0 < 10.0.0"
   }
 }

packages/isomorphic/.eslintignore

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

packages/isomorphic/.eslintrc.js

@@ -0,0 +1,75 @@
+module.exports = {
+  root: false,
+
+  parser: '@typescript-eslint/parser', // Make ESLint compatible with TypeScript
+  parserOptions: {
+    // Enable linting rules with type information from our tsconfig
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig.json', './tsconfig.eslint.json'],
+
+    sourceType: 'module', // Allow the use of imports / ES modules
+
+    ecmaFeatures: {
+      impliedStrict: true, // Enable global strict mode
+    },
+  },
+
+  // Specify global variables that are predefined
+  env: {
+    browser: true, // Enable browser global variables
+    node: true, // Enable node global variables & Node.js scoping
+    es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020
+    jest: true, // Add Jest testing global variables
+  },
+
+  plugins: [],
+  extends: ['@xrplf/eslint-config/base'],
+
+  rules: {
+    // ** TODO **
+    // all of the below are turned off for now during the migration to a
+    // monorepo. They need to actually be addressed!
+    // **
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-magic-numbers': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/restrict-plus-operands': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    '@typescript-eslint/promise-function-async': 'off',
+    '@typescript-eslint/restrict-template-expressions': 'off',
+    '@typescript-eslint/prefer-nullish-coalescing': 'off',
+    '@typescript-eslint/naming-convention': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    'import/no-unused-modules': 'off',
+    'import/prefer-default-export': 'off',
+    'jsdoc/require-jsdoc': 'off',
+    'jsdoc/require-description': 'off',
+    'jsdoc/require-returns': 'off',
+    'jsdoc/require-description-complete-sentence': 'off',
+    'jsdoc/check-tag-names': 'off',
+    'jsdoc/check-examples': 'off', // Not implemented in eslint 8
+    'jsdoc/no-types': 'off',
+    'tsdoc/syntax': 'off',
+    'import/order': 'off',
+    'eslint-comments/require-description': 'off',
+    'no-shadow': 'off',
+    'multiline-comment-style': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+  },
+
+  overrides: [
+    {
+      files: ['test/*.test.ts'],
+      // tests are importing through full module name to test in an isomorphic way
+      rules: {
+        'node/no-extraneous-import': 'off',
+        'import/no-extraneous-dependencies': 'off',
+      },
+    },
+  ],
+}

packages/isomorphic/HISTORY.md

@@ -0,0 +1,24 @@
+# @xrplf/isomorphic Release History
+
+## Unreleased
+
+## 1.0.1 (2024-06-03)
+
+### Fixed
+
+* Throw error if `hexToBytes` or `hexToString` is provided a string that is not in hex
+
+## 1.0.0 (2024-02-01)
+
+Initial release providing isomorphic and tree-shakable implementations of:
+
+* ripemd160
+* sha256
+* sha512
+* bytesToHash
+* hashToBytes
+* hexToString
+* stringToHex
+* randomBytes
+* stringToHex
+* ws

packages/isomorphic/LICENSE

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

packages/isomorphic/README.md

@@ -0,0 +1,124 @@
+# @xrplf/isomorphic
+
+A collection of isomorphic implementations of crypto and utility functions.
+
+Browser implementations of cryptographic functions use `@noble/hashes` and `crypto` for node .
+
+### Hashes
+
+All hash functions operate similarly to `@noble/hashes` and have the following properties:
+
+- They can be called directly by providing a Uint8Array or string which will be converted into a UInt8Array via UTF-8 encoding (not hex).
+- They all return a UInt8Array.
+
+```
+function hash(message: Uint8Array | string): Uint8Array;
+hash(new Uint8Array([1, 3]));
+hash('string') == hash(new TextEncoder().encode('string'));
+```
+
+All hash functions can be constructed via `hash.create()` method:
+
+- The result is `Hash` subclass instance, which has `update()` and `digest()` methods.
+- `digest()` finalizes the hash and makes it no longer usable
+
+```typescript
+hash
+  .create()
+  .update(new Uint8Array([1, 3]))
+  .digest();
+```
+
+### `@xrplf/isomorphic/ripemd160`
+```typescript
+import { ripemd160 } from '@xrplf/isomorphic/ripemd160';
+const hashA = ripemd160('abc');
+const hashB = ripemd160
+  .create()
+  .update(Uint8Array.from([1, 2, 3]))
+  .digest();
+```
+
+### `@xrplf/isomorphic/sha256`
+
+```typescript
+import { sha256 } from '@xrplf/isomorphic/sha256';
+const hashA = sha256('abc');
+const hashB = sha256
+  .create()
+  .update(Uint8Array.from([1, 2, 3]))
+  .digest();
+```
+
+### `@xrplf/isomorphic/sha512`
+
+```typescript
+import { sha512 } from '@xrplf/isomorphic/sha512';
+const hashA = sha512('abc');
+const hashB = sha512
+  .create()
+  .update(Uint8Array.from([1, 2, 3]))
+  .digest();
+```
+
+## Utilities
+
+### `@xrplf/isomorphic/utils`
+
+#### randomBytes
+
+Create an UInt8Array of the supplied size
+
+```typescript
+import { randomBytes } from @xrplf/isomorphic/utils
+
+console.log(randomBytes(12)) // Uint8Array(12) [95, 236, 188,  55, 208, 128, 161, 249, 171, 57, 141, 7]
+```
+
+#### bytesToHex
+
+Convert an UInt8Array to hex.
+
+```typescript
+import { bytesToHex } from @xrplf/isomorphic/utils
+
+console.log(bytesToHex([222, 173, 190, 239])) // "DEADBEEF"
+```
+
+#### hexToBytes
+
+Convert hex to an UInt8Array.
+
+```typescript
+import { hexToBytes } from @xrplf/isomorphic/utils
+
+console.log(hexToBytes('DEADBEEF')) // [222, 173, 190, 239]
+```
+
+#### hexToString
+
+Converts hex to its string equivalent. Useful to read the Domain field and some Memos.
+
+```typescript
+import { hexToString } from @xrplf/isomorphic/utils
+
+console.log(hexToString('6465616462656566D68D')) // "deadbeef֍"
+```
+
+#### stringToHex
+
+Converts a utf-8 to its hex equivalent. Useful for Memos.
+
+```typescript
+import { stringToHex } from @xrplf/isomorphic/utils
+
+console.log(stringToHex('deadbeef֍')) // "6465616462656566D68D"
+```
+
+### `@xrplf/isomorphic/ws`
+
+```typescript
+import WebSocket from '@xrplf/isomorphic/ws'
+
+const socket = new WebSocket('wss://localhost:8080')
+```

packages/isomorphic/jest.config.js

@@ -0,0 +1,8 @@
+// Jest configuration for api
+const base = require('../../jest.config.base.js')
+
+module.exports = {
+  ...base,
+  roots: [...base.roots, '<rootDir>/test'],
+  displayName: '@xrplf/isomorphic',
+}

packages/isomorphic/karma.config.js

@@ -0,0 +1,15 @@
+const baseKarmaConfig = require('../../karma.config')
+const webpackConfig = require('./test/webpack.config')
+delete webpackConfig.entry
+
+module.exports = function (config) {
+  baseKarmaConfig(config)
+
+  config.set({
+    base: '',
+    webpack: webpackConfig,
+
+    // list of files / patterns to load in the browser
+    files: ['test/**/*.test.ts'],
+  })
+}

packages/isomorphic/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@xrplf/isomorphic",
+  "version": "1.0.1",
+  "description": "A collection of isomorphic and tree-shakeable crypto hashes and utils for xahau.js",
+  "keywords": [
+    "crypto",
+    "isomorphic",
+    "xahau"
+  ],
+  "scripts": {
+    "build": "tsc --build ./tsconfig.build.json",
+    "test": "npm run build && jest --verbose false --silent=false ./test/*.test.ts",
+    "test:browser": "npm run build && karma start ./karma.config.js",
+    "clean": "rm -rf ./dist ./coverage ./test/testCompiledForWeb tsconfig.build.tsbuildinfo",
+    "lint": "eslint . --ext .ts",
+    "prepublish": "npm run lint && npm test"
+  },
+  "files": [
+    "dist/*",
+    "sha256/*",
+    "sha512/*",
+    "ripemd160/*",
+    "src/*",
+    "utils/*",
+    "ws/*"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.0.0",
+    "eventemitter3": "5.0.1",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.18.38",
+    "@types/ws": "^8.5.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Xahau/xahau.js.git"
+  },
+  "license": "ISC",
+  "prettier": "@xrplf/prettier-config",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

packages/isomorphic/ripemd160/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@xrplf/isomorphic/ripemd160",
+  "private": true,
+  "main": "../dist/ripemd160",
+  "types": "../dist/ripemd160",
+  "browser": "../dist/ripemd160/browser.js"
+}

packages/isomorphic/sha256/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@xrplf/isomorphic/sha256",
+  "private": true,
+  "main": "../dist/sha256",
+  "types": "../dist/sha256",
+  "browser": "../dist/sha256/browser.js"
+}

packages/isomorphic/sha512/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@xrplf/isomorphic/sha512",
+  "private": true,
+  "main": "../dist/sha512",
+  "types": "../dist/sha512",
+  "browser": "../dist/sha512/browser.js"
+}

packages/isomorphic/src/internal/normalizeInput.ts

@@ -0,0 +1,11 @@
+import { Input } from './types'
+
+/**
+ * Normalize a string, number array, or Uint8Array to a string or Uint8Array.
+ * Both node and noble lib functions accept these types.
+ *
+ * @param input - value to normalize
+ */
+export default function normalizeInput(input: Input): string | Uint8Array {
+  return Array.isArray(input) ? new Uint8Array(input) : input
+}

packages/isomorphic/src/internal/types.ts

@@ -0,0 +1,33 @@
+export type ByteEncodedString = string
+export type Input = Uint8Array | number[] | ByteEncodedString
+
+/**
+ * A stripped down isomorphic hash inspired by node's `crypto.Hash`
+ */
+export interface Hash {
+  /**
+   * Updates the hash content with the given data,
+   *
+   * @param data - a byte encoded string, an array of numbers or a Uint8Array
+   */
+  update: (data: Input) => this
+  /**
+   * Calculates the digest of all the data passed to be hashed and returns a Uint8Array
+   */
+  digest: () => Uint8Array
+}
+
+export interface HashFn {
+  /**
+   * Produces a Uint8Array for the given hash contents
+   * Shorthand for calling `create`, `update`, and then `digest`
+   *
+   * @param data - a byte encoded string, an array of numbers or a Uint8Array
+   */
+  (data: Input): Uint8Array
+
+  /**
+   * Creates a new empty `Hash`.
+   */
+  create: () => Hash
+}

packages/isomorphic/src/internal/wrapCryptoCreateHash.ts

@@ -0,0 +1,32 @@
+import { createHash } from 'crypto'
+import { Hash, HashFn, Input } from './types'
+import normalizeInput from './normalizeInput'
+
+/**
+ * Wrap createHash from node to provide an interface that is isomorphic
+ *
+ * @param type - the hash name
+ * @param fn - {createHash} the hash factory
+ */
+export default function wrapCryptoCreateHash(
+  type: string,
+  fn: typeof createHash,
+): HashFn {
+  function hashFn(input: Input): Uint8Array {
+    return fn(type).update(normalizeInput(input)).digest()
+  }
+
+  hashFn.create = (): Hash => {
+    const hash = fn(type)
+    return {
+      update(input: Input): Hash {
+        hash.update(normalizeInput(input))
+        return this
+      },
+      digest(): Uint8Array {
+        return hash.digest()
+      },
+    }
+  }
+  return hashFn
+}

packages/isomorphic/src/internal/wrapNoble.ts

@@ -0,0 +1,28 @@
+import { CHash } from '@noble/hashes/utils'
+import { Hash, HashFn, Input } from './types'
+import normalizeInput from './normalizeInput'
+
+/**
+ * Wrap a CHash object from @noble/hashes to provide a interface that is isomorphic
+ *
+ * @param chash - {CHash} hash function to wrap
+ */
+export default function wrapNoble(chash: CHash): HashFn {
+  function wrapped(input: Input): Uint8Array {
+    return chash(normalizeInput(input))
+  }
+
+  wrapped.create = (): Hash => {
+    const hash = chash.create()
+    return {
+      update(input: Input): Hash {
+        hash.update(normalizeInput(input))
+        return this
+      },
+      digest(): Uint8Array {
+        return hash.digest()
+      },
+    }
+  }
+  return wrapped
+}

packages/isomorphic/src/ripemd160/browser.ts

@@ -0,0 +1,8 @@
+import { ripemd160 as nobleImpl } from '@noble/hashes/ripemd160'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's ripemd160 implementation in HashFn
+ */
+export const ripemd160 = wrapNoble(nobleImpl)

packages/isomorphic/src/ripemd160/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native ripemd160 implementation in HashFn
+ */
+export const ripemd160 = wrapCryptoCreateHash('ripemd160', createHash)

packages/isomorphic/src/sha256/browser.ts

@@ -0,0 +1,8 @@
+import { sha256 as nobleImpl } from '@noble/hashes/sha256'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's sha256 implementation in HashFn
+ */
+export const sha256 = wrapNoble(nobleImpl)

packages/isomorphic/src/sha256/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native sha256 implementation in HashFn
+ */
+export const sha256 = wrapCryptoCreateHash('sha256', createHash)

packages/isomorphic/src/sha512/browser.ts

@@ -0,0 +1,8 @@
+import { sha512 as nobleImpl } from '@noble/hashes/sha512'
+
+import wrapNoble from '../internal/wrapNoble'
+
+/**
+ * Wrap noble-libs's sha512 implementation in HashFn
+ */
+export const sha512 = wrapNoble(nobleImpl)

packages/isomorphic/src/sha512/index.ts

@@ -0,0 +1,7 @@
+import { createHash } from 'crypto'
+import wrapCryptoCreateHash from '../internal/wrapCryptoCreateHash'
+
+/**
+ * Wrap node's native sha512 implementation in HashFn
+ */
+export const sha512 = wrapCryptoCreateHash('sha512', createHash)

packages/isomorphic/src/utils/browser.ts

@@ -0,0 +1,54 @@
+import {
+  bytesToHex as nobleBytesToHex,
+  randomBytes as nobleRandomBytes,
+} from '@noble/hashes/utils'
+import type {
+  BytesToHexFn,
+  HexToBytesFn,
+  HexToStringFn,
+  RandomBytesFn,
+  StringToHexFn,
+} from './types'
+import { HEX_REGEX } from './shared'
+
+/* eslint-disable func-style -- Typed to ensure uniformity between node and browser implementations and docs */
+export const bytesToHex: typeof BytesToHexFn = (bytes) => {
+  const hex = nobleBytesToHex(
+    bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes),
+  )
+  return hex.toUpperCase()
+}
+
+// A clone of hexToBytes from @noble/hashes without the length checks. This allows us to do our own checks.
+export const hexToBytes: typeof HexToBytesFn = (hex): Uint8Array => {
+  const len = hex.length
+  const array = new Uint8Array(len / 2)
+  if (!HEX_REGEX.test(hex)) {
+    throw new Error('Invalid hex string')
+  }
+  for (let i = 0; i < array.length; i++) {
+    const j = i * 2
+    const hexByte = hex.slice(j, j + 2)
+    const byte = Number.parseInt(hexByte, 16)
+    if (Number.isNaN(byte) || byte < 0) {
+      throw new Error('Invalid byte sequence')
+    }
+    array[i] = byte
+  }
+  return array
+}
+
+export const hexToString: typeof HexToStringFn = (
+  hex: string,
+  encoding = 'utf8',
+): string => {
+  return new TextDecoder(encoding).decode(hexToBytes(hex))
+}
+
+export const stringToHex: typeof StringToHexFn = (string: string): string => {
+  return bytesToHex(new TextEncoder().encode(string))
+}
+/* eslint-enable func-style */
+
+export const randomBytes: typeof RandomBytesFn = nobleRandomBytes
+export * from './shared'

packages/isomorphic/src/utils/index.ts

@@ -0,0 +1,93 @@
+import { randomBytes as cryptoRandomBytes } from 'crypto'
+import type { BytesToHexFn, HexToBytesFn, RandomBytesFn } from './types'
+import { HexToStringFn, StringToHexFn } from './types'
+import { HEX_REGEX } from './shared'
+
+const OriginalBuffer = Symbol('OriginalBuffer')
+
+/**
+ * An extended Uint8Array that incorporates a reference to the original Node.js Buffer.
+ *
+ * When converting a Node.js Buffer to a Uint8Array, there's an optimization that shares
+ * the memory of the original Buffer with the resulting Uint8Array instead of copying data.
+ * The Uint8ArrayWithReference interface is used to attach a reference to the original Buffer, ensuring
+ * its persistence in memory (preventing garbage collection) as long as the Uint8Array exists.
+ * This strategy upholds the ownership semantics of the slice of the ArrayBuffer.
+ */
+interface Uint8ArrayWithReference extends Uint8Array {
+  [OriginalBuffer]: Buffer
+}
+
+/**
+ * Converts a Node.js Buffer to a Uint8Array for uniform behavior with browser implementations.
+ *
+ * Choices:
+ * 1. Directly returning the Buffer:
+ *    - Operation: Return Buffer as is (a Buffer *IS* an instanceof Uint8Array).
+ *    - Pros: Most memory and performance efficient.
+ *    - Cons: Violates strict Uint8Array typing and may lead to issues where Buffer-specific features are [ab]used.
+ *
+ * 2. Using `new Uint8Array(buffer)` or `Uint8Array.from(buffer)`:
+ *    - Operation: Copies the buffer's data into a new Uint8Array.
+ *    - Pros: Ensures data isolation; memory-safe.
+ *    - Cons: Less performant due to data duplication.
+ *
+ * 3. Using buf.buffer slice:
+ *    - Operation: Shares memory between Buffer and Uint8Array.
+ *    - Pros: Performant.
+ *    - Cons: Risks with shared memory and potential for invalid references.
+ *
+ * 4. Using buf.buffer slice and keeping a Buffer reference for ownership semantics:
+ *    - Operation: Shares memory and associates the original Buffer with the resulting Uint8Array.
+ *    - Pros: Performant while ensuring the original Buffer isn't garbage collected.
+ *    - Cons: Risks with shared memory but mitigates potential for invalid references.
+ *
+ * The chosen method (4) prioritizes performance by sharing memory while ensuring buffer ownership.
+ *
+ * @param {Buffer} buffer - The Node.js Buffer to convert.
+ * @returns {Uint8Array} Resulting Uint8Array sharing the same memory as the Buffer and maintaining a reference to it.
+ */
+function toUint8Array(buffer: Buffer): Uint8Array {
+  const u8Array = new Uint8Array(
+    buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength,
+    ),
+  ) as Uint8ArrayWithReference
+  u8Array[OriginalBuffer] = buffer
+  return u8Array
+}
+
+/* eslint-disable func-style -- Typed to ensure uniformity between node and browser implementations and docs */
+export const bytesToHex: typeof BytesToHexFn = (bytes) => {
+  const buf = Buffer.from(bytes)
+  return buf.toString('hex').toUpperCase()
+}
+
+export const hexToBytes: typeof HexToBytesFn = (hex) => {
+  if (!HEX_REGEX.test(hex)) {
+    throw new Error('Invalid hex string')
+  }
+  return toUint8Array(Buffer.from(hex, 'hex'))
+}
+
+export const randomBytes: typeof RandomBytesFn = (size) => {
+  return toUint8Array(cryptoRandomBytes(size))
+}
+
+export const hexToString: typeof HexToStringFn = (
+  hex: string,
+  encoding = 'utf8',
+): string => {
+  if (!HEX_REGEX.test(hex)) {
+    throw new Error('Invalid hex string')
+  }
+  return new TextDecoder(encoding).decode(hexToBytes(hex))
+}
+
+export const stringToHex: typeof StringToHexFn = (string: string): string => {
+  return bytesToHex(new TextEncoder().encode(string))
+}
+/* eslint-enable func-style */
+
+export * from './shared'

packages/isomorphic/src/utils/shared.ts

@@ -0,0 +1,21 @@
+import { concatBytes } from '@noble/hashes/utils'
+
+export const HEX_REGEX = /^[A-F0-9]*$/iu
+
+export function concat(views: Uint8Array[]): Uint8Array {
+  return concatBytes(...views)
+}
+
+export function equal(buf1: Uint8Array, buf2: Uint8Array): boolean {
+  if (buf1.byteLength !== buf2.byteLength) {
+    return false
+  }
+  const dv1 = new Int8Array(buf1)
+  const dv2 = new Int8Array(buf2)
+  for (let i = 0; i !== buf1.byteLength; i++) {
+    if (dv1[i] !== dv2[i]) {
+      return false
+    }
+  }
+  return true
+}

packages/isomorphic/src/utils/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Convert a UInt8Array to hex. The returned hex will be in all caps.
+ *
+ * @param bytes - {Uint8Array} to convert to hex
+ */
+export declare function BytesToHexFn(bytes: Uint8Array | number[]): string
+
+/**
+ * Convert hex to a Uint8Array.
+ *
+ * @param hex - {string} to convert to a Uint8Array
+ */
+export declare function HexToBytesFn(hex: string): Uint8Array
+
+/**
+ * Create a Uint8Array of the supplied size.
+ *
+ * @param size - number of bytes to generate
+ */
+export declare function RandomBytesFn(size: number): Uint8Array
+
+/**
+ * Converts hex to its string equivalent. Useful to read the Domain field and some Memos.
+ *
+ * @param hex - The hex to convert to a string.
+ * @param encoding - The encoding to use. Defaults to 'utf8' (UTF-8). 'ascii' is also allowed.
+ * @returns The converted string.
+ */
+export declare function HexToStringFn(hex: string, encoding?: string): string
+
+/**
+ * Converts a utf-8 to its hex equivalent. Useful for Memos.
+ *
+ * @param string - The string to convert to Hex.
+ * @returns The Hex equivalent of the string.
+ */
+export declare function StringToHexFn(string: string): string

packages/isomorphic/src/ws/browser.ts

@@ -0,0 +1,105 @@
+/* eslint-disable max-classes-per-file -- Needs to be a wrapper for ws */
+import { EventEmitter } from 'eventemitter3'
+
+// Define the global WebSocket class found on the native browser
+declare class WebSocket {
+  public onclose?: (closeEvent: CloseEvent) => void
+  public onopen?: (openEvent: Event) => void
+  public onerror?: (error: Error) => void
+  public onmessage?: (message: MessageEvent) => void
+  public readyState: number
+  public constructor(url: string)
+  public close(code?: number, reason?: Uint8Array): void
+  public send(message: string): void
+}
+
+interface WSWrapperOptions {
+  perMessageDeflate: boolean
+  handshakeTimeout: number
+  protocolVersion: number
+  origin: string
+  maxPayload: number
+  followRedirects: boolean
+  maxRedirects: number
+}
+
+/**
+ * Provides `EventEmitter` interface for native browser `WebSocket`,
+ * same, as `ws` package provides.
+ */
+export default class WSWrapper extends EventEmitter {
+  public static CONNECTING = 0
+  public static OPEN = 1
+  public static CLOSING = 2
+
+  public static CLOSED = 3
+  private readonly ws: WebSocket
+
+  /**
+   * Constructs a browser-safe websocket.
+   *
+   * @param url - URL to connect to.
+   * @param _protocols - Not used.
+   * @param _websocketOptions - Not used.
+   */
+  public constructor(
+    url: string,
+    _protocols: string | string[] | WSWrapperOptions | undefined,
+    _websocketOptions: WSWrapperOptions,
+  ) {
+    super()
+
+    this.ws = new WebSocket(url)
+
+    this.ws.onclose = (closeEvent: CloseEvent): void => {
+      let reason: Uint8Array | undefined
+      if (closeEvent.reason) {
+        const enc = new TextEncoder()
+        reason = enc.encode(closeEvent.reason)
+      }
+      this.emit('close', closeEvent.code, reason)
+    }
+
+    this.ws.onopen = (): void => {
+      this.emit('open')
+    }
+
+    this.ws.onerror = (error): void => {
+      this.emit('error', error)
+    }
+
+    this.ws.onmessage = (message: MessageEvent): void => {
+      this.emit('message', message.data)
+    }
+  }
+
+  /**
+   * Get the ready state of the websocket.
+   *
+   * @returns The Websocket's ready state.
+   */
+  public get readyState(): number {
+    return this.ws.readyState
+  }
+
+  /**
+   * Closes the websocket.
+   *
+   * @param code - Close code.
+   * @param reason - Close reason.
+   */
+  public close(code?: number, reason?: Buffer): void {
+    if (this.readyState === 1) {
+      this.ws.close(code, reason)
+    }
+  }
+
+  /**
+   * Sends a message over the Websocket connection.
+   *
+   * @param message - Message to send.
+   */
+  public send(message: string): void {
+    this.ws.send(message)
+  }
+}

packages/isomorphic/src/ws/index.ts

@@ -0,0 +1,10 @@
+import WebSocket from 'ws'
+
+export default class Socket extends WebSocket {
+  constructor(...args) {
+    super(args[0], args[1], args[2])
+    this.setMaxListeners(Infinity)
+  }
+}
+
+export type ClientOptions = WebSocket.ClientOptions

packages/isomorphic/test/ripemd160.test.ts

@@ -0,0 +1,16 @@
+import { ripemd160 } from '@xrplf/isomorphic/ripemd160'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
+
+describe('ripemd160', () => {
+  it('hashes', () => {
+    const hashA = ripemd160('abc')
+    const hashB = ripemd160
+      .create()
+      .update(Uint8Array.from([97, 98, 99]))
+      .digest()
+    const expectedHash = `8EB208F7E05D987A9B044A8E98C6B087F15A0BFC`
+
+    expect(bytesToHex(hashA)).toEqual(expectedHash)
+    expect(bytesToHex(hashB)).toEqual(expectedHash)
+  })
+})

packages/isomorphic/test/sha256.test.ts

@@ -0,0 +1,17 @@
+import { sha256 } from '@xrplf/isomorphic/sha256'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
+
+describe('sha256', () => {
+  it('hashes', () => {
+    const hashA = sha256('abc')
+    const hashB = sha256
+      .create()
+      .update(Uint8Array.from([97, 98, 99]))
+      .digest()
+    const expectedHash =
+      'BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD'
+
+    expect(bytesToHex(hashA)).toEqual(expectedHash)
+    expect(bytesToHex(hashB)).toEqual(expectedHash)
+  })
+})

packages/isomorphic/test/sha512.test.ts

@@ -0,0 +1,17 @@
+import { sha512 } from '@xrplf/isomorphic/sha512'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
+
+describe('sha512', () => {
+  it('hashes', () => {
+    const hashA = sha512('abc')
+    const hashB = sha512
+      .create()
+      .update(Uint8Array.from([97, 98, 99]))
+      .digest()
+    const expectedHash =
+      'DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F'
+
+    expect(bytesToHex(hashA)).toEqual(expectedHash)
+    expect(bytesToHex(hashB)).toEqual(expectedHash)
+  })
+})

packages/isomorphic/test/utils.test.ts

@@ -0,0 +1,61 @@
+import {
+  bytesToHex,
+  hexToBytes,
+  hexToString,
+  randomBytes,
+  stringToHex,
+} from '../utils'
+
+describe('utils', function () {
+  it('randomBytes', () => {
+    expect(randomBytes(16).byteLength).toEqual(16)
+  })
+
+  it('hexToBytes - empty', () => {
+    expect(hexToBytes('')).toEqual(new Uint8Array([]))
+  })
+
+  it('hexToBytes - zero', () => {
+    expect(hexToBytes('000000')).toEqual(new Uint8Array([0, 0, 0]))
+  })
+
+  it('hexToBytes - DEADBEEF', () => {
+    expect(hexToBytes('DEADBEEF')).toEqual(new Uint8Array([222, 173, 190, 239]))
+  })
+
+  it('hexToBytes - DEADBEEF', () => {
+    expect(hexToBytes('DEADBEEF')).toEqual(new Uint8Array([222, 173, 190, 239]))
+  })
+
+  it('bytesToHex - DEADBEEF', () => {
+    expect(bytesToHex([222, 173, 190, 239])).toEqual('DEADBEEF')
+  })
+
+  it('bytesToHex - bad hex', () => {
+    expect(() => hexToBytes('hello')).toThrow(new Error('Invalid hex string'))
+  })
+
+  it('bytesToHex - 010203', () => {
+    expect(bytesToHex([1, 2, 3])).toEqual('010203')
+  })
+
+  it('bytesToHex - DEADBEEF (Uint8Array)', () => {
+    expect(bytesToHex(new Uint8Array([222, 173, 190, 239]))).toEqual('DEADBEEF')
+  })
+
+  it('hexToString - deadbeef+infinity symbol (HEX ASCII)', () => {
+    expect(hexToString('646561646265656658D', 'ascii')).toEqual('deadbeefX')
+  })
+
+  it('hexToString - deadbeef+infinity symbol (HEX)', () => {
+    expect(hexToString('6465616462656566D68D')).toEqual('deadbeef֍')
+  })
+
+  it('hexToString - bad hex', () => {
+    expect(() => hexToString('hello')).toThrow(new Error('Invalid hex string'))
+  })
+
+  it('stringToHex - deadbeef+infinity symbol (utf8)', () => {
+    expect(stringToHex('deadbeef֍')).toEqual('6465616462656566D68D')
+  })
+})

packages/isomorphic/test/webpack.config.js

@@ -0,0 +1,9 @@
+'use strict'
+const { merge } = require('webpack-merge')
+const { webpackForTest } = require('../../../weback.test.config')
+const { getDefaultConfiguration } = require('../../../webpack.config')
+
+module.exports = merge(
+  getDefaultConfiguration(),
+  webpackForTest('./test/index.ts', __dirname),
+)

packages/isomorphic/tsconfig.build.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+  },
+  "include": ["./src/**/*.ts", "./src/**/*.json"],
+}

packages/isomorphic/tsconfig.eslint.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}

packages/isomorphic/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "target": "es6",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "noImplicitAny": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true,
+    "strictNullChecks": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"]
+}

packages/isomorphic/utils/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@xrplf/isomorphic/utils",
+  "private": true,
+  "main": "../dist/utils",
+  "types": "../dist/utils",
+  "browser": "../dist/utils/browser.js"
+}

packages/isomorphic/ws/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@xrplf/isomorphic/ws",
+  "private": true,
+  "main": "../dist/ws",
+  "types": "../dist/ws",
+  "browser": "../dist/ws/browser.js",
+  "dependencies": {
+    "ws": "^8.13.0",
+    "eventemitter3": "^5.0.1"
+  }
+}

packages/secret-numbers/.eslintignore

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

packages/secret-numbers/.eslintrc.js

@@ -0,0 +1,47 @@
+module.exports = {
+  root: true,
+
+  parser: "@typescript-eslint/parser", // Make ESLint compatible with TypeScript
+  parserOptions: {
+    // Enable linting rules with type information from our tsconfig
+    tsconfigRootDir: __dirname,
+    project: ["./tsconfig.eslint.json"],
+
+    sourceType: "module", // Allow the use of imports / ES modules
+
+    ecmaFeatures: {
+      impliedStrict: true, // Enable global strict mode
+    },
+  },
+
+  // Specify global variables that are predefined
+  env: {
+    browser: true, // Enable browser global variables
+    node: true, // Enable node global variables & Node.js scoping
+    es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020
+  },
+
+  plugins: [],
+  extends: ["@xrplf/eslint-config/base"],
+
+  rules: {
+    // This creates a lot of false positives. We should turn this off in our
+    // general config.
+    "jsdoc/require-description-complete-sentence": "off",
+
+    // ** TODO **
+    // all of the below are turned off for now during the migration to a
+    // monorepo. They need to actually be addressed!
+    // **
+    "@typescript-eslint/no-magic-numbers": "off",
+    "jsdoc/require-returns": "off",
+    "jsdoc/check-param-names": "off",
+    "jsdoc/require-throws": "off",
+    "jsdoc/require-jsdoc": "off",
+    "jsdoc/require-param": "off",
+    "jsdoc/check-examples": "off", // Not implemented in eslint 8
+    "tsdoc/syntax": "off",
+    "@typescript-eslint/no-require-imports": "off",
+    "@typescript-eslint/explicit-member-accessibility": "off",
+  },
+};

packages/secret-numbers/HISTORY.md

@@ -0,0 +1,21 @@
+# @xrplf/secret-numbers (xrpl-secret-numbers) Release History
+
+Subscribe to [the **xrpl-announce** mailing list](https://groups.google.com/g/xrpl-announce) for release announcements. We recommend that `@xrplf/secret-numbers` users stay up-to-date with the latest stable release.
+
+## Unreleased
+
+## 1.0.0 (2024-02-01)
+
+### BREAKING CHANGES:
+* `xrpl-secret-numbers` is now `@xrplf/secret-numbers`.
+* The bundled file produced changed from  `dist/browerified.js` to `build/xrplf-secret-numbers-latest.js`.
+* Bundle variable is `xrplf_secret_numbers` instead of using browserify's loader.
+* * Moved all methods that were on `Utils` are now individually exported.
+* `Buffer` has been replaced with `UInt8Array` for both params and return values. `Buffer` may continue to work with params since they extend `UInt8Arrays`.
+
+### Non-Breaking Changes
+* Add `xrpl-secret-numbers` by @WietseWind  to the mono repo.
+* `unpkg` and `jsdelivr` support was simplified.
+* Unit tests run in a browser and node.
+* Remove `brorand` as a dependency and use `@xrplf/isomorphic` instead.
+* Eliminates 4 runtime dependencies: `base-x`, `base64-js`, `buffer`, and `ieee754`.

packages/secret-numbers/LICENSE

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

packages/secret-numbers/README.md

@@ -0,0 +1,97 @@
+# XRPL Secret Numbers [![npm version](https://badge.fury.io/js/@xrplf%2Fsecret-numbers.svg)](https://www.npmjs.com/@xrplf/secret-numbers)
+
+For more background information, please read the [proposed Standard](https://github.com/xrp-community/standards-drafts/issues/15).
+
+A tool to convert Secret Numbers to the widely used Family Seed `s...` format is [available here](https://github.com/WietseWind/secret-numbers-to-family-seed/releases)
+
+A bundled version of this lib is available at NPM (`build/xrplf-secret-numbers-latest.js`), CDN: https://cdn.jsdelivr.net/npm/@xrplf/secret-numbers. You can access the library as `xrplf_secret_numbers`. Sample:
+https://jsfiddle.net/WietseWind/uo1zy0q7/
+
+#### Generate XRPL Accounts with a number-based secret: 8 chunks of 6 digits.
+
+The common formats for XRPL account secrets are (at the time of writing this, July 2019):
+
+- Family Seed, eg. `sh1HiK7SwjS1VxFdXi7qeMHRedrYX`
+- Mnemonic, eg. `car banana apple road ...`
+
+These formats are prone to typo's and not that user friendly. Using numbers means it's language (spoken, written) agnostic as well. They may be especially intimidating for the public that's relatively new to cryptocurrencies / blockchain technology.
+
+This library encodes the entropy to generate accounts into 8 chunks of 6 digits, of which 5 digits are 1/8th of the entropy, and a 6th digit contains a checksum allowing realtime typo detection.
+
+##### A secret now looks like:
+
+```
+554872 394230 209376 323698
+140250 387423 652803 258676
+```
+
+For compatibility with existing clients, this library supports exporting the family seed for a generated / entered "Secret Number"-set as well.
+
+## API
+
+The typescript code to use resides in `./src/` and the compiled js in `./dist/` of the package. See the `./samples/` folder for some simple JS samples.
+
+##### Generating a new account:
+
+```
+const {Account} = require('@xrplf/secret-numbers')
+const account = new Account()
+```
+
+##### Importing an existing account:
+
+```
+const {Account} = require('@xrplf/secret-numbers')
+const secret = '399150 474506 009147 088773 432160 282843 253738 605430'
+const account = new Account(secret)
+```
+
+Or importing with custom entropy (buffer, 16):
+
+```
+const {Account} = require('@xrplf/secret-numbers')
+const entropy = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex')
+const account = new Account(entropy)
+```
+
+##### After generating / importing:
+
+You can fetch the account details (address, secret, etc.) using these methods:
+
+```
+console.log(account.getAddress())
+console.log(account.getSecret())
+```
+
+##### Available methods:
+
+- `getSecret()`: Array<string>[8]
+- `getSecretString()`: string `012345 456789 ...`
+- `getAddress()`: string `rXXXXXXXX...`
+- `getFamilySeed()`: string `sXXXXXXXX...`
+- `getKeypair()`: `Keypair({privateKey, publicKey}`
+
+##### To split/check/encode/decode some more:
+
+There's a `Utils` export as well:
+
+```
+const {Account, Utils} = require('@xrplf/secret-numbers')
+```
+
+Some Utils methods (that you may want to use in your UI / ... before using the Account constructor):
+
+ - To calculate the 6th decimal for a group of 5 digits:  
+   `calculateChecksum(position: number, value: number)`: number
+ - To check a checksum (either sliced or the 6th char of a string containing numbers:  
+   `checkChecksum(position: number, value: number | string, checksum?: number)`: Boolean
+
+## Development
+
+Run `npm run prepublish` to clean, lint, test and build. Or just run `npm run build`, `npm run test` or `npm run lint`. 
+
+Tests are in `./test/`
+
+## Credits
+
+This concept is based on an idea by [@nbougalis](https://github.com/nbougalis).

packages/secret-numbers/jest.config.js

@@ -0,0 +1,8 @@
+// Jest configuration for api
+const base = require("../../jest.config.base.js");
+
+module.exports = {
+  ...base,
+  roots: [...base.roots, "<rootDir>/test"],
+  displayName: "@xrplf/secret-numbers",
+};

packages/secret-numbers/karma.config.js

@@ -0,0 +1,14 @@
+const webpackConfig = require("./test/webpack.config");
+const baseKarmaConfig = require("../../karma.config");
+delete webpackConfig.entry;
+
+module.exports = function (config) {
+  config.set({
+    webpack: webpackConfig,
+
+    // list of files / patterns to load in the browser
+    files: ["build/xrplf-secret-numbers-latest.js", "test/*.test.ts"],
+  });
+
+  baseKarmaConfig(config);
+};

packages/secret-numbers/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@xrplf/secret-numbers",
+  "version": "1.0.0",
+  "description": "Generate XAHL Accounts with a number-based secret: 8 chunks of 6 digits",
+  "main": "dist/index.js",
+  "unpkg": "build/xrplf-secret-numbers-latest-min.js",
+  "jsdelivr": "build/xrplf-secret-numbers-latest-min.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "npm run clean && npm run lint && npm run test && npm run test:browser && npm run build",
+    "clean": "rm -rf ./dist ./coverage ./test/testCompiledForWeb tsconfig.build.tsbuildinfo",
+    "test": "jest --verbose",
+    "test:browser": "npm run build && npm run build:browserTests && karma start ./karma.config.js",
+    "build": "run-s build:lib build:web",
+    "build:lib": "tsc --build tsconfig.build.json",
+    "build:web": "webpack",
+    "build:browserTests": "webpack --config ./test/webpack.config.js",
+    "lint": "eslint . --ext .ts --ext .test.ts --fix",
+    "analyze": "webpack --analyze"
+  },
+  "files": [
+    "build/*",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "src/*"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@xrplf/isomorphic": "^1.0.0",
+    "xahau-keypairs": "^2.0.0"
+  },
+  "prettier": "@xrplf/prettier-config",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Xahau/xahau.js.git"
+  },
+  "license": "ISC",
+  "readmeFilename": "README.md",
+  "keywords": [
+    "xah",
+    "xahau-ledger",
+    "multi sign",
+    "sign"
+  ]
+}

packages/secret-numbers/samples/es5.js

@@ -0,0 +1,26 @@
+const {Account} = require('../dist/')
+
+console.log(`😎 Generate an account`)
+const generatedAccount = new Account()
+console.log(`\n  Generated account address\n    `, generatedAccount.getAddress())
+console.log(`\n  Generated numbers (secret)\n    `, generatedAccount.getSecretString())
+
+console.log(`\n\n`)
+
+const account = [
+  '399150', '474506', '009147', '088773', '432160', '282843', '253738', '605430'
+]
+console.log(`😎 Import account "${account.join(' ')}"`)
+const importedAccount = new Account(account)
+console.log(`\n  Imported account address\n    `, importedAccount.getAddress())
+console.log(`\n  Imported account family seed\n    `, importedAccount.getFamilySeed())
+
+console.log(`\n\n`)
+
+const entropy = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex')
+console.log(`😎 Import account from entropy buffer "${entropy.toString('hex')}"`)
+const entropyAccount = new Account(entropy)
+console.log(`\n  Imported account address\n    `, entropyAccount.getAddress())
+console.log(`\n  Imported account family seed\n    `, entropyAccount.getFamilySeed())
+
+console.log(`\n\n`)

packages/secret-numbers/src/index.ts

@@ -0,0 +1,2 @@
+export * from './schema/Account'
+export * from './utils'

packages/secret-numbers/src/schema/Account.ts

@@ -0,0 +1,101 @@
+import { deriveAddress, deriveKeypair, generateSeed } from 'xahau-keypairs'
+
+import {
+  entropyToSecret,
+  parseSecretString,
+  randomSecret,
+  secretToEntropy,
+} from '../utils'
+
+/* Types ==================================================================== */
+
+export interface Keypair {
+  publicKey: string
+  privateKey: string
+}
+
+interface AccountData {
+  familySeed: string
+  address: string
+  keypair: Keypair
+}
+
+/* Class ==================================================================== */
+
+export class Account {
+  private readonly _secret: string[]
+  private readonly _account: AccountData = {
+    familySeed: '',
+    address: '',
+    keypair: {
+      publicKey: '',
+      privateKey: '',
+    },
+  }
+
+  constructor(secretNumbers?: string[] | string | Uint8Array) {
+    if (typeof secretNumbers === 'string') {
+      this._secret = parseSecretString(secretNumbers)
+    } else if (Array.isArray(secretNumbers)) {
+      this._secret = secretNumbers
+    } else if (secretNumbers instanceof Uint8Array) {
+      this._secret = entropyToSecret(secretNumbers)
+    } else {
+      this._secret = randomSecret()
+    }
+
+    validateLengths(this._secret)
+    this.derive()
+  }
+
+  getSecret(): string[] {
+    return this._secret
+  }
+
+  getSecretString(): string {
+    return this._secret.join(' ')
+  }
+
+  getAddress(): string {
+    return this._account.address
+  }
+
+  getFamilySeed(): string {
+    return this._account.familySeed
+  }
+
+  getKeypair(): Keypair {
+    return this._account.keypair
+  }
+
+  toString(): string {
+    return this.getSecretString()
+  }
+
+  private derive(): void {
+    try {
+      const entropy = secretToEntropy(this._secret)
+      this._account.familySeed = generateSeed({ entropy })
+      this._account.keypair = deriveKeypair(this._account.familySeed)
+      this._account.address = deriveAddress(this._account.keypair.publicKey)
+    } catch (error) {
+      let message = 'Unknown Error'
+      if (error instanceof Error) {
+        message = error.message
+      }
+      // we'll proceed, but let's report it
+      throw new Error(message)
+    }
+  }
+}
+
+function validateLengths(secretNumbers: string[]): void {
+  if (secretNumbers.length !== 8) {
+    throw new Error('Secret must have 8 numbers')
+  }
+  secretNumbers.forEach((num) => {
+    if (num.length !== 6) {
+      throw new Error('Each secret number must be 6 digits')
+    }
+  })
+}

packages/secret-numbers/src/utils/index.ts

@@ -0,0 +1,95 @@
+import {
+  bytesToHex,
+  concat,
+  hexToBytes,
+  randomBytes,
+} from '@xrplf/isomorphic/utils'
+
+function randomEntropy(): Uint8Array {
+  return randomBytes(16)
+}
+
+function calculateChecksum(position: number, value: number): number {
+  return (value * (position * 2 + 1)) % 9
+}
+
+function checkChecksum(
+  position: number,
+  value: number | string,
+  checksum?: number,
+): boolean {
+  let normalizedChecksum: number
+  let normalizedValue: number
+
+  if (typeof value === 'string') {
+    if (value.length !== 6) {
+      throw new Error('value must have a length of 6')
+    }
+    normalizedChecksum = parseInt(value.slice(5), 10)
+    normalizedValue = parseInt(value.slice(0, 5), 10)
+  } else {
+    if (typeof checksum !== 'number') {
+      throw new Error('checksum must be a number when value is a number')
+    }
+    normalizedChecksum = checksum
+    normalizedValue = value
+  }
+  return (normalizedValue * (position * 2 + 1)) % 9 === normalizedChecksum
+}
+
+function entropyToSecret(entropy: Uint8Array): string[] {
+  const len = new Array(Math.ceil(entropy.length / 2))
+  const chunks = Array.from(len, (_a, chunk) => {
+    const buffChunk = entropy.slice(chunk * 2, (chunk + 1) * 2)
+    const no = parseInt(bytesToHex(buffChunk), 16)
+    const fill = '0'.repeat(5 - String(no).length)
+    return fill + String(no) + String(calculateChecksum(chunk, no))
+  })
+  if (chunks.length !== 8) {
+    throw new Error('Chucks must have 8 digits')
+  }
+  return chunks
+}
+
+function randomSecret(): string[] {
+  return entropyToSecret(randomEntropy())
+}
+
+function secretToEntropy(secret: string[]): Uint8Array {
+  return concat(
+    secret.map((chunk, i) => {
+      const no = Number(chunk.slice(0, 5))
+      const checksum = Number(chunk.slice(5))
+      if (chunk.length !== 6) {
+        throw new Error('Invalid secret: number invalid')
+      }
+      if (!checkChecksum(i, no, checksum)) {
+        throw new Error('Invalid secret part: checksum invalid')
+      }
+      const hex = `0000${no.toString(16)}`.slice(-4)
+      return hexToBytes(hex)
+    }),
+  )
+}
+
+function parseSecretString(secret: string): string[] {
+  const normalizedSecret = secret.replace(/[^0-9]/gu, '')
+  if (normalizedSecret.length !== 48) {
+    throw new Error(
+      'Invalid secret string (should contain 8 blocks of 6 digits',
+    )
+  }
+  return Array.from(new Array(8), (_a, index) => {
+    return normalizedSecret.slice(index * 6, (index + 1) * 6)
+  })
+}
+
+export {
+  randomEntropy,
+  randomSecret,
+  entropyToSecret,
+  secretToEntropy,
+  calculateChecksum,
+  checkChecksum,
+  parseSecretString,
+}

packages/secret-numbers/test/api.test.ts

@@ -0,0 +1,96 @@
+import { hexToBytes } from '@xrplf/isomorphic/utils'
+import { deriveAddress, deriveKeypair, generateSeed } from 'xahau-keypairs'
+
+import { Account, secretToEntropy } from '../src'
+
+describe('API: XAHL Secret Numbers', () => {
+  describe('Generate new account', () => {
+    const account = new Account()
+    it('Output sanity checks', () => {
+      expect(account.getAddress()).toMatch(/^r[a-zA-Z0-9]{19,}$/u)
+      const entropy = secretToEntropy(`${account.toString()}`.split(' '))
+      const familySeed = generateSeed({ entropy })
+      const keypair = deriveKeypair(familySeed)
+      const address = deriveAddress(keypair.publicKey)
+      expect(address).toEqual(account.getAddress())
+      expect(familySeed).toEqual(account.getFamilySeed())
+    })
+  })
+
+  describe('Account based on entropy', () => {
+    const entropy = hexToBytes('0123456789ABCDEF0123456789ABCDEF')
+    const account = new Account(entropy)
+
+    it('familySeed as expected', () => {
+      expect(account.getFamilySeed()).toEqual('sp5DmDCut79BpgumfHhvRzdxXYQyU')
+    })
+    it('address as expected', () => {
+      expect(account.getAddress()).toEqual('rMCcybKHfwCSkDHd3M36PAeUniEoygwjR3')
+    })
+    it('Account object to string as expected', () => {
+      const accountAsStr =
+        '002913 177673 352434 527196 002910 177672 352435 527190'
+      expect(`${account.toString()}`).toEqual(accountAsStr)
+    })
+  })
+
+  describe('Account based on existing secret', () => {
+    const secret = [
+      '084677',
+      '005323',
+      '580272',
+      '282388',
+      '626800',
+      '105300',
+      '560913',
+      '071783',
+    ]
+
+    const account = new Account(secret)
+
+    it('familySeed as expected', () => {
+      expect(account.getFamilySeed()).toEqual('sswpWwri7Y11dNCSmXdphgcoPZk3y')
+    })
+    it('publicKey as expected', () => {
+      const pubkey =
+        '020526A0EDC9123F7FBB7588402518B80FCD2C8D8AB4C45F5A68A2F220098EA06F'
+      expect(account.getKeypair().publicKey).toEqual(pubkey)
+    })
+    it('privateKey as expected', () => {
+      const privkey =
+        '005122B2127B4635FEE7D242FA6EC9B02B611C04494D0D7D49764374D90C8BC8D3'
+      expect(account.getKeypair().privateKey).toEqual(privkey)
+    })
+    it('address as expected', () => {
+      expect(account.getAddress()).toEqual('rfqJsRLLmr7wdWnEzW1mP6AVaPSdzmso9Z')
+    })
+    it('Account object to string as expected', () => {
+      const accountAsStr =
+        '084677 005323 580272 282388 626800 105300 560913 071783'
+      expect(`${account.toString()}`).toEqual(accountAsStr)
+    })
+  })
+
+  describe('Checksum error', () => {
+    const secret = [
+      '084677',
+      '005324',
+      '580272',
+      '626800',
+      '282388',
+      '105300',
+      '560913',
+      '071783',
+    ]
+    it('Should throw an Checksum Error', () => {
+      expect(() => {
+        // eslint-disable-next-line no-new -- Don't want unused variable
+        new Account(secret)
+      })
+        // TODO: Remove if jest is removed.
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- Jest and Jasmine have two different signatures.
+        // @ts-expect-error
+        .toThrowError(Error, 'Invalid secret part: checksum invalid')
+    })
+  })
+})

packages/secret-numbers/test/index.ts

@@ -0,0 +1 @@
+/* eslint-disable import/unambiguous -- silence is golden */

packages/secret-numbers/test/utils.test.ts

@@ -0,0 +1,115 @@
+import { bytesToHex, hexToBytes } from '@xrplf/isomorphic/utils'
+
+import {
+  calculateChecksum,
+  checkChecksum,
+  entropyToSecret,
+  parseSecretString,
+  randomEntropy,
+  randomSecret,
+  secretToEntropy,
+} from '../src/utils'
+
+describe('Utils', () => {
+  it('randomEntropy: valid output', () => {
+    const data = randomEntropy()
+    expect(typeof data).toEqual('object')
+    expect(data instanceof Uint8Array).toBeTruthy()
+    expect(data.length).toEqual(16)
+    expect(bytesToHex(data).length).toEqual(32)
+    expect(bytesToHex(data)).toMatch(/^[A-F0-9]+$/u)
+  })
+
+  it('calculateChecksum: 1st position', () => {
+    expect(calculateChecksum(0, 55988)).toEqual(8)
+  })
+
+  it('calculateChecksum: 8th position', () => {
+    expect(calculateChecksum(7, 49962)).toEqual(0)
+  })
+
+  it('checkChecksum: 2nd position, split numbers', () => {
+    expect(checkChecksum(1, 55450, 3)).toBeTruthy()
+  })
+
+  it('checkChecksum: 7th position, split numbers', () => {
+    expect(checkChecksum(6, 18373, 7)).toBeTruthy()
+  })
+
+  it('checkChecksum: 4th position, as string', () => {
+    expect(checkChecksum(3, '391566')).toBeTruthy()
+  })
+
+  it('randomSecret: valid checksums', () => {
+    randomSecret()
+    expect(0).toEqual(0)
+  })
+
+  it('randomSecret: valid output', () => {
+    const data = randomSecret()
+    expect(Array.isArray(data)).toBeTruthy()
+    expect(data.length).toEqual(8)
+    expect(typeof data[0]).toEqual('string')
+    expect(data[0].length).toEqual(6)
+    expect(data[7].length).toEqual(6)
+  })
+
+  it('entropyToSecret', () => {
+    const entropy = hexToBytes('76ebb2d06879b45b7568fb9c1ded097c')
+    const secret = [
+      '304435',
+      '457766',
+      '267453',
+      '461717',
+      '300560',
+      '644127',
+      '076618',
+      '024286',
+    ]
+    expect(entropyToSecret(entropy)).toEqual(secret)
+  })
+
+  it('secretToEntropy', () => {
+    const secret = [
+      '304435',
+      '457766',
+      '267453',
+      '461717',
+      '300560',
+      '644127',
+      '076618',
+      '024286',
+    ]
+    const entropy = hexToBytes('76ebb2d06879b45b7568fb9c1ded097c')
+    expect(secretToEntropy(secret)).toEqual(entropy)
+  })
+
+  it('parseSecretString with spaces valid', () => {
+    const secret = [
+      '304435',
+      '457766',
+      '267453',
+      '461717',
+      '300560',
+      '644127',
+      '076618',
+      '024286',
+    ]
+    expect(
+      parseSecretString(
+        '304435 457766 267453 461717 300560 644127 076618 024286',
+      ),
+    ).toEqual(secret)
+    expect(
+      parseSecretString('304435457766267453461717300560644127076618024286'),
+    ).toEqual(secret)
+    expect(
+      parseSecretString(`
+      304435 457766
+      267453 461717
+      300560 644127
+      076618 024286
+    `),
+    ).toEqual(secret)
+  })
+})

packages/secret-numbers/test/webpack.config.js

@@ -0,0 +1,9 @@
+"use strict";
+const { merge } = require("webpack-merge");
+const { webpackForTest } = require("../../../weback.test.config");
+const baseConfig = require("../webpack.base.config");
+
+module.exports = merge(
+  baseConfig,
+  webpackForTest("./test/index.ts", __dirname)
+);

packages/secret-numbers/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+  },
+  "include": ["./src/**/*.ts", "./src/**/*.json"],
+  "references": [
+    {
+      "path": "../xahau-keypairs/tsconfig.json"
+    }
+  ]
+}

packages/secret-numbers/tsconfig.eslint.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}

packages/secret-numbers/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "pretty": true,
+    "target": "es6",
+    "lib": ["es2019", "dom"],
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "strictNullChecks": true,
+    "noImplicitAny": false,
+    "noUnusedLocals": true,
+    "removeComments": true,
+    "preserveConstEnums": false,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "preserveSymlinks": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.json"]
+}

packages/secret-numbers/webpack.base.config.js

@@ -0,0 +1,14 @@
+"use strict";
+const { merge } = require("webpack-merge");
+const { getDefaultConfiguration, wrapForEnv } = require("../../webpack.config");
+const path = require("path");
+
+module.exports = merge(getDefaultConfiguration(), {
+  entry: "./dist/index.js",
+  // overriding the output path and filename
+  output: {
+    library: "xrplf_secret_numbers",
+    filename: `xrplf-secret-numbers.default.js`,
+    path: path.join(__dirname, "build/"),
+  },
+});

packages/secret-numbers/webpack.config.js

@@ -0,0 +1,8 @@
+const path = require("path");
+const { getDefaultConfiguration, wrapForEnv } = require("../../webpack.config");
+const { merge } = require("webpack-merge");
+
+module.exports = wrapForEnv(
+  "xrplf-secret-numbers",
+  merge(getDefaultConfiguration(), require("./webpack.base.config"))
+);

packages/xahau-address-codec/.eslintignore

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

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

@@ -0,0 +1,46 @@
+module.exports = {
+  root: true,
+
+  parser: '@typescript-eslint/parser', // Make ESLint compatible with TypeScript
+  parserOptions: {
+    // Enable linting rules with type information from our tsconfig
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig.eslint.json'],
+
+    sourceType: 'module', // Allow the use of imports / ES modules
+
+    ecmaFeatures: {
+      impliedStrict: true, // Enable global strict mode
+    },
+  },
+
+  // Specify global variables that are predefined
+  env: {
+    browser: true, // Enable browser global variables
+    node: true, // Enable node global variables & Node.js scoping
+    es2020: true, // Add all ECMAScript 2020 globals and automatically set the ecmaVersion parser option to ES2020
+  },
+
+  plugins: [],
+  extends: ['@xrplf/eslint-config/base'],
+
+  rules: {
+    // This creates a lot of false positives. We should turn this off in our
+    // general config.
+    'jsdoc/require-description-complete-sentence': 'off',
+
+    // ** TODO **
+    // all of the below are turned off for now during the migration to a
+    // monorepo. They need to actually be addressed!
+    // **
+    '@typescript-eslint/no-magic-numbers': 'off',
+    'jsdoc/require-returns': 'off',
+    'jsdoc/check-param-names': 'off',
+    'jsdoc/require-throws': 'off',
+    'jsdoc/require-jsdoc': 'off',
+    'jsdoc/require-param': 'off',
+    'jsdoc/check-examples': 'off', // Not implemented in eslint 8
+    'tsdoc/syntax': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+  },
+}

packages/xahau-address-codec/HISTORY.md

@@ -0,0 +1,104 @@
+# ripple-address-codec
+
+## Unreleased
+
+## 5.0.0 (2024-02-01)
+
+### BREAKING CHANGES
+* Bump typescript to 5.x
+* Remove Node 14 support
+* Remove `assert` dependency. If you were catching `AssertionError` you need to change to `Error`.
+* Remove `create-hash` in favor of `@noble/hashes`
+* `Buffer` has been replaced with `UInt8Array` for both params and return values. `Buffer` may continue to work with params since they extend `UInt8Arrays`.
+
+### Non-Breaking Changes
+* Eliminates 4 runtime dependencies: `base-x`, `base64-js`, `buffer`, and `ieee754`.
+* Execute test in a browser in addition to node
+
+## 4.3.1 (2023-09-27)
+### Fixed
+* Fix source-maps not finding their designated source
+
+## 4.3.0 (2023-06-13)
+### Added
+* Adds support for npm v9
+
+## 4.2.5 (2023-03-08)
+### Changed
+- All tests now use the Jest test runner and have been refactored for consistency across all packages
+
+## 4.2.4 (2022-04-21)
+### Fixed
+- Fixed `encodeXAddress` to handle `null` equivalently to `false`.
+
+## 4.2.1 (2021-12-1)
+- Fix issue where npm < 7 could not install the library
+- Initial pass at linting this codebase with new rules
+
+## 4.2.0 (2021-11-15)
+- Converts ripple-address-codec into a monorepo with ripple-binary-codec,
+  ripple-keypairs, and xrpl. Changes to build tooling but no new features or
+  bug fixes
+
+## 4.1.3 (2021-05-10)
+
+* Update dependencies
+* Add `build` script as an alias for `compile`
+* Update README
+
+## 4.1.2 (2021-01-11)
+
+* Internal dependencies
+  * Update jest, ts-jest, typescript, lodash
+    * Fix potential moderate severity vulnerabilities
+  * Update @types/node, @types/jest, base-x
+* Docs
+  * Update example for encoding test address
+  * Document functions (#73)
+  * xAddressToClassicAddress when there is no tag (#114)
+  * Add README badges (#120)
+  * Add LICENSE (#138)
+* Cleanup and polish
+  * Add GitHub CI (#115)
+  * Fix linting
+
+## 4.1.1 (2020-04-03)
+
+* Require node v10+
+* CI: Drop node 6 & 8 and add node 13
+* Update dependencies
+  * Bump @types/node to 13.7.7 (#60)
+  * Bump jest and ts-jest (#40)
+  * Bump @types/jest to 25.1.2 (#51)
+  * Bump ts-jest from 25.0.0 to 25.2.0 (#50)
+  * Bump typescript from 3.7.5 to 3.8.3 (#61)
+  * Update all dependencies in yarn.lock
+
+## 4.1.0 (2020-01-22)
+
+* Throwable 'unexpected_payload_length' error: The message has been expanded with ' Ensure that the bytes are a Buffer.'
+* Docs (readme): Correct X-address to classic address example (#15) (thanks @RareData)
+
+### New Features
+
+* `encodeAccountPublic` - Encode a public key, as for payment channels
+* `decodeAccountPublic` - Decode a public key, as for payment channels
+
+* Internal
+  * Update dependencies: ts-jest, @types/jest, @types/node, typescript, tslint,
+    base-x
+
+## 4.0.0 (2019-10-08)
+
+### Breaking Changes
+
+* `decodeAddress` has been renamed to `decodeAccountID`
+* `isValidAddress` has been renamed to `isValidClassicAddress`
+
+### New Features
+
+* `classicAddressToXAddress` - Derive X-address from classic address, tag, and network ID
+* `encodeXAddress` - Encode account ID, tag, and network ID as an X-address
+* `xAddressToClassicAddress` - Decode an X-address to account ID, tag, and network ID
+* `decodeXAddress` - Convert X-address to classic address, tag, and network ID
+* `isValidXAddress` - Check whether an X-address (X...) is valid

packages/xahau-address-codec/LICENSE

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

packages/xahau-address-codec/README.md

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

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

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

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

@@ -0,0 +1,8 @@
+// Jest configuration for api
+const base = require('../../jest.config.base.js')
+
+module.exports = {
+  ...base,
+  roots: [...base.roots, '<rootDir>/test'],
+  displayName: 'xahau-address-codec',
+}