Set version to 3.0.0-b1 (#5859)

Fixes a (currently harmless) bug introduced by PR #5594

.codecov.yml

@@ -33,5 +33,6 @@ slack_app: false
 
 ignore:
   - "src/test/"
+  - "src/tests/"
   - "include/xrpl/beast/test/"
   - "include/xrpl/beast/unit_test/"

.github/actions/build-deps/action.yml

@@ -20,14 +20,18 @@ runs:
   steps:
     - name: Install Conan dependencies
       shell: bash
+      env:
+        BUILD_DIR: ${{ inputs.build_dir }}
+        BUILD_OPTION: ${{ inputs.force_build == 'true' && '*' || 'missing' }}
+        BUILD_TYPE: ${{ inputs.build_type }}
       run: |
         echo 'Installing dependencies.'
-        mkdir -p ${{ inputs.build_dir }}
-        cd ${{ inputs.build_dir }}
+        mkdir -p '${{ env.BUILD_DIR }}'
+        cd '${{ env.BUILD_DIR }}'
         conan install \
           --output-folder . \
-          --build ${{ inputs.force_build == 'true' && '"*"' || 'missing' }} \
-          --options:host '&:tests=True' \
-          --options:host '&:xrpld=True' \
-          --settings:all build_type=${{ inputs.build_type }} \
+          --build=${{ env.BUILD_OPTION }} \
+          --options:host='&:tests=True' \
+          --options:host='&:xrpld=True' \
+          --settings:all build_type='${{ env.BUILD_TYPE }}' \
           ..

.github/actions/build-test/action.yml

@@ -1,96 +0,0 @@
-# This action build and tests the binary. The Conan dependencies must have
-# already been installed (see the build-deps action).
-name: Build and Test
-description: "Build and test the binary."
-
-# Note that actions do not support 'type' and all inputs are strings, see
-# https://docs.github.com/en/actions/reference/workflows-and-actions/metadata-syntax#inputs.
-inputs:
-  build_dir:
-    description: "The directory where to build."
-    required: true
-  build_only:
-    description: 'Whether to only build or to build and test the code ("true", "false").'
-    required: false
-    default: "false"
-  build_type:
-    description: 'The build type to use ("Debug", "Release").'
-    required: true
-  cmake_args:
-    description: "Additional arguments to pass to CMake."
-    required: false
-    default: ""
-  cmake_target:
-    description: "The CMake target to build."
-    required: true
-  codecov_token:
-    description: "The Codecov token to use for uploading coverage reports."
-    required: false
-    default: ""
-  os:
-    description: 'The operating system to use for the build ("linux", "macos", "windows").'
-    required: true
-
-runs:
-  using: composite
-  steps:
-    - name: Configure CMake
-      shell: bash
-      working-directory: ${{ inputs.build_dir }}
-      run: |
-        echo 'Configuring CMake.'
-        cmake \
-          -G '${{ inputs.os == 'windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
-          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-          -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} \
-          ${{ inputs.cmake_args }} \
-          ..
-    - name: Build the binary
-      shell: bash
-      working-directory: ${{ inputs.build_dir }}
-      run: |
-        echo 'Building binary.'
-        cmake \
-          --build . \
-          --config ${{ inputs.build_type }} \
-          --parallel $(nproc) \
-          --target ${{ inputs.cmake_target }}
-    - name: Check linking
-      if: ${{ inputs.os == 'linux' }}
-      shell: bash
-      working-directory: ${{ inputs.build_dir }}
-      run: |
-        echo 'Checking linking.'
-        ldd ./rippled
-        if [ "$(ldd ./rippled | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
-          echo 'The binary is statically linked.'
-        else
-          echo 'The binary is dynamically linked.'
-          exit 1
-        fi
-    - name: Verify voidstar
-      if: ${{ contains(inputs.cmake_args, '-Dvoidstar=ON') }}
-      shell: bash
-      working-directory: ${{ inputs.build_dir }}
-      run: |
-        echo 'Verifying presence of instrumentation.'
-        ./rippled --version | grep libvoidstar
-    - name: Test the binary
-      if: ${{ inputs.build_only == 'false' }}
-      shell: bash
-      working-directory: ${{ inputs.build_dir }}/${{ inputs.os == 'windows' && inputs.build_type || '' }}
-      run: |
-        echo 'Testing binary.'
-        ./rippled --unittest --unittest-jobs $(nproc)
-        ctest -j $(nproc) --output-on-failure
-    - name: Upload coverage report
-      if: ${{ inputs.cmake_target == 'coverage' }}
-      uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
-      with:
-        disable_search: true
-        disable_telem: true
-        fail_ci_if_error: true
-        files: ${{ inputs.build_dir }}/coverage.xml
-        plugins: noop
-        token: ${{ inputs.codecov_token }}
-        verbose: true

.github/actions/print-env/action.yml

@@ -0,0 +1,43 @@
+name: Print build environment
+description: "Print environment and some tooling versions"
+
+runs:
+  using: composite
+  steps:
+    - name: Check configuration (Windows)
+      if: ${{ runner.os == 'Windows' }}
+      shell: bash
+      run: |
+        echo 'Checking environment variables.'
+        set
+
+        echo 'Checking CMake version.'
+        cmake --version
+
+        echo 'Checking Conan version.'
+        conan --version
+
+    - name: Check configuration (Linux and macOS)
+      if: ${{ runner.os == 'Linux' || runner.os == 'macOS' }}
+      shell: bash
+      run: |
+        echo 'Checking path.'
+        echo ${PATH} | tr ':' '\n'
+
+        echo 'Checking environment variables.'
+        env | sort
+
+        echo 'Checking CMake version.'
+        cmake --version
+
+        echo 'Checking compiler version.'
+        ${{ runner.os == 'Linux' && '${CC}' || 'clang' }} --version
+
+        echo 'Checking Conan version.'
+        conan --version
+
+        echo 'Checking Ninja version.'
+        ninja --version
+
+        echo 'Checking nproc version.'
+        nproc --version

.github/actions/setup-conan/action.yml

@@ -35,9 +35,12 @@ runs:
 
     - name: Set up Conan remote
       shell: bash
+      env:
+        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+        CONAN_REMOTE_URL: ${{ inputs.conan_remote_url }}
       run: |
-        echo "Adding Conan remote '${{ inputs.conan_remote_name }}' at ${{ inputs.conan_remote_url }}."
-        conan remote add --index 0 --force ${{ inputs.conan_remote_name }} ${{ inputs.conan_remote_url }}
+        echo "Adding Conan remote '${{ env.CONAN_REMOTE_NAME }}' at '${{ env.CONAN_REMOTE_URL }}'."
+        conan remote add --index 0 --force '${{ env.CONAN_REMOTE_NAME }}' '${{ env.CONAN_REMOTE_URL }}'
 
         echo 'Listing Conan remotes.'
         conan remote list

.github/scripts/levelization/README.md

@@ -72,15 +72,15 @@ It generates many files of [results](results):
   desired as described above. In a perfect repo, this file will be
   empty.
   This file is committed to the repo, and is used by the [levelization
-  Github workflow](../../workflows/check-levelization.yml) to validate
+  Github workflow](../../workflows/reusable-check-levelization.yml) to validate
   that nothing changed.
 - [`ordering.txt`](results/ordering.txt): A list showing relationships
   between modules where there are no loops as they actually exist, as
   opposed to how they are desired as described above.
   This file is committed to the repo, and is used by the [levelization
-  Github workflow](../../workflows/check-levelization.yml) to validate
+  Github workflow](../../workflows/reusable-check-levelization.yml) to validate
   that nothing changed.
-- [`levelization.yml`](../../workflows/check-levelization.yml)
+- [`levelization.yml`](../../workflows/reusable-check-levelization.yml)
   Github Actions workflow to test that levelization loops haven't
   changed. Unfortunately, if changes are detected, it can't tell if
   they are improvements or not, so if you have resolved any issues or

.github/scripts/levelization/results/loops.txt

@@ -7,9 +7,6 @@ Loop: test.jtx test.unit_test
 Loop: xrpld.app xrpld.core
   xrpld.app > xrpld.core
 
-Loop: xrpld.app xrpld.ledger
-  xrpld.app > xrpld.ledger
-
 Loop: xrpld.app xrpld.overlay
   xrpld.overlay > xrpld.app
 

.github/scripts/levelization/results/ordering.txt

@@ -2,6 +2,10 @@ libxrpl.basics > xrpl.basics
 libxrpl.crypto > xrpl.basics
 libxrpl.json > xrpl.basics
 libxrpl.json > xrpl.json
+libxrpl.ledger > xrpl.basics
+libxrpl.ledger > xrpl.json
+libxrpl.ledger > xrpl.ledger
+libxrpl.ledger > xrpl.protocol
 libxrpl.net > xrpl.basics
 libxrpl.net > xrpl.net
 libxrpl.protocol > xrpl.basics
@@ -21,11 +25,11 @@ test.app > test.unit_test
 test.app > xrpl.basics
 test.app > xrpld.app
 test.app > xrpld.core
-test.app > xrpld.ledger
 test.app > xrpld.nodestore
 test.app > xrpld.overlay
 test.app > xrpld.rpc
 test.app > xrpl.json
+test.app > xrpl.ledger
 test.app > xrpl.protocol
 test.app > xrpl.resource
 test.basics > test.jtx
@@ -44,8 +48,8 @@ test.consensus > test.unit_test
 test.consensus > xrpl.basics
 test.consensus > xrpld.app
 test.consensus > xrpld.consensus
-test.consensus > xrpld.ledger
 test.consensus > xrpl.json
+test.consensus > xrpl.ledger
 test.core > test.jtx
 test.core > test.toplevel
 test.core > test.unit_test
@@ -63,9 +67,9 @@ test.json > xrpl.json
 test.jtx > xrpl.basics
 test.jtx > xrpld.app
 test.jtx > xrpld.core
-test.jtx > xrpld.ledger
 test.jtx > xrpld.rpc
 test.jtx > xrpl.json
+test.jtx > xrpl.ledger
 test.jtx > xrpl.net
 test.jtx > xrpl.protocol
 test.jtx > xrpl.resource
@@ -75,7 +79,7 @@ test.ledger > test.toplevel
 test.ledger > xrpl.basics
 test.ledger > xrpld.app
 test.ledger > xrpld.core
-test.ledger > xrpld.ledger
+test.ledger > xrpl.ledger
 test.ledger > xrpl.protocol
 test.nodestore > test.jtx
 test.nodestore > test.toplevel
@@ -134,7 +138,10 @@ test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 tests.libxrpl > xrpl.basics
+tests.libxrpl > xrpl.net
 xrpl.json > xrpl.basics
+xrpl.ledger > xrpl.basics
+xrpl.ledger > xrpl.protocol
 xrpl.net > xrpl.basics
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
@@ -151,6 +158,7 @@ xrpld.app > xrpld.consensus
 xrpld.app > xrpld.nodestore
 xrpld.app > xrpld.perflog
 xrpld.app > xrpl.json
+xrpld.app > xrpl.ledger
 xrpld.app > xrpl.net
 xrpld.app > xrpl.protocol
 xrpld.app > xrpl.resource
@@ -163,9 +171,6 @@ xrpld.core > xrpl.basics
 xrpld.core > xrpl.json
 xrpld.core > xrpl.net
 xrpld.core > xrpl.protocol
-xrpld.ledger > xrpl.basics
-xrpld.ledger > xrpl.json
-xrpld.ledger > xrpl.protocol
 xrpld.nodestore > xrpl.basics
 xrpld.nodestore > xrpld.core
 xrpld.nodestore > xrpld.unity
@@ -186,9 +191,9 @@ xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.json
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpld.core
-xrpld.rpc > xrpld.ledger
 xrpld.rpc > xrpld.nodestore
 xrpld.rpc > xrpl.json
+xrpld.rpc > xrpl.ledger
 xrpld.rpc > xrpl.net
 xrpld.rpc > xrpl.protocol
 xrpld.rpc > xrpl.resource

.github/scripts/strategy-matrix/generate.py

@@ -162,7 +162,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
             'config_name': config_name,
             'cmake_args': cmake_args,
             'cmake_target': cmake_target,
-            'build_only': 'true' if build_only else 'false',
+            'build_only': build_only,
             'build_type': build_type,
             'os': os,
             'architecture': architecture,

.github/scripts/strategy-matrix/windows.json

@@ -2,7 +2,7 @@
   "architecture": [
     {
       "platform": "windows/amd64",
-      "runner": ["windows-latest"]
+      "runner": ["self-hosted", "Windows", "devbox"]
     }
   ],
   "os": [

.github/workflows/build-test.yml

@@ -1,146 +0,0 @@
-# This workflow builds and tests the binary for various configurations.
-name: Build and test
-
-# This workflow can only be triggered by other workflows. Note that the
-# workflow_call event does not support the 'choice' input type, see
-# https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#onworkflow_callinputsinput_idtype,
-# so we use 'string' instead.
-on:
-  workflow_call:
-    inputs:
-      build_dir:
-        description: "The directory where to build."
-        required: false
-        type: string
-        default: ".build"
-      dependencies_force_build:
-        description: "Force building of all dependencies."
-        required: false
-        type: boolean
-        default: false
-      dependencies_force_upload:
-        description: "Force uploading of all dependencies."
-        required: false
-        type: boolean
-        default: false
-      os:
-        description: 'The operating system to use for the build ("linux", "macos", "windows").'
-        required: true
-        type: string
-      strategy_matrix:
-        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
-        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
-        required: false
-        type: string
-        default: "minimal"
-    secrets:
-      codecov_token:
-        description: "The Codecov token to use for uploading coverage reports."
-        required: false
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}-${{ inputs.os }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  # Generate the strategy matrix to be used by the following job.
-  generate-matrix:
-    uses: ./.github/workflows/reusable-strategy-matrix.yml
-    with:
-      os: ${{ inputs.os }}
-      strategy_matrix: ${{ inputs.strategy_matrix }}
-
-  # Build and test the binary.
-  build-test:
-    needs:
-      - generate-matrix
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
-    runs-on: ${{ matrix.architecture.runner }}
-    container: ${{ inputs.os == 'linux' && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version) || null }}
-    steps:
-      - name: Check strategy matrix
-        run: |
-          echo 'Operating system distro name: ${{ matrix.os.distro_name }}'
-          echo 'Operating system distro version: ${{ matrix.os.distro_version }}'
-          echo 'Operating system compiler name: ${{ matrix.os.compiler_name }}'
-          echo 'Operating system compiler version: ${{ matrix.os.compiler_version }}'
-          echo 'Architecture platform: ${{ matrix.architecture.platform }}'
-          echo 'Architecture runner: ${{ toJson(matrix.architecture.runner) }}'
-          echo 'Build type: ${{ matrix.build_type }}'
-          echo 'Build only: ${{ matrix.build_only }}'
-          echo 'CMake arguments: ${{ matrix.cmake_args }}'
-          echo 'CMake target: ${{ matrix.cmake_target }}'
-          echo 'Config name: ${{ matrix.config_name }}'
-
-      - name: Cleanup workspace
-        if: ${{ runner.os == 'macOS' }}
-        uses: XRPLF/actions/.github/actions/cleanup-workspace@3f044c7478548e3c32ff68980eeb36ece02b364e
-
-      - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
-      - name: Prepare runner
-        uses: XRPLF/actions/.github/actions/prepare-runner@638e0dc11ea230f91bd26622fb542116bb5254d5
-        with:
-          disable_ccache: false
-
-      - name: Check configuration (Windows)
-        if: ${{ inputs.os == 'windows' }}
-        run: |
-          echo 'Checking environment variables.'
-          set
-
-          echo 'Checking CMake version.'
-          cmake --version
-
-          echo 'Checking Conan version.'
-          conan --version
-      - name: Check configuration (Linux and MacOS)
-        if: ${{ inputs.os == 'linux' || inputs.os == 'macos' }}
-        run: |
-          echo 'Checking path.'
-          echo ${PATH} | tr ':' '\n'
-
-          echo 'Checking environment variables.'
-          env | sort
-
-          echo 'Checking CMake version.'
-          cmake --version
-
-          echo 'Checking compiler version.'
-          ${{ inputs.os == 'linux' && '${CC}' || 'clang' }} --version
-
-          echo 'Checking Conan version.'
-          conan --version
-
-          echo 'Checking Ninja version.'
-          ninja --version
-
-          echo 'Checking nproc version.'
-          nproc --version
-
-      - name: Setup Conan
-        uses: ./.github/actions/setup-conan
-
-      - name: Build dependencies
-        uses: ./.github/actions/build-deps
-        with:
-          build_dir: ${{ inputs.build_dir }}
-          build_type: ${{ matrix.build_type }}
-          force_build: ${{ inputs.dependencies_force_build }}
-
-      - name: Build and test binary
-        uses: ./.github/actions/build-test
-        with:
-          build_dir: ${{ inputs.build_dir }}
-          build_only: ${{ matrix.build_only }}
-          build_type: ${{ matrix.build_type }}
-          cmake_args: ${{ matrix.cmake_args }}
-          cmake_target: ${{ matrix.cmake_target }}
-          codecov_token: ${{ secrets.codecov_token }}
-          os: ${{ inputs.os }}

.github/workflows/on-pr.yml

@@ -50,8 +50,8 @@ jobs:
           files: |
             # These paths are unique to `on-pr.yml`.
             .github/scripts/levelization/**
-            .github/workflows/check-levelization.yml
-            .github/workflows/notify-clio.yml
+            .github/workflows/reusable-check-levelization.yml
+            .github/workflows/reusable-notify-clio.yml
             .github/workflows/on-pr.yml
 
             # Keep the paths below in sync with those in `on-trigger.yml`.
@@ -59,8 +59,11 @@ jobs:
             .github/actions/build-test/**
             .github/actions/setup-conan/**
             .github/scripts/strategy-matrix/**
-            .github/workflows/build-test.yml
+            .github/workflows/reusable-build.yml
+            .github/workflows/reusable-build-test-config.yml
+            .github/workflows/reusable-build-test.yml
             .github/workflows/reusable-strategy-matrix.yml
+            .github/workflows/reusable-test.yml
             .codecov.yml
             cmake/**
             conan/**
@@ -92,27 +95,27 @@ jobs:
 
   check-levelization:
     needs: should-run
-    if: needs.should-run.outputs.go == 'true'
-    uses: ./.github/workflows/check-levelization.yml
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-levelization.yml
 
   build-test:
     needs: should-run
-    if: needs.should-run.outputs.go == 'true'
-    uses: ./.github/workflows/build-test.yml
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-build-test.yml
     strategy:
       matrix:
         os: [linux, macos, windows]
     with:
       os: ${{ matrix.os }}
     secrets:
-      codecov_token: ${{ secrets.CODECOV_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   notify-clio:
     needs:
       - should-run
       - build-test
-    if: needs.should-run.outputs.go == 'true'
-    uses: ./.github/workflows/notify-clio.yml
+    if: ${{ needs.should-run.outputs.go == 'true' && contains(fromJSON('["release", "master"]'), github.ref_name) }}
+    uses: ./.github/workflows/reusable-notify-clio.yml
     secrets:
       clio_notify_token: ${{ secrets.CLIO_NOTIFY_TOKEN }}
       conan_remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}

.github/workflows/on-trigger.yml

@@ -14,7 +14,7 @@ on:
       - master
     paths:
       # These paths are unique to `on-trigger.yml`.
-      - ".github/workflows/check-missing-commits.yml"
+      - ".github/workflows/reusable-check-missing-commits.yml"
       - ".github/workflows/on-trigger.yml"
       - ".github/workflows/publish-docs.yml"
 
@@ -23,8 +23,11 @@ on:
       - ".github/actions/build-test/**"
       - ".github/actions/setup-conan/**"
       - ".github/scripts/strategy-matrix/**"
-      - ".github/workflows/build-test.yml"
+      - ".github/workflows/reusable-build.yml"
+      - ".github/workflows/reusable-build-test-config.yml"
+      - ".github/workflows/reusable-build-test.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
+      - ".github/workflows/reusable-test.yml"
       - ".codecov.yml"
       - "cmake/**"
       - "conan/**"
@@ -43,22 +46,8 @@ on:
   schedule:
     - cron: "32 6 * * 1-5"
 
-  # Run when manually triggered via the GitHub UI or API. If `force_upload` is
-  # true, then the dependencies that were missing (`force_rebuild` is false) or
-  # rebuilt (`force_rebuild` is true) will be uploaded, overwriting existing
-  # dependencies if needed.
+  # Run when manually triggered via the GitHub UI or API.
   workflow_dispatch:
-    inputs:
-      dependencies_force_build:
-        description: "Force building of all dependencies."
-        required: false
-        type: boolean
-        default: false
-      dependencies_force_upload:
-        description: "Force uploading of all dependencies."
-        required: false
-        type: boolean
-        default: false
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -71,15 +60,15 @@ defaults:
 jobs:
   check-missing-commits:
     if: ${{ github.event_name == 'push' && github.ref_type == 'branch' && contains(fromJSON('["develop", "release"]'), github.ref_name) }}
-    uses: ./.github/workflows/check-missing-commits.yml
+    uses: ./.github/workflows/reusable-check-missing-commits.yml
 
   build-test:
-    uses: ./.github/workflows/build-test.yml
+    uses: ./.github/workflows/reusable-build-test.yml
     strategy:
       matrix:
         os: [linux, macos, windows]
     with:
       os: ${{ matrix.os }}
-      strategy_matrix: "minimal"
+      strategy_matrix: ${{ github.event_name == 'schedule' && 'all' || 'minimal' }}
     secrets:
-      codecov_token: ${{ secrets.CODECOV_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/pre-commit.yml

@@ -7,8 +7,9 @@ on:
   workflow_dispatch:
 
 jobs:
+  # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
     uses: XRPLF/actions/.github/workflows/pre-commit.yml@af1b0f0d764cda2e5435f5ac97b240d4bd4d95d3
     with:
       runs_on: ubuntu-latest
-      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit" }'
+      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-d1496b8" }'

.github/workflows/publish-docs.yml

@@ -27,7 +27,7 @@ env:
 jobs:
   publish:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/ci/tools-rippled-documentation
+    container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-d1496b8
     permissions:
       contents: write
     steps:

.github/workflows/reusable-build-test-config.yml

@@ -0,0 +1,69 @@
+name: Build and test configuration
+
+on:
+  workflow_call:
+    inputs:
+      build_dir:
+        description: "The directory where to build."
+        required: true
+        type: string
+      build_only:
+        description: 'Whether to only build or to build and test the code ("true", "false").'
+        required: true
+        type: boolean
+      build_type:
+        description: 'The build type to use ("Debug", "Release").'
+        type: string
+        required: true
+      cmake_args:
+        description: "Additional arguments to pass to CMake."
+        required: false
+        type: string
+        default: ""
+      cmake_target:
+        description: "The CMake target to build."
+        type: string
+        required: true
+
+      runs_on:
+        description: Runner to run the job on as a JSON string
+        required: true
+        type: string
+      image:
+        description: "The image to run in (leave empty to run natively)"
+        required: true
+        type: string
+
+      config_name:
+        description: "The configuration string (used for naming artifacts and such)."
+        required: true
+        type: string
+
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+jobs:
+  build:
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      build_dir: ${{ inputs.build_dir }}
+      build_type: ${{ inputs.build_type }}
+      cmake_args: ${{ inputs.cmake_args }}
+      cmake_target: ${{ inputs.cmake_target }}
+      runs_on: ${{ inputs.runs_on }}
+      image: ${{ inputs.image }}
+      config_name: ${{ inputs.config_name }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  test:
+    needs: build
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      run_tests: ${{ !inputs.build_only }}
+      verify_voidstar: ${{ contains(inputs.cmake_args, '-Dvoidstar=ON') }}
+      runs_on: ${{ inputs.runs_on }}
+      image: ${{ inputs.image }}
+      config_name: ${{ inputs.config_name }}

.github/workflows/reusable-build-test.yml

@@ -0,0 +1,58 @@
+# This workflow builds and tests the binary for various configurations.
+name: Build and test
+
+# This workflow can only be triggered by other workflows. Note that the
+# workflow_call event does not support the 'choice' input type, see
+# https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#onworkflow_callinputsinput_idtype,
+# so we use 'string' instead.
+on:
+  workflow_call:
+    inputs:
+      build_dir:
+        description: "The directory where to build."
+        required: false
+        type: string
+        default: ".build"
+      os:
+        description: 'The operating system to use for the build ("linux", "macos", "windows").'
+        required: true
+        type: string
+      strategy_matrix:
+        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
+        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
+        required: false
+        type: string
+        default: "minimal"
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+jobs:
+  # Generate the strategy matrix to be used by the following job.
+  generate-matrix:
+    uses: ./.github/workflows/reusable-strategy-matrix.yml
+    with:
+      os: ${{ inputs.os }}
+      strategy_matrix: ${{ inputs.strategy_matrix }}
+
+  # Build and test the binary for each configuration.
+  build-test-config:
+    needs:
+      - generate-matrix
+    uses: ./.github/workflows/reusable-build-test-config.yml
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+      max-parallel: 10
+    with:
+      build_dir: ${{ inputs.build_dir }}
+      build_only: ${{ matrix.build_only }}
+      build_type: ${{ matrix.build_type }}
+      cmake_args: ${{ matrix.cmake_args }}
+      cmake_target: ${{ matrix.cmake_target }}
+      runs_on: ${{ toJSON(matrix.architecture.runner) }}
+      image: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-5dd7158', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version) || '' }}
+      config_name: ${{ matrix.config_name }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/reusable-build.yml

@@ -0,0 +1,121 @@
+name: Build rippled
+
+on:
+  workflow_call:
+    inputs:
+      build_dir:
+        description: "The directory where to build."
+        required: true
+        type: string
+      build_type:
+        description: 'The build type to use ("Debug", "Release").'
+        required: true
+        type: string
+      cmake_args:
+        description: "Additional arguments to pass to CMake."
+        required: true
+        type: string
+      cmake_target:
+        description: "The CMake target to build."
+        required: true
+        type: string
+
+      runs_on:
+        description: Runner to run the job on as a JSON string
+        required: true
+        type: string
+      image:
+        description: "The image to run in (leave empty to run natively)"
+        required: true
+        type: string
+
+      config_name:
+        description: "The name of the configuration."
+        required: true
+        type: string
+
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build:
+    name: Build ${{ inputs.config_name }}
+    runs-on: ${{ fromJSON(inputs.runs_on) }}
+    container: ${{ inputs.image != '' && inputs.image || null }}
+    steps:
+      - name: Cleanup workspace
+        if: ${{ runner.os == 'macOS' }}
+        uses: XRPLF/actions/.github/actions/cleanup-workspace@3f044c7478548e3c32ff68980eeb36ece02b364e
+
+      - name: Checkout repository
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+
+      - name: Prepare runner
+        uses: XRPLF/actions/.github/actions/prepare-runner@638e0dc11ea230f91bd26622fb542116bb5254d5
+        with:
+          disable_ccache: false
+
+      - name: Print build environment
+        uses: ./.github/actions/print-env
+
+      - name: Setup Conan
+        uses: ./.github/actions/setup-conan
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_dir: ${{ inputs.build_dir }}
+          build_type: ${{ inputs.build_type }}
+
+      - name: Configure CMake
+        shell: bash
+        working-directory: ${{ inputs.build_dir }}
+        env:
+          BUILD_TYPE: ${{ inputs.build_type }}
+          CMAKE_ARGS: ${{ inputs.cmake_args }}
+        run: |
+          cmake \
+            -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} \
+            ${{ env.CMAKE_ARGS }} \
+            ..
+
+      - name: Build the binary
+        shell: bash
+        working-directory: ${{ inputs.build_dir }}
+        env:
+          BUILD_TYPE: ${{ inputs.build_type }}
+          CMAKE_TARGET: ${{ inputs.cmake_target }}
+        run: |
+          cmake \
+            --build . \
+            --config ${{ env.BUILD_TYPE }} \
+            --parallel $(nproc) \
+            --target ${{ env.CMAKE_TARGET }}
+
+      - name: Upload rippled artifact
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: rippled-${{ inputs.config_name }}
+          path: ${{ inputs.build_dir }}/${{ runner.os == 'Windows' && inputs.build_type || '' }}/rippled${{ runner.os == 'Windows' && '.exe' || '' }}
+          retention-days: 3
+          if-no-files-found: error
+
+      - name: Upload coverage report
+        if: ${{ inputs.cmake_target == 'coverage' }}
+        uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
+        with:
+          disable_search: true
+          disable_telem: true
+          fail_ci_if_error: true
+          files: ${{ inputs.build_dir }}/coverage.xml
+          plugins: noop
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true

.github/workflows/reusable-notify-clio.yml

@@ -40,47 +40,50 @@ jobs:
   upload:
     if: ${{ github.event.pull_request.head.repo.full_name == github.repository }}
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13
+    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
     steps:
       - name: Checkout repository
         uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
       - name: Generate outputs
         id: generate
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
           echo 'Generating user and channel.'
           echo "user=clio" >> "${GITHUB_OUTPUT}"
-          echo "channel=pr_${{ github.event.pull_request.number }}" >> "${GITHUB_OUTPUT}"
+          echo "channel=pr_${{ env.PR_NUMBER }}" >> "${GITHUB_OUTPUT}"
           echo 'Extracting version.'
           echo "version=$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')" >> "${GITHUB_OUTPUT}"
       - name: Calculate conan reference
         id: conan_ref
         run: |
           echo "conan_ref=${{ steps.generate.outputs.version }}@${{ steps.generate.outputs.user }}/${{ steps.generate.outputs.channel }}" >> "${GITHUB_OUTPUT}"
-
       - name: Set up Conan
         uses: ./.github/actions/setup-conan
         with:
           conan_remote_name: ${{ inputs.conan_remote_name }}
           conan_remote_url: ${{ inputs.conan_remote_url }}
-
       - name: Log into Conan remote
         run: conan remote login ${{ inputs.conan_remote_name }} "${{ secrets.conan_remote_username }}" --password "${{ secrets.conan_remote_password }}"
       - name: Upload package
+        env:
+          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
         run: |
           conan export --user=${{ steps.generate.outputs.user }} --channel=${{ steps.generate.outputs.channel }} .
-          conan upload --confirm --check --remote=${{ inputs.conan_remote_name }} xrpl/${{ steps.conan_ref.outputs.conan_ref }}
+          conan upload --confirm --check --remote=${{ env.CONAN_REMOTE_NAME }} xrpl/${{ steps.conan_ref.outputs.conan_ref }}
     outputs:
       conan_ref: ${{ steps.conan_ref.outputs.conan_ref }}
 
   notify:
     needs: upload
     runs-on: ubuntu-latest
-    env:
-      GH_TOKEN: ${{ secrets.clio_notify_token }}
     steps:
       - name: Notify Clio
+        env:
+          GH_TOKEN: ${{ secrets.clio_notify_token }}
+          PR_URL: ${{ github.event.pull_request.html_url }}
         run: |
           gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
           /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
           -F "client_payload[conan_ref]=${{ needs.upload.outputs.conan_ref }}" \
-          -F "client_payload[pr_url]=${{ github.event.pull_request.html_url }}"
+          -F "client_payload[pr_url]=${{ env.PR_URL }}"

.github/workflows/reusable-strategy-matrix.yml

@@ -35,4 +35,7 @@ jobs:
       - name: Generate strategy matrix
         working-directory: .github/scripts/strategy-matrix
         id: generate
-        run: ./generate.py ${{ inputs.strategy_matrix == 'all' && '--all' || '' }} ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }} >> "${GITHUB_OUTPUT}"
+        env:
+          GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }}
+          GENERATE_OPTION: ${{ inputs.strategy_matrix == 'all' && '--all' || '' }}
+        run: ./generate.py ${{ env.GENERATE_OPTION }} ${{ env.GENERATE_CONFIG }} >> "${GITHUB_OUTPUT}"

.github/workflows/reusable-test.yml

@@ -0,0 +1,69 @@
+name: Test rippled
+
+on:
+  workflow_call:
+    inputs:
+      verify_voidstar:
+        description: "Whether to verify the presence of voidstar instrumentation."
+        required: true
+        type: boolean
+      run_tests:
+        description: "Whether to run unit tests"
+        required: true
+        type: boolean
+
+      runs_on:
+        description: Runner to run the job on as a JSON string
+        required: true
+        type: string
+      image:
+        description: "The image to run in (leave empty to run natively)"
+        required: true
+        type: string
+
+      config_name:
+        description: "The name of the configuration."
+        required: true
+        type: string
+
+jobs:
+  test:
+    name: Test ${{ inputs.config_name }}
+    runs-on: ${{ fromJSON(inputs.runs_on) }}
+    container: ${{ inputs.image != '' && inputs.image || null }}
+    steps:
+      - name: Download rippled artifact
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: rippled-${{ inputs.config_name }}
+
+      - name: Make binary executable (Linux and macOS)
+        shell: bash
+        if: ${{ runner.os == 'Linux' || runner.os == 'macOS' }}
+        run: |
+          chmod +x ./rippled
+
+      - name: Check linking (Linux)
+        if: ${{ runner.os == 'Linux' }}
+        shell: bash
+        run: |
+          ldd ./rippled
+          if [ "$(ldd ./rippled | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
+            echo 'The binary is statically linked.'
+          else
+            echo 'The binary is dynamically linked.'
+            exit 1
+          fi
+
+      - name: Verifying presence of instrumentation
+        if: ${{ inputs.verify_voidstar }}
+        shell: bash
+        run: |
+          ./rippled --version | grep libvoidstar
+
+      - name: Test the binary
+        if: ${{ inputs.run_tests }}
+        shell: bash
+        run: |
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure

.github/workflows/upload-conan-deps.yml

@@ -24,16 +24,17 @@ on:
     branches: [develop]
     paths:
       - .github/workflows/upload-conan-deps.yml
-
       - .github/workflows/reusable-strategy-matrix.yml
-
       - .github/actions/build-deps/action.yml
       - .github/actions/setup-conan/action.yml
       - ".github/scripts/strategy-matrix/**"
-
       - conanfile.py
       - conan.lock
 
+env:
+  CONAN_REMOTE_NAME: xrplf
+  CONAN_REMOTE_URL: https://conan.ripplex.io
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
@@ -52,7 +53,7 @@ jobs:
       matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
       max-parallel: 10
     runs-on: ${{ matrix.architecture.runner }}
-    container: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version) || null }}
+    container: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-5dd7158', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version) || null }}
 
     steps:
       - name: Cleanup workspace
@@ -67,6 +68,9 @@ jobs:
 
       - name: Setup Conan
         uses: ./.github/actions/setup-conan
+        with:
+          conan_remote_name: ${{ env.CONAN_REMOTE_NAME }}
+          conan_remote_url: ${{ env.CONAN_REMOTE_URL }}
 
       - name: Build dependencies
         uses: ./.github/actions/build-deps
@@ -75,10 +79,12 @@ jobs:
           build_type: ${{ matrix.build_type }}
           force_build: ${{ github.event_name == 'schedule' || github.event.inputs.force_source_build == 'true' }}
 
-      - name: Login to Conan
-        if: github.repository_owner == 'XRPLF' && github.event_name != 'pull_request'
-        run: conan remote login -p ${{ secrets.CONAN_PASSWORD }} ${{ inputs.conan_remote_name }} ${{ secrets.CONAN_USERNAME }}
+      - name: Log into Conan remote
+        if: ${{ github.repository_owner == 'XRPLF' && github.event_name != 'pull_request' }}
+        run: conan remote login ${{ env.CONAN_REMOTE_NAME }} "${{ secrets.CONAN_REMOTE_USERNAME }}" --password "${{ secrets.CONAN_REMOTE_PASSWORD }}"
 
       - name: Upload Conan packages
-        if: github.repository_owner == 'XRPLF' && github.event_name != 'pull_request' && github.event_name != 'schedule'
-        run: conan upload "*" -r=${{ inputs.conan_remote_name }} --confirm ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
+        if: ${{ github.repository_owner == 'XRPLF' && github.event_name != 'pull_request' && github.event_name != 'schedule' }}
+        env:
+          FORCE_OPTION: ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
+        run: conan upload "*" --remote='${{ env.CONAN_REMOTE_NAME }}' --confirm ${{ env.FORCE_OPTION }}

cmake/CodeCoverage.cmake

@@ -104,6 +104,11 @@
 # 2025-08-28, Bronek Kozicki
 #     - fix "At least one COMMAND must be given" CMake warning from policy CMP0175
 #
+# 2025-09-03, Jingchen Wu
+#     - remove the unused function append_coverage_compiler_flags and append_coverage_compiler_flags_to_target
+#     - add a new function add_code_coverage_to_target
+#     - remove some unused code
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -112,10 +117,8 @@
 #    using a CMake option() to enable it just optionally):
 #      include(CodeCoverage)
 #
-# 3. Append necessary compiler flags for all supported source files:
-#      append_coverage_compiler_flags()
-#    Or for specific target:
-#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
+# 3. Append necessary compiler flags and linker flags for all supported source files:
+#      add_code_coverage_to_target(<target> <PRIVATE|PUBLIC|INTERFACE>)
 #
 # 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
 #
@@ -204,67 +207,69 @@ endforeach()
 
 set(COVERAGE_COMPILER_FLAGS "-g --coverage"
     CACHE INTERNAL "")
+
+set(COVERAGE_CXX_COMPILER_FLAGS "")
+set(COVERAGE_C_COMPILER_FLAGS "")
+set(COVERAGE_CXX_LINKER_FLAGS "")
+set(COVERAGE_C_LINKER_FLAGS "")
+
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
     include(CheckCCompilerFlag)
+    include(CheckLinkerFlag)
+
+    set(COVERAGE_CXX_COMPILER_FLAGS ${COVERAGE_COMPILER_FLAGS})
+    set(COVERAGE_C_COMPILER_FLAGS ${COVERAGE_COMPILER_FLAGS})
+    set(COVERAGE_CXX_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
+    set(COVERAGE_C_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
 
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
     if(HAVE_cxx_fprofile_abs_path)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
 
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
     if(HAVE_c_fprofile_abs_path)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+
+    check_linker_flag(CXX -fprofile-abs-path HAVE_cxx_linker_fprofile_abs_path)
+    if(HAVE_cxx_linker_fprofile_abs_path)
+        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path")
+    endif()
+
+    check_linker_flag(C -fprofile-abs-path HAVE_c_linker_fprofile_abs_path)
+    if(HAVE_c_linker_fprofile_abs_path)
+        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path")
     endif()
 
     check_cxx_compiler_flag(-fprofile-update=atomic HAVE_cxx_fprofile_update)
     if(HAVE_cxx_fprofile_update)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS}  -fprofile-update=atomic")
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic")
     endif()
 
     check_c_compiler_flag(-fprofile-update=atomic HAVE_c_fprofile_update)
     if(HAVE_c_fprofile_update)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-update=atomic")
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic")
     endif()
-endif()
 
-set(CMAKE_Fortran_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
-    FORCE )
-set(CMAKE_CXX_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the C++ compiler during coverage builds."
-    FORCE )
-set(CMAKE_C_FLAGS_COVERAGE
-    ${COVERAGE_COMPILER_FLAGS}
-    CACHE STRING "Flags used by the C compiler during coverage builds."
-    FORCE )
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    ""
-    CACHE STRING "Flags used for linking binaries during coverage builds."
-    FORCE )
-set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-    ""
-    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
-    FORCE )
-mark_as_advanced(
-    CMAKE_Fortran_FLAGS_COVERAGE
-    CMAKE_CXX_FLAGS_COVERAGE
-    CMAKE_C_FLAGS_COVERAGE
-    CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+    check_linker_flag(CXX -fprofile-update=atomic HAVE_cxx_linker_fprofile_update)
+    if(HAVE_cxx_linker_fprofile_update)
+        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic")
+    endif()
+
+    check_linker_flag(C -fprofile-update=atomic HAVE_c_linker_fprofile_update)
+    if(HAVE_c_linker_fprofile_update)
+        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic")
+    endif()
+
+endif()
 
 get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
     message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
 endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 
-if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
-    link_libraries(gcov)
-endif()
-
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
 # NOTE! The executable should always have a ZERO as exit code otherwise
@@ -454,18 +459,19 @@ function(setup_target_for_coverage_gcovr)
     )
 endfunction() # setup_target_for_coverage_gcovr
 
-function(append_coverage_compiler_flags)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
-    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
-endfunction() # append_coverage_compiler_flags
+function(add_code_coverage_to_target name scope)
+    separate_arguments(COVERAGE_CXX_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_COMPILER_FLAGS}")
+    separate_arguments(COVERAGE_C_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_C_COMPILER_FLAGS}")
+    separate_arguments(COVERAGE_CXX_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_LINKER_FLAGS}")
+    separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
 
-# Setup coverage for specific library
-function(append_coverage_compiler_flags_to_target name)
-    separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
-    target_compile_options(${name} PRIVATE ${_flag_list})
-    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
-        target_link_libraries(${name} PRIVATE gcov)
-    endif()
-endfunction()
+    # Add compiler options to the target
+    target_compile_options(${name} ${scope}
+            $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+            $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
+
+    target_link_libraries (${name} ${scope}
+            $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS} gcov>
+            $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS} gcov>
+    )
+endfunction() # add_code_coverage_to_target

cmake/RippledCompiler.cmake

@@ -16,16 +16,13 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 target_compile_definitions (common
   INTERFACE
     $<$<CONFIG:Debug>:DEBUG _DEBUG>
-    #[===[
-    NOTE: CMAKE release builds already have NDEBUG defined, so no need to add it
-    explicitly except for the special case of (profile ON) and (assert OFF).
-    Presumably this is because we don't want profile builds asserting unless
-    asserts were specifically requested.
-    ]===]
-    $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
-    # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
-    OPENSSL_SUPPRESS_DEPRECATED
-)
+    $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>)
+    # ^^^^ NOTE: CMAKE release builds already have NDEBUG
+    # defined, so no need to add it explicitly except for
+    # this special case of (profile ON) and (assert OFF)
+    # -- presumably this is because we don't want profile
+    # builds asserting unless asserts were specifically
+    # requested
 
 if (MSVC)
   # remove existing exception flag since we set it to -EHa

cmake/RippledCore.cmake

@@ -111,6 +111,12 @@ target_link_libraries(xrpl.libxrpl.net PUBLIC
 add_module(xrpl server)
 target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol)
 
+add_module(xrpl ledger)
+target_link_libraries(xrpl.libxrpl.ledger PUBLIC
+  xrpl.libxrpl.basics
+  xrpl.libxrpl.json
+  xrpl.libxrpl.protocol
+)
 
 add_library(xrpl.libxrpl)
 set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
@@ -131,6 +137,7 @@ target_link_modules(xrpl PUBLIC
   resource
   server
   net
+  ledger
 )
 
 # All headers in libxrpl are in modules.

cmake/RippledCov.cmake

@@ -33,6 +33,8 @@ setup_target_for_coverage_gcovr(
   FORMAT ${coverage_format}
   EXECUTABLE rippled
   EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
-  EXCLUDE "src/test" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+  EXCLUDE "src/test" "src/tests" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
   DEPENDENCIES rippled
 )
+
+add_code_coverage_to_target(opts INTERFACE)

cmake/RippledInstall.cmake

@@ -18,6 +18,7 @@ install (
     xrpl.libxrpl.json
     xrpl.libxrpl.protocol
     xrpl.libxrpl.resource
+    xrpl.libxrpl.ledger
     xrpl.libxrpl.server
     xrpl.libxrpl.net
     xrpl.libxrpl

cmake/RippledInterface.cmake

@@ -28,15 +28,11 @@ target_compile_options (opts
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

conan.lock

@@ -9,7 +9,7 @@
         "rocksdb/10.0.1#85537f46e538974d67da0c3977de48ac%1756234304.347",
         "re2/20230301#dfd6e2bf050eb90ddd8729cfb4c844a4%1756234257.976",
         "protobuf/3.21.12#d927114e28de9f4691a6bbcdd9a529d1%1756234251.614",
-        "openssl/3.5.2#0c5a5e15ae569f45dff57adcf1770cf7%1756234259.61",
+        "openssl/1.1.1w#a8f0792d7c5121b954578a7149d23e03%1756223730.729",
         "nudb/2.0.9#c62cfd501e57055a7e0d8ee3d5e5427d%1756234237.107",
         "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1756234228.999",
         "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1756223727.64",

conanfile.py

@@ -27,7 +27,7 @@ class Xrpl(ConanFile):
         'grpc/1.50.1',
         'libarchive/3.8.1',
         'nudb/2.0.9',
-        'openssl/3.5.2',
+        'openssl/1.1.1w',
         'soci/4.0.3',
         'zlib/1.3.1',
     ]

include/xrpl/basics/base_uint.h

@@ -632,6 +632,16 @@ to_string(base_uint<Bits, Tag> const& a)
     return strHex(a.cbegin(), a.cend());
 }
 
+template <std::size_t Bits, class Tag>
+inline std::string
+to_short_string(base_uint<Bits, Tag> const& a)
+{
+    static_assert(
+        base_uint<Bits, Tag>::bytes > 4,
+        "For 4 bytes or less, use a native type");
+    return strHex(a.cbegin(), a.cbegin() + 4) + "...";
+}
+
 template <std::size_t Bits, class Tag>
 inline std::ostream&
 operator<<(std::ostream& out, base_uint<Bits, Tag> const& u)

include/xrpl/basics/safe_cast.h

@@ -28,9 +28,8 @@ namespace ripple {
 // the destination can hold all values of the source.  This is particularly
 // handy when the source or destination is an enumeration type.
 
-template <class Dest, class Src>
-static constexpr bool is_safetocasttovalue_v =
-    (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
+template <class Src, class Dest>
+concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
     (std::is_signed<Src>::value || std::is_unsigned<Dest>::value) &&
     (std::is_signed<Src>::value != std::is_signed<Dest>::value
          ? sizeof(Dest) > sizeof(Src)
@@ -78,7 +77,7 @@ inline constexpr std::
     unsafe_cast(Src s) noexcept
 {
     static_assert(
-        !is_safetocasttovalue_v<Dest, Src>,
+        !SafeToCast<Src, Dest>,
         "Only unsafe if casting signed to unsigned or "
         "destination is too small");
     return static_cast<Dest>(s);

include/xrpl/beast/utility/instrumentation.h

@@ -39,11 +39,16 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #endif
 
 #define XRPL_ASSERT ALWAYS_OR_UNREACHABLE
+#define XRPL_ASSERT_PARTS(cond, function, description, ...) \
+    XRPL_ASSERT(cond, function " : " description)
 
 // How to use the instrumentation macros:
 //
 // * XRPL_ASSERT if cond must be true but the line might not be reached during
 //   fuzzing. Same like `assert` in normal use.
+// * XRPL_ASSERT_PARTS is for convenience, and works like XRPL_ASSERT, but
+//   splits the message param into "function" and "description", then joins
+//   them with " : " before passing to XRPL_ASSERT.
 // * ALWAYS if cond must be true _and_ the line must be reached during fuzzing.
 //   Same like `assert` in normal use.
 // * REACHABLE if the line must be reached during fuzzing

include/xrpl/ledger/ApplyView.h

@@ -20,11 +20,10 @@
 #ifndef RIPPLE_LEDGER_APPLYVIEW_H_INCLUDED
 #define RIPPLE_LEDGER_APPLYVIEW_H_INCLUDED
 
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/ReadView.h>
 
 namespace ripple {
 

include/xrpl/ledger/ApplyViewImpl.h

@@ -20,9 +20,8 @@
 #ifndef RIPPLE_LEDGER_APPLYVIEWIMPL_H_INCLUDED
 #define RIPPLE_LEDGER_APPLYVIEWIMPL_H_INCLUDED
 
-#include <xrpld/ledger/OpenView.h>
-#include <xrpld/ledger/detail/ApplyViewBase.h>
-
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/detail/ApplyViewBase.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/TER.h>
 

include/xrpl/ledger/BookDirs.h

@@ -20,9 +20,8 @@
 #ifndef RIPPLE_LEDGER_BOOK_DIRS_H_INCLUDED
 #define RIPPLE_LEDGER_BOOK_DIRS_H_INCLUDED
 
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ReadView.h>
 
 namespace ripple {
 

include/xrpl/ledger/CachedView.h

@@ -20,10 +20,9 @@
 #ifndef RIPPLE_LEDGER_CACHEDVIEW_H_INCLUDED
 #define RIPPLE_LEDGER_CACHEDVIEW_H_INCLUDED
 
-#include <xrpld/ledger/CachedSLEs.h>
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/basics/hardened_hash.h>
+#include <xrpl/ledger/CachedSLEs.h>
+#include <xrpl/ledger/ReadView.h>
 
 #include <mutex>
 #include <type_traits>

include/xrpl/ledger/CredentialHelpers.h

@@ -20,12 +20,11 @@
 #ifndef RIPPLE_APP_MISC_CREDENTIALHELPERS_H_INCLUDED
 #define RIPPLE_APP_MISC_CREDENTIALHELPERS_H_INCLUDED
 
-#include <xrpld/ledger/ApplyView.h>
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/STArray.h>
 #include <xrpl/protocol/STTx.h>

include/xrpl/ledger/Dir.h

@@ -20,8 +20,7 @@
 #ifndef RIPPLE_LEDGER_DIR_H_INCLUDED
 #define RIPPLE_LEDGER_DIR_H_INCLUDED
 
-#include <xrpld/ledger/ReadView.h>
-
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Indexes.h>
 
 namespace ripple {

include/xrpl/ledger/OpenView.h

@@ -20,10 +20,9 @@
 #ifndef RIPPLE_LEDGER_OPENVIEW_H_INCLUDED
 #define RIPPLE_LEDGER_OPENVIEW_H_INCLUDED
 
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/ReadView.h>
-#include <xrpld/ledger/detail/RawStateTable.h>
-
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/detail/RawStateTable.h>
 #include <xrpl/protocol/STArray.h>
 #include <xrpl/protocol/XRPAmount.h>
 

include/xrpl/ledger/PaymentSandbox.h

@@ -20,10 +20,9 @@
 #ifndef RIPPLE_LEDGER_PAYMENTSANDBOX_H_INCLUDED
 #define RIPPLE_LEDGER_PAYMENTSANDBOX_H_INCLUDED
 
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/Sandbox.h>
-#include <xrpld/ledger/detail/ApplyViewBase.h>
-
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/Sandbox.h>
+#include <xrpl/ledger/detail/ApplyViewBase.h>
 #include <xrpl/protocol/AccountID.h>
 
 #include <map>

include/xrpl/ledger/RawView.h

@@ -20,8 +20,7 @@
 #ifndef RIPPLE_LEDGER_RAWVIEW_H_INCLUDED
 #define RIPPLE_LEDGER_RAWVIEW_H_INCLUDED
 
-#include <xrpld/ledger/ReadView.h>
-
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/Serializer.h>
 

include/xrpl/ledger/ReadView.h

@@ -20,10 +20,9 @@
 #ifndef RIPPLE_LEDGER_READVIEW_H_INCLUDED
 #define RIPPLE_LEDGER_READVIEW_H_INCLUDED
 
-#include <xrpld/ledger/detail/ReadViewFwdRange.h>
-
 #include <xrpl/basics/chrono.h>
 #include <xrpl/beast/hash/uhash.h>
+#include <xrpl/ledger/detail/ReadViewFwdRange.h>
 #include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/Indexes.h>
@@ -280,6 +279,6 @@ makeRulesGivenLedger(
 
 }  // namespace ripple
 
-#include <xrpld/ledger/detail/ReadViewFwdRange.ipp>
+#include <xrpl/ledger/detail/ReadViewFwdRange.ipp>
 
 #endif

include/xrpl/ledger/Sandbox.h

@@ -20,8 +20,8 @@
 #ifndef RIPPLE_LEDGER_SANDBOX_H_INCLUDED
 #define RIPPLE_LEDGER_SANDBOX_H_INCLUDED
 
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/detail/ApplyViewBase.h>
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/detail/ApplyViewBase.h>
 
 namespace ripple {
 

include/xrpl/ledger/View.h

@@ -20,11 +20,10 @@
 #ifndef RIPPLE_LEDGER_VIEW_H_INCLUDED
 #define RIPPLE_LEDGER_VIEW_H_INCLUDED
 
-#include <xrpld/ledger/ApplyView.h>
-#include <xrpld/ledger/OpenView.h>
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/Protocol.h>
@@ -562,12 +561,28 @@ createPseudoAccount(
 [[nodiscard]] bool
 isPseudoAccount(std::shared_ptr<SLE const> sleAcct);
 
+// Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account if
+// set
+// Pseudo-account designator fields MUST be maintained by including the
+// SField::sMD_PseudoAccount flag in the SField definition. (Don't forget to
+// "| SField::sMD_Default"!) The fields do NOT need to be amendment-gated,
+// since a non-active amendment will not set any field, by definition.
+// Specific properties of a pseudo-account are NOT checked here, that's what
+// InvariantCheck is for.
+[[nodiscard]] std::vector<SField const*> const&
+getPseudoAccountFields();
+
 [[nodiscard]] inline bool
 isPseudoAccount(ReadView const& view, AccountID accountId)
 {
     return isPseudoAccount(view.read(keylet::account(accountId)));
 }
 
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, Asset const& asset);
+
+/// Any transactors that call addEmptyHolding() in doApply must call
+/// canAddHolding() in preflight with the same View and Asset
 [[nodiscard]] TER
 addEmptyHolding(
     ApplyView& view,
@@ -719,7 +734,8 @@ rippleUnlockEscrowMPT(
     ApplyView& view,
     AccountID const& uGrantorID,
     AccountID const& uGranteeID,
-    STAmount const& saAmount,
+    STAmount const& netAmount,
+    STAmount const& grossAmount,
     beast::Journal j);
 
 /** Calls static accountSendIOU if saAmount represents Issue.

include/xrpl/ledger/detail/ApplyStateTable.h

@@ -20,11 +20,10 @@
 #ifndef RIPPLE_LEDGER_APPLYSTATETABLE_H_INCLUDED
 #define RIPPLE_LEDGER_APPLYSTATETABLE_H_INCLUDED
 
-#include <xrpld/ledger/OpenView.h>
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/ReadView.h>
-
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxMeta.h>
 #include <xrpl/protocol/XRPAmount.h>

include/xrpl/ledger/detail/ApplyViewBase.h

@@ -20,10 +20,9 @@
 #ifndef RIPPLE_LEDGER_APPLYVIEWBASE_H_INCLUDED
 #define RIPPLE_LEDGER_APPLYVIEWBASE_H_INCLUDED
 
-#include <xrpld/ledger/ApplyView.h>
-#include <xrpld/ledger/ReadView.h>
-#include <xrpld/ledger/detail/ApplyStateTable.h>
-
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/detail/ApplyStateTable.h>
 #include <xrpl/protocol/XRPAmount.h>
 
 namespace ripple {

include/xrpl/ledger/detail/RawStateTable.h

@@ -20,8 +20,8 @@
 #ifndef RIPPLE_LEDGER_RAWSTATETABLE_H_INCLUDED
 #define RIPPLE_LEDGER_RAWSTATETABLE_H_INCLUDED
 
-#include <xrpld/ledger/RawView.h>
-#include <xrpld/ledger/ReadView.h>
+#include <xrpl/ledger/RawView.h>
+#include <xrpl/ledger/ReadView.h>
 
 #include <boost/container/pmr/monotonic_buffer_resource.hpp>
 #include <boost/container/pmr/polymorphic_allocator.hpp>

include/xrpl/protocol/FeeUnits.h

@@ -1,565 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2019 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or 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.
-*/
-
-#ifndef BASICS_FEES_H_INCLUDED
-#define BASICS_FEES_H_INCLUDED
-
-#include <xrpl/basics/safe_cast.h>
-#include <xrpl/beast/utility/Zero.h>
-#include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/json/json_value.h>
-
-#include <boost/multiprecision/cpp_int.hpp>
-#include <boost/operators.hpp>
-
-#include <iosfwd>
-#include <limits>
-#include <optional>
-
-namespace ripple {
-
-namespace feeunit {
-
-/** "drops" are the smallest divisible amount of XRP. This is what most
-    of the code uses. */
-struct dropTag;
-/** "fee units" calculations are a not-really-unitless value that is used
-    to express the cost of a given transaction vs. a reference transaction.
-    They are primarily used by the Transactor classes. */
-struct feeunitTag;
-/** "fee levels" are used by the transaction queue to compare the relative
-    cost of transactions that require different levels of effort to process.
-    See also: src/ripple/app/misc/FeeEscalation.md#fee-level */
-struct feelevelTag;
-/** unitless values are plain scalars wrapped in a TaggedFee. They are
-    used for calculations in this header. */
-struct unitlessTag;
-
-template <class T>
-using enable_if_unit_t = typename std::enable_if_t<
-    std::is_class_v<T> && std::is_object_v<typename T::unit_type> &&
-    std::is_object_v<typename T::value_type>>;
-
-/** `is_usable_unit_v` is checked to ensure that only values with
-    known valid type tags can be used (sometimes transparently) in
-    non-fee contexts. At the time of implementation, this includes
-    all known tags, but more may be added in the future, and they
-    should not be added automatically unless determined to be
-    appropriate.
-*/
-template <class T, class = enable_if_unit_t<T>>
-constexpr bool is_usable_unit_v =
-    std::is_same_v<typename T::unit_type, feeunitTag> ||
-    std::is_same_v<typename T::unit_type, feelevelTag> ||
-    std::is_same_v<typename T::unit_type, unitlessTag> ||
-    std::is_same_v<typename T::unit_type, dropTag>;
-
-template <class UnitTag, class T>
-class TaggedFee : private boost::totally_ordered<TaggedFee<UnitTag, T>>,
-                  private boost::additive<TaggedFee<UnitTag, T>>,
-                  private boost::equality_comparable<TaggedFee<UnitTag, T>, T>,
-                  private boost::dividable<TaggedFee<UnitTag, T>, T>,
-                  private boost::modable<TaggedFee<UnitTag, T>, T>,
-                  private boost::unit_steppable<TaggedFee<UnitTag, T>>
-{
-public:
-    using unit_type = UnitTag;
-    using value_type = T;
-
-private:
-    value_type fee_;
-
-protected:
-    template <class Other>
-    static constexpr bool is_compatible_v =
-        std::is_arithmetic_v<Other> && std::is_arithmetic_v<value_type> &&
-        std::is_convertible_v<Other, value_type>;
-
-    template <class OtherFee, class = enable_if_unit_t<OtherFee>>
-    static constexpr bool is_compatiblefee_v =
-        is_compatible_v<typename OtherFee::value_type> &&
-        std::is_same_v<UnitTag, typename OtherFee::unit_type>;
-
-    template <class Other>
-    using enable_if_compatible_t =
-        typename std::enable_if_t<is_compatible_v<Other>>;
-
-    template <class OtherFee>
-    using enable_if_compatiblefee_t =
-        typename std::enable_if_t<is_compatiblefee_v<OtherFee>>;
-
-public:
-    TaggedFee() = default;
-    constexpr TaggedFee(TaggedFee const& other) = default;
-    constexpr TaggedFee&
-    operator=(TaggedFee const& other) = default;
-
-    constexpr explicit TaggedFee(beast::Zero) : fee_(0)
-    {
-    }
-
-    constexpr TaggedFee&
-    operator=(beast::Zero)
-    {
-        fee_ = 0;
-        return *this;
-    }
-
-    constexpr explicit TaggedFee(value_type fee) : fee_(fee)
-    {
-    }
-
-    TaggedFee&
-    operator=(value_type fee)
-    {
-        fee_ = fee;
-        return *this;
-    }
-
-    /** Instances with the same unit, and a type that is
-        "safe" to convert to this one can be converted
-        implicitly */
-    template <
-        class Other,
-        class = std::enable_if_t<
-            is_compatible_v<Other> &&
-            is_safetocasttovalue_v<value_type, Other>>>
-    constexpr TaggedFee(TaggedFee<unit_type, Other> const& fee)
-        : TaggedFee(safe_cast<value_type>(fee.fee()))
-    {
-    }
-
-    constexpr TaggedFee
-    operator*(value_type const& rhs) const
-    {
-        return TaggedFee{fee_ * rhs};
-    }
-
-    friend constexpr TaggedFee
-    operator*(value_type lhs, TaggedFee const& rhs)
-    {
-        // multiplication is commutative
-        return rhs * lhs;
-    }
-
-    constexpr value_type
-    operator/(TaggedFee const& rhs) const
-    {
-        return fee_ / rhs.fee_;
-    }
-
-    TaggedFee&
-    operator+=(TaggedFee const& other)
-    {
-        fee_ += other.fee();
-        return *this;
-    }
-
-    TaggedFee&
-    operator-=(TaggedFee const& other)
-    {
-        fee_ -= other.fee();
-        return *this;
-    }
-
-    TaggedFee&
-    operator++()
-    {
-        ++fee_;
-        return *this;
-    }
-
-    TaggedFee&
-    operator--()
-    {
-        --fee_;
-        return *this;
-    }
-
-    TaggedFee&
-    operator*=(value_type const& rhs)
-    {
-        fee_ *= rhs;
-        return *this;
-    }
-
-    TaggedFee&
-    operator/=(value_type const& rhs)
-    {
-        fee_ /= rhs;
-        return *this;
-    }
-
-    template <class transparent = value_type>
-    std::enable_if_t<std::is_integral_v<transparent>, TaggedFee&>
-    operator%=(value_type const& rhs)
-    {
-        fee_ %= rhs;
-        return *this;
-    }
-
-    TaggedFee
-    operator-() const
-    {
-        static_assert(
-            std::is_signed_v<T>, "- operator illegal on unsigned fee types");
-        return TaggedFee{-fee_};
-    }
-
-    bool
-    operator==(TaggedFee const& other) const
-    {
-        return fee_ == other.fee_;
-    }
-
-    template <class Other, class = enable_if_compatible_t<Other>>
-    bool
-    operator==(TaggedFee<unit_type, Other> const& other) const
-    {
-        return fee_ == other.fee();
-    }
-
-    bool
-    operator==(value_type other) const
-    {
-        return fee_ == other;
-    }
-
-    template <class Other, class = enable_if_compatible_t<Other>>
-    bool
-    operator!=(TaggedFee<unit_type, Other> const& other) const
-    {
-        return !operator==(other);
-    }
-
-    bool
-    operator<(TaggedFee const& other) const
-    {
-        return fee_ < other.fee_;
-    }
-
-    /** Returns true if the amount is not zero */
-    explicit constexpr
-    operator bool() const noexcept
-    {
-        return fee_ != 0;
-    }
-
-    /** Return the sign of the amount */
-    constexpr int
-    signum() const noexcept
-    {
-        return (fee_ < 0) ? -1 : (fee_ ? 1 : 0);
-    }
-
-    /** Returns the number of drops */
-    constexpr value_type
-    fee() const
-    {
-        return fee_;
-    }
-
-    template <class Other>
-    constexpr double
-    decimalFromReference(TaggedFee<unit_type, Other> reference) const
-    {
-        return static_cast<double>(fee_) / reference.fee();
-    }
-
-    // `is_usable_unit_v` is checked to ensure that only values with
-    // known valid type tags can be converted to JSON. At the time
-    // of implementation, that includes all known tags, but more may
-    // be added in the future.
-    std::enable_if_t<is_usable_unit_v<TaggedFee>, Json::Value>
-    jsonClipped() const
-    {
-        if constexpr (std::is_integral_v<value_type>)
-        {
-            using jsontype = std::conditional_t<
-                std::is_signed_v<value_type>,
-                Json::Int,
-                Json::UInt>;
-
-            constexpr auto min = std::numeric_limits<jsontype>::min();
-            constexpr auto max = std::numeric_limits<jsontype>::max();
-
-            if (fee_ < min)
-                return min;
-            if (fee_ > max)
-                return max;
-            return static_cast<jsontype>(fee_);
-        }
-        else
-        {
-            return fee_;
-        }
-    }
-
-    /** Returns the underlying value. Code SHOULD NOT call this
-        function unless the type has been abstracted away,
-        e.g. in a templated function.
-    */
-    constexpr value_type
-    value() const
-    {
-        return fee_;
-    }
-
-    friend std::istream&
-    operator>>(std::istream& s, TaggedFee& val)
-    {
-        s >> val.fee_;
-        return s;
-    }
-};
-
-// Output Fees as just their numeric value.
-template <class Char, class Traits, class UnitTag, class T>
-std::basic_ostream<Char, Traits>&
-operator<<(std::basic_ostream<Char, Traits>& os, TaggedFee<UnitTag, T> const& q)
-{
-    return os << q.value();
-}
-
-template <class UnitTag, class T>
-std::string
-to_string(TaggedFee<UnitTag, T> const& amount)
-{
-    return std::to_string(amount.fee());
-}
-
-template <class Source, class = enable_if_unit_t<Source>>
-constexpr bool can_muldiv_source_v =
-    std::is_convertible_v<typename Source::value_type, std::uint64_t>;
-
-template <class Dest, class = enable_if_unit_t<Dest>>
-constexpr bool can_muldiv_dest_v =
-    can_muldiv_source_v<Dest> &&  // Dest is also a source
-    std::is_convertible_v<std::uint64_t, typename Dest::value_type> &&
-    sizeof(typename Dest::value_type) >= sizeof(std::uint64_t);
-
-template <
-    class Source1,
-    class Source2,
-    class = enable_if_unit_t<Source1>,
-    class = enable_if_unit_t<Source2>>
-constexpr bool can_muldiv_sources_v =
-    can_muldiv_source_v<Source1> && can_muldiv_source_v<Source2> &&
-    std::is_same_v<typename Source1::unit_type, typename Source2::unit_type>;
-
-template <
-    class Source1,
-    class Source2,
-    class Dest,
-    class = enable_if_unit_t<Source1>,
-    class = enable_if_unit_t<Source2>,
-    class = enable_if_unit_t<Dest>>
-constexpr bool can_muldiv_v =
-    can_muldiv_sources_v<Source1, Source2> && can_muldiv_dest_v<Dest>;
-// Source and Dest can be the same by default
-
-template <
-    class Source1,
-    class Source2,
-    class Dest,
-    class = enable_if_unit_t<Source1>,
-    class = enable_if_unit_t<Source2>,
-    class = enable_if_unit_t<Dest>>
-constexpr bool can_muldiv_commute_v = can_muldiv_v<Source1, Source2, Dest> &&
-    !std::is_same_v<typename Source1::unit_type, typename Dest::unit_type>;
-
-template <class T>
-using enable_muldiv_source_t =
-    typename std::enable_if_t<can_muldiv_source_v<T>>;
-
-template <class T>
-using enable_muldiv_dest_t = typename std::enable_if_t<can_muldiv_dest_v<T>>;
-
-template <class Source1, class Source2>
-using enable_muldiv_sources_t =
-    typename std::enable_if_t<can_muldiv_sources_v<Source1, Source2>>;
-
-template <class Source1, class Source2, class Dest>
-using enable_muldiv_t =
-    typename std::enable_if_t<can_muldiv_v<Source1, Source2, Dest>>;
-
-template <class Source1, class Source2, class Dest>
-using enable_muldiv_commute_t =
-    typename std::enable_if_t<can_muldiv_commute_v<Source1, Source2, Dest>>;
-
-template <class T>
-TaggedFee<unitlessTag, T>
-scalar(T value)
-{
-    return TaggedFee<unitlessTag, T>{value};
-}
-
-template <
-    class Source1,
-    class Source2,
-    class Dest,
-    class = enable_muldiv_t<Source1, Source2, Dest>>
-std::optional<Dest>
-mulDivU(Source1 value, Dest mul, Source2 div)
-{
-    // Fees can never be negative in any context.
-    if (value.value() < 0 || mul.value() < 0 || div.value() < 0)
-    {
-        // split the asserts so if one hits, the user can tell which
-        // without a debugger.
-        XRPL_ASSERT(
-            value.value() >= 0,
-            "ripple::feeunit::mulDivU : minimum value input");
-        XRPL_ASSERT(
-            mul.value() >= 0, "ripple::feeunit::mulDivU : minimum mul input");
-        XRPL_ASSERT(
-            div.value() >= 0, "ripple::feeunit::mulDivU : minimum div input");
-        return std::nullopt;
-    }
-
-    using desttype = typename Dest::value_type;
-    constexpr auto max = std::numeric_limits<desttype>::max();
-
-    // Shortcuts, since these happen a lot in the real world
-    if (value == div)
-        return mul;
-    if (mul.value() == div.value())
-    {
-        if (value.value() > max)
-            return std::nullopt;
-        return Dest{static_cast<desttype>(value.value())};
-    }
-
-    using namespace boost::multiprecision;
-
-    uint128_t product;
-    product = multiply(
-        product,
-        static_cast<std::uint64_t>(value.value()),
-        static_cast<std::uint64_t>(mul.value()));
-
-    auto quotient = product / div.value();
-
-    if (quotient > max)
-        return std::nullopt;
-
-    return Dest{static_cast<desttype>(quotient)};
-}
-
-}  // namespace feeunit
-
-template <class T>
-using FeeLevel = feeunit::TaggedFee<feeunit::feelevelTag, T>;
-using FeeLevel64 = FeeLevel<std::uint64_t>;
-using FeeLevelDouble = FeeLevel<double>;
-
-template <
-    class Source1,
-    class Source2,
-    class Dest,
-    class = feeunit::enable_muldiv_t<Source1, Source2, Dest>>
-std::optional<Dest>
-mulDiv(Source1 value, Dest mul, Source2 div)
-{
-    return feeunit::mulDivU(value, mul, div);
-}
-
-template <
-    class Source1,
-    class Source2,
-    class Dest,
-    class = feeunit::enable_muldiv_commute_t<Source1, Source2, Dest>>
-std::optional<Dest>
-mulDiv(Dest value, Source1 mul, Source2 div)
-{
-    // Multiplication is commutative
-    return feeunit::mulDivU(mul, value, div);
-}
-
-template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
-std::optional<Dest>
-mulDiv(std::uint64_t value, Dest mul, std::uint64_t div)
-{
-    // Give the scalars a non-tag so the
-    // unit-handling version gets called.
-    return feeunit::mulDivU(feeunit::scalar(value), mul, feeunit::scalar(div));
-}
-
-template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
-std::optional<Dest>
-mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
-{
-    // Multiplication is commutative
-    return mulDiv(mul, value, div);
-}
-
-template <
-    class Source1,
-    class Source2,
-    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
-std::optional<std::uint64_t>
-mulDiv(Source1 value, std::uint64_t mul, Source2 div)
-{
-    // Give the scalars a dimensionless unit so the
-    // unit-handling version gets called.
-    auto unitresult = feeunit::mulDivU(value, feeunit::scalar(mul), div);
-
-    if (!unitresult)
-        return std::nullopt;
-
-    return unitresult->value();
-}
-
-template <
-    class Source1,
-    class Source2,
-    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
-std::optional<std::uint64_t>
-mulDiv(std::uint64_t value, Source1 mul, Source2 div)
-{
-    // Multiplication is commutative
-    return mulDiv(mul, value, div);
-}
-
-template <class Dest, class Src>
-constexpr std::enable_if_t<
-    std::is_same_v<typename Dest::unit_type, typename Src::unit_type> &&
-        std::is_integral_v<typename Dest::value_type> &&
-        std::is_integral_v<typename Src::value_type>,
-    Dest>
-safe_cast(Src s) noexcept
-{
-    // Dest may not have an explicit value constructor
-    return Dest{safe_cast<typename Dest::value_type>(s.value())};
-}
-
-template <class Dest, class Src>
-constexpr std::enable_if_t<
-    std::is_same_v<typename Dest::unit_type, typename Src::unit_type> &&
-        std::is_integral_v<typename Dest::value_type> &&
-        std::is_integral_v<typename Src::value_type>,
-    Dest>
-unsafe_cast(Src s) noexcept
-{
-    // Dest may not have an explicit value constructor
-    return Dest{unsafe_cast<typename Dest::value_type>(s.value())};
-}
-
-}  // namespace ripple
-
-#endif  // BASICS_FEES_H_INCLUDED

include/xrpl/protocol/Indexes.h

@@ -287,9 +287,11 @@ delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept;
 Keylet
 bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType);
 
+// `seq` is stored as `sfXChainClaimID` in the object
 Keylet
 xChainClaimID(STXChainBridge const& bridge, std::uint64_t seq);
 
+// `seq` is stored as `sfXChainAccountCreateCount` in the object
 Keylet
 xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t seq);
 

include/xrpl/protocol/LedgerFormats.h

@@ -56,7 +56,7 @@ enum LedgerEntryType : std::uint16_t
 #pragma push_macro("LEDGER_ENTRY")
 #undef LEDGER_ENTRY
 
-#define LEDGER_ENTRY(tag, value, name, rpcName, fields) tag = value,
+#define LEDGER_ENTRY(tag, value, ...) tag = value,
 
 #include <xrpl/protocol/detail/ledger_entries.macro>
 
@@ -188,6 +188,15 @@ enum LedgerSpecificFlags {
     lsfMPTCanTransfer = 0x00000020,
     lsfMPTCanClawback = 0x00000040,
 
+    lsmfMPTCanMutateCanLock = 0x00000002,
+    lsmfMPTCanMutateRequireAuth = 0x00000004,
+    lsmfMPTCanMutateCanEscrow = 0x00000008,
+    lsmfMPTCanMutateCanTrade = 0x00000010,
+    lsmfMPTCanMutateCanTransfer = 0x00000020,
+    lsmfMPTCanMutateCanClawback = 0x00000040,
+    lsmfMPTCanMutateMetadata = 0x00010000,
+    lsmfMPTCanMutateTransferFee = 0x00020000,
+
     // ltMPTOKEN
     lsfMPTAuthorized = 0x00000002,
 

include/xrpl/protocol/Permissions.h

@@ -74,6 +74,9 @@ public:
     Permission&
     operator=(Permission const&) = delete;
 
+    std::optional<std::string>
+    getPermissionName(std::uint32_t const value) const;
+
     std::optional<std::uint32_t>
     getGranularValue(std::string const& name) const;
 
@@ -83,6 +86,9 @@ public:
     std::optional<TxType>
     getGranularTxType(GranularPermissionType const& gpType) const;
 
+    std::optional<std::reference_wrapper<uint256 const>> const
+    getTxFeature(TxType txType) const;
+
     bool
     isDelegatable(std::uint32_t const& permissionValue, Rules const& rules)
         const;

include/xrpl/protocol/Protocol.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/basics/ByteUtilities.h>
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/partitioned_unordered_map.h>
 
 #include <cstdint>
 

include/xrpl/protocol/SField.h

@@ -22,6 +22,7 @@
 
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/Units.h>
 
 #include <cstdint>
 #include <map>
@@ -71,8 +72,10 @@ class STCurrency;
     STYPE(STI_VL, 7)                              \
     STYPE(STI_ACCOUNT, 8)                         \
     STYPE(STI_NUMBER, 9)                          \
+    STYPE(STI_INT32, 10)                          \
+    STYPE(STI_INT64, 11)                          \
                                                   \
-    /* 10-13 are reserved */                      \
+    /* 12-13 are reserved */                      \
     STYPE(STI_OBJECT, 14)                         \
     STYPE(STI_ARRAY, 15)                          \
                                                   \
@@ -148,8 +151,10 @@ public:
         sMD_ChangeNew = 0x02,    // new value when it changes
         sMD_DeleteFinal = 0x04,  // final value when it is deleted
         sMD_Create = 0x08,       // value when it's created
-        sMD_Always = 0x10,  // value when node containing it is affected at all
-        sMD_BaseTen = 0x20,
+        sMD_Always = 0x10,   // value when node containing it is affected at all
+        sMD_BaseTen = 0x20,  // value is treated as base 10, overriding behavior
+        sMD_PseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
+        // _only_, then it is a pseudo-account
         sMD_Default =
             sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create
     };
@@ -184,7 +189,7 @@ public:
         char const* fn,
         int meta = sMD_Default,
         IsSigning signing = IsSigning::yes);
-    explicit SField(private_access_tag_t, int fc);
+    explicit SField(private_access_tag_t, int fc, char const* fn);
 
     static SField const&
     getField(int fieldCode);
@@ -297,7 +302,7 @@ public:
     static int
     compare(SField const& f1, SField const& f2);
 
-    static std::map<int, SField const*> const&
+    static std::unordered_map<int, SField const*> const&
     getKnownCodeToField()
     {
         return knownCodeToField;
@@ -305,7 +310,8 @@ public:
 
 private:
     static int num;
-    static std::map<int, SField const*> knownCodeToField;
+    static std::unordered_map<int, SField const*> knownCodeToField;
+    static std::unordered_map<std::string, SField const*> knownNameToField;
 };
 
 /** A field with a type known at compile time. */
@@ -352,6 +358,9 @@ using SF_UINT256 = TypedField<STBitString<256>>;
 using SF_UINT384 = TypedField<STBitString<384>>;
 using SF_UINT512 = TypedField<STBitString<512>>;
 
+using SF_INT32 = TypedField<STInteger<std::int32_t>>;
+using SF_INT64 = TypedField<STInteger<std::int64_t>>;
+
 using SF_ACCOUNT = TypedField<STAccount>;
 using SF_AMOUNT = TypedField<STAmount>;
 using SF_ISSUE = TypedField<STIssue>;

include/xrpl/protocol/STInteger.h

@@ -81,6 +81,8 @@ using STUInt16 = STInteger<std::uint16_t>;
 using STUInt32 = STInteger<std::uint32_t>;
 using STUInt64 = STInteger<std::uint64_t>;
 
+using STInt32 = STInteger<std::int32_t>;
+
 template <typename Integer>
 inline STInteger<Integer>::STInteger(Integer v) : value_(v)
 {

include/xrpl/protocol/STLedgerEntry.h

@@ -26,7 +26,9 @@
 namespace ripple {
 
 class Rules;
+namespace test {
 class Invariants_test;
+}
 
 class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 {
@@ -36,6 +38,8 @@ class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 public:
     using pointer = std::shared_ptr<STLedgerEntry>;
     using ref = std::shared_ptr<STLedgerEntry> const&;
+    using const_pointer = std::shared_ptr<STLedgerEntry const>;
+    using const_ref = std::shared_ptr<STLedgerEntry const> const&;
 
     /** Create an empty object with the given key and type. */
     explicit STLedgerEntry(Keylet const& k);
@@ -54,7 +58,7 @@ public:
     getText() const override;
 
     Json::Value
-    getJson(JsonOptions options) const override;
+    getJson(JsonOptions options = JsonOptions::none) const override;
 
     /** Returns the 'key' (or 'index') of this item.
         The key identifies this entry's position in
@@ -84,7 +88,8 @@ private:
     void
     setSLEType();
 
-    friend Invariants_test;  // this test wants access to the private type_
+    friend test::Invariants_test;  // this test wants access to the private
+                                   // type_
 
     STBase*
     copy(std::size_t n, void* buf) const override;

include/xrpl/protocol/STObject.h

@@ -25,7 +25,6 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/STAmount.h>
@@ -34,6 +33,7 @@
 #include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/STPathSet.h>
 #include <xrpl/protocol/STVector256.h>
+#include <xrpl/protocol/Units.h>
 #include <xrpl/protocol/detail/STVar.h>
 
 #include <boost/iterator/transform_iterator.hpp>
@@ -231,6 +231,8 @@ public:
     getFieldH192(SField const& field) const;
     uint256
     getFieldH256(SField const& field) const;
+    std::int32_t
+    getFieldI32(SField const& field) const;
     AccountID
     getAccountID(SField const& field) const;
 
@@ -365,6 +367,8 @@ public:
     void
     setFieldH256(SField const& field, uint256 const&);
     void
+    setFieldI32(SField const& field, std::int32_t);
+    void
     setFieldVL(SField const& field, Blob const&);
     void
     setFieldVL(SField const& field, Slice const&);

include/xrpl/protocol/STParsedJSON.h

@@ -54,34 +54,6 @@ public:
     Json::Value error;
 };
 
-/** Holds the serialized result of parsing an input JSON array.
-    This does validation and checking on the provided JSON.
-*/
-class STParsedJSONArray
-{
-public:
-    /** Parses and creates an STParsedJSON array.
-        The result of the parsing is stored in array and error.
-        Exceptions:
-            Does not throw.
-        @param name The name of the JSON field, used in diagnostics.
-        @param json The JSON-RPC to parse.
-    */
-    STParsedJSONArray(std::string const& name, Json::Value const& json);
-
-    STParsedJSONArray() = delete;
-    STParsedJSONArray(STParsedJSONArray const&) = delete;
-    STParsedJSONArray&
-    operator=(STParsedJSONArray const&) = delete;
-    ~STParsedJSONArray() = default;
-
-    /** The STArray if the parse was successful. */
-    std::optional<STArray> array;
-
-    /** On failure, an appropriate set of error values. */
-    Json::Value error;
-};
-
 }  // namespace ripple
 
 #endif

include/xrpl/protocol/STValidation.h

@@ -22,10 +22,10 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Units.h>
 
 #include <cstdint>
 #include <optional>

include/xrpl/protocol/TER.h

@@ -673,7 +673,8 @@ isTerRetry(TER x) noexcept
 inline bool
 isTesSuccess(TER x) noexcept
 {
-    return (x == tesSUCCESS);
+    // Makes use of TERSubset::operator bool()
+    return !(x);
 }
 
 inline bool

include/xrpl/protocol/TxFlags.h

@@ -127,6 +127,8 @@ constexpr std::uint32_t tfTrustSetPermissionMask = ~(tfUniversal | tfSetfAuth |
 // EnableAmendment flags:
 constexpr std::uint32_t tfGotMajority                      = 0x00010000;
 constexpr std::uint32_t tfLostMajority                     = 0x00020000;
+constexpr std::uint32_t tfChangeMask =
+    ~( tfUniversal | tfGotMajority | tfLostMajority);
 
 // PaymentChannelClaim flags:
 constexpr std::uint32_t tfRenew                            = 0x00010000;
@@ -141,7 +143,8 @@ constexpr std::uint32_t const tfTransferable               = 0x00000008;
 constexpr std::uint32_t const tfMutable                    = 0x00000010;
 
 // MPTokenIssuanceCreate flags:
-// NOTE - there is intentionally no flag here for lsfMPTLocked, which this transaction cannot mutate.
+// Note: tf/lsfMPTLocked is intentionally omitted, since this transaction
+// is not allowed to modify it.
 constexpr std::uint32_t const tfMPTCanLock                 = lsfMPTCanLock;
 constexpr std::uint32_t const tfMPTRequireAuth             = lsfMPTRequireAuth;
 constexpr std::uint32_t const tfMPTCanEscrow               = lsfMPTCanEscrow;
@@ -151,6 +154,20 @@ constexpr std::uint32_t const tfMPTCanClawback             = lsfMPTCanClawback;
 constexpr std::uint32_t const tfMPTokenIssuanceCreateMask  =
   ~(tfUniversal | tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow | tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback);
 
+// MPTokenIssuanceCreate MutableFlags:
+// Indicating specific fields or flags may be changed after issuance.
+constexpr std::uint32_t const tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
+constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
+constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
+constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
+constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
+constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
+constexpr std::uint32_t const tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
+constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
+constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
+  ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
+    | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
+
 // MPTokenAuthorize flags:
 constexpr std::uint32_t const tfMPTUnauthorize             = 0x00000001;
 constexpr std::uint32_t const tfMPTokenAuthorizeMask  = ~(tfUniversal | tfMPTUnauthorize);
@@ -161,6 +178,25 @@ constexpr std::uint32_t const tfMPTUnlock                 = 0x00000002;
 constexpr std::uint32_t const tfMPTokenIssuanceSetMask  = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
 constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
 
+// MPTokenIssuanceSet MutableFlags:
+// Set or Clear flags.
+constexpr std::uint32_t const tmfMPTSetCanLock             = 0x00000001;
+constexpr std::uint32_t const tmfMPTClearCanLock           = 0x00000002;
+constexpr std::uint32_t const tmfMPTSetRequireAuth         = 0x00000004;
+constexpr std::uint32_t const tmfMPTClearRequireAuth       = 0x00000008;
+constexpr std::uint32_t const tmfMPTSetCanEscrow           = 0x00000010;
+constexpr std::uint32_t const tmfMPTClearCanEscrow         = 0x00000020;
+constexpr std::uint32_t const tmfMPTSetCanTrade            = 0x00000040;
+constexpr std::uint32_t const tmfMPTClearCanTrade          = 0x00000080;
+constexpr std::uint32_t const tmfMPTSetCanTransfer         = 0x00000100;
+constexpr std::uint32_t const tmfMPTClearCanTransfer       = 0x00000200;
+constexpr std::uint32_t const tmfMPTSetCanClawback         = 0x00000400;
+constexpr std::uint32_t const tmfMPTClearCanClawback       = 0x00000800;
+constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
+    tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
+    tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
+    tmfMPTSetCanClawback | tmfMPTClearCanClawback);
+
 // MPTokenIssuanceDestroy flags:
 constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask  = ~tfUniversal;
 

include/xrpl/protocol/Units.h

@@ -0,0 +1,555 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2019 Ripple Labs Inc.
+
+    Permission to use, copy, modify, and/or 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.
+*/
+
+#ifndef PROTOCOL_UNITS_H_INCLUDED
+#define PROTOCOL_UNITS_H_INCLUDED
+
+#include <xrpl/basics/safe_cast.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/json/json_value.h>
+
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/operators.hpp>
+
+#include <iosfwd>
+#include <limits>
+#include <optional>
+
+namespace ripple {
+
+namespace unit {
+
+/** "drops" are the smallest divisible amount of XRP. This is what most
+    of the code uses. */
+struct dropTag;
+/** "fee levels" are used by the transaction queue to compare the relative
+    cost of transactions that require different levels of effort to process.
+    See also: src/ripple/app/misc/FeeEscalation.md#fee-level */
+struct feelevelTag;
+/** unitless values are plain scalars wrapped in a ValueUnit. They are
+    used for calculations in this header. */
+struct unitlessTag;
+
+/** Units to represent basis points (bips) and 1/10 basis points */
+class BipsTag;
+class TenthBipsTag;
+
+// These names don't have to be too descriptive, because we're in the "unit"
+// namespace.
+
+template <class T>
+concept Valid = std::is_class_v<T> && std::is_object_v<typename T::unit_type> &&
+    std::is_object_v<typename T::value_type>;
+
+/** `Usable` is checked to ensure that only values with
+    known valid type tags can be used (sometimes transparently) in
+    non-unit contexts. At the time of implementation, this includes
+    all known tags, but more may be added in the future, and they
+    should not be added automatically unless determined to be
+    appropriate.
+*/
+template <class T>
+concept Usable = Valid<T> &&
+    (std::is_same_v<typename T::unit_type, feelevelTag> ||
+     std::is_same_v<typename T::unit_type, unitlessTag> ||
+     std::is_same_v<typename T::unit_type, dropTag> ||
+     std::is_same_v<typename T::unit_type, BipsTag> ||
+     std::is_same_v<typename T::unit_type, TenthBipsTag>);
+
+template <class Other, class VU>
+concept Compatible = Valid<VU> && std::is_arithmetic_v<Other> &&
+    std::is_arithmetic_v<typename VU::value_type> &&
+    std::is_convertible_v<Other, typename VU::value_type>;
+
+template <class T>
+concept Integral = std::is_integral_v<T>;
+
+template <class VU>
+concept IntegralValue = Integral<typename VU::value_type>;
+
+template <class VU1, class VU2>
+concept CastableValue = IntegralValue<VU1> && IntegralValue<VU2> &&
+    std::is_same_v<typename VU1::unit_type, typename VU2::unit_type>;
+
+template <class UnitTag, class T>
+class ValueUnit : private boost::totally_ordered<ValueUnit<UnitTag, T>>,
+                  private boost::additive<ValueUnit<UnitTag, T>>,
+                  private boost::equality_comparable<ValueUnit<UnitTag, T>, T>,
+                  private boost::dividable<ValueUnit<UnitTag, T>, T>,
+                  private boost::modable<ValueUnit<UnitTag, T>, T>,
+                  private boost::unit_steppable<ValueUnit<UnitTag, T>>
+{
+public:
+    using unit_type = UnitTag;
+    using value_type = T;
+
+private:
+    value_type value_;
+
+public:
+    ValueUnit() = default;
+    constexpr ValueUnit(ValueUnit const& other) = default;
+    constexpr ValueUnit&
+    operator=(ValueUnit const& other) = default;
+
+    constexpr explicit ValueUnit(beast::Zero) : value_(0)
+    {
+    }
+
+    constexpr ValueUnit&
+    operator=(beast::Zero)
+    {
+        value_ = 0;
+        return *this;
+    }
+
+    constexpr explicit ValueUnit(value_type value) : value_(value)
+    {
+    }
+
+    constexpr ValueUnit&
+    operator=(value_type value)
+    {
+        value_ = value;
+        return *this;
+    }
+
+    /** Instances with the same unit, and a type that is
+        "safe" to convert to this one can be converted
+        implicitly */
+    template <Compatible<ValueUnit> Other>
+    constexpr ValueUnit(ValueUnit<unit_type, Other> const& value)
+        requires SafeToCast<Other, value_type>
+        : ValueUnit(safe_cast<value_type>(value.value()))
+    {
+    }
+
+    constexpr ValueUnit
+    operator+(value_type const& rhs) const
+    {
+        return ValueUnit{value_ + rhs};
+    }
+
+    friend constexpr ValueUnit
+    operator+(value_type lhs, ValueUnit const& rhs)
+    {
+        // addition is commutative
+        return rhs + lhs;
+    }
+
+    constexpr ValueUnit
+    operator-(value_type const& rhs) const
+    {
+        return ValueUnit{value_ - rhs};
+    }
+
+    friend constexpr ValueUnit
+    operator-(value_type lhs, ValueUnit const& rhs)
+    {
+        // subtraction is NOT commutative, but (lhs + (-rhs)) is addition, which
+        // is
+        return -rhs + lhs;
+    }
+
+    constexpr ValueUnit
+    operator*(value_type const& rhs) const
+    {
+        return ValueUnit{value_ * rhs};
+    }
+
+    friend constexpr ValueUnit
+    operator*(value_type lhs, ValueUnit const& rhs)
+    {
+        // multiplication is commutative
+        return rhs * lhs;
+    }
+
+    constexpr value_type
+    operator/(ValueUnit const& rhs) const
+    {
+        return value_ / rhs.value_;
+    }
+
+    ValueUnit&
+    operator+=(ValueUnit const& other)
+    {
+        value_ += other.value();
+        return *this;
+    }
+
+    ValueUnit&
+    operator-=(ValueUnit const& other)
+    {
+        value_ -= other.value();
+        return *this;
+    }
+
+    ValueUnit&
+    operator++()
+    {
+        ++value_;
+        return *this;
+    }
+
+    ValueUnit&
+    operator--()
+    {
+        --value_;
+        return *this;
+    }
+
+    ValueUnit&
+    operator*=(value_type const& rhs)
+    {
+        value_ *= rhs;
+        return *this;
+    }
+
+    ValueUnit&
+    operator/=(value_type const& rhs)
+    {
+        value_ /= rhs;
+        return *this;
+    }
+
+    template <Integral transparent = value_type>
+    ValueUnit&
+    operator%=(value_type const& rhs)
+    {
+        value_ %= rhs;
+        return *this;
+    }
+
+    ValueUnit
+    operator-() const
+    {
+        static_assert(
+            std::is_signed_v<T>, "- operator illegal on unsigned value types");
+        return ValueUnit{-value_};
+    }
+
+    constexpr bool
+    operator==(ValueUnit const& other) const
+    {
+        return value_ == other.value_;
+    }
+
+    template <Compatible<ValueUnit> Other>
+    constexpr bool
+    operator==(ValueUnit<unit_type, Other> const& other) const
+    {
+        return value_ == other.value();
+    }
+
+    constexpr bool
+    operator==(value_type other) const
+    {
+        return value_ == other;
+    }
+
+    template <Compatible<ValueUnit> Other>
+    constexpr bool
+    operator!=(ValueUnit<unit_type, Other> const& other) const
+    {
+        return !operator==(other);
+    }
+
+    constexpr bool
+    operator<(ValueUnit const& other) const
+    {
+        return value_ < other.value_;
+    }
+
+    /** Returns true if the amount is not zero */
+    explicit constexpr
+    operator bool() const noexcept
+    {
+        return value_ != 0;
+    }
+
+    /** Return the sign of the amount */
+    constexpr int
+    signum() const noexcept
+    {
+        return (value_ < 0) ? -1 : (value_ ? 1 : 0);
+    }
+
+    /** Returns the number of drops */
+    // TODO: Move this to a new class, maybe with the old "TaggedFee" name
+    constexpr value_type
+    fee() const
+    {
+        return value_;
+    }
+
+    template <class Other>
+    constexpr double
+    decimalFromReference(ValueUnit<unit_type, Other> reference) const
+    {
+        return static_cast<double>(value_) / reference.value();
+    }
+
+    // `Usable` is checked to ensure that only values with
+    // known valid type tags can be converted to JSON. At the time
+    // of implementation, that includes all known tags, but more may
+    // be added in the future.
+    Json::Value
+    jsonClipped() const
+        requires Usable<ValueUnit>
+    {
+        if constexpr (std::is_integral_v<value_type>)
+        {
+            using jsontype = std::conditional_t<
+                std::is_signed_v<value_type>,
+                Json::Int,
+                Json::UInt>;
+
+            constexpr auto min = std::numeric_limits<jsontype>::min();
+            constexpr auto max = std::numeric_limits<jsontype>::max();
+
+            if (value_ < min)
+                return min;
+            if (value_ > max)
+                return max;
+            return static_cast<jsontype>(value_);
+        }
+        else
+        {
+            return value_;
+        }
+    }
+
+    /** Returns the underlying value. Code SHOULD NOT call this
+        function unless the type has been abstracted away,
+        e.g. in a templated function.
+    */
+    constexpr value_type
+    value() const
+    {
+        return value_;
+    }
+
+    friend std::istream&
+    operator>>(std::istream& s, ValueUnit& val)
+    {
+        s >> val.value_;
+        return s;
+    }
+};
+
+// Output Values as just their numeric value.
+template <class Char, class Traits, class UnitTag, class T>
+std::basic_ostream<Char, Traits>&
+operator<<(std::basic_ostream<Char, Traits>& os, ValueUnit<UnitTag, T> const& q)
+{
+    return os << q.value();
+}
+
+template <class UnitTag, class T>
+std::string
+to_string(ValueUnit<UnitTag, T> const& amount)
+{
+    return std::to_string(amount.value());
+}
+
+template <class Source>
+concept muldivSource = Valid<Source> &&
+    std::is_convertible_v<typename Source::value_type, std::uint64_t>;
+
+template <class Dest>
+concept muldivDest = muldivSource<Dest> &&  // Dest is also a source
+    std::is_convertible_v<std::uint64_t, typename Dest::value_type> &&
+    sizeof(typename Dest::value_type) >= sizeof(std::uint64_t);
+
+template <class Source2, class Source1>
+concept muldivSources = muldivSource<Source1> && muldivSource<Source2> &&
+    std::is_same_v<typename Source1::unit_type, typename Source2::unit_type>;
+
+template <class Dest, class Source1, class Source2>
+concept muldivable = muldivSources<Source1, Source2> && muldivDest<Dest>;
+// Source and Dest can be the same by default
+
+template <class Dest, class Source1, class Source2>
+concept muldivCommutable = muldivable<Dest, Source1, Source2> &&
+    !std::is_same_v<typename Source1::unit_type, typename Dest::unit_type>;
+
+template <class T>
+ValueUnit<unitlessTag, T>
+scalar(T value)
+{
+    return ValueUnit<unitlessTag, T>{value};
+}
+
+template <class Source1, class Source2, unit::muldivable<Source1, Source2> Dest>
+std::optional<Dest>
+mulDivU(Source1 value, Dest mul, Source2 div)
+{
+    // values can never be negative in any context.
+    if (value.value() < 0 || mul.value() < 0 || div.value() < 0)
+    {
+        // split the asserts so if one hits, the user can tell which
+        // without a debugger.
+        XRPL_ASSERT(
+            value.value() >= 0, "ripple::unit::mulDivU : minimum value input");
+        XRPL_ASSERT(
+            mul.value() >= 0, "ripple::unit::mulDivU : minimum mul input");
+        XRPL_ASSERT(
+            div.value() > 0, "ripple::unit::mulDivU : minimum div input");
+        return std::nullopt;
+    }
+
+    using desttype = typename Dest::value_type;
+    constexpr auto max = std::numeric_limits<desttype>::max();
+
+    // Shortcuts, since these happen a lot in the real world
+    if (value == div)
+        return mul;
+    if (mul.value() == div.value())
+    {
+        if (value.value() > max)
+            return std::nullopt;
+        return Dest{static_cast<desttype>(value.value())};
+    }
+
+    using namespace boost::multiprecision;
+
+    uint128_t product;
+    product = multiply(
+        product,
+        static_cast<std::uint64_t>(value.value()),
+        static_cast<std::uint64_t>(mul.value()));
+
+    auto quotient = product / div.value();
+
+    if (quotient > max)
+        return std::nullopt;
+
+    return Dest{static_cast<desttype>(quotient)};
+}
+
+}  // namespace unit
+
+// Fee Levels
+template <class T>
+using FeeLevel = unit::ValueUnit<unit::feelevelTag, T>;
+using FeeLevel64 = FeeLevel<std::uint64_t>;
+using FeeLevelDouble = FeeLevel<double>;
+
+// Basis points (Bips)
+template <class T>
+using Bips = unit::ValueUnit<unit::BipsTag, T>;
+using Bips16 = Bips<std::uint16_t>;
+using Bips32 = Bips<std::uint32_t>;
+template <class T>
+using TenthBips = unit::ValueUnit<unit::TenthBipsTag, T>;
+using TenthBips16 = TenthBips<std::uint16_t>;
+using TenthBips32 = TenthBips<std::uint32_t>;
+
+template <class Source1, class Source2, unit::muldivable<Source1, Source2> Dest>
+std::optional<Dest>
+mulDiv(Source1 value, Dest mul, Source2 div)
+{
+    return unit::mulDivU(value, mul, div);
+}
+
+template <
+    class Source1,
+    class Source2,
+    unit::muldivCommutable<Source1, Source2> Dest>
+std::optional<Dest>
+mulDiv(Dest value, Source1 mul, Source2 div)
+{
+    // Multiplication is commutative
+    return unit::mulDivU(mul, value, div);
+}
+
+template <unit::muldivDest Dest>
+std::optional<Dest>
+mulDiv(std::uint64_t value, Dest mul, std::uint64_t div)
+{
+    // Give the scalars a non-tag so the
+    // unit-handling version gets called.
+    return unit::mulDivU(unit::scalar(value), mul, unit::scalar(div));
+}
+
+template <unit::muldivDest Dest>
+std::optional<Dest>
+mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
+{
+    // Multiplication is commutative
+    return mulDiv(mul, value, div);
+}
+
+template <unit::muldivSource Source1, unit::muldivSources<Source1> Source2>
+std::optional<std::uint64_t>
+mulDiv(Source1 value, std::uint64_t mul, Source2 div)
+{
+    // Give the scalars a dimensionless unit so the
+    // unit-handling version gets called.
+    auto unitresult = unit::mulDivU(value, unit::scalar(mul), div);
+
+    if (!unitresult)
+        return std::nullopt;
+
+    return unitresult->value();
+}
+
+template <unit::muldivSource Source1, unit::muldivSources<Source1> Source2>
+std::optional<std::uint64_t>
+mulDiv(std::uint64_t value, Source1 mul, Source2 div)
+{
+    // Multiplication is commutative
+    return mulDiv(mul, value, div);
+}
+
+template <unit::IntegralValue Dest, unit::CastableValue<Dest> Src>
+constexpr Dest
+safe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{safe_cast<typename Dest::value_type>(s.value())};
+}
+
+template <unit::IntegralValue Dest, unit::Integral Src>
+constexpr Dest
+safe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{safe_cast<typename Dest::value_type>(s)};
+}
+
+template <unit::IntegralValue Dest, unit::CastableValue<Dest> Src>
+constexpr Dest
+unsafe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{unsafe_cast<typename Dest::value_type>(s.value())};
+}
+
+template <unit::IntegralValue Dest, unit::Integral Src>
+constexpr Dest
+unsafe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{unsafe_cast<typename Dest::value_type>(s)};
+}
+
+}  // namespace ripple
+
+#endif  // PROTOCOL_UNITS_H_INCLUDED

include/xrpl/protocol/XRPAmount.h

@@ -24,7 +24,7 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/json/json_value.h>
-#include <xrpl/protocol/FeeUnits.h>
+#include <xrpl/protocol/Units.h>
 
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
@@ -42,7 +42,7 @@ class XRPAmount : private boost::totally_ordered<XRPAmount>,
                   private boost::additive<XRPAmount, std::int64_t>
 {
 public:
-    using unit_type = feeunit::dropTag;
+    using unit_type = unit::dropTag;
     using value_type = std::int64_t;
 
 private:

include/xrpl/protocol/detail/features.macro

@@ -32,8 +32,11 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
+XRPL_FIX    (IncludeKeyletFields,        Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(DynamicMPT,                 Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FIX    (TokenEscrowV1,              Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (DelegateV1_1,               Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FIX    (PriceOracleOrder,           Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FIX    (PriceOracleOrder,           Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (MPTDeliveredAmount,         Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (AMMClawbackRounding,        Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(TokenEscrow,                Supported::yes, VoteBehavior::DefaultNo)
@@ -42,7 +45,7 @@ XRPL_FIX    (AMMv1_3,                    Supported::yes, VoteBehavior::DefaultNo
 XRPL_FEATURE(PermissionedDEX,            Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Batch,                      Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(SingleAssetVault,           Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(PermissionDelegation,       Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(PermissionDelegation,       Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (PayChanCancelAfter,         Supported::yes, VoteBehavior::DefaultNo)
 // Check flags in Credential transactions
 XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -120,6 +120,7 @@ LEDGER_ENTRY(ltNFTOKEN_PAGE, 0x0050, NFTokenPage, nft_page, ({
 // All fields are soeREQUIRED because there is always a SignerEntries.
 // If there are no SignerEntries the node is deleted.
 LEDGER_ENTRY(ltSIGNER_LIST, 0x0053, SignerList, signer_list, ({
+    {sfOwner,                soeOPTIONAL},
     {sfOwnerNode,            soeREQUIRED},
     {sfSignerQuorum,         soeREQUIRED},
     {sfSignerEntries,        soeREQUIRED},
@@ -188,7 +189,7 @@ LEDGER_ENTRY(ltDIR_NODE, 0x0064, DirectoryNode, directory, ({
     {sfNFTokenID,            soeOPTIONAL},
     {sfPreviousTxnID,        soeOPTIONAL},
     {sfPreviousTxnLgrSeq,    soeOPTIONAL},
-    {sfDomainID,             soeOPTIONAL}
+    {sfDomainID,             soeOPTIONAL}   // order book directories
 }))
 
 /** The ledger object which lists details about amendments on the network.
@@ -343,6 +344,7 @@ LEDGER_ENTRY(ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID, 0x0074, XChainOwnedCreateAc
  */
 LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
     {sfAccount,              soeREQUIRED},
+    {sfSequence,             soeOPTIONAL},
     {sfDestination,          soeREQUIRED},
     {sfAmount,               soeREQUIRED},
     {sfCondition,            soeOPTIONAL},
@@ -365,6 +367,7 @@ LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
 LEDGER_ENTRY(ltPAYCHAN, 0x0078, PayChannel, payment_channel, ({
     {sfAccount,              soeREQUIRED},
     {sfDestination,          soeREQUIRED},
+    {sfSequence,             soeOPTIONAL},
     {sfAmount,               soeREQUIRED},
     {sfBalance,              soeREQUIRED},
     {sfPublicKey,            soeREQUIRED},
@@ -412,6 +415,7 @@ LEDGER_ENTRY(ltMPTOKEN_ISSUANCE, 0x007e, MPTokenIssuance, mpt_issuance, ({
     {sfPreviousTxnID,            soeREQUIRED},
     {sfPreviousTxnLgrSeq,        soeREQUIRED},
     {sfDomainID,                 soeOPTIONAL},
+    {sfMutableFlags,             soeDEFAULT},
 }))
 
 /** A ledger object which tracks MPToken
@@ -432,6 +436,7 @@ LEDGER_ENTRY(ltMPTOKEN, 0x007f, MPToken, mptoken, ({
  */
 LEDGER_ENTRY(ltORACLE, 0x0080, Oracle, oracle, ({
     {sfOwner,                soeREQUIRED},
+    {sfOracleDocumentID,     soeOPTIONAL},
     {sfProvider,             soeREQUIRED},
     {sfPriceDataSeries,      soeREQUIRED},
     {sfAssetClass,           soeREQUIRED},

include/xrpl/protocol/detail/sfields.macro

@@ -114,6 +114,7 @@ TYPED_SFIELD(sfVoteWeight,               UINT32,    48)
 TYPED_SFIELD(sfFirstNFTokenSequence,     UINT32,    50)
 TYPED_SFIELD(sfOracleDocumentID,         UINT32,    51)
 TYPED_SFIELD(sfPermissionValue,          UINT32,    52)
+TYPED_SFIELD(sfMutableFlags,             UINT32,    53)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -173,7 +174,8 @@ TYPED_SFIELD(sfNFTokenID,                UINT256,   10)
 TYPED_SFIELD(sfEmitParentTxnID,          UINT256,   11)
 TYPED_SFIELD(sfEmitNonce,                UINT256,   12)
 TYPED_SFIELD(sfEmitHookHash,             UINT256,   13)
-TYPED_SFIELD(sfAMMID,                    UINT256,   14)
+TYPED_SFIELD(sfAMMID,                    UINT256,   14,
+    SField::sMD_PseudoAccount | SField::sMD_Default)
 
 // 256-bit (uncommon)
 TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
@@ -195,7 +197,8 @@ TYPED_SFIELD(sfHookHash,                 UINT256,   31)
 TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
-TYPED_SFIELD(sfVaultID,                  UINT256,   35)
+TYPED_SFIELD(sfVaultID,                  UINT256,   35,
+    SField::sMD_PseudoAccount | SField::sMD_Default)
 TYPED_SFIELD(sfParentBatchID,            UINT256,   36)
 
 // number (common)
@@ -205,6 +208,12 @@ TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3)
 TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4)
 TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5)
 
+// int32
+// NOTE: Do not use `sfDummyInt32`. It's so far the only use of INT32
+// in this file and has been defined here for test only.
+// TODO: Replace `sfDummyInt32` with actually useful field.
+TYPED_SFIELD(sfDummyInt32,               INT32,      1) // for tests only
+
 // currency amount (common)
 TYPED_SFIELD(sfAmount,                   AMOUNT,     1)
 TYPED_SFIELD(sfBalance,                  AMOUNT,     2)

include/xrpl/protocol/detail/transactions.macro

@@ -22,16 +22,31 @@
 #endif
 
 /**
- * TRANSACTION(tag, value, name, delegatable, amendments, fields)
+ * TRANSACTION(tag, value, name, delegatable, amendments, privileges, fields)
+ *
+ * To ease maintenance, you may replace any unneeded values with "..."
+ * e.g. #define TRANSACTION(tag, value, name, ...)
  *
  * You must define a transactor class in the `ripple` namespace named `name`,
- * and include its header in `src/xrpld/app/tx/detail/applySteps.cpp`.
+ * and include its header alongside the TRANSACTOR definition using this
+ * format:
+ * #if TRANSACTION_INCLUDE
+ * #   include <xrpld/app/tx/detail/HEADER.h>
+ * #endif
+ *
+ * The `privileges` parameter of the TRANSACTION macro is a bitfield
+ * defining which operations the transaction can perform.
+ * The values are defined and used in InvariantCheck.cpp
  */
 
 /** This transaction type executes a payment. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Payment.h>
+#endif
 TRANSACTION(ttPAYMENT, 0, Payment,
     Delegation::delegatable,
     uint256{},
+    createAcct,
     ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
@@ -45,9 +60,13 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 }))
 
 /** This transaction type creates an escrow object. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Escrow.h>
+#endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
@@ -61,6 +80,7 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
 TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
@@ -71,9 +91,13 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
 
 
 /** This transaction type adjusts various account settings. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetAccount.h>
+#endif
 TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfEmailHash, soeOPTIONAL},
     {sfWalletLocator, soeOPTIONAL},
@@ -88,18 +112,26 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 }))
 
 /** This transaction type cancels an existing escrow. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Escrow.h>
+#endif
 TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfOwner, soeREQUIRED},
     {sfOfferSequence, soeREQUIRED},
 }))
 
 /** This transaction type sets or clears an account's "regular key". */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetRegularKey.h>
+#endif
 TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfRegularKey, soeOPTIONAL},
 }))
@@ -107,9 +139,13 @@ TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
 // 6 deprecated
 
 /** This transaction type creates an offer to trade one asset for another. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateOffer.h>
+#endif
 TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfTakerPays, soeREQUIRED},
     {sfTakerGets, soeREQUIRED},
@@ -119,9 +155,13 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
 }))
 
 /** This transaction type cancels existing offers to trade one asset for another. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CancelOffer.h>
+#endif
 TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfOfferSequence, soeREQUIRED},
 }))
@@ -129,9 +169,13 @@ TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
 // 9 deprecated
 
 /** This transaction type creates a new set of tickets. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateTicket.h>
+#endif
 TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
     Delegation::delegatable,
     featureTicketBatch,
+    noPriv,
     ({
     {sfTicketCount, soeREQUIRED},
 }))
@@ -141,18 +185,26 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
 /** This transaction type modifies the signer list associated with an account. */
 // The SignerEntries are optional because a SignerList is deleted by
 // setting the SignerQuorum to zero and omitting SignerEntries.
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetSignerList.h>
+#endif
 TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfSignerQuorum, soeREQUIRED},
     {sfSignerEntries, soeOPTIONAL},
 }))
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PayChan.h>
+#endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfDestination, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -166,6 +218,7 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -176,6 +229,7 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
 TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfChannel, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -186,9 +240,13 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
 }))
 
 /** This transaction type creates a new check. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateCheck.h>
+#endif
 TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
     Delegation::delegatable,
     featureChecks,
+    noPriv,
     ({
     {sfDestination, soeREQUIRED},
     {sfSendMax, soeREQUIRED},
@@ -198,9 +256,13 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
 }))
 
 /** This transaction type cashes an existing check. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CashCheck.h>
+#endif
 TRANSACTION(ttCHECK_CASH, 17, CheckCash,
     Delegation::delegatable,
     featureChecks,
+    noPriv,
     ({
     {sfCheckID, soeREQUIRED},
     {sfAmount, soeOPTIONAL},
@@ -208,17 +270,25 @@ TRANSACTION(ttCHECK_CASH, 17, CheckCash,
 }))
 
 /** This transaction type cancels an existing check. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CancelCheck.h>
+#endif
 TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
     Delegation::delegatable,
     featureChecks,
+    noPriv,
     ({
     {sfCheckID, soeREQUIRED},
 }))
 
 /** This transaction type grants or revokes authorization to transfer funds. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DepositPreauth.h>
+#endif
 TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
     Delegation::delegatable,
     featureDepositPreauth,
+    noPriv,
     ({
     {sfAuthorize, soeOPTIONAL},
     {sfUnauthorize, soeOPTIONAL},
@@ -227,9 +297,13 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
 }))
 
 /** This transaction type modifies a trustline between two accounts. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetTrust.h>
+#endif
 TRANSACTION(ttTRUST_SET, 20, TrustSet,
     Delegation::delegatable,
     uint256{},
+    noPriv,
     ({
     {sfLimitAmount, soeOPTIONAL},
     {sfQualityIn, soeOPTIONAL},
@@ -237,9 +311,13 @@ TRANSACTION(ttTRUST_SET, 20, TrustSet,
 }))
 
 /** This transaction type deletes an existing account. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DeleteAccount.h>
+#endif
 TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
     Delegation::notDelegatable,
     uint256{},
+    mustDeleteAcct,
     ({
     {sfDestination, soeREQUIRED},
     {sfDestinationTag, soeOPTIONAL},
@@ -249,9 +327,13 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
 // 22 reserved
 
 /** This transaction mints a new NFT. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenMint.h>
+#endif
 TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
     Delegation::delegatable,
     featureNonFungibleTokensV1,
+    changeNFTCounts,
     ({
     {sfNFTokenTaxon, soeREQUIRED},
     {sfTransferFee, soeOPTIONAL},
@@ -263,18 +345,26 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
 }))
 
 /** This transaction burns (i.e. destroys) an existing NFT. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenBurn.h>
+#endif
 TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
     Delegation::delegatable,
     featureNonFungibleTokensV1,
+    changeNFTCounts,
     ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction creates a new offer to buy or sell an NFT. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenCreateOffer.h>
+#endif
 TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
     Delegation::delegatable,
     featureNonFungibleTokensV1,
+    noPriv,
     ({
     {sfNFTokenID, soeREQUIRED},
     {sfAmount, soeREQUIRED},
@@ -284,17 +374,25 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
 }))
 
 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenCancelOffer.h>
+#endif
 TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
     Delegation::delegatable,
     featureNonFungibleTokensV1,
+    noPriv,
     ({
     {sfNFTokenOffers, soeREQUIRED},
 }))
 
 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenAcceptOffer.h>
+#endif
 TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
     Delegation::delegatable,
     featureNonFungibleTokensV1,
+    noPriv,
     ({
     {sfNFTokenBuyOffer, soeOPTIONAL},
     {sfNFTokenSellOffer, soeOPTIONAL},
@@ -302,18 +400,26 @@ TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
 }))
 
 /** This transaction claws back issued tokens. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Clawback.h>
+#endif
 TRANSACTION(ttCLAWBACK, 30, Clawback,
     Delegation::delegatable,
     featureClawback,
+    noPriv,
     ({
     {sfAmount, soeREQUIRED, soeMPTSupported},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction claws back tokens from an AMM pool. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMClawback.h>
+#endif
 TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
     Delegation::delegatable,
     featureAMMClawback,
+    mayDeleteAcct | overrideFreeze,
     ({
     {sfHolder, soeREQUIRED},
     {sfAsset, soeREQUIRED},
@@ -322,9 +428,13 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
 }))
 
 /** This transaction type creates an AMM instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMCreate.h>
+#endif
 TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
     Delegation::delegatable,
     featureAMM,
+    createPseudoAcct,
     ({
     {sfAmount, soeREQUIRED},
     {sfAmount2, soeREQUIRED},
@@ -332,9 +442,13 @@ TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
 }))
 
 /** This transaction type deposits into an AMM instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMDeposit.h>
+#endif
 TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
     Delegation::delegatable,
     featureAMM,
+    noPriv,
     ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -346,9 +460,13 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
 }))
 
 /** This transaction type withdraws from an AMM instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMWithdraw.h>
+#endif
 TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
     Delegation::delegatable,
     featureAMM,
+    mayDeleteAcct,
     ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -359,9 +477,13 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
 }))
 
 /** This transaction type votes for the trading fee */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMVote.h>
+#endif
 TRANSACTION(ttAMM_VOTE, 38, AMMVote,
     Delegation::delegatable,
     featureAMM,
+    noPriv,
     ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -369,9 +491,13 @@ TRANSACTION(ttAMM_VOTE, 38, AMMVote,
 }))
 
 /** This transaction type bids for the auction slot */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMBid.h>
+#endif
 TRANSACTION(ttAMM_BID, 39, AMMBid,
     Delegation::delegatable,
     featureAMM,
+    noPriv,
     ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
@@ -381,18 +507,26 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
 }))
 
 /** This transaction type deletes AMM in the empty state */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMDelete.h>
+#endif
 TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
     Delegation::delegatable,
     featureAMM,
+    mustDeleteAcct,
     ({
     {sfAsset, soeREQUIRED},
     {sfAsset2, soeREQUIRED},
 }))
 
 /** This transactions creates a crosschain sequence number */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/XChainBridge.h>
+#endif
 TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
@@ -403,6 +537,7 @@ TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
 TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
@@ -414,6 +549,7 @@ TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
 TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfXChainClaimID, soeREQUIRED},
@@ -426,6 +562,7 @@ TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
 TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfDestination, soeREQUIRED},
@@ -437,6 +574,7 @@ TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
 TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
     Delegation::delegatable,
     featureXChainBridge,
+    createAcct,
     ({
     {sfXChainBridge, soeREQUIRED},
 
@@ -453,9 +591,11 @@ TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
 }))
 
 /** This transaction adds an attestation to an account */
-TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateAttestation,
+TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
+    XChainAddAccountCreateAttestation,
     Delegation::delegatable,
     featureXChainBridge,
+    createAcct,
     ({
     {sfXChainBridge, soeREQUIRED},
 
@@ -476,6 +616,7 @@ TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateA
 TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeOPTIONAL},
@@ -486,6 +627,7 @@ TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
 TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
     Delegation::delegatable,
     featureXChainBridge,
+    noPriv,
     ({
     {sfXChainBridge, soeREQUIRED},
     {sfSignatureReward, soeREQUIRED},
@@ -493,9 +635,13 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
 }))
 
 /** This transaction type creates or updates a DID */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DID.h>
+#endif
 TRANSACTION(ttDID_SET, 49, DIDSet,
     Delegation::delegatable,
     featureDID,
+    noPriv,
     ({
     {sfDIDDocument, soeOPTIONAL},
     {sfURI, soeOPTIONAL},
@@ -506,12 +652,17 @@ TRANSACTION(ttDID_SET, 49, DIDSet,
 TRANSACTION(ttDID_DELETE, 50, DIDDelete,
     Delegation::delegatable,
     featureDID,
+    noPriv,
     ({}))
 
 /** This transaction type creates an Oracle instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetOracle.h>
+#endif
 TRANSACTION(ttORACLE_SET, 51, OracleSet,
     Delegation::delegatable,
     featurePriceOracle,
+    noPriv,
     ({
     {sfOracleDocumentID, soeREQUIRED},
     {sfProvider, soeOPTIONAL},
@@ -522,65 +673,97 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
 }))
 
 /** This transaction type deletes an Oracle instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DeleteOracle.h>
+#endif
 TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
     Delegation::delegatable,
     featurePriceOracle,
+    noPriv,
     ({
     {sfOracleDocumentID, soeREQUIRED},
 }))
 
 /** This transaction type fixes a problem in the ledger state */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/LedgerStateFix.h>
+#endif
 TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
     Delegation::delegatable,
     fixNFTokenPageLinks,
+    noPriv,
     ({
     {sfLedgerFixType, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
 }))
 
 /** This transaction type creates a MPTokensIssuance instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceCreate.h>
+#endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
     Delegation::delegatable,
     featureMPTokensV1,
+    createMPTIssuance,
     ({
     {sfAssetScale, soeOPTIONAL},
     {sfTransferFee, soeOPTIONAL},
     {sfMaximumAmount, soeOPTIONAL},
     {sfMPTokenMetadata, soeOPTIONAL},
     {sfDomainID, soeOPTIONAL},
+    {sfMutableFlags, soeOPTIONAL},
 }))
 
 /** This transaction type destroys a MPTokensIssuance instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceDestroy.h>
+#endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
     Delegation::delegatable,
     featureMPTokensV1,
+    destroyMPTIssuance,
     ({
     {sfMPTokenIssuanceID, soeREQUIRED},
 }))
 
 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceSet.h>
+#endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
     Delegation::delegatable,
     featureMPTokensV1,
+    noPriv,
     ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
     {sfDomainID, soeOPTIONAL},
+    {sfMPTokenMetadata, soeOPTIONAL},
+    {sfTransferFee, soeOPTIONAL},
+    {sfMutableFlags, soeOPTIONAL},
 }))
 
 /** This transaction type authorizes a MPToken instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenAuthorize.h>
+#endif
 TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
     Delegation::delegatable,
     featureMPTokensV1,
+    mustAuthorizeMPT,
     ({
     {sfMPTokenIssuanceID, soeREQUIRED},
     {sfHolder, soeOPTIONAL},
 }))
 
 /** This transaction type create an Credential instance */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Credentials.h>
+#endif
 TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
     Delegation::delegatable,
     featureCredentials,
+    noPriv,
     ({
     {sfSubject, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
@@ -592,6 +775,7 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
 TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
     Delegation::delegatable,
     featureCredentials,
+    noPriv,
     ({
     {sfIssuer, soeREQUIRED},
     {sfCredentialType, soeREQUIRED},
@@ -601,6 +785,7 @@ TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
 TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
     Delegation::delegatable,
     featureCredentials,
+    noPriv,
     ({
     {sfSubject, soeOPTIONAL},
     {sfIssuer, soeOPTIONAL},
@@ -608,9 +793,13 @@ TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
 }))
 
 /** This transaction type modify a NFToken */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenModify.h>
+#endif
 TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
     Delegation::delegatable,
     featureDynamicNFT,
+    noPriv,
     ({
     {sfNFTokenID, soeREQUIRED},
     {sfOwner, soeOPTIONAL},
@@ -618,35 +807,51 @@ TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
 }))
 
 /** This transaction type creates or modifies a Permissioned Domain */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PermissionedDomainSet.h>
+#endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
     Delegation::delegatable,
     featurePermissionedDomains,
+    noPriv,
     ({
     {sfDomainID, soeOPTIONAL},
     {sfAcceptedCredentials, soeREQUIRED},
 }))
 
 /** This transaction type deletes a Permissioned Domain */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PermissionedDomainDelete.h>
+#endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
     Delegation::delegatable,
     featurePermissionedDomains,
+    noPriv,
     ({
     {sfDomainID, soeREQUIRED},
 }))
 
 /** This transaction type delegates authorized account specified permissions */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DelegateSet.h>
+#endif
 TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
     Delegation::notDelegatable,
     featurePermissionDelegation,
+    noPriv,
     ({
     {sfAuthorize, soeREQUIRED},
     {sfPermissions, soeREQUIRED},
 }))
 
 /** This transaction creates a single asset vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultCreate.h>
+#endif
 TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
     Delegation::delegatable,
     featureSingleAssetVault,
+    createPseudoAcct | createMPTIssuance,
     ({
     {sfAsset, soeREQUIRED, soeMPTSupported},
     {sfAssetsMaximum, soeOPTIONAL},
@@ -658,9 +863,13 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
 }))
 
 /** This transaction updates a single asset vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultSet.h>
+#endif
 TRANSACTION(ttVAULT_SET, 66, VaultSet,
     Delegation::delegatable,
     featureSingleAssetVault,
+    noPriv,
     ({
     {sfVaultID, soeREQUIRED},
     {sfAssetsMaximum, soeOPTIONAL},
@@ -669,26 +878,38 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet,
 }))
 
 /** This transaction deletes a single asset vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultDelete.h>
+#endif
 TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
     Delegation::delegatable,
     featureSingleAssetVault,
+    mustDeleteAcct | destroyMPTIssuance,
     ({
     {sfVaultID, soeREQUIRED},
 }))
 
 /** This transaction trades assets for shares with a vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultDeposit.h>
+#endif
 TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
     Delegation::delegatable,
     featureSingleAssetVault,
+    mayAuthorizeMPT,
     ({
     {sfVaultID, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
 }))
 
 /** This transaction trades shares for assets with a vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultWithdraw.h>
+#endif
 TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
     Delegation::delegatable,
     featureSingleAssetVault,
+    mayDeleteMPT,
     ({
     {sfVaultID, soeREQUIRED},
     {sfAmount, soeREQUIRED, soeMPTSupported},
@@ -697,9 +918,13 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
 }))
 
 /** This transaction claws back tokens from a vault. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultClawback.h>
+#endif
 TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
     Delegation::delegatable,
     featureSingleAssetVault,
+    mayDeleteMPT,
     ({
     {sfVaultID, soeREQUIRED},
     {sfHolder, soeREQUIRED},
@@ -707,9 +932,13 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
 }))
 
 /** This transaction type batches together transactions. */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Batch.h>
+#endif
 TRANSACTION(ttBATCH, 71, Batch,
     Delegation::notDelegatable,
     featureBatch,
+    noPriv,
     ({
     {sfRawTransactions, soeREQUIRED},
     {sfBatchSigners, soeOPTIONAL},
@@ -719,9 +948,13 @@ TRANSACTION(ttBATCH, 71, Batch,
 
     For details, see: https://xrpl.org/amendments.html
  */
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Change.h>
+#endif
 TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfLedgerSequence, soeREQUIRED},
     {sfAmendment, soeREQUIRED},
@@ -733,6 +966,7 @@ TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
 TRANSACTION(ttFEE, 101, SetFee,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfLedgerSequence, soeOPTIONAL},
     // Old version uses raw numbers
@@ -753,6 +987,7 @@ TRANSACTION(ttFEE, 101, SetFee,
 TRANSACTION(ttUNL_MODIFY, 102, UNLModify,
     Delegation::notDelegatable,
     uint256{},
+    noPriv,
     ({
     {sfUNLModifyDisabling, soeREQUIRED},
     {sfLedgerSequence, soeREQUIRED},

include/xrpl/protocol/jss.h

@@ -722,11 +722,11 @@ JSS(write_load);              // out: GetCounts
 #pragma push_macro("LEDGER_ENTRY_DUPLICATE")
 #undef LEDGER_ENTRY_DUPLICATE
 
-#define LEDGER_ENTRY(tag, value, name, rpcName, fields) \
-    JSS(name);                                          \
+#define LEDGER_ENTRY(tag, value, name, rpcName, ...) \
+    JSS(name);                                       \
     JSS(rpcName);
 
-#define LEDGER_ENTRY_DUPLICATE(tag, value, name, rpcName, fields) JSS(rpcName);
+#define LEDGER_ENTRY_DUPLICATE(tag, value, name, rpcName, ...) JSS(rpcName);
 
 #include <xrpl/protocol/detail/ledger_entries.macro>
 

include/xrpl/server/detail/Door.h

@@ -30,15 +30,29 @@
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/post.hpp>
 #include <boost/asio/spawn.hpp>
+#include <boost/asio/steady_timer.hpp>
 #include <boost/beast/core/detect_ssl.hpp>
 #include <boost/beast/core/multi_buffer.hpp>
 #include <boost/beast/core/tcp_stream.hpp>
 #include <boost/container/flat_map.hpp>
+#include <boost/predef.h>
 
+#if !BOOST_OS_WINDOWS
+#include <sys/resource.h>
+
+#include <dirent.h>
+#include <unistd.h>
+#endif
+
+#include <algorithm>
 #include <chrono>
+#include <cstdint>
 #include <functional>
 #include <memory>
+#include <optional>
+#include <sstream>
 
 namespace ripple {
 
@@ -98,10 +112,27 @@ private:
     boost::asio::strand<boost::asio::io_context::executor_type> strand_;
     bool ssl_;
     bool plain_;
+    static constexpr std::chrono::milliseconds INITIAL_ACCEPT_DELAY{50};
+    static constexpr std::chrono::milliseconds MAX_ACCEPT_DELAY{2000};
+    std::chrono::milliseconds accept_delay_{INITIAL_ACCEPT_DELAY};
+    boost::asio::steady_timer backoff_timer_;
+    static constexpr double FREE_FD_THRESHOLD = 0.70;
+
+    struct FDStats
+    {
+        std::uint64_t used{0};
+        std::uint64_t limit{0};
+    };
 
     void
     reOpen();
 
+    std::optional<FDStats>
+    query_fd_stats() const;
+
+    bool
+    should_throttle_for_fds();
+
 public:
     Door(
         Handler& handler,
@@ -299,6 +330,7 @@ Door<Handler>::Door(
     , plain_(
           port_.protocol.count("http") > 0 || port_.protocol.count("ws") > 0 ||
           port_.protocol.count("ws2"))
+    , backoff_timer_(io_context)
 {
     reOpen();
 }
@@ -323,6 +355,7 @@ Door<Handler>::close()
         return boost::asio::post(
             strand_,
             std::bind(&Door<Handler>::close, this->shared_from_this()));
+    backoff_timer_.cancel();
     error_code ec;
     acceptor_.close(ec);
 }
@@ -368,6 +401,17 @@ Door<Handler>::do_accept(boost::asio::yield_context do_yield)
 {
     while (acceptor_.is_open())
     {
+        if (should_throttle_for_fds())
+        {
+            backoff_timer_.expires_after(accept_delay_);
+            boost::system::error_code tec;
+            backoff_timer_.async_wait(do_yield[tec]);
+            accept_delay_ = std::min(accept_delay_ * 2, MAX_ACCEPT_DELAY);
+            JLOG(j_.warn()) << "Throttling do_accept for "
+                            << accept_delay_.count() << "ms.";
+            continue;
+        }
+
         error_code ec;
         endpoint_type remote_address;
         stream_type stream(ioc_);
@@ -377,15 +421,28 @@ Door<Handler>::do_accept(boost::asio::yield_context do_yield)
         {
             if (ec == boost::asio::error::operation_aborted)
                 break;
-            JLOG(j_.error()) << "accept: " << ec.message();
-            if (ec == boost::asio::error::no_descriptors)
+
+            if (ec == boost::asio::error::no_descriptors ||
+                ec == boost::asio::error::no_buffer_space)
             {
-                JLOG(j_.info()) << "re-opening acceptor";
-                reOpen();
+                JLOG(j_.warn()) << "accept: Too many open files. Pausing for "
+                                << accept_delay_.count() << "ms.";
+
+                backoff_timer_.expires_after(accept_delay_);
+                boost::system::error_code tec;
+                backoff_timer_.async_wait(do_yield[tec]);
+
+                accept_delay_ = std::min(accept_delay_ * 2, MAX_ACCEPT_DELAY);
+            }
+            else
+            {
+                JLOG(j_.error()) << "accept error: " << ec.message();
             }
             continue;
         }
 
+        accept_delay_ = INITIAL_ACCEPT_DELAY;
+
         if (ssl_ && plain_)
         {
             if (auto sp = ios().template emplace<Detector>(
@@ -408,6 +465,60 @@ Door<Handler>::do_accept(boost::asio::yield_context do_yield)
     }
 }
 
+template <class Handler>
+std::optional<typename Door<Handler>::FDStats>
+Door<Handler>::query_fd_stats() const
+{
+#if BOOST_OS_WINDOWS
+    return std::nullopt;
+#else
+    FDStats s;
+    struct rlimit rl;
+    if (getrlimit(RLIMIT_NOFILE, &rl) != 0 || rl.rlim_cur == RLIM_INFINITY)
+        return std::nullopt;
+    s.limit = static_cast<std::uint64_t>(rl.rlim_cur);
+#if BOOST_OS_LINUX
+    constexpr char const* kFdDir = "/proc/self/fd";
+#else
+    constexpr char const* kFdDir = "/dev/fd";
+#endif
+    if (DIR* d = ::opendir(kFdDir))
+    {
+        std::uint64_t cnt = 0;
+        while (::readdir(d) != nullptr)
+            ++cnt;
+        ::closedir(d);
+        // readdir counts '.', '..', and the DIR* itself shows in the list
+        s.used = (cnt >= 3) ? (cnt - 3) : 0;
+        return s;
+    }
+    return std::nullopt;
+#endif
+}
+
+template <class Handler>
+bool
+Door<Handler>::should_throttle_for_fds()
+{
+#if BOOST_OS_WINDOWS
+    return false;
+#else
+    auto const stats = query_fd_stats();
+    if (!stats || stats->limit == 0)
+        return false;
+
+    auto const& s = *stats;
+    auto const free = (s.limit > s.used) ? (s.limit - s.used) : 0ull;
+    double const free_ratio =
+        static_cast<double>(free) / static_cast<double>(s.limit);
+    if (free_ratio < FREE_FD_THRESHOLD)
+    {
+        return true;
+    }
+    return false;
+#endif
+}
+
 }  // namespace ripple
 
 #endif

src/libxrpl/ledger/ApplyStateTable.cpp

@@ -17,11 +17,10 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/detail/ApplyStateTable.h>
-
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/ledger/detail/ApplyStateTable.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/st.h>
 

src/libxrpl/ledger/ApplyView.cpp

@@ -17,10 +17,9 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/ApplyView.h>
-
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/ApplyView.h>
 #include <xrpl/protocol/Protocol.h>
 
 namespace ripple {

src/libxrpl/ledger/ApplyViewBase.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/detail/ApplyViewBase.h>
+#include <xrpl/ledger/detail/ApplyViewBase.h>
 
 namespace ripple {
 namespace detail {

src/libxrpl/ledger/ApplyViewImpl.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/ApplyViewImpl.h>
+#include <xrpl/ledger/ApplyViewImpl.h>
 
 namespace ripple {
 

src/libxrpl/ledger/BookDirs.cpp

@@ -18,9 +18,8 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/BookDirs.h>
-#include <xrpld/ledger/View.h>
-
+#include <xrpl/ledger/BookDirs.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Indexes.h>
 
 namespace ripple {

src/libxrpl/ledger/CachedView.cpp

@@ -17,9 +17,8 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/CachedView.h>
-
 #include <xrpl/basics/TaggedCache.ipp>
+#include <xrpl/ledger/CachedView.h>
 
 namespace ripple {
 namespace detail {

src/libxrpl/ledger/CredentialHelpers.cpp

@@ -17,9 +17,8 @@
 */
 //==============================================================================
 
-#include <xrpld/app/misc/CredentialHelpers.h>
-#include <xrpld/ledger/View.h>
-
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/digest.h>
 

src/libxrpl/ledger/Dir.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/Dir.h>
+#include <xrpl/ledger/Dir.h>
 
 namespace ripple {
 

src/libxrpl/ledger/OpenView.cpp

@@ -17,9 +17,8 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/OpenView.h>
-
 #include <xrpl/basics/contract.h>
+#include <xrpl/ledger/OpenView.h>
 
 namespace ripple {
 

src/libxrpl/ledger/PaymentSandbox.cpp

@@ -17,11 +17,9 @@
 */
 //==============================================================================
 
-#include <xrpld/app/paths/detail/AmountSpec.h>
-#include <xrpld/ledger/PaymentSandbox.h>
-#include <xrpld/ledger/View.h>
-
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/PaymentSandbox.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/SField.h>
 
 namespace ripple {

src/libxrpl/ledger/RawStateTable.cpp

@@ -17,9 +17,8 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/detail/RawStateTable.h>
-
 #include <xrpl/basics/contract.h>
+#include <xrpl/ledger/detail/RawStateTable.h>
 
 namespace ripple {
 namespace detail {

src/libxrpl/ledger/ReadView.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/ReadView.h>
+#include <xrpl/ledger/ReadView.h>
 
 namespace ripple {
 

src/libxrpl/ledger/View.cpp

@@ -17,14 +17,13 @@
 */
 //==============================================================================
 
-#include <xrpld/app/misc/CredentialHelpers.h>
-#include <xrpld/ledger/ReadView.h>
-#include <xrpld/ledger/View.h>
-
 #include <xrpl/basics/Expected.h>
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/chrono.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/CredentialHelpers.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>
@@ -627,8 +626,8 @@ xrpLiquid(
     std::uint32_t const ownerCount = confineOwnerCount(
         view.ownerCountHook(id, sle->getFieldU32(sfOwnerCount)), ownerCountAdj);
 
-    // AMMs have no reserve requirement
-    auto const reserve = sle->isFieldPresent(sfAMMID)
+    // Pseudo-accounts have no reserve requirement
+    auto const reserve = isPseudoAccount(sle)
         ? XRPAmount{0}
         : view.fees().accountReserve(ownerCount);
 
@@ -1040,7 +1039,7 @@ adjustOwnerCount(
     AccountID const id = (*sle)[sfAccount];
     std::uint32_t const adjusted = confineOwnerCount(current, amount, id, j);
     view.adjustOwnerCountHook(id, current, adjusted);
-    sle->setFieldU32(sfOwnerCount, adjusted);
+    sle->at(sfOwnerCount) = adjusted;
     view.update(sle);
 }
 
@@ -1080,15 +1079,51 @@ pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey)
     return beast::zero;
 }
 
-// Note, the list of the pseudo-account designator fields below MUST be
-// maintained but it does NOT need to be amendment-gated, since a
-// non-active amendment will not set any field, by definition. Specific
-// properties of a pseudo-account are NOT checked here, that's what
+// Pseudo-account designator fields MUST be maintained by including the
+// SField::sMD_PseudoAccount flag in the SField definition. (Don't forget to
+// "| SField::sMD_Default"!) The fields do NOT need to be amendment-gated,
+// since a non-active amendment will not set any field, by definition.
+// Specific properties of a pseudo-account are NOT checked here, that's what
 // InvariantCheck is for.
-static std::array<SField const*, 2> const pseudoAccountOwnerFields = {
-    &sfAMMID,    //
-    &sfVaultID,  //
-};
+[[nodiscard]] std::vector<SField const*> const&
+getPseudoAccountFields()
+{
+    static std::vector<SField const*> const pseudoFields = []() {
+        auto const ar = LedgerFormats::getInstance().findByType(ltACCOUNT_ROOT);
+        if (!ar)
+        {
+            // LCOV_EXCL_START
+            LogicError(
+                "ripple::isPseudoAccount : unable to find account root ledger "
+                "format");
+            // LCOV_EXCL_STOP
+        }
+        auto const& soTemplate = ar->getSOTemplate();
+
+        std::vector<SField const*> pseudoFields;
+        for (auto const& field : soTemplate)
+        {
+            if (field.sField().shouldMeta(SField::sMD_PseudoAccount))
+                pseudoFields.emplace_back(&field.sField());
+        }
+        return pseudoFields;
+    }();
+    return pseudoFields;
+}
+
+[[nodiscard]] bool
+isPseudoAccount(std::shared_ptr<SLE const> sleAcct)
+{
+    auto const& fields = getPseudoAccountFields();
+
+    // Intentionally use defensive coding here because it's cheap and makes the
+    // semantics of true return value clean.
+    return sleAcct && sleAcct->getType() == ltACCOUNT_ROOT &&
+        std::count_if(
+            fields.begin(), fields.end(), [&sleAcct](SField const* sf) -> bool {
+                return sleAcct->isFieldPresent(*sf);
+            }) > 0;
+}
 
 Expected<std::shared_ptr<SLE>, TER>
 createPseudoAccount(
@@ -1096,10 +1131,11 @@ createPseudoAccount(
     uint256 const& pseudoOwnerKey,
     SField const& ownerField)
 {
+    auto const& fields = getPseudoAccountFields();
     XRPL_ASSERT(
         std::count_if(
-            pseudoAccountOwnerFields.begin(),
-            pseudoAccountOwnerFields.end(),
+            fields.begin(),
+            fields.end(),
             [&ownerField](SField const* sf) -> bool {
                 return *sf == ownerField;
             }) == 1,
@@ -1135,18 +1171,42 @@ createPseudoAccount(
     return account;
 }
 
-[[nodiscard]] bool
-isPseudoAccount(std::shared_ptr<SLE const> sleAcct)
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, Issue const& issue)
 {
-    // Intentionally use defensive coding here because it's cheap and makes the
-    // semantics of true return value clean.
-    return sleAcct && sleAcct->getType() == ltACCOUNT_ROOT &&
-        std::count_if(
-            pseudoAccountOwnerFields.begin(),
-            pseudoAccountOwnerFields.end(),
-            [&sleAcct](SField const* sf) -> bool {
-                return sleAcct->isFieldPresent(*sf);
-            }) > 0;
+    if (issue.native())
+        return tesSUCCESS;  // No special checks for XRP
+
+    auto const issuer = view.read(keylet::account(issue.getIssuer()));
+    if (!issuer)
+        return terNO_ACCOUNT;
+    else if (!issuer->isFlag(lsfDefaultRipple))
+        return terNO_RIPPLE;
+
+    return tesSUCCESS;
+}
+
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, MPTIssue const& mptIssue)
+{
+    auto mptID = mptIssue.getMptID();
+    auto issuance = view.read(keylet::mptIssuance(mptID));
+    if (!issuance)
+        return tecOBJECT_NOT_FOUND;
+    if (!issuance->isFlag(lsfMPTCanTransfer))
+        return tecNO_AUTH;
+
+    return tesSUCCESS;
+}
+
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, Asset const& asset)
+{
+    return std::visit(
+        [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
+            return canAddHolding(view, issue);
+        },
+        asset.value());
 }
 
 [[nodiscard]] TER
@@ -3006,11 +3066,17 @@ rippleUnlockEscrowMPT(
     ApplyView& view,
     AccountID const& sender,
     AccountID const& receiver,
-    STAmount const& amount,
+    STAmount const& netAmount,
+    STAmount const& grossAmount,
     beast::Journal j)
 {
-    auto const issuer = amount.getIssuer();
-    auto const mptIssue = amount.get<MPTIssue>();
+    if (!view.rules().enabled(fixTokenEscrowV1))
+        XRPL_ASSERT(
+            netAmount == grossAmount,
+            "ripple::rippleUnlockEscrowMPT : netAmount == grossAmount");
+
+    auto const& issuer = netAmount.getIssuer();
+    auto const& mptIssue = netAmount.get<MPTIssue>();
     auto const mptID = keylet::mptIssuance(mptIssue.getMptID());
     auto sleIssuance = view.peek(mptID);
     if (!sleIssuance)
@@ -3031,7 +3097,7 @@ rippleUnlockEscrowMPT(
         }  // LCOV_EXCL_STOP
 
         auto const locked = sleIssuance->getFieldU64(sfLockedAmount);
-        auto const redeem = amount.mpt().value();
+        auto const redeem = grossAmount.mpt().value();
 
         // Underflow check for subtraction
         if (!canSubtract(
@@ -3060,11 +3126,11 @@ rippleUnlockEscrowMPT(
         {  // LCOV_EXCL_START
             JLOG(j.error())
                 << "rippleUnlockEscrowMPT: MPToken not found for " << receiver;
-            return tecOBJECT_NOT_FOUND;  // LCOV_EXCL_LINE
+            return tecOBJECT_NOT_FOUND;
         }  // LCOV_EXCL_STOP
 
         auto current = sle->getFieldU64(sfMPTAmount);
-        auto delta = amount.mpt().value();
+        auto delta = netAmount.mpt().value();
 
         // Overflow check for addition
         if (!canAdd(STAmount(mptIssue, current), STAmount(mptIssue, delta)))
@@ -3082,7 +3148,7 @@ rippleUnlockEscrowMPT(
     {
         // Decrease the Issuance OutstandingAmount
         auto const outstanding = sleIssuance->getFieldU64(sfOutstandingAmount);
-        auto const redeem = amount.mpt().value();
+        auto const redeem = netAmount.mpt().value();
 
         // Underflow check for subtraction
         if (!canSubtract(
@@ -3126,7 +3192,7 @@ rippleUnlockEscrowMPT(
         }  // LCOV_EXCL_STOP
 
         auto const locked = sle->getFieldU64(sfLockedAmount);
-        auto const delta = amount.mpt().value();
+        auto const delta = grossAmount.mpt().value();
 
         // Underflow check for subtraction
         if (!canSubtract(STAmount(mptIssue, locked), STAmount(mptIssue, delta)))
@@ -3144,6 +3210,28 @@ rippleUnlockEscrowMPT(
             sle->setFieldU64(sfLockedAmount, newLocked);
         view.update(sle);
     }
+
+    // Note: The gross amount is the amount that was locked, the net
+    // amount is the amount that is being unlocked. The difference is the fee
+    // that was charged for the transfer. If this difference is greater than
+    // zero, we need to update the outstanding amount.
+    auto const diff = grossAmount.mpt().value() - netAmount.mpt().value();
+    if (diff != 0)
+    {
+        auto const outstanding = sleIssuance->getFieldU64(sfOutstandingAmount);
+        // Underflow check for subtraction
+        if (!canSubtract(
+                STAmount(mptIssue, outstanding), STAmount(mptIssue, diff)))
+        {  // LCOV_EXCL_START
+            JLOG(j.error())
+                << "rippleUnlockEscrowMPT: insufficient outstanding amount for "
+                << mptIssue.getMptID() << ": " << outstanding << " < " << diff;
+            return tecINTERNAL;
+        }  // LCOV_EXCL_STOP
+
+        sleIssuance->setFieldU64(sfOutstandingAmount, outstanding - diff);
+        view.update(sleIssuance);
+    }
     return tesSUCCESS;
 }
 

src/libxrpl/net/HTTPClient.cpp

@@ -383,7 +383,7 @@ public:
         static boost::regex reStatus{
             "\\`HTTP/1\\S+ (\\d{3}) .*\\'"};  // HTTP/1.1 200 OK
         static boost::regex reSize{
-            "\\`.*\\r\\nContent-Length:\\s+([0-9]+).*\\'"};
+            "\\`.*\\r\\nContent-Length:\\s+([0-9]+).*\\'", boost::regex::icase};
         static boost::regex reBody{"\\`.*\\r\\n\\r\\n(.*)\\'"};
 
         boost::smatch smMatch;

src/libxrpl/protocol/BuildInfo.cpp

@@ -36,7 +36,7 @@ namespace BuildInfo {
 //  and follow the format described at http://semver.org/
 //------------------------------------------------------------------------------
 // clang-format off
-char const* const versionString = "2.6.0"
+char const* const versionString = "3.0.0-b1"
 // clang-format on
 
 #if defined(DEBUG) || defined(SANITIZER)

src/libxrpl/protocol/Permissions.cpp

@@ -101,6 +101,22 @@ Permission::getInstance()
     return instance;
 }
 
+std::optional<std::string>
+Permission::getPermissionName(std::uint32_t const value) const
+{
+    auto const permissionValue = static_cast<GranularPermissionType>(value);
+    if (auto const granular = getGranularName(permissionValue))
+        return *granular;
+
+    // not a granular permission, check if it maps to a transaction type
+    auto const txType = permissionToTxType(value);
+    if (auto const* item = TxFormats::getInstance().findByType(txType);
+        item != nullptr)
+        return item->getName();
+
+    return std::nullopt;
+}
+
 std::optional<std::uint32_t>
 Permission::getGranularValue(std::string const& name) const
 {
@@ -131,6 +147,19 @@ Permission::getGranularTxType(GranularPermissionType const& gpType) const
     return std::nullopt;
 }
 
+std::optional<std::reference_wrapper<uint256 const>> const
+Permission::getTxFeature(TxType txType) const
+{
+    auto const txFeaturesIt = txFeatureMap_.find(txType);
+    XRPL_ASSERT(
+        txFeaturesIt != txFeatureMap_.end(),
+        "ripple::Permissions::getTxFeature : tx exists in txFeatureMap_");
+
+    if (txFeaturesIt->second == uint256{})
+        return std::nullopt;
+    return txFeaturesIt->second;
+}
+
 bool
 Permission::isDelegatable(
     std::uint32_t const& permissionValue,
@@ -150,16 +179,12 @@ Permission::isDelegatable(
         if (it == delegatableTx_.end())
             return false;
 
-        auto const txFeaturesIt = txFeatureMap_.find(txType);
-        XRPL_ASSERT(
-            txFeaturesIt != txFeatureMap_.end(),
-            "ripple::Permissions::isDelegatable : tx exists in txFeatureMap_");
+        auto const feature = getTxFeature(txType);
 
         // fixDelegateV1_1: Delegation is only allowed if the required amendment
         // for the transaction is enabled. For transactions that do not require
         // an amendment, delegation is always allowed.
-        if (txFeaturesIt->second != uint256{} &&
-            !rules.enabled(txFeaturesIt->second))
+        if (feature && !rules.enabled(*feature))
             return false;
     }
 

src/libxrpl/protocol/SField.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/SField.h>
 
 #include <map>
@@ -27,7 +28,8 @@ namespace ripple {
 // Storage for static const members.
 SField::IsSigning const SField::notSigning;
 int SField::num = 0;
-std::map<int, SField const*> SField::knownCodeToField;
+std::unordered_map<int, SField const*> SField::knownCodeToField;
+std::unordered_map<std::string, SField const*> SField::knownNameToField;
 
 // Give only this translation unit permission to construct SFields
 struct SField::private_access_tag_t
@@ -45,7 +47,7 @@ TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
 }
 
 // Construct all compile-time SFields, and register them in the knownCodeToField
-// database:
+// and knownNameToField databases:
 
 // Use macros for most SField construction to enforce naming conventions.
 #pragma push_macro("UNTYPED_SFIELD")
@@ -69,8 +71,8 @@ TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
         ##__VA_ARGS__);
 
 // SFields which, for historical reasons, do not follow naming conventions.
-SField const sfInvalid(access, -1);
-SField const sfGeneric(access, 0);
+SField const sfInvalid(access, -1, "");
+SField const sfGeneric(access, 0, "Generic");
 // The following two fields aren't used anywhere, but they break tests/have
 // downstream effects.
 SField const sfHash(access, STI_UINT256, 257, "hash");
@@ -99,19 +101,34 @@ SField::SField(
     , signingField(signing)
     , jsonName(fieldName.c_str())
 {
+    XRPL_ASSERT(
+        !knownCodeToField.contains(fieldCode),
+        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldCode is unique");
+    XRPL_ASSERT(
+        !knownNameToField.contains(fieldName),
+        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldName is unique");
     knownCodeToField[fieldCode] = this;
+    knownNameToField[fieldName] = this;
 }
 
-SField::SField(private_access_tag_t, int fc)
+SField::SField(private_access_tag_t, int fc, char const* fn)
     : fieldCode(fc)
     , fieldType(STI_UNKNOWN)
     , fieldValue(0)
+    , fieldName(fn)
     , fieldMeta(sMD_Never)
     , fieldNum(++num)
     , signingField(IsSigning::yes)
     , jsonName(fieldName.c_str())
 {
+    XRPL_ASSERT(
+        !knownCodeToField.contains(fieldCode),
+        "ripple::SField::SField(fc,fn) : fieldCode is unique");
+    XRPL_ASSERT(
+        !knownNameToField.contains(fieldName),
+        "ripple::SField::SField(fc,fn) : fieldName is unique");
     knownCodeToField[fieldCode] = this;
+    knownNameToField[fieldName] = this;
 }
 
 SField const&
@@ -145,11 +162,11 @@ SField::compare(SField const& f1, SField const& f2)
 SField const&
 SField::getField(std::string const& fieldName)
 {
-    for (auto const& [_, f] : knownCodeToField)
+    auto it = knownNameToField.find(fieldName);
+
+    if (it != knownNameToField.end())
     {
-        (void)_;
-        if (f->fieldName == fieldName)
-            return *f;
+        return *(it->second);
     }
     return sfInvalid;
 }

src/libxrpl/protocol/STInteger.cpp

@@ -62,8 +62,10 @@ STUInt8::getText() const
         if (transResultInfo(TER::fromInt(value_), token, human))
             return human;
 
+        // LCOV_EXCL_START
         JLOG(debugLog().error())
             << "Unknown result code in metadata: " << value_;
+        // LCOV_EXCL_STOP
     }
 
     return std::to_string(value_);
@@ -80,8 +82,10 @@ STUInt8::getJson(JsonOptions) const
         if (transResultInfo(TER::fromInt(value_), token, human))
             return token;
 
+        // LCOV_EXCL_START
         JLOG(debugLog().error())
             << "Unknown result code in metadata: " << value_;
+        // LCOV_EXCL_STOP
     }
 
     return value_;
@@ -171,6 +175,13 @@ template <>
 std::string
 STUInt32::getText() const
 {
+    if (getFName() == sfPermissionValue)
+    {
+        auto const permissionName =
+            Permission::getInstance().getPermissionName(value_);
+        if (permissionName)
+            return *permissionName;
+    }
     return std::to_string(value_);
 }
 
@@ -180,23 +191,10 @@ STUInt32::getJson(JsonOptions) const
 {
     if (getFName() == sfPermissionValue)
     {
-        auto const permissionValue =
-            static_cast<GranularPermissionType>(value_);
-        auto const granular =
-            Permission::getInstance().getGranularName(permissionValue);
-
-        if (granular)
-        {
-            return *granular;
-        }
-        else
-        {
-            auto const txType =
-                Permission::getInstance().permissionToTxType(value_);
-            auto item = TxFormats::getInstance().findByType(txType);
-            if (item != nullptr)
-                return item->getName();
-        }
+        auto const permissionName =
+            Permission::getInstance().getPermissionName(value_);
+        if (permissionName)
+            return *permissionName;
     }
 
     return value_;
@@ -251,4 +249,33 @@ STUInt64::getJson(JsonOptions) const
     return convertToString(value_, 16);  // Convert to base 16
 }
 
+//------------------------------------------------------------------------------
+
+template <>
+STInteger<std::int32_t>::STInteger(SerialIter& sit, SField const& name)
+    : STInteger(name, sit.get32())
+{
+}
+
+template <>
+SerializedTypeID
+STInt32::getSType() const
+{
+    return STI_INT32;
+}
+
+template <>
+std::string
+STInt32::getText() const
+{
+    return std::to_string(value_);
+}
+
+template <>
+Json::Value
+STInt32::getJson(JsonOptions) const
+{
+    return value_;
+}
+
 }  // namespace ripple

src/libxrpl/protocol/STObject.cpp

@@ -647,6 +647,12 @@ STObject::getFieldH256(SField const& field) const
     return getFieldByValue<STUInt256>(field);
 }
 
+std::int32_t
+STObject::getFieldI32(SField const& field) const
+{
+    return getFieldByValue<STInt32>(field);
+}
+
 AccountID
 STObject::getAccountID(SField const& field) const
 {
@@ -761,6 +767,12 @@ STObject::setFieldH256(SField const& field, uint256 const& v)
     setFieldUsingSetValue<STUInt256>(field, v);
 }
 
+void
+STObject::setFieldI32(SField const& field, std::int32_t v)
+{
+    setFieldUsingSetValue<STInt32>(field, v);
+}
+
 void
 STObject::setFieldV256(SField const& field, STVector256 const& v)
 {

src/libxrpl/protocol/STParsedJSON.cpp

@@ -83,7 +83,8 @@ constexpr std::
     return static_cast<U1>(value);
 }
 
-static std::string
+// LCOV_EXCL_START
+static inline std::string
 make_name(std::string const& object, std::string const& field)
 {
     if (field.empty())
@@ -92,7 +93,7 @@ make_name(std::string const& object, std::string const& field)
     return object + "." + field;
 }
 
-static Json::Value
+static inline Json::Value
 not_an_object(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -100,20 +101,20 @@ not_an_object(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' is not a JSON object.");
 }
 
-static Json::Value
+static inline Json::Value
 not_an_object(std::string const& object)
 {
     return not_an_object(object, "");
 }
 
-static Json::Value
+static inline Json::Value
 not_an_array(std::string const& object)
 {
     return RPC::make_error(
         rpcINVALID_PARAMS, "Field '" + object + "' is not a JSON array.");
 }
 
-static Json::Value
+static inline Json::Value
 unknown_field(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -121,7 +122,7 @@ unknown_field(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' is unknown.");
 }
 
-static Json::Value
+static inline Json::Value
 out_of_range(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -129,7 +130,7 @@ out_of_range(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' is out of range.");
 }
 
-static Json::Value
+static inline Json::Value
 bad_type(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -137,7 +138,7 @@ bad_type(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' has bad type.");
 }
 
-static Json::Value
+static inline Json::Value
 invalid_data(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -145,13 +146,13 @@ invalid_data(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' has invalid data.");
 }
 
-static Json::Value
+static inline Json::Value
 invalid_data(std::string const& object)
 {
     return invalid_data(object, "");
 }
 
-static Json::Value
+static inline Json::Value
 array_expected(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -159,7 +160,7 @@ array_expected(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' must be a JSON array.");
 }
 
-static Json::Value
+static inline Json::Value
 string_expected(std::string const& object, std::string const& field)
 {
     return RPC::make_error(
@@ -167,7 +168,7 @@ string_expected(std::string const& object, std::string const& field)
         "Field '" + make_name(object, field) + "' must be a string.");
 }
 
-static Json::Value
+static inline Json::Value
 too_deep(std::string const& object)
 {
     return RPC::make_error(
@@ -175,7 +176,7 @@ too_deep(std::string const& object)
         "Field '" + object + "' exceeds nesting depth limit.");
 }
 
-static Json::Value
+static inline Json::Value
 singleton_expected(std::string const& object, unsigned int index)
 {
     return RPC::make_error(
@@ -184,7 +185,7 @@ singleton_expected(std::string const& object, unsigned int index)
             "]' must be an object with a single key/object value.");
 }
 
-static Json::Value
+static inline Json::Value
 template_mismatch(SField const& sField)
 {
     return RPC::make_error(
@@ -193,7 +194,7 @@ template_mismatch(SField const& sField)
             "' contents did not meet requirements for that type.");
 }
 
-static Json::Value
+static inline Json::Value
 non_object_in_array(std::string const& item, Json::UInt index)
 {
     return RPC::make_error(
@@ -201,6 +202,176 @@ non_object_in_array(std::string const& item, Json::UInt index)
         "Item '" + item + "' at index " + std::to_string(index) +
             " is not an object.  Arrays may only contain objects.");
 }
+// LCOV_EXCL_STOP
+
+template <class STResult, class Integer>
+static std::optional<detail::STVar>
+parseUnsigned(
+    SField const& field,
+    std::string const& json_name,
+    std::string const& fieldName,
+    SField const* name,
+    Json::Value const& value,
+    Json::Value& error)
+{
+    std::optional<detail::STVar> ret;
+
+    try
+    {
+        if (value.isString())
+        {
+            ret = detail::make_stvar<STResult>(
+                field,
+                safe_cast<typename STResult::value_type>(
+                    beast::lexicalCastThrow<Integer>(value.asString())));
+        }
+        else if (value.isInt())
+        {
+            ret = detail::make_stvar<STResult>(
+                field,
+                to_unsigned<typename STResult::value_type>(value.asInt()));
+        }
+        else if (value.isUInt())
+        {
+            ret = detail::make_stvar<STResult>(
+                field,
+                to_unsigned<typename STResult::value_type>(value.asUInt()));
+        }
+        else
+        {
+            error = bad_type(json_name, fieldName);
+            return ret;
+        }
+    }
+    catch (std::exception const&)
+    {
+        error = invalid_data(json_name, fieldName);
+        return ret;
+    }
+
+    return ret;
+}
+
+template <class STResult, class Integer = std::uint16_t>
+static std::optional<detail::STVar>
+parseUint16(
+    SField const& field,
+    std::string const& json_name,
+    std::string const& fieldName,
+    SField const* name,
+    Json::Value const& value,
+    Json::Value& error)
+{
+    std::optional<detail::STVar> ret;
+
+    try
+    {
+        if (value.isString())
+        {
+            std::string const strValue = value.asString();
+
+            if (!strValue.empty() &&
+                ((strValue[0] < '0') || (strValue[0] > '9')))
+            {
+                if (field == sfTransactionType)
+                {
+                    ret = detail::make_stvar<STResult>(
+                        field,
+                        safe_cast<typename STResult::value_type>(
+                            static_cast<Integer>(
+                                TxFormats::getInstance().findTypeByName(
+                                    strValue))));
+
+                    if (*name == sfGeneric)
+                        name = &sfTransaction;
+                }
+                else if (field == sfLedgerEntryType)
+                {
+                    ret = detail::make_stvar<STResult>(
+                        field,
+                        safe_cast<typename STResult::value_type>(
+                            static_cast<Integer>(
+                                LedgerFormats::getInstance().findTypeByName(
+                                    strValue))));
+
+                    if (*name == sfGeneric)
+                        name = &sfLedgerEntry;
+                }
+                else
+                {
+                    error = invalid_data(json_name, fieldName);
+                    return ret;
+                }
+            }
+        }
+        if (!ret)
+            return parseUnsigned<STResult, Integer>(
+                field, json_name, fieldName, name, value, error);
+    }
+    catch (std::exception const&)
+    {
+        error = invalid_data(json_name, fieldName);
+        return ret;
+    }
+
+    return ret;
+}
+
+template <class STResult, class Integer = std::uint32_t>
+static std::optional<detail::STVar>
+parseUint32(
+    SField const& field,
+    std::string const& json_name,
+    std::string const& fieldName,
+    SField const* name,
+    Json::Value const& value,
+    Json::Value& error)
+{
+    std::optional<detail::STVar> ret;
+
+    try
+    {
+        if (value.isString())
+        {
+            if (field == sfPermissionValue)
+            {
+                std::string const strValue = value.asString();
+                auto const granularPermission =
+                    Permission::getInstance().getGranularValue(strValue);
+                if (granularPermission)
+                {
+                    ret = detail::make_stvar<STResult>(
+                        field, *granularPermission);
+                }
+                else
+                {
+                    auto const& txType =
+                        TxFormats::getInstance().findTypeByName(strValue);
+                    ret = detail::make_stvar<STResult>(
+                        field,
+                        Permission::getInstance().txToPermissionType(txType));
+                }
+            }
+            else
+            {
+                ret = detail::make_stvar<STResult>(
+                    field,
+                    safe_cast<typename STResult::value_type>(
+                        beast::lexicalCastThrow<Integer>(value.asString())));
+            }
+        }
+        if (!ret)
+            return parseUnsigned<STResult, Integer>(
+                field, json_name, fieldName, name, value, error);
+    }
+    catch (std::exception const&)
+    {
+        error = invalid_data(json_name, fieldName);
+        return ret;
+    }
+
+    return ret;
+}
 
 // This function is used by parseObject to parse any JSON type that doesn't
 // recurse.  Everything represented here is a leaf-type.
@@ -216,10 +387,13 @@ parseLeaf(
 
     auto const& field = SField::getField(fieldName);
 
+    // checked in parseObject
     if (field == sfInvalid)
     {
+        // LCOV_EXCL_START
         error = unknown_field(json_name, fieldName);
         return ret;
+        // LCOV_EXCL_STOP
     }
 
     switch (field.fieldType)
@@ -302,130 +476,18 @@ parseLeaf(
             break;
 
         case STI_UINT16:
-            try
-            {
-                if (value.isString())
-                {
-                    std::string const strValue = value.asString();
-
-                    if (!strValue.empty() &&
-                        ((strValue[0] < '0') || (strValue[0] > '9')))
-                    {
-                        if (field == sfTransactionType)
-                        {
-                            ret = detail::make_stvar<STUInt16>(
-                                field,
-                                static_cast<std::uint16_t>(
-                                    TxFormats::getInstance().findTypeByName(
-                                        strValue)));
-
-                            if (*name == sfGeneric)
-                                name = &sfTransaction;
-                        }
-                        else if (field == sfLedgerEntryType)
-                        {
-                            ret = detail::make_stvar<STUInt16>(
-                                field,
-                                static_cast<std::uint16_t>(
-                                    LedgerFormats::getInstance().findTypeByName(
-                                        strValue)));
-
-                            if (*name == sfGeneric)
-                                name = &sfLedgerEntry;
-                        }
-                        else
-                        {
-                            error = invalid_data(json_name, fieldName);
-                            return ret;
-                        }
-                    }
-                    else
-                    {
-                        ret = detail::make_stvar<STUInt16>(
-                            field,
-                            beast::lexicalCastThrow<std::uint16_t>(strValue));
-                    }
-                }
-                else if (value.isInt())
-                {
-                    ret = detail::make_stvar<STUInt16>(
-                        field, to_unsigned<std::uint16_t>(value.asInt()));
-                }
-                else if (value.isUInt())
-                {
-                    ret = detail::make_stvar<STUInt16>(
-                        field, to_unsigned<std::uint16_t>(value.asUInt()));
-                }
-                else
-                {
-                    error = bad_type(json_name, fieldName);
-                    return ret;
-                }
-            }
-            catch (std::exception const&)
-            {
-                error = invalid_data(json_name, fieldName);
+            ret = parseUint16<STUInt16>(
+                field, json_name, fieldName, name, value, error);
+            if (!ret)
                 return ret;
-            }
 
             break;
 
         case STI_UINT32:
-            try
-            {
-                if (value.isString())
-                {
-                    if (field == sfPermissionValue)
-                    {
-                        std::string const strValue = value.asString();
-                        auto const granularPermission =
-                            Permission::getInstance().getGranularValue(
-                                strValue);
-                        if (granularPermission)
-                        {
-                            ret = detail::make_stvar<STUInt32>(
-                                field, *granularPermission);
-                        }
-                        else
-                        {
-                            auto const& txType =
-                                TxFormats::getInstance().findTypeByName(
-                                    strValue);
-                            ret = detail::make_stvar<STUInt32>(
-                                field,
-                                Permission::getInstance().txToPermissionType(
-                                    txType));
-                        }
-                    }
-                    else
-                    {
-                        ret = detail::make_stvar<STUInt32>(
-                            field,
-                            beast::lexicalCastThrow<std::uint32_t>(
-                                value.asString()));
-                    }
-                }
-                else if (value.isInt())
-                {
-                    ret = detail::make_stvar<STUInt32>(
-                        field, to_unsigned<std::uint32_t>(value.asInt()));
-                }
-                else if (value.isUInt())
-                {
-                    ret = detail::make_stvar<STUInt32>(
-                        field, safe_cast<std::uint32_t>(value.asUInt()));
-                }
-                else
-                {
-                    error = bad_type(json_name, fieldName);
-                    return ret;
-                }
-            }
-            catch (std::exception const&)
-            {
-                error = invalid_data(json_name, fieldName);
+            ret = parseUint32<STUInt32>(
+                field, json_name, fieldName, name, value, error);
+            if (!ret)
                 return ret;
-            }
 
             break;
 
@@ -501,30 +563,6 @@ parseLeaf(
             break;
         }
 
-        case STI_UINT192: {
-            if (!value.isString())
-            {
-                error = bad_type(json_name, fieldName);
-                return ret;
-            }
-
-            uint192 num;
-
-            if (auto const s = value.asString(); !num.parseHex(s))
-            {
-                if (!s.empty())
-                {
-                    error = invalid_data(json_name, fieldName);
-                    return ret;
-                }
-
-                num.zero();
-            }
-
-            ret = detail::make_stvar<STUInt192>(field, num);
-            break;
-        }
-
         case STI_UINT160: {
             if (!value.isString())
             {
@@ -549,6 +587,30 @@ parseLeaf(
             break;
         }
 
+        case STI_UINT192: {
+            if (!value.isString())
+            {
+                error = bad_type(json_name, fieldName);
+                return ret;
+            }
+
+            uint192 num;
+
+            if (auto const s = value.asString(); !num.parseHex(s))
+            {
+                if (!s.empty())
+                {
+                    error = invalid_data(json_name, fieldName);
+                    return ret;
+                }
+
+                num.zero();
+            }
+
+            ret = detail::make_stvar<STUInt192>(field, num);
+            break;
+        }
+
         case STI_UINT256: {
             if (!value.isString())
             {
@@ -573,6 +635,52 @@ parseLeaf(
             break;
         }
 
+        case STI_INT32:
+            try
+            {
+                if (value.isString())
+                {
+                    ret = detail::make_stvar<STInt32>(
+                        field,
+                        beast::lexicalCastThrow<std::int32_t>(
+                            value.asString()));
+                }
+                else if (value.isInt())
+                {
+                    // future-proofing - a static assert failure if the JSON
+                    // library ever supports larger ints
+                    // In such case, we will need additional bounds checks here
+                    static_assert(
+                        std::is_same_v<decltype(value.asInt()), std::int32_t>);
+                    ret = detail::make_stvar<STInt32>(field, value.asInt());
+                }
+                else if (value.isUInt())
+                {
+                    auto const uintValue = value.asUInt();
+                    if (uintValue >
+                        static_cast<std::uint32_t>(
+                            std::numeric_limits<std::int32_t>::max()))
+                    {
+                        error = out_of_range(json_name, fieldName);
+                        return ret;
+                    }
+                    ret = detail::make_stvar<STInt32>(
+                        field, static_cast<std::int32_t>(uintValue));
+                }
+                else
+                {
+                    error = bad_type(json_name, fieldName);
+                    return ret;
+                }
+            }
+            catch (std::exception const&)
+            {
+                error = invalid_data(json_name, fieldName);
+                return ret;
+            }
+
+            break;
+
         case STI_VL:
             if (!value.isString())
             {
@@ -703,6 +811,12 @@ parseLeaf(
                         AccountID uAccount, uIssuer;
                         Currency uCurrency;
 
+                        if (!account && !currency && !issuer)
+                        {
+                            error = invalid_data(element_name);
+                            return ret;
+                        }
+
                         if (account)
                         {
                             // human account id
@@ -1052,8 +1166,7 @@ parseArray(
             Json::Value const objectFields(json[i][objectName]);
 
             std::stringstream ss;
-            ss << json_name << "."
-               << "[" << i << "]." << objectName;
+            ss << json_name << "." << "[" << i << "]." << objectName;
 
             auto ret = parseObject(
                 ss.str(), objectFields, nameField, depth + 1, error);
@@ -1096,24 +1209,4 @@ STParsedJSONObject::STParsedJSONObject(
     object = parseObject(name, json, sfGeneric, 0, error);
 }
 
-//------------------------------------------------------------------------------
-
-STParsedJSONArray::STParsedJSONArray(
-    std::string const& name,
-    Json::Value const& json)
-{
-    using namespace STParsedJSONDetail;
-    auto arr = parseArray(name, json, sfGeneric, 0, error);
-    if (!arr)
-        array.reset();
-    else
-    {
-        auto p = dynamic_cast<STArray*>(&arr->get());
-        if (p == nullptr)
-            array.reset();
-        else
-            array = std::move(*p);
-    }
-}
-
 }  // namespace ripple

src/libxrpl/protocol/STVar.cpp

@@ -208,6 +208,9 @@ STVar::constructST(SerializedTypeID id, int depth, Args&&... args)
         case STI_UINT256:
             construct<STUInt256>(std::forward<Args>(args)...);
             return;
+        case STI_INT32:
+            construct<STInt32>(std::forward<Args>(args)...);
+            return;
         case STI_VECTOR256:
             construct<STVector256>(std::forward<Args>(args)...);
             return;

src/libxrpl/protocol/Serializer.cpp

@@ -83,6 +83,12 @@ Serializer::addInteger(std::uint64_t i)
 {
     return add64(i);
 }
+template <>
+int
+Serializer::addInteger(std::int32_t i)
+{
+    return add32(i);
+}
 
 int
 Serializer::addRaw(Blob const& vector)

src/libxrpl/protocol/TxFormats.cpp

@@ -55,7 +55,8 @@ TxFormats::TxFormats()
 #undef TRANSACTION
 
 #define UNWRAP(...) __VA_ARGS__
-#define TRANSACTION(tag, value, name, delegatable, amendment, fields) \
+#define TRANSACTION(                                              \
+    tag, value, name, delegatable, amendment, privileges, fields) \
     add(jss::name, tag, UNWRAP fields, commonFields);
 
 #include <xrpl/protocol/detail/transactions.macro>

src/test/app/AMMCalc_test.cpp

@@ -67,7 +67,7 @@ class AMMCalc_test : public beast::unit_test::suite
             // drops
             else if (match[1] == "XRPA")
                 return XRPAmount{std::stoll(match[2])};
-            return amountFromString(gw[match[1]], match[2]);
+            return amountFromString(gw[match[1]].asset(), match[2]);
         }
         return std::nullopt;
     }

src/test/app/AMMExtended_test.cpp

@@ -29,8 +29,8 @@
 #include <xrpld/app/paths/AMMOffer.h>
 #include <xrpld/app/paths/Flow.h>
 #include <xrpld/app/paths/detail/StrandFlow.h>
-#include <xrpld/ledger/PaymentSandbox.h>
 
+#include <xrpl/ledger/PaymentSandbox.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/STParsedJSON.h>
 
@@ -181,9 +181,9 @@ private:
 
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, alice, XRP(20'000) - XRP(50) - txfee(env, 1)));
-            BEAST_EXPECT(expectLine(env, bob, USD1(100)));
-            BEAST_EXPECT(expectLine(env, bob, USD2(0)));
-            BEAST_EXPECT(expectLine(env, carol, USD2(50)));
+            BEAST_EXPECT(expectHolding(env, bob, USD1(100)));
+            BEAST_EXPECT(expectHolding(env, bob, USD2(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD2(50)));
         }
     }
 
@@ -220,7 +220,7 @@ private:
                     BEAST_EXPECT(expectLedgerEntryRoot(
                         env, carol, XRP(30'000) - (txfee(env, 1))));
                     BEAST_EXPECT(expectOffers(env, carol, 0));
-                    BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
 
                     // Order that can be filled
                     env(offer(carol, XRP(100), USD(100)),
@@ -230,7 +230,7 @@ private:
                         XRP(10'000), USD(10'100), ammAlice.tokens()));
                     BEAST_EXPECT(expectLedgerEntryRoot(
                         env, carol, XRP(30'000) + XRP(100) - txfee(env, 2)));
-                    BEAST_EXPECT(expectLine(env, carol, USD(29'900)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(29'900)));
                     BEAST_EXPECT(expectOffers(env, carol, 0));
                 },
                 {{XRP(10'100), USD(10'000)}},
@@ -254,7 +254,7 @@ private:
                     BEAST_EXPECT(expectLedgerEntryRoot(
                         env, carol, XRP(30'000) + XRP(100) - txfee(env, 1)));
                     // AMM
-                    BEAST_EXPECT(expectLine(env, carol, USD(29'900)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(29'900)));
                     BEAST_EXPECT(expectOffers(env, carol, 0));
                 },
                 {{XRP(10'100), USD(10'000)}},
@@ -327,7 +327,7 @@ private:
             USD(49),
             IOUAmount{273'861'278752583, -8}));
 
-        BEAST_EXPECT(expectLine(env, bob, STAmount{USD, 101}));
+        BEAST_EXPECT(expectHolding(env, bob, STAmount{USD, 101}));
         BEAST_EXPECT(expectLedgerEntryRoot(
             env, bob, XRP(300'000) - xrpTransferred - txfee(env, 1)));
         BEAST_EXPECT(expectOffers(env, bob, 0));
@@ -390,7 +390,7 @@ private:
 
         BEAST_EXPECT(
             ammBob.expectBalances(USD(300), XRP(1'000), ammBob.tokens()));
-        BEAST_EXPECT(expectLine(env, alice, USD(0)));
+        BEAST_EXPECT(expectHolding(env, alice, USD(0)));
 
         auto jrr = ledgerEntryRoot(env, alice);
         BEAST_EXPECT(
@@ -423,7 +423,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRPAmount{9'900'990'100}, USD(10'100), ammAlice.tokens()));
                 // initial 30,000 - 10,000AMM - 100pay
-                BEAST_EXPECT(expectLine(env, alice, USD(19'900)));
+                BEAST_EXPECT(expectHolding(env, alice, USD(19'900)));
                 // initial 30,000 - 10,0000AMM + 99.009900pay - fee*3
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env,
@@ -453,7 +453,7 @@ private:
                 env(pay(alice, bob, USD(100)), sendmax(XRP(100)));
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
-                BEAST_EXPECT(expectLine(env, bob, USD(100)));
+                BEAST_EXPECT(expectHolding(env, bob, USD(100)));
             },
             {{XRP(10'000), USD(10'100)}},
             0,
@@ -533,7 +533,7 @@ private:
             STAmount{USD1, UINT64_C(5'030'181086519115), -12},
             ammCarol.tokens()));
         BEAST_EXPECT(expectOffers(env, dan, 1, {{Amounts{XRP(200), EUR(20)}}}));
-        BEAST_EXPECT(expectLine(env, bob, STAmount{EUR1, 30}));
+        BEAST_EXPECT(expectHolding(env, bob, STAmount{EUR1, 30}));
     }
 
     void
@@ -642,7 +642,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'000), USD(9'999), ammAlice.tokens()));
                 BEAST_EXPECT(expectOffers(env, carol, 0));
-                BEAST_EXPECT(expectLine(env, carol, USD(30'101)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'101)));
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, carol, XRP(30'000) - XRP(100) - txfee(env, 1)));
             },
@@ -682,7 +682,7 @@ private:
         env(offer(alice, USD(100), XRP(200)), json(jss::Flags, tfSell));
         BEAST_EXPECT(
             ammBob.expectBalances(XRP(1'100), USD(2'000), ammBob.tokens()));
-        BEAST_EXPECT(expectLine(env, alice, USD(200)));
+        BEAST_EXPECT(expectHolding(env, alice, USD(200)));
         BEAST_EXPECT(expectLedgerEntryRoot(env, alice, XRP(250)));
         BEAST_EXPECT(expectOffers(env, alice, 0));
     }
@@ -733,7 +733,7 @@ private:
                 STAmount(XTS, UINT64_C(101'010101010101), -12),
                 XXX(99),
                 ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, bob, STAmount{XTS, UINT64_C(98'989898989899), -12}));
         }
         else
@@ -742,10 +742,10 @@ private:
                 STAmount(XTS, UINT64_C(101'0101010101011), -13),
                 XXX(99),
                 ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, bob, STAmount{XTS, UINT64_C(98'9898989898989), -13}));
         }
-        BEAST_EXPECT(expectLine(env, bob, XXX(101)));
+        BEAST_EXPECT(expectHolding(env, bob, XXX(101)));
     }
 
     void
@@ -783,8 +783,8 @@ private:
                 XRP(10'100), USD(10'000), ammAlice.tokens()));
             BEAST_EXPECT(ammBob.expectBalances(
                 XRP(10'000), EUR(10'100), ammBob.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(15'100)));
-            BEAST_EXPECT(expectLine(env, carol, EUR(14'900)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(15'100)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(14'900)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
         }
 
@@ -816,8 +816,8 @@ private:
 
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(10'100), USD(10'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(15'100)));
-            BEAST_EXPECT(expectLine(env, carol, EUR(14'900)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(15'100)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(14'900)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(expectOffers(env, bob, 0));
         }
@@ -850,8 +850,8 @@ private:
 
             BEAST_EXPECT(ammBob.expectBalances(
                 XRP(10'000), EUR(10'100), ammBob.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(15'100)));
-            BEAST_EXPECT(expectLine(env, carol, EUR(14'900)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(15'100)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(14'900)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(expectOffers(env, alice, 0));
         }
@@ -894,7 +894,7 @@ private:
                 XRP(20'220),
                 STAmount{USD, UINT64_C(197'8239366963403), -13},
                 ammBob.tokens()));
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, alice, STAmount{USD, UINT64_C(1'002'17606330366), -11}));
             BEAST_EXPECT(expectOffers(env, alice, 0));
         }
@@ -912,7 +912,7 @@ private:
                 XRP(21'500),
                 STAmount{USD, UINT64_C(186'046511627907), -12},
                 ammBob.tokens()));
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, alice, STAmount{USD, UINT64_C(1'013'953488372093), -12}));
             BEAST_EXPECT(expectOffers(env, alice, 0));
         }
@@ -953,7 +953,7 @@ private:
                 // AMM doesn't pay the transfer fee
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
-                BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
                 BEAST_EXPECT(expectOffers(env, carol, 0));
             },
             {{XRP(10'000), USD(10'100)}},
@@ -974,7 +974,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'000), USD(10'100), ammAlice.tokens()));
                 // Carol pays 25% transfer fee
-                BEAST_EXPECT(expectLine(env, carol, USD(29'875)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(29'875)));
                 BEAST_EXPECT(expectOffers(env, carol, 0));
             },
             {{XRP(10'100), USD(10'000)}},
@@ -1011,9 +1011,9 @@ private:
             // AMM doesn't pay the transfer fee
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(10'100), USD(10'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(15'100)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(15'100)));
             // Carol pays 25% transfer fee.
-            BEAST_EXPECT(expectLine(env, carol, EUR(14'875)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(14'875)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(expectOffers(env, bob, 0));
         }
@@ -1051,9 +1051,9 @@ private:
             // AMM doesn't pay the transfer fee
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(10'050), USD(10'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(15'050)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(15'050)));
             // Carol pays 25% transfer fee.
-            BEAST_EXPECT(expectLine(env, carol, EUR(14'937.5)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(14'937.5)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(
                 expectOffers(env, bob, 1, {{Amounts{EUR(50), XRP(50)}}}));
@@ -1077,7 +1077,7 @@ private:
             env(pay(gw, carol, EUR(1'000)), sendmax(EUR(10'000)));
             env.close();
             // 1000 / 0.8
-            BEAST_EXPECT(expectLine(env, carol, EUR(1'250)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(1'250)));
             // The scenario:
             //   o USD/XRP AMM is created.
             //   o EUR/XRP Offer is created.
@@ -1096,9 +1096,9 @@ private:
             // AMM doesn't pay the transfer fee
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(10'100), USD(10'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(100)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(100)));
             // Carol pays 25% transfer fee: 1250 - 100(offer) - 25(transfer fee)
-            BEAST_EXPECT(expectLine(env, carol, EUR(1'125)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(1'125)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(expectOffers(env, bob, 0));
         }
@@ -1120,7 +1120,7 @@ private:
             env(pay(gw, alice, USD(11'000)));
             env(pay(gw, carol, EUR(1'000)), sendmax(EUR(10'000)));
             env.close();
-            BEAST_EXPECT(expectLine(env, carol, EUR(1'000)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(1'000)));
             // The scenario:
             //   o USD/XRP AMM is created.
             //   o EUR/XRP Offer is created.
@@ -1139,9 +1139,9 @@ private:
             // AMM pay doesn't transfer fee
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(10'100), USD(10'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(100)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(100)));
             // Carol pays 25% transfer fee: 1000 - 100(offer) - 25(transfer fee)
-            BEAST_EXPECT(expectLine(env, carol, EUR(875)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(875)));
             BEAST_EXPECT(expectOffers(env, carol, 0));
             BEAST_EXPECT(expectOffers(env, bob, 0));
         }
@@ -1170,7 +1170,7 @@ private:
         BEAST_EXPECT(ammBob.expectBalances(
             XRP(10'100), USD_bob(10'000), ammBob.tokens()));
         BEAST_EXPECT(expectOffers(env, alice, 0));
-        BEAST_EXPECT(expectLine(env, alice, USD_bob(100)));
+        BEAST_EXPECT(expectHolding(env, alice, USD_bob(100)));
     }
 
     void
@@ -1206,19 +1206,19 @@ private:
             env.close();
             env(pay(dan, bob, D_BUX(100)));
             env.close();
-            BEAST_EXPECT(expectLine(env, bob, D_BUX(100)));
+            BEAST_EXPECT(expectHolding(env, bob, D_BUX(100)));
 
             env(pay(ann, cam, D_BUX(60)), path(bob, dan), sendmax(A_BUX(200)));
             env.close();
 
-            BEAST_EXPECT(expectLine(env, ann, A_BUX(none)));
-            BEAST_EXPECT(expectLine(env, ann, D_BUX(none)));
-            BEAST_EXPECT(expectLine(env, bob, A_BUX(72)));
-            BEAST_EXPECT(expectLine(env, bob, D_BUX(40)));
-            BEAST_EXPECT(expectLine(env, cam, A_BUX(none)));
-            BEAST_EXPECT(expectLine(env, cam, D_BUX(60)));
-            BEAST_EXPECT(expectLine(env, dan, A_BUX(none)));
-            BEAST_EXPECT(expectLine(env, dan, D_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, ann, A_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, ann, D_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, bob, A_BUX(72)));
+            BEAST_EXPECT(expectHolding(env, bob, D_BUX(40)));
+            BEAST_EXPECT(expectHolding(env, cam, A_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, cam, D_BUX(60)));
+            BEAST_EXPECT(expectHolding(env, dan, A_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, dan, D_BUX(none)));
 
             AMM ammBob(env, bob, A_BUX(30), D_BUX(30));
 
@@ -1234,12 +1234,12 @@ private:
 
             BEAST_EXPECT(
                 ammBob.expectBalances(A_BUX(30), D_BUX(30), ammBob.tokens()));
-            BEAST_EXPECT(expectLine(env, ann, A_BUX(none)));
-            BEAST_EXPECT(expectLine(env, ann, D_BUX(0)));
-            BEAST_EXPECT(expectLine(env, cam, A_BUX(none)));
-            BEAST_EXPECT(expectLine(env, cam, D_BUX(60)));
-            BEAST_EXPECT(expectLine(env, dan, A_BUX(0)));
-            BEAST_EXPECT(expectLine(env, dan, D_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, ann, A_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, ann, D_BUX(0)));
+            BEAST_EXPECT(expectHolding(env, cam, A_BUX(none)));
+            BEAST_EXPECT(expectHolding(env, cam, D_BUX(60)));
+            BEAST_EXPECT(expectHolding(env, dan, A_BUX(0)));
+            BEAST_EXPECT(expectHolding(env, dan, D_BUX(none)));
         }
     }
 
@@ -1363,7 +1363,7 @@ private:
         env(pay(gw, bob, USD(50)));
         env.close();
 
-        BEAST_EXPECT(expectLine(env, bob, USD(50)));
+        BEAST_EXPECT(expectHolding(env, bob, USD(50)));
 
         // Bob's offer should cross Alice's AMM
         env(offer(bob, XRP(50), USD(50)));
@@ -1372,7 +1372,7 @@ private:
         BEAST_EXPECT(
             ammAlice.expectBalances(USD(1'050), XRP(1'000), ammAlice.tokens()));
         BEAST_EXPECT(expectOffers(env, bob, 0));
-        BEAST_EXPECT(expectLine(env, bob, USD(0)));
+        BEAST_EXPECT(expectHolding(env, bob, USD(0)));
     }
 
     void
@@ -1403,7 +1403,7 @@ private:
 
         env(pay(gw, bob, USD(50)));
         env.close();
-        BEAST_EXPECT(expectLine(env, bob, USD(50)));
+        BEAST_EXPECT(expectHolding(env, bob, USD(50)));
 
         // Alice should not be able to create AMM without authorization.
         {
@@ -1440,7 +1440,7 @@ private:
         BEAST_EXPECT(
             ammAlice.expectBalances(USD(1'050), XRP(1'000), ammAlice.tokens()));
         BEAST_EXPECT(expectOffers(env, bob, 0));
-        BEAST_EXPECT(expectLine(env, bob, USD(0)));
+        BEAST_EXPECT(expectHolding(env, bob, USD(0)));
     }
 
     void
@@ -1535,7 +1535,7 @@ private:
         // AMM offer is 51.282052XRP/11AUD, 11AUD/1.1 = 10AUD to bob
         BEAST_EXPECT(
             ammCarol.expectBalances(XRP(51), AUD(40), ammCarol.tokens()));
-        BEAST_EXPECT(expectLine(env, bob, AUD(10)));
+        BEAST_EXPECT(expectHolding(env, bob, AUD(10)));
 
         auto const result =
             find_paths(env, alice, bob, Account(bob)["USD"](25));
@@ -1950,10 +1950,10 @@ private:
 
             env(pay(alice, carol, USD(50)), path(~USD), sendmax(BTC(50)));
 
-            BEAST_EXPECT(expectLine(env, alice, BTC(50)));
-            BEAST_EXPECT(expectLine(env, bob, BTC(0)));
-            BEAST_EXPECT(expectLine(env, bob, USD(0)));
-            BEAST_EXPECT(expectLine(env, carol, USD(200)));
+            BEAST_EXPECT(expectHolding(env, alice, BTC(50)));
+            BEAST_EXPECT(expectHolding(env, bob, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, bob, USD(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(200)));
             BEAST_EXPECT(
                 ammBob.expectBalances(BTC(150), USD(100), ammBob.tokens()));
         }
@@ -1974,10 +1974,10 @@ private:
 
             env(pay(alice, carol, USD(50)), path(~XRP, ~USD), sendmax(BTC(50)));
 
-            BEAST_EXPECT(expectLine(env, alice, BTC(50)));
-            BEAST_EXPECT(expectLine(env, bob, BTC(0)));
-            BEAST_EXPECT(expectLine(env, bob, USD(0)));
-            BEAST_EXPECT(expectLine(env, carol, USD(200)));
+            BEAST_EXPECT(expectHolding(env, alice, BTC(50)));
+            BEAST_EXPECT(expectHolding(env, bob, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, bob, USD(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(200)));
             BEAST_EXPECT(ammBobBTC_XRP.expectBalances(
                 BTC(150), XRP(100), ammBobBTC_XRP.tokens()));
             BEAST_EXPECT(ammBobXRP_USD.expectBalances(
@@ -2003,8 +2003,8 @@ private:
                 env, alice, xrpMinusFee(env, 10'000 - 50)));
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, bob, XRP(10'000) - XRP(100) - ammCrtFee(env)));
-            BEAST_EXPECT(expectLine(env, bob, USD(0)));
-            BEAST_EXPECT(expectLine(env, carol, USD(200)));
+            BEAST_EXPECT(expectHolding(env, bob, USD(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(200)));
             BEAST_EXPECT(
                 ammBob.expectBalances(XRP(150), USD(100), ammBob.tokens()));
         }
@@ -2024,10 +2024,10 @@ private:
 
             env(pay(alice, carol, XRP(50)), path(~XRP), sendmax(USD(50)));
 
-            BEAST_EXPECT(expectLine(env, alice, USD(50)));
+            BEAST_EXPECT(expectHolding(env, alice, USD(50)));
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, bob, XRP(10'000) - XRP(150) - ammCrtFee(env)));
-            BEAST_EXPECT(expectLine(env, bob, USD(0)));
+            BEAST_EXPECT(expectHolding(env, bob, USD(0)));
             BEAST_EXPECT(expectLedgerEntryRoot(env, carol, XRP(10'000 + 50)));
             BEAST_EXPECT(
                 ammBob.expectBalances(USD(150), XRP(100), ammBob.tokens()));
@@ -2209,7 +2209,7 @@ private:
                 sendmax(USD(0.4)),
                 txflags(tfNoRippleDirect | tfPartialPayment));
 
-            BEAST_EXPECT(expectLine(env, carol, EUR(1)));
+            BEAST_EXPECT(expectHolding(env, carol, EUR(1)));
             BEAST_EXPECT(ammBob.expectBalances(
                 USD(8.4), XRPAmount{20}, ammBob.tokens()));
         }
@@ -2244,7 +2244,7 @@ private:
 
             // alice buys 107.1428USD with 120GBP and pays 25% tr fee on 120GBP
             // 1,000 - 120*1.25 = 850GBP
-            BEAST_EXPECT(expectLine(env, alice, GBP(850)));
+            BEAST_EXPECT(expectHolding(env, alice, GBP(850)));
             if (!features[fixAMMv1_1])
             {
                 // 120GBP is swapped in for 107.1428USD
@@ -2262,7 +2262,7 @@ private:
             }
             // 25% of 85.7142USD is paid in tr fee
             // 85.7142*1.25 = 107.1428USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'085'714285714286), -12)));
         }
 
@@ -2294,10 +2294,10 @@ private:
             // alice buys 120EUR with 120GBP via the offer
             // and pays 25% tr fee on 120GBP
             // 1,000 - 120*1.25 = 850GBP
-            BEAST_EXPECT(expectLine(env, alice, GBP(850)));
+            BEAST_EXPECT(expectHolding(env, alice, GBP(850)));
             // consumed offer is 120GBP/120EUR
             // ed doesn't pay tr fee
-            BEAST_EXPECT(expectLine(env, ed, EUR(880), GBP(1'120)));
+            BEAST_EXPECT(expectHolding(env, ed, EUR(880), GBP(1'120)));
             BEAST_EXPECT(
                 expectOffers(env, ed, 1, {Amounts{GBP(880), EUR(880)}}));
             // 25% on 96EUR is paid in tr fee 96*1.25 = 120EUR
@@ -2307,7 +2307,7 @@ private:
                 STAmount{USD, UINT64_C(912'4087591240876), -13},
                 amm.tokens()));
             // 25% on 70.0729USD is paid in tr fee 70.0729*1.25 = 87.5912USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'070'07299270073), -11)));
         }
         {
@@ -2333,7 +2333,7 @@ private:
                 txflags(tfNoRippleDirect | tfPartialPayment));
             env.close();
 
-            BEAST_EXPECT(expectLine(env, alice, GBP(850)));
+            BEAST_EXPECT(expectHolding(env, alice, GBP(850)));
             if (!features[fixAMMv1_1])
             {
                 // alice buys 107.1428EUR with 120GBP and pays 25% tr fee on
@@ -2367,7 +2367,7 @@ private:
                     amm2.tokens()));
             }
             // 25% on 63.1578USD is paid in tr fee 63.1578*1.25 = 78.9473USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'063'157894736842), -12)));
         }
         {
@@ -2386,7 +2386,7 @@ private:
             BEAST_EXPECT(
                 amm.expectBalances(USD(1'100), EUR(1'000), amm.tokens()));
             // alice pays 25% tr fee on 100USD 1100-100*1.25 = 975USD
-            BEAST_EXPECT(expectLine(env, alice, USD(975), EUR(1'200)));
+            BEAST_EXPECT(expectHolding(env, alice, USD(975), EUR(1'200)));
             BEAST_EXPECT(expectOffers(env, alice, 0));
         }
 
@@ -2416,7 +2416,7 @@ private:
             // alice buys 125USD with 142.8571GBP and pays 25% tr fee
             // on 142.8571GBP
             // 1,000 - 142.8571*1.25 = 821.4285GBP
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, alice, STAmount(GBP, UINT64_C(821'4285714285712), -13)));
             // 142.8571GBP is swapped in for 125USD
             BEAST_EXPECT(amm.expectBalances(
@@ -2425,7 +2425,7 @@ private:
                 amm.tokens()));
             // 25% on 100USD is paid in tr fee
             // 100*1.25 = 125USD
-            BEAST_EXPECT(expectLine(env, carol, USD(1'100)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(1'100)));
         }
         {
             // Payment via AMM with limit quality, deliver less
@@ -2456,7 +2456,7 @@ private:
                 // alice buys 28.125USD with 24GBP and pays 25% tr fee
                 // on 24GBP
                 // 1,200 - 24*1.25 = 1,170GBP
-                BEAST_EXPECT(expectLine(env, alice, GBP(1'170)));
+                BEAST_EXPECT(expectHolding(env, alice, GBP(1'170)));
                 // 24GBP is swapped in for 28.125USD
                 BEAST_EXPECT(amm.expectBalances(
                     GBP(1'024), USD(1'171.875), amm.tokens()));
@@ -2466,7 +2466,7 @@ private:
                 // alice buys 28.125USD with 24GBP and pays 25% tr fee
                 // on 24GBP
                 // 1,200 - 24*1.25 =~ 1,170GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'169'999999999999), -12}));
@@ -2478,7 +2478,7 @@ private:
             }
             // 25% on 22.5USD is paid in tr fee
             // 22.5*1.25 = 28.125USD
-            BEAST_EXPECT(expectLine(env, carol, USD(1'222.5)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(1'222.5)));
         }
         {
             // Payment via offer and AMM with limit quality, deliver less
@@ -2513,13 +2513,13 @@ private:
                 // alice buys 70.4210EUR with 70.4210GBP via the offer
                 // and pays 25% tr fee on 70.4210GBP
                 // 1,400 - 70.4210*1.25 = 1400 - 88.0262 = 1311.9736GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'311'973684210527), -12}));
                 // ed doesn't pay tr fee, the balances reflect consumed offer
                 // 70.4210GBP/70.4210EUR
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     ed,
                     STAmount{EUR, UINT64_C(1'329'578947368421), -12},
@@ -2543,13 +2543,13 @@ private:
                 // alice buys 70.4210EUR with 70.4210GBP via the offer
                 // and pays 25% tr fee on 70.4210GBP
                 // 1,400 - 70.4210*1.25 = 1400 - 88.0262 = 1311.9736GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'311'973684210525), -12}));
                 // ed doesn't pay tr fee, the balances reflect consumed offer
                 // 70.4210GBP/70.4210EUR
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     ed,
                     STAmount{EUR, UINT64_C(1'329'57894736842), -11},
@@ -2569,7 +2569,7 @@ private:
                     amm.tokens()));
             }
             // 25% on 59.7321USD is paid in tr fee 59.7321*1.25 = 74.6651USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'459'732142857143), -12)));
         }
         {
@@ -2605,7 +2605,7 @@ private:
                 // alice buys 53.3322EUR with 56.3368GBP via the amm
                 // and pays 25% tr fee on 56.3368GBP
                 // 1,400 - 56.3368*1.25 = 1400 - 70.4210 = 1329.5789GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'329'578947368421), -12}));
@@ -2622,7 +2622,7 @@ private:
                 // alice buys 53.3322EUR with 56.3368GBP via the amm
                 // and pays 25% tr fee on 56.3368GBP
                 // 1,400 - 56.3368*1.25 = 1400 - 70.4210 = 1329.5789GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'329'57894736842), -11}));
@@ -2636,7 +2636,7 @@ private:
             }
             // 25% on 42.6658EUR is paid in tr fee 42.6658*1.25 = 53.3322EUR
             // 42.6658EUR/59.7321USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env,
                 ed,
                 STAmount{USD, UINT64_C(1'340'267857142857), -12},
@@ -2649,7 +2649,7 @@ private:
                     STAmount{EUR, UINT64_C(957'3341836734693), -13},
                     STAmount{USD, UINT64_C(1'340'267857142857), -12}}}));
             // 25% on 47.7857USD is paid in tr fee 47.7857*1.25 = 59.7321USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'447'785714285714), -12)));
         }
         {
@@ -2683,7 +2683,7 @@ private:
                 // alice buys 53.3322EUR with 107.5308GBP
                 // 25% on 86.0246GBP is paid in tr fee
                 // 1,400 - 86.0246*1.25 = 1400 - 107.5308 = 1229.4691GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'292'469135802469), -12}));
@@ -2704,7 +2704,7 @@ private:
                 // alice buys 53.3322EUR with 107.5308GBP
                 // 25% on 86.0246GBP is paid in tr fee
                 // 1,400 - 86.0246*1.25 = 1400 - 107.5308 = 1229.4691GBP
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     alice,
                     STAmount{GBP, UINT64_C(1'292'469135802466), -12}));
@@ -2721,7 +2721,7 @@ private:
                     amm2.tokens()));
             }
             // 25% on 66.7432USD is paid in tr fee 66.7432*1.25 = 83.4291USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount(USD, UINT64_C(1'466'743295019157), -12)));
         }
         {
@@ -2778,7 +2778,7 @@ private:
                     amm2.tokens()));
             }
             // 25% on 81.1111USD is paid in tr fee 81.1111*1.25 = 101.3888USD
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(
                 env, carol, STAmount{USD, UINT64_C(1'481'111111111111), -12}));
         }
     }
@@ -2808,7 +2808,7 @@ private:
 
             BEAST_EXPECT(
                 ammBob.expectBalances(XRP(1'050), USD(1'000), ammBob.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(2'050)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(2'050)));
             BEAST_EXPECT(expectOffers(env, bob, 1, {{{XRP(100), USD(50)}}}));
         }
     }

src/test/app/AMM_test.cpp

@@ -97,8 +97,8 @@ private:
             AMM ammAlice(env, alice, USD(20'000), BTC(0.5));
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(20'000), BTC(0.5), IOUAmount{100, 0}));
-            BEAST_EXPECT(expectLine(env, alice, USD(0)));
-            BEAST_EXPECT(expectLine(env, alice, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, alice, USD(0)));
+            BEAST_EXPECT(expectHolding(env, alice, BTC(0)));
         }
 
         // Require authorization is set, account is authorized
@@ -1394,7 +1394,7 @@ private:
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(11'000), USD(11'000), IOUAmount{11'000'000, 0}));
             // 30,000 less deposited 1,000
-            BEAST_EXPECT(expectLine(env, carol, USD(29'000)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(29'000)));
             // 30,000 less deposited 1,000 and 10 drops tx fee
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, carol, XRPAmount{29'000'000'000 - baseFee}));
@@ -1449,7 +1449,8 @@ private:
                     IOUAmount{1, 7} + newLPTokens));
 
                 // 30,000 less deposited depositUSD
-                BEAST_EXPECT(expectLine(env, carol, USD(30'000) - depositUSD));
+                BEAST_EXPECT(
+                    expectHolding(env, carol, USD(30'000) - depositUSD));
                 // 30,000 less deposited depositXRP and 10 drops tx fee
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, carol, XRP(30'000) - depositXRP - txfee(env, 1)));
@@ -1553,15 +1554,15 @@ private:
             AMM ammAlice(env, alice, USD(20'000), BTC(0.5));
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(20'000), BTC(0.5), IOUAmount{100, 0}));
-            BEAST_EXPECT(expectLine(env, alice, USD(0)));
-            BEAST_EXPECT(expectLine(env, alice, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, alice, USD(0)));
+            BEAST_EXPECT(expectHolding(env, alice, BTC(0)));
             fund(env, gw, {carol}, {USD(2'000), BTC(0.05)}, Fund::Acct);
             // no transfer fee on deposit
             ammAlice.deposit(carol, 10);
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(22'000), BTC(0.55), IOUAmount{110, 0}));
-            BEAST_EXPECT(expectLine(env, carol, USD(0)));
-            BEAST_EXPECT(expectLine(env, carol, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(0)));
+            BEAST_EXPECT(expectHolding(env, carol, BTC(0)));
         }
 
         // Tiny deposits
@@ -2281,7 +2282,7 @@ private:
             BEAST_EXPECT(
                 ammAlice.expectLPTokens(carol, IOUAmount{1'000'000, 0}));
             // 30,000 less deposited 1,000
-            BEAST_EXPECT(expectLine(env, carol, USD(29'000)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(29'000)));
             // 30,000 less deposited 1,000 and 10 drops tx fee
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, carol, XRPAmount{29'000'000'000 - baseFee}));
@@ -2290,7 +2291,7 @@ private:
             ammAlice.withdraw(carol, 1'000'000);
             BEAST_EXPECT(
                 ammAlice.expectLPTokens(carol, IOUAmount(beast::Zero())));
-            BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env, carol, XRPAmount{30'000'000'000 - 2 * baseFee}));
         });
@@ -2525,22 +2526,22 @@ private:
             AMM ammAlice(env, alice, USD(20'000), BTC(0.5));
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(20'000), BTC(0.5), IOUAmount{100, 0}));
-            BEAST_EXPECT(expectLine(env, alice, USD(0)));
-            BEAST_EXPECT(expectLine(env, alice, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, alice, USD(0)));
+            BEAST_EXPECT(expectHolding(env, alice, BTC(0)));
             fund(env, gw, {carol}, {USD(2'000), BTC(0.05)}, Fund::Acct);
             // no transfer fee on deposit
             ammAlice.deposit(carol, 10);
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(22'000), BTC(0.55), IOUAmount{110, 0}));
-            BEAST_EXPECT(expectLine(env, carol, USD(0)));
-            BEAST_EXPECT(expectLine(env, carol, BTC(0)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(0)));
+            BEAST_EXPECT(expectHolding(env, carol, BTC(0)));
             // no transfer fee on withdraw
             ammAlice.withdraw(carol, 10);
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(20'000), BTC(0.5), IOUAmount{100, 0}));
             BEAST_EXPECT(ammAlice.expectLPTokens(carol, IOUAmount{0, 0}));
-            BEAST_EXPECT(expectLine(env, carol, USD(2'000)));
-            BEAST_EXPECT(expectLine(env, carol, BTC(0.05)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(2'000)));
+            BEAST_EXPECT(expectHolding(env, carol, BTC(0.05)));
         }
 
         // Tiny withdraw
@@ -3527,7 +3528,7 @@ private:
             // Alice doesn't have anymore lp tokens
             env(amm.bid({.account = alice, .bidMin = 500}));
             BEAST_EXPECT(amm.expectAuctionSlot(100, 0, IOUAmount{500}));
-            BEAST_EXPECT(expectLine(env, alice, STAmount{lpIssue, 0}));
+            BEAST_EXPECT(expectHolding(env, alice, STAmount{lpIssue, 0}));
             // But trades with the discounted fee since she still owns the slot.
             // Alice pays 10011 drops in fees
             env(pay(alice, bob, USD(10)), path(~USD), sendmax(XRP(11)));
@@ -3571,7 +3572,7 @@ private:
                     env.current()->rules(),
                     tapNONE,
                     env.journal);
-                auto pf = AMMBid::preflight(pfctx);
+                auto pf = Transactor::invokePreflight<AMMBid>(pfctx);
                 BEAST_EXPECT(pf == temDISABLED);
                 env.app().config().features.insert(featureAMM);
             }
@@ -3586,7 +3587,7 @@ private:
                     env.current()->rules(),
                     tapNONE,
                     env.journal);
-                auto pf = AMMBid::preflight(pfctx);
+                auto pf = Transactor::invokePreflight<AMMBid>(pfctx);
                 BEAST_EXPECT(pf != tesSUCCESS);
             }
 
@@ -3601,7 +3602,7 @@ private:
                     env.current()->rules(),
                     tapNONE,
                     env.journal);
-                auto pf = AMMBid::preflight(pfctx);
+                auto pf = Transactor::invokePreflight<AMMBid>(pfctx);
                 BEAST_EXPECT(pf == temBAD_AMM_TOKENS);
             }
         }
@@ -3790,7 +3791,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
                 // Initial balance 30,000 + 100
-                BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
                 // Initial balance 30,000 - 100(sendmax) - 10(tx fee)
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, bob, XRP(30'000) - XRP(100) - txfee(env, 1)));
@@ -3810,7 +3811,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
                 // Initial balance 30,000 + 100
-                BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
                 // Initial balance 30,000 - 100(sendmax) - 10(tx fee)
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, bob, XRP(30'000) - XRP(100) - txfee(env, 1)));
@@ -3831,7 +3832,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
                 // Initial balance 30,000 + 100
-                BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
                 // Initial balance 30,000 - 100(sendmax) - 10(tx fee)
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, bob, XRP(30'000) - XRP(100) - txfee(env, 1)));
@@ -3857,7 +3858,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'010), USD(10'000), ammAlice.tokens()));
                 // Initial balance 30,000 + 10(limited by limitQuality)
-                BEAST_EXPECT(expectLine(env, carol, USD(30'010)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'010)));
                 // Initial balance 30,000 - 10(limited by limitQuality) - 10(tx
                 // fee)
                 BEAST_EXPECT(expectLedgerEntryRoot(
@@ -3897,7 +3898,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'010), USD(10'000), ammAlice.tokens()));
                 // 10USD - 10% transfer fee
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{USD, UINT64_C(30'009'09090909091), -11}));
@@ -3984,7 +3985,7 @@ private:
                 BEAST_EXPECT(expectOffers(env, alice, 1, {{expectedAmounts}}));
             }
             // Initial 30,000 + 100
-            BEAST_EXPECT(expectLine(env, carol, STAmount{USD, 30'100}));
+            BEAST_EXPECT(expectHolding(env, carol, STAmount{USD, 30'100}));
             // Initial 1,000 - 30082730(AMM pool) - 70798251(offer) - 10(tx fee)
             BEAST_EXPECT(expectLedgerEntryRoot(
                 env,
@@ -4027,7 +4028,7 @@ private:
                           STAmount(EUR, UINT64_C(49'98750312422), -11),
                           STAmount(USD, UINT64_C(49'98750312422), -11)}}}));
                 // Initial 30,000 + 99.99999999999
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{USD, UINT64_C(30'099'99999999999), -11}));
@@ -4061,7 +4062,7 @@ private:
                     BEAST_EXPECT(ammAlice.expectBalances(
                         XRP(10'100), USD(10'000), ammAlice.tokens()));
                     // Initial 30,000 + 200
-                    BEAST_EXPECT(expectLine(env, carol, USD(30'200)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(30'200)));
                 }
                 else
                 {
@@ -4069,7 +4070,7 @@ private:
                         XRP(10'100),
                         STAmount(USD, UINT64_C(10'000'00000000001), -11),
                         ammAlice.tokens()));
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount(USD, UINT64_C(30'199'99999999999), -11)));
@@ -4104,7 +4105,7 @@ private:
             env.close();
             BEAST_EXPECT(ammAlice.expectBalances(
                 XRP(1'050), USD(1'000), ammAlice.tokens()));
-            BEAST_EXPECT(expectLine(env, carol, USD(2'200)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(2'200)));
             BEAST_EXPECT(expectOffers(env, bob, 0));
         }
 
@@ -4118,7 +4119,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     XRP(10'100), USD(10'000), ammAlice.tokens()));
                 // Initial 1,000 + 100
-                BEAST_EXPECT(expectLine(env, bob, USD(1'100)));
+                BEAST_EXPECT(expectHolding(env, bob, USD(1'100)));
                 // Initial 30,000 - 100(offer) - 10(tx fee)
                 BEAST_EXPECT(expectLedgerEntryRoot(
                     env, bob, XRP(30'000) - XRP(100) - txfee(env, 1)));
@@ -4145,9 +4146,9 @@ private:
                 BEAST_EXPECT(ammAlice.expectBalances(
                     GBP(1'100), EUR(1'000), ammAlice.tokens()));
                 // Initial 30,000 - 100(offer) - 25% transfer fee
-                BEAST_EXPECT(expectLine(env, carol, GBP(29'875)));
+                BEAST_EXPECT(expectHolding(env, carol, GBP(29'875)));
                 // Initial 30,000 + 100(offer)
-                BEAST_EXPECT(expectLine(env, carol, EUR(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, EUR(30'100)));
                 BEAST_EXPECT(expectOffers(env, bob, 0));
             },
             {{GBP(1'000), EUR(1'100)}},
@@ -4285,12 +4286,12 @@ private:
                     //     = 58.825 = ~29941.17
                     // carol bought ~72.93EUR at the cost of ~70.68GBP
                     // the offer is partially consumed
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{GBP, UINT64_C(29'941'16770347333), -11}));
                     // Initial 30,000 + ~49.3(offers = 39.3(AMM) + 10(LOB))
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{EUR, UINT64_C(30'049'31517120716), -11}));
@@ -4324,20 +4325,20 @@ private:
                     //     = 88.35 = ~29911.64
                     // carol bought ~72.93EUR at the cost of ~70.68GBP
                     // the offer is partially consumed
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{GBP, UINT64_C(29'911'64396400896), -11}));
                     // Initial 30,000 + ~72.93(offers = 62.93(AMM) + 10(LOB))
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{EUR, UINT64_C(30'072'93416277865), -11}));
                 }
                 // Initial 2000 + 10 = 2010
-                BEAST_EXPECT(expectLine(env, bob, GBP(2'010)));
+                BEAST_EXPECT(expectHolding(env, bob, GBP(2'010)));
                 // Initial 2000 - 10 * 1.25 = 1987.5
-                BEAST_EXPECT(expectLine(env, ed, EUR(1'987.5)));
+                BEAST_EXPECT(expectHolding(env, ed, EUR(1'987.5)));
             },
             {{GBP(1'000), EUR(1'100)}},
             0,
@@ -4363,8 +4364,8 @@ private:
                 env.close();
                 BEAST_EXPECT(ammAlice.expectBalances(
                     GBP(1'100), EUR(1'000), ammAlice.tokens()));
-                BEAST_EXPECT(expectLine(env, bob, GBP(75)));
-                BEAST_EXPECT(expectLine(env, carol, EUR(30'080)));
+                BEAST_EXPECT(expectHolding(env, bob, GBP(75)));
+                BEAST_EXPECT(expectHolding(env, carol, EUR(30'080)));
             },
             {{GBP(1'000), EUR(1'100)}},
             0,
@@ -4401,12 +4402,12 @@ private:
                     sendmax(CAN(195.3125)),
                     txflags(tfPartialPayment));
                 env.close();
-                BEAST_EXPECT(expectLine(env, bob, CAN(0)));
-                BEAST_EXPECT(expectLine(env, dan, CAN(356.25), GBP(43.75)));
+                BEAST_EXPECT(expectHolding(env, bob, CAN(0)));
+                BEAST_EXPECT(expectHolding(env, dan, CAN(356.25), GBP(43.75)));
                 BEAST_EXPECT(ammAlice.expectBalances(
                     GBP(10'125), EUR(10'000), ammAlice.tokens()));
-                BEAST_EXPECT(expectLine(env, ed, EUR(300), USD(100)));
-                BEAST_EXPECT(expectLine(env, carol, USD(80)));
+                BEAST_EXPECT(expectHolding(env, ed, EUR(300), USD(100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(80)));
             },
             {{GBP(10'000), EUR(10'125)}},
             0,
@@ -4523,7 +4524,7 @@ private:
             BEAST_EXPECT(btc_usd.expectBalances(
                 BTC(10'100), USD(10'000), btc_usd.tokens()));
 
-            BEAST_EXPECT(expectLine(env, carol, USD(300)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(300)));
         }
 
         // Dependent AMM
@@ -4594,7 +4595,7 @@ private:
                     STAmount{EUR, UINT64_C(10'917'2945958102), -10},
                     eth_eur.tokens()));
             }
-            BEAST_EXPECT(expectLine(env, carol, USD(300)));
+            BEAST_EXPECT(expectHolding(env, carol, USD(300)));
         }
 
         // AMM offers limit
@@ -4620,7 +4621,7 @@ private:
                         XRP(10'030),
                         STAmount{USD, UINT64_C(9'970'089730807577), -12},
                         ammAlice.tokens()));
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{USD, UINT64_C(30'029'91026919241), -11}));
@@ -4631,7 +4632,7 @@ private:
                         XRP(10'030),
                         STAmount{USD, UINT64_C(9'970'089730807827), -12},
                         ammAlice.tokens()));
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{USD, UINT64_C(30'029'91026919217), -11}));
@@ -4663,14 +4664,14 @@ private:
                 if (!features[fixAMMv1_1])
                 {
                     // Carol gets ~100USD
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{USD, UINT64_C(30'099'99999999999), -11}));
                 }
                 else
                 {
-                    BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
                 }
                 BEAST_EXPECT(expectOffers(
                     env,
@@ -4717,7 +4718,7 @@ private:
                     1,
                     {{{XRPAmount{50'074'628},
                        STAmount{USD, UINT64_C(50'07512950697), -11}}}}));
-                BEAST_EXPECT(expectLine(env, carol, USD(30'100)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'100)));
             }
         }
 
@@ -4809,11 +4810,11 @@ private:
             env(offer(carol, STAmount{token2, 100}, STAmount{token1, 100}));
             env.close();
             BEAST_EXPECT(
-                expectLine(env, alice, STAmount{token1, 10'000'100}) &&
-                expectLine(env, alice, STAmount{token2, 9'999'900}));
+                expectHolding(env, alice, STAmount{token1, 10'000'100}) &&
+                expectHolding(env, alice, STAmount{token2, 9'999'900}));
             BEAST_EXPECT(
-                expectLine(env, carol, STAmount{token2, 1'000'100}) &&
-                expectLine(env, carol, STAmount{token1, 999'900}));
+                expectHolding(env, carol, STAmount{token2, 1'000'100}) &&
+                expectHolding(env, carol, STAmount{token1, 999'900}));
             BEAST_EXPECT(
                 expectOffers(env, alice, 0) && expectOffers(env, carol, 0));
         });
@@ -5034,7 +5035,7 @@ private:
                 BEAST_EXPECT(ammAlice.expectLPTokens(carol, IOUAmount{1'000}));
                 ammAlice.withdrawAll(carol, USD(3'000));
                 BEAST_EXPECT(ammAlice.expectLPTokens(carol, IOUAmount{0}));
-                BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
                 // Set fee to 1%
                 ammAlice.vote(alice, 1'000);
                 BEAST_EXPECT(ammAlice.expectTradingFee(1'000));
@@ -5043,12 +5044,12 @@ private:
                 ammAlice.deposit(carol, USD(3'000));
                 BEAST_EXPECT(ammAlice.expectLPTokens(
                     carol, IOUAmount{994'981155689671, -12}));
-                BEAST_EXPECT(expectLine(env, carol, USD(27'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(27'000)));
                 // Set fee to 0
                 ammAlice.vote(alice, 0);
                 ammAlice.withdrawAll(carol, USD(0));
                 // Carol gets back less than the original deposit
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{USD, UINT64_C(29'994'96220068281), -11}));
@@ -5109,13 +5110,13 @@ private:
                 ammAlice.deposit(carol, USD(3'000));
 
                 BEAST_EXPECT(ammAlice.expectLPTokens(carol, IOUAmount{1'000}));
-                BEAST_EXPECT(expectLine(env, carol, USD(27'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(27'000)));
                 // Set fee to 1%
                 ammAlice.vote(alice, 1'000);
                 BEAST_EXPECT(ammAlice.expectTradingFee(1'000));
                 // Single withdrawal. Carol gets ~5USD less than deposited.
                 ammAlice.withdrawAll(carol, USD(0));
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{USD, UINT64_C(29'994'97487437186), -11}));
@@ -5189,9 +5190,9 @@ private:
                     {USD(1'000), EUR(1'000)},
                     Fund::Acct);
                 // Alice contributed 1010EUR and 1000USD to the pool
-                BEAST_EXPECT(expectLine(env, alice, EUR(28'990)));
-                BEAST_EXPECT(expectLine(env, alice, USD(29'000)));
-                BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+                BEAST_EXPECT(expectHolding(env, alice, EUR(28'990)));
+                BEAST_EXPECT(expectHolding(env, alice, USD(29'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
                 // Carol pays to Alice with no fee
                 env(pay(carol, alice, EUR(10)),
                     path(~EUR),
@@ -5199,9 +5200,9 @@ private:
                     txflags(tfNoRippleDirect));
                 env.close();
                 // Alice has 10EUR more and Carol has 10USD less
-                BEAST_EXPECT(expectLine(env, alice, EUR(29'000)));
-                BEAST_EXPECT(expectLine(env, alice, USD(29'000)));
-                BEAST_EXPECT(expectLine(env, carol, USD(29'990)));
+                BEAST_EXPECT(expectHolding(env, alice, EUR(29'000)));
+                BEAST_EXPECT(expectHolding(env, alice, USD(29'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(29'990)));
 
                 // Set fee to 1%
                 ammAlice.vote(alice, 1'000);
@@ -5213,10 +5214,10 @@ private:
                     txflags(tfNoRippleDirect));
                 env.close();
                 // Bob sends 10.1~EUR to pay 10USD
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env, bob, STAmount{EUR, UINT64_C(989'8989898989899), -13}));
                 // Carol got 10USD
-                BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
                 BEAST_EXPECT(ammAlice.expectBalances(
                     USD(1'000),
                     STAmount{EUR, UINT64_C(1'010'10101010101), -11},
@@ -5233,8 +5234,8 @@ private:
                 // No fee
                 env(offer(carol, EUR(10), USD(10)));
                 env.close();
-                BEAST_EXPECT(expectLine(env, carol, USD(29'990)));
-                BEAST_EXPECT(expectLine(env, carol, EUR(30'010)));
+                BEAST_EXPECT(expectHolding(env, carol, USD(29'990)));
+                BEAST_EXPECT(expectHolding(env, carol, EUR(30'010)));
                 // Change pool composition back
                 env(offer(carol, USD(10), EUR(10)));
                 env.close();
@@ -5245,11 +5246,11 @@ private:
                 env.close();
                 // Alice gets fewer ~4.97EUR for ~5.02USD, the difference goes
                 // to the pool
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{USD, UINT64_C(29'995'02512562814), -11}));
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     carol,
                     STAmount{EUR, UINT64_C(30'004'97487437186), -11}));
@@ -5299,16 +5300,16 @@ private:
                 path(~USD),
                 sendmax(EUR(15)),
                 txflags(tfNoRippleDirect));
-            BEAST_EXPECT(expectLine(env, ed, USD(2'010)));
+            BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             if (!features[fixAMMv1_1])
             {
-                BEAST_EXPECT(expectLine(env, bob, EUR(1'990)));
+                BEAST_EXPECT(expectHolding(env, bob, EUR(1'990)));
                 BEAST_EXPECT(ammAlice.expectBalances(
                     USD(1'000), EUR(1'005), ammAlice.tokens()));
             }
             else
             {
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env, bob, STAmount(EUR, UINT64_C(1989'999999999999), -12)));
                 BEAST_EXPECT(ammAlice.expectBalances(
                     USD(1'000),
@@ -5336,10 +5337,10 @@ private:
                 path(~USD),
                 sendmax(EUR(15)),
                 txflags(tfNoRippleDirect));
-            BEAST_EXPECT(expectLine(env, ed, USD(2'010)));
+            BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             if (!features[fixAMMv1_1])
             {
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     bob,
                     STAmount{EUR, UINT64_C(1'989'987453007618), -12}));
@@ -5350,7 +5351,7 @@ private:
             }
             else
             {
-                BEAST_EXPECT(expectLine(
+                BEAST_EXPECT(expectHolding(
                     env,
                     bob,
                     STAmount{EUR, UINT64_C(1'989'987453007628), -12}));
@@ -5381,8 +5382,8 @@ private:
                 path(~USD),
                 sendmax(EUR(15)),
                 txflags(tfNoRippleDirect));
-            BEAST_EXPECT(expectLine(env, ed, USD(2'010)));
-            BEAST_EXPECT(expectLine(env, bob, EUR(1'990)));
+            BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
+            BEAST_EXPECT(expectHolding(env, bob, EUR(1'990)));
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(1'005), EUR(1'000), ammAlice.tokens()));
             BEAST_EXPECT(expectOffers(env, carol, 0));
@@ -5408,8 +5409,8 @@ private:
                 path(~USD),
                 sendmax(EUR(15)),
                 txflags(tfNoRippleDirect));
-            BEAST_EXPECT(expectLine(env, ed, USD(2'010)));
-            BEAST_EXPECT(expectLine(
+            BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
+            BEAST_EXPECT(expectHolding(
                 env, bob, STAmount{EUR, UINT64_C(1'989'993923296712), -12}));
             BEAST_EXPECT(ammAlice.expectBalances(
                 USD(1'004),
@@ -5480,47 +5481,47 @@ private:
                 else
                     BEAST_EXPECT(ammAlice.expectBalances(
                         XRP(10'000), USD(10'000), IOUAmount{10'000'000}));
-                BEAST_EXPECT(expectLine(env, ben, USD(1'500'000)));
-                BEAST_EXPECT(expectLine(env, simon, USD(1'500'000)));
-                BEAST_EXPECT(expectLine(env, chris, USD(1'500'000)));
-                BEAST_EXPECT(expectLine(env, dan, USD(1'500'000)));
+                BEAST_EXPECT(expectHolding(env, ben, USD(1'500'000)));
+                BEAST_EXPECT(expectHolding(env, simon, USD(1'500'000)));
+                BEAST_EXPECT(expectHolding(env, chris, USD(1'500'000)));
+                BEAST_EXPECT(expectHolding(env, dan, USD(1'500'000)));
                 if (!features[fixAMMv1_1] && !features[fixAMMv1_3])
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         carol,
                         STAmount{USD, UINT64_C(30'000'00000000001), -11}));
                 else if (features[fixAMMv1_1] && !features[fixAMMv1_3])
-                    BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
                 else
-                    BEAST_EXPECT(expectLine(env, carol, USD(30'000)));
-                BEAST_EXPECT(expectLine(env, ed, USD(1'500'000)));
-                BEAST_EXPECT(expectLine(env, paul, USD(1'500'000)));
+                    BEAST_EXPECT(expectHolding(env, carol, USD(30'000)));
+                BEAST_EXPECT(expectHolding(env, ed, USD(1'500'000)));
+                BEAST_EXPECT(expectHolding(env, paul, USD(1'500'000)));
                 if (!features[fixAMMv1_1] && !features[fixAMMv1_3])
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         nataly,
                         STAmount{USD, UINT64_C(1'500'000'000000002), -9}));
                 else if (features[fixAMMv1_1] && !features[fixAMMv1_3])
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         nataly,
                         STAmount{USD, UINT64_C(1'500'000'000000005), -9}));
                 else
-                    BEAST_EXPECT(expectLine(env, nataly, USD(1'500'000)));
+                    BEAST_EXPECT(expectHolding(env, nataly, USD(1'500'000)));
                 ammAlice.withdrawAll(alice);
                 BEAST_EXPECT(!ammAlice.ammExists());
                 if (!features[fixAMMv1_1])
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         alice,
                         STAmount{USD, UINT64_C(30'000'0000000013), -10}));
                 else if (features[fixAMMv1_3])
-                    BEAST_EXPECT(expectLine(
+                    BEAST_EXPECT(expectHolding(
                         env,
                         alice,
                         STAmount{USD, UINT64_C(30'000'0000000003), -10}));
                 else
-                    BEAST_EXPECT(expectLine(env, alice, USD(30'000)));
+                    BEAST_EXPECT(expectHolding(env, alice, USD(30'000)));
                 // alice XRP balance is 30,000initial - 50 ammcreate fee -
                 // 10drops fee
                 BEAST_EXPECT(
@@ -5883,7 +5884,7 @@ private:
                         BEAST_EXPECT(amm->expectBalances(
                             USD(1'000), ETH(1'000), amm->tokens()));
                     }
-                    BEAST_EXPECT(expectLine(env, bob, USD(2'100)));
+                    BEAST_EXPECT(expectHolding(env, bob, USD(2'100)));
                     q[i] = Quality(Amounts{
                         ETH(2'000) - env.balance(carol, ETH),
                         env.balance(bob, USD) - USD(2'000)});
@@ -6056,7 +6057,7 @@ private:
                                         -13}}}}));
                         }
                     }
-                    BEAST_EXPECT(expectLine(env, bob, USD(2'100)));
+                    BEAST_EXPECT(expectHolding(env, bob, USD(2'100)));
                     q[i] = Quality(Amounts{
                         ETH(2'000) - env.balance(carol, ETH),
                         env.balance(bob, USD) - USD(2'000)});
@@ -6203,7 +6204,7 @@ private:
                         sendmax(ETH(600)));
                     env.close();
 
-                    BEAST_EXPECT(expectLine(env, bob, USD(2'100)));
+                    BEAST_EXPECT(expectHolding(env, bob, USD(2'100)));
 
                     if (i == 2 && !features[fixAMMv1_1])
                     {
@@ -7484,7 +7485,7 @@ private:
         using namespace test::jtx;
 
         auto const testCase = [&](std::string suffix, FeatureBitset features) {
-            testcase("Failed pseudo-account allocation " + suffix);
+            testcase("Fail pseudo-account allocation " + suffix);
             std::string logs;
             Env env{*this, features, std::make_unique<CaptureLogs>(&logs)};
             env.fund(XRP(30'000), gw, alice);